这里需要extern关键字，const在cpp文件中

Question

If I have in header file

namespace Bob
{
    extern const T x;
};

And in source file

extern const T Bob::x = 123;

Is the second extern in the source file required or optional?

I've searched and found conflicting information.

From this webpage: http://msdn.microsoft.com/en-us/library/357syhfh.aspx

But to get the same behavior in C++, you must declare your const variable [in source file] as:

extern const int i = 2;

Answer 1

Usually, the extern keyword tells the compiler not to define a symbol, because it will be defined somewhere else. So writing eg

namespace Bob {
    extern T x;
}

does not define the variable x , but rather declares it. You can have as many extern declarations as you like. However, if you do not provide a definition the linking will fail. So you have to define

T Bob::x;

somewhere in the code in order to provide the definition.

The const keyword is a little special here, because it implies internal linkage. This means, that the definition of x will not be visible outside the specific compilation unit where it was defined. To alter this behavior you do need to write

    extern const T Bob::x = 123;

if you want x to be const and also reference it from other compilation units.

----yet another edit----
Just to be absolutely clear: If a const variable is supposed to be referenced outside of its compilation unit, then you must explicitly declare it extern .

However, if the declaration is given separately from the definition, then the definition does not necessarily need to specify the keyword extern again. Yet another example for demonstration:

myheader.h

extern const int i;

This declares i a const integer with external linkage, but does not define it.

main.cpp, version 1

#include "myheader.h" //Through the include, the above declaration of `i` comes before its definition.

const int i=123; // Although the `extern` modifier is omitted here,
                 // it's still in effect because we already declared `i` as `extern`
                 // Therefore it makes no difference here, whether or not you specify `extern` again.
                 // The compiler knows this is a definition either way, because of the initialization.

main.cpp, version 2

//#include "myheader.h"

extern const int i=123; // this line is declaration and definition in one, because we did not include
                        // the declaration from myheader.h. Thus, to tell the compiler that you want
                        // `i` with external linkage, you MUST specify `extern`. Otherwise you'll get
                        // internal linkage.

I hope all this now makes sense to you.

Answer 2

You can control the linkage of a symbol with the static and extern keywords. The default linkage is extern for non-const symbols and static (ie internal) for const symbols at namespace scope. This is valid for C++ but not for C (where you would have to declare it as static to make it have internal linkage).

So if you have

const int i = 2;

into a .c file and you use it into another unit by declaring

extern const int i;

that's fine in C since that variable has external linkage by default (and with the extern keyword you're instructing the compiler to find it into another unit), but in C++ the same

const int i = 2;

into a .cpp file (firmstanding what I wrote) has internal linkage and it would have to be defined with

extern const int i = 2;

to explicitly have external linkage and be able to be used into another unit with

extern const int i;

Finally when you initialize a global variable you're always defining it in the module where you're doing it, this means that the following is perfectly valid:

#include <iostream>
using namespace std;

#define T int

extern const T x; // This is a declaration
extern const T x = 123; // This is a definition

int main() {

  std::cout << x; // 123

  return 0;
}

That means the second 'extern' keyword is also unnecessary.