Thread: Enum as array

OK, now am confused. I have a hashtable class, this class contains a dynamic array that contains objects. Now, I want to have a way of knowing which index is occupied, deleted, or unoccupied. Before, I was using another dynamic boolean array that told me which index is un(occupied). It worked well till I realised that I needed a third state. The problem now is that it doesn't look like enum will act as a replacement. For a start, I can't declare it dynamically and I need this because the table will be resized. For the boolean, it was easy:

Code:

bool * states;

states = new bool [initialTableSize];

then with a loop, filled each index with the default unoccupied. Later on, then as I filled each position, change status accordingly. When rehashing (resizing table), I declared another local dynamic array, copied the values, and rehashed values. Everything worked well. But wit enum, I am confused.

I can't declare it as a pointer, can't say States * states; can't resize it with table. So, is there a way, analogous to the boolean array but with 3 states, this can be done?

Something like;

Code:

States * states;

states = new States[100]//declared 100 states

//fill each index with default unoccupied states
for(int i = 0; i < 100; ++)
states[i] = unoccupied;

Then later just use it, changing the value of each states to one of the three predefined states. And be able to increase the size of the states array. Or am I overcomplicating things?

This is not really on topic, but why do people keep doing this:

Originally Posted by Dontgiveup

Code:

States * states;

states = new States[100]//declared 100 states

??

Why not just do

Code:

States* states = new States[100];

and be done with it?
You gain absolutely nothing from using two lines for something so trivial. In fact you incur the risk of uninitialized pointers if you add more coder later between the declaration of the pointer and its initialization.
Also, by condensing this into one statement, you can even make the pointer const (provided that you don't need to modify it later).

Code:

States* const states = new States[100];

Well I don't think it applies to new as much because new throws an exception much of the time when it fails, but I've combined the statement which assigns new memory to a pointer with the if condition that checks it for validity, on more than one occasion. It's only an idiosyncrasy, and it can work safely in a larger program if you care enough to initialize your pointers to NULL.

Originally Posted by whiteflags

Well I don't think it applies to new as much because new throws an exception much of the time when it fails

That's not my point. Let me show you what I was getting at.

Code:

States* states;
 
states = new States[100];

for ( std::size_t i = 0; i < 100; ++i )
{
    ...
}

Months later, the program is extended by additional functionality. The developer inserts a few lines of code between the declaration of the pointer and it's initialization.

Code:

States* states;

if ( someFlag )
{
    someFunc();
}
 
states = new States[100];

for ( std::size_t i = 0; i < 100; ++i )
{
    ...
}

Add another few months and the developer decides to remove to the recently added stuff (for whatever reason). Unfortunately he ends up removing a little too much.

Code:

States* states;

for ( std::size_t i = 0; i < 100; ++i )
{
    ...
}

Now mistakes like that happen, but by spreading out declaration and initialization over 2 statements, you're making yourself a lot more vulnerable to such bugs. I've found a whole ton of bugs similar to this in a number of projects I've inherited. We use a dynamic coder checker (IBM Rational Purify), and in fact the most frequent error it finds are UMRs (Uninitialized Memory Read), most of which are a direct result of developers insisting on deferring initialization of local variables until later, when in most cases it could easily be done right then and there. This style of coding is particularly annoying when it is combined with the old C habit of declaring all local variables at the top of the function.

Originally Posted by laserlight

Eh, but you can. Perhaps you should post the smallest and simplest program that you expect should compile but which demonstrates this problem.

Yeah thanks, you are right. It was my mistake but I managed to sort it out and all is well. Also, can't use vectors because we are not allowed to use that as we have to design our own data structure and not use predefined data structures in STL. But it is fine and all is well. But I have come across something that I would like if someone could elaborate on its cause.

Normally, if I have a pointer as a member variable, I can initialise it in an initialisation list thus:

Code:

class Test {

bool * test;

Test (): test(false);

}

and then later allocate dynamic memory for 100 like this:

Code:

test = new bool[100];

my question is, when I am initialising test with false in the initialisation field, what is set to false? Will all the 100 elements I have allocated memory have false or, because this happens later, false here is meaningless as it only sets false to a pointer (akin to initialising pointer to 0)?

Finally, why would this not work with enum?

Code:

enum Example{

state1,
state2,
state3
};

class Test {

State * test;

Test (): test(state1);

}

compiler gives error: cannot convert Example to Example* in initialization

Originally Posted by laserlight

You are initialising a member that is a pointer, therefore, the member pointer is set to false. However, since false is not actually an address, what probably happened is that you initialised the pointer to be a null pointer. It would have been simpler to do so directly instead of writing false. This also explains your second question.

Thanks. I think that is clear. So basically, if you want to initialise a pointer, just initialise it as null and don't initialise it with some other funny stuff.

Is there any way that one can for example initialise a dynamic array with initial default values in the initialisation list. Something like:

Code:

Test () : test(new bool[100]); //this works but test has undefined values

so is there anyway I can say in the initialisation list: "Fill test with 100 false default values"?

Originally Posted by Dontgiveup

Code:

Test () : test(new bool[100]); //this works but test has undefined values

so is there anyway I can say in the initialisation list: "Fill test with 100 false default values"?

Cant you just use:

Code:

fill(test, test+100, false);

Originally Posted by R41D3N

Cant you just use:

Code:

fill(test, test+100, false);

or

Code:

bool* t;

t = new bool [100] {false};

I know of course that I can use another method. I am already using an init method in the constructor body to fill in. But I was thinking of whether it is possible with the constructor (initialisation fields).

Originally Posted by R41D3N

Just compiled it, its not undefined. All elements are initialized to false by default.

Not sure that is a good idea. I think, and someone correct me if I am wrong, in C++, unless you assign values, everything remains undefined.

Originally Posted by Dontgiveup

Not sure that is a good idea. I think, and someone correct me if I am wrong, in C++, unless you assign values, everything remains undefined.

I think bool's default constructor gets called and it produces false.