Thread: Questions about variable declarations

Hi Guys
I try to do my own research, but some questions I can’t express well into Google.
Basically, I’d like to know if I’m correct about some things I just assume at the moment.

Code:

int n;
int i = 10;

If you declared variables n and i as above in the top line,
and your program never used either of them, the compiler would discard n at compile time, but the value 10 in i would consume RAM at program run time because you put a value in it.

Code:

unsigned char dataa[10]={0,1,2,3,4,5,6,7,8,9};
const unsigned char datab[10]={0,1,2,3,4,5,6,7,8,9};

If you declared arrays dataa and datab as above, the reason datab array can’t be written to is due to being stored in a program memory area.
Thanks

but the value 10 in i would consume RAM at program run time because you put a value in it.

Not necessarily, if the variable is never used the compiler can optimize the variable away and not use any memory.

the reason datab array can’t be written to is due to being stored in a program memory area.

Again not necessarily. First not all architectures have separate memory areas. I've seen systems that only have volatile memory, if they loos power you need to reload the "program". I've also see programs that only have a few bytes of volatile memory, relying mainly on registers to store "variables". Getting a C compiler to that creates programs to run on these types of systems is quite problematic so you won't usually see them in a C programming environment.

However, with most systems today, const qualified variables are quite possibly (probably) placed into read only segments to prevent modifications to the variables.

Jim

Originally Posted by jimblumberg

However, with most systems today, const qualified variables are quite possibly (probably) placed into read only segments to prevent modifications to the variables.

const is checked at compile time.
It is not necessarily (not usually?) placed in read-only memory. (That would be difficult on the stack.)
It can be fooled:

Code:

#include <stdio.h>

int main(void) {
    const char a[] = "abcde";
    printf("%s\n", a);
    // a[0] = 'x';  // compiler will complain if you uncomment this
    *((char*)a) = 'x'; // but this might work (does for me: intel, gcc, linux)
    printf("%s\n", a);
    return 0;
}

I think algorism makes a good point. You can easily cast away const-ness. I think just like the inline decoration, the compiler knows what's actually being written to and will decide on its own const-ness. If anything, const just makes it very easy to maintain, read and reason about your code. The compiler is your instruction generator so it knows what's being written to and what's being read from. const might just be more for the sake of humans.

Sadly, in C some library functions return a non-const to what may have been a const object. E.g.,

Code:

char *strstr(const char *, const char *);

This is a hack and necessitates a conversion from const to non-const within the function. It's not technically UB since strstr doesn't write to the object. But the user of the function could make it UB as in the example below. So you should avoid this kind of thing if possible. I wonder why C doesn't have function overloading?

Code:

#include <stdio.h>
#include <string.h>

int main(void) {
    const char s[] = "abcde";
    printf("%s\n", s);
    char *p = strstr(s, "cd");
    *p = 'x';  // UB
    printf("%s\n", s);
    return 0;
}

Note that if it was

Code:

const char *s = "abcde";

then the data is not stored on the stack but (if possible) in a non-writable page, so the write would cause a segfault.

Thanks for the replies
I’m programming for dsPic micro at the moment with Microchip C30 compiler.
Memory is tight (RAM), and there comes a point where if I make an unsigned char array a const unsigned char array instead,
that was the difference between the program compiling or not. Furthermore, I haven’t yet reached a limitation on constant arrays.
Also, when I removed some variables that were declared with a value, because they were unused, I was able to declare, and use a few more variables.