How to return an Array of Objects from a function

Question

This simple object return works fine.

Bubbles& Foo() {
  static Bubbles foo(10);
  foo.print();
  return foo;
}

int main() {

  Bubbles *bar;
  bar = &Foo();

  bar->print();

  printf("Program Ends");
  return 0;
}

Now I need to know how to return an Array of Objects! I have 0 idea on how I should declare it

All I know is:

Bubbles& createBubbles() {
 static Bubbles *BubblesArray[arrayNumber];
 for (int i = 0; i < arrayNumber; i++) {
    BubblesArray[i] = new Bubbles(i);
    BubblesArray[i]->print();

  }

  return BubblesArray;
}

seems to create an array of Objects the way I need.
So how can I return this array so I can use it outside the function?

Use std::array or std::vector and this becomes trivial. Otherwise it's not happening unless you pass the array as an output parameter. — sweenish
– sweenish, Commented Jan 31, 2020 at 4:22
BubblesArray is a pointer to the start of an array. Hence you want the return type to be Bubbles* i.e. Bubbles* createBubbles(), then the return statement makes sense. Note that you using a static variable won't play nice with multi-threading and there's a lot of memory leak in the code. Consider using std:: functions and classes such as std::vector and std::unique_ptr or std::shared_ptr. — TuanDT
– TuanDT, Commented Jan 31, 2020 at 4:36
Why is the variable static? This is, except in narrow circumstances, a bad design. If you added an explanation of why you think that is necessary, then we could probably suggest a better approach. — walnut
– walnut, Commented Jan 31, 2020 at 4:47
ok so I guess the best approach is std:: functions. I will try std::vector — Nathan Almeida
– Nathan Almeida, Commented Jan 31, 2020 at 4:51

TuanDT · Accepted Answer · 2020-01-31 04:59:42Z

1

Your return type expects only 1 Bubbles object. If you want to return an array, you have to change the function return type. I would strongly recommend not playing with raw array and stick with the std library. Using C++11 (DISCLAIMER: CODE UNTESTED) will look something along the line of:

std::vector<Bubbles> createBubbles(const int& arrayNumber) {
 std::vector<Bubbles> bubblesVector;
 for (int i = 0; i < arrayNumber; i++) {
    bubblesVector.push_back(Bubbles(i));
    bubblesVector[i].print();    
  }    
  return bubblesVector;
}

Note that this assume your Bubbles object has appropriate default/copy/move constructor, destructor, assignment operator...

Simple return type std::vector<Bubbles> can take advantage of copy-elision which is extremely efficient.

edited Jan 31, 2020 at 4:59

answered Jan 31, 2020 at 4:51

TuanDT

1,67713 silver badges28 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Michael Francis Over a year ago

Since the OP has no need for resizing the array, I think std::array<Bubbles, arrayNumber> would be better here.

robthebloke Over a year ago

Bubbles tend to pop. I'd suggest a vector.

walnut · Accepted Answer · 2020-01-31 05:52:05Z

1

You can get the same behavior as in your first example. You just have to specify the type correctly:

using BubblesArrayType = Bubbles*[arrayNumber];

BubblesArrayType& createBubbles() {
  static BubblesArrayType BubblesArray;
  //...
  return BubblesArray;
}

or you can let type deduction figure the type out for you:

auto& createBubbles() {
  static Bubbles *BubblesArray[arrayNumber];
  //...
  return BubblesArray;
}

But as mentioned in comments and other answers, this is unlikely to be a good design and style. Without further information it is not really clear though, why you are using static and return-by-reference in the first place.

edited Jan 31, 2020 at 5:52

answered Jan 31, 2020 at 5:04

walnut

22.3k4 gold badges30 silver badges65 bronze badges

4 Comments

N. Shead Over a year ago

Also possible without the typedef, though even uglier: Bubbles* (&createBubbles())[arrayNumber] { /* ... */ }

walnut Over a year ago

@N.Shead I hope I will never see that in any code I work with.

walnut Over a year ago

@N.Shead I suppose auto createBubbles() -> Bubbles*(&)[arrayNumber] could be an ok alternative though, or really just auto& createBubbles().

N. Shead Over a year ago

Yes, auto type deduction is definitely the way to go there. Though honestly I'd prefer to not be returning array types at all — I just felt it worthwhile to point out the possibility!

Collectives™ on Stack Overflow

How to return an Array of Objects from a function

2 Answers 2

2 Comments

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related