# Weird response from statement in c.

In the program below -
Code:
#include<stdio.h>
char places = 4;
main()
{
char m = 3;
short i;
char counter[places - 2][1];
for(i = 0;i<=places-3;i++)
{
counter[i][0] = m;
m++;
counter[i][1] = i - i;
}
printf("%d \n", counter[1][0]);//Value of counter[1][0] = 4
counter[0][1] = 2;
printf("%d", counter[1][0]);//Value of counter[1][0] switches to 2 after the above statement...WHAT???
}
The statement 'counter[0][1] = 2;' changes the value of counter[1][0] to 2...and it was 4 previously.

Related Programming and Computer Science News on Phys.org
sylas
The statement 'counter[0][1] = 2;' changes the value of counter[1][0] to 2...and it was 4 previously.
The size of your array is "1" in the second dimension! You declared the array as
Code:
	char counter[places - 2][1];
Note that any index to the array must be strictly LESS than the size given in the array declaration. Thus the only valid value for the second index is zero!

Hence the expression counter[0][1] is an overflow of the second index, and in fact it is indeed the same thing as counter[1][0].

By the way; it's a really bad idea to use a variable in the size of the array. If you intend "places" to be a constant, then use one of these two methods.
Code:
// ONLY USE ONE OF THESE METHODS!
#define places 4      // old method
enum { places = 4 };  // better new method, unless you have a very old compiler
My preference would be this:
Code:
// Array size definition
enum {
numrows = 3,
numcols = 2
};

void main()
{
char array[numrows][numcols];
Cheers -- sylas

OH YES!...HOW STUPID!

Thanks man!

places will have to vary...actually this is a section of a program.

sylas
places will have to vary...actually this is a section of a program.
You can't vary the size of an array in C. You can perhaps pick a maximum possible size, define that for a constant, and then have another variable which effectively says how much of the array you will use.

Cheers -- sylas

Yes, on second thought, it is a good idea.

Thanks!

So there's no difference between

#define places 4
and
enum { places = 4 }?

Both will be called symbolic constants?

What will enum stand for?

mgb_phys
Homework Helper
They do the same job
The enum (stands for enumeration) is a little safer - the compiler knows the value is an integer and can check where using it in the code makes sense.
The #define is just a search/replace - if you make a mistake such as writing #define places 4;
The compiler will simply copy this to give you char array[4;];
which is an error - but the error message will be harder to understand because it will say the error is in "char array[places];"

edit - one other thing to be carefull of, if you are using gcc (if you are on Linux) then you can write
int places=4;
char array[places];
This is an extention to c++ by the gcc compiler and doesn't work anywhere else - don't use it.

edit - one other thing to be carefull of, if you are using gcc (if you are on Linux) then you can write
int places=4;
char array[places];
This is an extention to c++ by the gcc compiler and doesn't work anywhere else - don't use it.
YES, I DID THAT!!

AND IT DID WORK...but it was sorta confusing, at times it works and at times it does not.

I made places and array global variables and it did not work all of a sudden...and I dont think we have absolutely no reference to this in ANY ebook...or in general book.

So, if I make place a symbolic constant, will array[places] work...in most compilers?

Another question with enum...if I make enum {places = 5.4857}...i.e float, will it get rejected?

mgb_phys