6

I have some difficult situation here which I hope some body will help me.

I have the following,

struct CandyBar{ 
  std::string name; 
  double weight; 
  int calories; 
} ;

Now, for creating an array of structure to contain many CandyBars is much simple which I have done like;

int main(){
   CandyBar bars[] = {{"Mango tart", 2.3, 100}, {"Yo Yo", 3.2, 130}, {"Orange Ball", 1.7, 98}};
  return 0;
}

But, now I want to create the same structure using new. It is quite simple when I think it but this crashes and does not work.

CandyBar *bars = new CandyBar;
  (*bars).name = "Mango tart";
   bars->weight =  2.3;
   bars->calories =  100;
   bars += 1;

  (*bars).name = "Yo Yo";
  bars->weight =  3.2;
  bars->calories =  130;

  bars += 1;
  (*bars).name =  "Orange Ball";
  bars->weight =  1.7;
  bars->calories =  98;

But, this does not work. As I think that the first pointer is a memory location pointing to the first structure and then I create the structure and then increase the address using bar += 1, and go on creating the pointer but am I missing something really serious.

I would really appreciate your help.

Improve this question
7
  • 2
    You're only allocating space for 1 CandyBar. Commented Jan 1, 2013 at 22:08
  • I don't have much experience in C++ but a vector or sharedptr sounds like the way to go. Commented Jan 1, 2013 at 22:09
  • You probably want a std::vector<CandyBar>. Commented Jan 1, 2013 at 22:09
  • 1
    Answers above. But can I ask why you alternate between (*bars). and bars->? It looks silly. Also, how can you delete the array later, when you've modified the pointer that holds its address? Commented Jan 1, 2013 at 22:10
  • @LewsTherin no, shared_ptr would use delete in the destructor on something allocated with new[]. Commented Jan 1, 2013 at 22:11

4 Answers 4

Reset to default
16

In your second example, you are only allocating a single CandyBar structure, but you're treating it as if it was an array. That isn't going to end well and is a recipe for a buffer overflow.

In order to allocate an array of CandyBars, you need to tell new that you want an array, like so:

CandyBar* bars = new CandyBar[3];

Make sure that when you are deleting your array of CandyBars, you are using array delete like this:

delete[] bars;

All that said, in C++ production code you would normally use a std::vector or a std::arrray to handle this situation as you don't have to deal with as much resource management as you have to in this particular case.

If you have to dynamically allocate an array on the heap and still use RAII, I would also look at boost::shared_array and boost::scoped_array.

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

1 Comment

Thanks. You mentioned the delete[] as well. I thought it to be difficult, now I know how easy peasy it is ;)
6

Space is only being allocated for one CandyBar, so you are writing to unallocated heap memory. This is a big no-no. You are actually lucky that it is failing because this has the capability of produce very difficult to debug problems.

You can allocate room for more CandyBars like so:

CandyBar *bars = new CandyBar[3]; // 3 CandyBars.

...and don't forget to use an array deletor like so:

delete[] bars;

But still, there is the capability to overrun the number of CandyBars that you have allocated. The much preferred method of doing this in C++ is to use a std::vector.

In this example, I give CandyBar a constructor for shorthand and place them into a std::vector.

#include <string>
#include <vector>

struct CandyBar{ 
  std::string name;
  double weight;
  int calories;
  CandyBar(std::string name, double weight, int calories)
  {
      this->name = name;
      this->weight = weight;
      this->calories = calories;
  }
};

int main()
{
    std::vector<CandyBar> bars;
    bars.push_back(CandyBar("Mango tart", 2.3, 100));
    bars.push_back(CandyBar("Yo Yo", 3.2, 130));
    bars.push_back(CandyBar("Orange Ball", 1.7, 98));

    return 0;
}

No new's, no delete's, no leaks, no corruption.

I would also add that if you are using a compiler with some C++11 support and do not want the dynamic allocation that std::vector gives you, you may consider using std::array instead.

Improve this answer

1 Comment

Wow, that's great. I didn't know about vectors. It seems it is much easy with vectors.
1

Foo * a = new Foo allocates space for exactly one instance of Foo. If you want to allocate an array of Foo, you need to use Foo * a = new Foo[ARRAY_LEN].

Basically, what you really want to do is to dynamically allocate some memory to hold an array of objects, in your case CandyBar objects. The problem is, you're using the new operator, which only allocates memory for one such object. You're then trying to use the returned memory address as if it pointed to an array. You'll inevitably try to access memory you haven't allocated yet, which will lead to segmentation faults (at best).

The operator you're really looking for is the new[] operator (invoked as new CandyBar[ARRAY_LEN]), which allocates enough memory for an array of the specified number of objects. You can then take the returned memory address and treat it exactly like an array of the size you provide without fear of overrunning your memory allocation.

In general, if you're dealing with a collection of CandyBars that could grow or shrink throughout the lifetime of your program, allocating a fixed-size array is not the way to go. Take a look at the std::vector template class in the C++ STL - a std::vector<CandyBar> can grow or shrink dynamically depending on how many CandyBars you want to store, and can be freely accessed as if it were an array (e.g. as foo[42]).

Improve this answer

2 Comments

You mentioned something about new[]. Can I also use new[] instead of new CandyBar[20].
@NSProxy Even though we call it the new[] operator, we invoke the operator using the form new CandyBar[20]; that's just how the syntax works.
0

You should allocate an array of CandyBar with :

CandyBar *bars = new CandyBar[20];

Then you use bars[0], bars[1] ... bars[19], etc, to access the individual candybars.

Note that your code bars + 1 adds one sizeof CandyBar to the pointer, but this points to an unallocated region (because you have just allocated a single CandyBar). Thus your code crashes.

Improve this answer

3 Comments

No you shouldn't. There's really never any case where you should use array new.
Of course there are STL solutions which are better and it's good that other answers advice this. I am only showing how to use new for arrays.
But there is no case where you would ever use new for an array. Ever.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.