Updating a static member in a function call causes crash - c++

Question

I have a class polymer with a static int count.
When I create a new polymer to add to an array of pointers I am using the count to find the correct location in the array and then I update the count in the constructor. While compiling in Windows it worked. However, when compiling in Linux (Ubuntu) it crashes unless I remove the updating of the count out of the constructor.
WORKS in Windows and Ubuntu:
polymerPointer[polymer::count] = new polymer();
polymer::count++;
WHEN the constructor doesn't update the static variable (see below)
polymer::polymer(){
//sets up lots of variables but doesn't update the static member
};
CRASHES in Ubuntu (works in Windows):
polymerPointer[polymer::count] = new polymer();
WHEN the constructor does update the static variable (see below)
polymer::polymer(){
//sets up lots of variables and then updates the static member
count++;
};
I can rewrite the code, but I liked not having to remember to update the variable separately, which is why I put the update in the constructor. Any ideas on what is going wrong?

Answer 1

You're hitting undefined behavior.
The following:
polymerPointer[polymer::count] = new polymer();
polymer::count++;
is not equivalent to
polymerPointer[polymer::count] = new polymer();
where polymer() increments polymer::count.
The undefined behavior results from the fact that you're modifying a value and using that value in the same statement:
§1.9 p15 If a side effect on a scalar object is unsequenced relative
to either another side effect on the same scalar object or a value
computation using the value of the same scalar object, the behavior is
undefined.
What probably is occuring is that the count is incremented and then the object is placed in that new position in the array. Now code will access the empty spot left as though it held a valid pointer, or when you get to the end of an array you may try to place the pointer out of the bounds of the array.
It's bad design to put the count increment in a different place than where you actually insert into the array. What you should do is write a static member function that adds elements to the array and updates the count, and then use that instead of manually creating the object and manually placing it in the array, while expecting the count to get updated automatically.
class polymer {
static void create_new_polymer() {
polymerPointer[polymer::count] = new polymer();
count++;
}
};
Even better would be to just use a vector and have it manage it's own count:
polymerPointer.push_back(new polymer());

Answer 2

The compiler may legally evaluate polymerPointer[polymer::count] before new polymer(); or the other way around, as it wishes. This means that you cannot depend on polymer::count to be the original value. You must use something more deterministic, like std::vector<std::unique_ptr<Polymer>>?

Answer 3

It could be due to an uninitialised variable. Try stepping through the code in a debugger or just printing out the value of count.
You could also check that polymerPointer points to allocated memory (how much memory did you allocate for the storage and is it enough for all values of count?).

Answer 4

Your problem is that the standard doesn't guarantee in which order your statement is executed, so polymerPointer[polymer::count] = new polymer(); might evaluate polymer::count either before or after new polymer(); is executed.
If you change polymer::count inside of polymers constructor and polymer::count is evaluated after new polymer() you obviously skip indices, which is likely what leads to your crashes.
But do you really have any pressing reason to use what seems like a c-style array here instead of using std::vector (which would not need the extra count variable)? Furthermore if you have the choice you really shouldn't use manual memory management, so use std::unique_ptr or std::shared_ptr if you have access to C++11, std::tr1::shared_ptr or boost::shared_ptr otherwise. If you are using boost boost::ptr_vector is also an option

Answer 5

The easiest fix would be to split that assignment in two, hence introducing a sequencing:
polymer*& insert_point = polymerPointer[polymer::count];
insert_point = new polymer();
The reasoning is explained in other answers.