Thread: extern const?Please help

I just wonder why the "const" keyword is required??Can anyone please tell me?

const is required because there's no implicit conversion from const int * to int *. int * mean that you can modify the element to which the pointer points. const int * mean that you can't modify the element to which the pointer points. Your array is defined as being an array of const elements, so you can't modify the element the array holds; if you can't, the functions using the array can't either.

Can anyone tell me, would it cause any problems by adding the "extern" to its declarartion?
Why is it an "extern const" is needed in the declaration instead of just the "const"?

It won't cause any problem to add "extern" to the definition. In fact, you want the extern keyword to be there. And you certainly want the extern keyword to show in every declaration. In C++, const global variables are static by default (contrary to C, where they are extern by default). By defining a variable as extern, you make it available to other source files.

This can be a bit confusing. If you look on google for extern/static keywords, you might find something enlightening.

Const is used to tell the compiler that the this variable will not/cannot be modified. There is a difference between "const T" and "T", because the compiler treats them as different types.
The "extern" keyword is used to typically tell the compiler that a variable is indeed defined, but not within the current source file (or compilation unit). To help the compiler (and the linker!), you must put the EXACT same type.

Example 1:
const int myint = 5;
extern const int myint;
extern int myint; // Will cause a linking error

Example 2:
int myint = 5;
extern int myint; // OK
extern const int myint; // Will cause a linking error

Also, do not put globals inside headers, because the compiler will happily include the same global in multiple source files, but when the linker encounters them, it will give an error.
With normal constant, simple values, such as const int, it's OK to define them in a header because the compiler will treat them as constant expressions. That means it will basically just replace the variable name with the variable contents wherever it encounters it. The variable will actually never be created. I don't know if this applies to arrays, however.

In C++, constant global variables are automatically static; that is, they are restricted to the scope of the file in which they are declared. This means that you can declare a constant variable of the same name in multiple source files, and it will compile.

(In C, it's a little different.)

None of this applies to non-constant global variables in C++, unless you explicitly make them static, too. (But that might not do what you want, because such variables behave differently.)

It's worth noting that you can do this:

Code:

extern int x;
int x = 3;

In fact, you can precede a declaration with any number of identical (except for initialization) extern declarations.

This means that you can do this in a header file

Code:

extern int x;

and then in one source file, actually declare the variable:

Code:

int x = 4;  // initialization optional

You can then include that header file in any source file that needs to use the global variable, even the source file that actually declares the global variable.

Here is another question.

In test.c

Code:

extern const int try_table[] = {1, 2, 3};

In test_user_def.h

Code:

extern int try_table[];   // Note that this array is defined without "const" keyword

In try_source.c

Code:

...
#include "test_user_def.h"
...
...

void function_test()
{
   ....
   ....
   testTry_table(try_table);
   ....
}

The above code were compiled successfully.

I just wonder why the compilation was sucessful when try_table[] was defined without the "const" keyword.
For some of other const global variables, if the variables were defined without "const", the compiler complains with "declaration is incompatible....".

You should have const in both places. Also, I would expect that if you include test_user_def.h into your test.c file, the compiler will complain about inconsistent const-ness.

Unfortunately, the linker [particularly in C, as opposed to C++] symbols do not contain information about type. For example, we can do this:

Code:

// foo.c
#include <stdio.h>
int foo()
{
    printf("Hello, world\n");
}

// main.c
#include <stdio.h>
int main()
{
    extern int foo[];
    printf("foo[0] = &#37;d\n", foo[0]);
    return 0;
}

This won't make much sense, but the compiler WILL allow it.

--
Mats

The const keyword is used to tell the compiler that "I'm not going to change this". The compiler will then use that information for two purposes:
1. Validating that you are not breaking your own rule of not changing it.
2. Optimize code that uses that constant data by knowing that it doesn't change (for example, a const variable is not expected to change across a function call, so if it is held in a local register, the compiler won't have to re-load it after the function call).

Naturally, if you "loose" the const-ness, then you are breaking your own rules, because after you have lost the const, the data is possibly going to change. It is harmless to "add" const to something, it doesn't change what the compilers assumptions are.

So whenever something starts out as const, it should be kept as const. If you have something that wasn't const from the beginning, you can make it const. But you can't "unconst" something. If you REALLY know what you are doing [and you should check at least twice that you are SURE that you know what you are doing], then you can use a cast to remove const [in C++ there is a special const_cast<T>(expr) form] - but it's NASTY and usually incorrect to "loose" the const.

As a summary, you should never REMOVE const. You should never assign the address of something const to a non-const pointer. Never pass a const pointer to a non-const parameter of a function.

--
Mats