Need help with arrays

[Ebsanu]

I'm trying to make an array to hold the item name of 12 items:

Here's what I did

char itemname[12][32]= ("Milk", "Cereals", "Shampoo", "Facial Tissue", "Miller Lite", "Laundry Detergent", "Navel Oranges", "Heineken", "Seedless Grapes", "Dry Dog Food", "Diapers", "Chardonnay Wine");

When it compiles it says "Invalid Initializer".


What am I doing wrong?

And how would I call these separate arrays when its correct?

[curiously enough]

You're using paranthesis instead of brackets.

[Tassos Souris]

The correct way to do this is:

char *itemname[] = {  "Milk", "Cereals", "Shampoo", "Facial Tissue", "Miller Lite", "Laundry Detergent", "Navel Oranges", "Heineken", "Seedless Grapes", "Dry Dog Food", "Diapers", "Chardonnay Wine"
};
 

I used an array of pointers to strings to save space.
I also need not state the number of elements of the array. This gives me more flexibility to add more strings in the array.

[donbock]

I suggest a couple of changes to post #3 by Tassos Souris:

1. Declare itemname as "const char * const". That prevents you from ever trying to write into the literal strings. Doing so is nonportable because whether literal strings are writeable is implementation dependent. It also prevents you from changing any itemname entries to point at different strings.

2. It is helpful to have some variable that holds the number of entries in the itemname array.

..... 2a. If your compiler warns you when you have too few initializers for an array then the following snippet works for you. Such a warning is not mandated by the Standard.

#define NUMITEMS 12
const char * const itemname[NUMITEMS] = {  "Milk", "Cereals", "Shampoo", ..., "Chardonnay Wine" };

..... 2b. The following technique is portable, but you have to be careful to only use the ARRAYSIZE macro with actual arrays, never with pointers.

#define ARRAYSIZE(a) ( (int)(sizeof(a) / sizeof(a[0])) )
const char * const itemname[NUMITEMS] = {  "Milk", "Cereals", "Shampoo", ..., "Chardonnay Wine" };
const int numitems = ARRAYSIZE(itemname);

[Tassos Souris]

I suggest a couple of changes to post #3 by Tassos Souris:

1. Declare itemname as "const char * const". That prevents you from ever trying to write into the literal strings. Doing so is nonportable because whether literal strings are writeable is implementation dependent. It also prevents you from changing any itemname entries to point at different strings.

2. It is helpful to have some variable that holds the number of entries in the itemname array.

..... 2a. If your compiler warns you when you have too few initializers for an array then the following snippet works for you. Such a warning is not mandated by the Standard.

#define NUMITEMS 12
const char * const itemname[NUMITEMS] = {  "Milk", "Cereals", "Shampoo", ..., "Chardonnay Wine" };

..... 2b. The following technique is portable, but you have to be careful to only use the ARRAYSIZE macro with actual arrays, never with pointers.

#define ARRAYSIZE(a) ( (int)(sizeof(a) / sizeof(a[0])) )
const char * const itemname[NUMITEMS] = {  "Milk", "Cereals", "Shampoo", ..., "Chardonnay Wine" };
const int numitems = ARRAYSIZE(itemname);

I totally agree with the second but i thought that if someone were to access an array at least he/she knows the problems about indexing and getting off the bounds of arrays and the rest of the stuff, so he/she would put a guard in the form of #define :-P

As far as the first is concerned, it really does not matter, because as you said you don't know what the hell the compiler will do. Some implementations, treat multiple occurrences of the same literal strings as one in memory not allowing you to change it, but some as distinct which are the most likely to let you change it... :-P
Personally, i put the first const.. i miss the second even though now it seems like a good idea (not that it will make a difference cause const does nothing...)

Thanks

[donbock]

Personally, i put the first const.. i miss the second even though now it seems like a good idea (not that it will make a difference cause const does nothing...)

If by 'const does nothing' you mean 'const can be trivially defeated by casting' then I have to agree. If you mean 'const is worthless' then I disagree.

Advantages of using const:

1. It acts as a comment to the maintenance programmer indicating my intentions regarding whether a particular variable should be changed.

2. Liberal use of const reduces the number of nuisance const/non-const warnings from using functions in the standard library.

3. The compiler will warn me if I accidentally write into a const variable.

4. Static analysis tools (like lint) may warn me if I deliberately write into a const variable by casting away const-ness or omitting 'const' from the extern in one source file.

5. On some compilers, if the moon is full and my heart is pure, declaring a variable as 'static const' with an initializer might maybe cause that variable to be defined in the code segment. This would speed up my program by the tiniest bit and activate a run-time error if my program writes into the variable (whether accidentally or deliberately). I can't rely on this behavior, but no harm in taking advantage of it when it is available.

[Tassos Souris]

If by 'const does nothing' you mean 'const can be trivially defeated by casting' then I have to agree. If you mean 'const is worthless' then I disagree.

Advantages of using const:

1. It acts as a comment to the maintenance programmer indicating my intentions regarding whether a particular variable should be changed.

2. Liberal use of const reduces the number of nuisance const/non-const warnings from using functions in the standard library.

3. The compiler will warn me if I accidentally write into a const variable.

4. Static analysis tools (like lint) may warn me if I deliberately write into a const variable by casting away const-ness or omitting 'const' from the extern in one source file.

5. On some compilers, if the moon is full and my heart is pure, declaring a variable as 'static const' with an initializer might maybe cause that variable to be defined in the code segment. This would speed up my program by the tiniest bit and activate a run-time error if my program writes into the variable (whether accidentally or deliberately). I can't rely on this behavior, but no harm in taking advantage of it when it is available.

you can see the related topic about const ( something called "how this is possible in c(const variable)" ) to see my view on const...