Why does "extern const int n;" not work as expected?

Question

My project consists of only two source files:

a.cpp:

const int n = 8;

b.cpp:

extern const int n;

int main()
{
    // error LNK2001: unresolved external symbol "int const n" (?n@@3HB)
    int m = n; 
}

I know there are several methods to make it work; however, I just wonder WHY it does't work?

John

Try changing a.cpp to extern const int n = 8; AFAIK const implies static, although I don't really know. – Larrigan

Does a.cpp need to see the decleration of n with the extern keyword? – Gringo

You didnt tell us what you link and how... – Phenomenology

Yup, it implies internal linkage. – Papst

@Joachim, Yes. I compiled and linked them together. – John

If these were c files compiled with gcc it would work fine. There's no reason to have this tagged C – Vachell

Put the extern const int n; in a.h and include that in both cpp files. – Nebulous

@Bo, I just wonder why that doesn't work rather than how to make it work. – John

@John - In C++ (but possibly not in C) a const int is the same as a static const int. This means that the value in a.cpp isn't visible outside that file, so b.cpp can't see it. – Nebulous

Answer 1

It's because const implies internal linkage by default, so your "definition" isn't visible outside of the translation unit where it appears.

In this case, by far the best solution is to put the declaration (extern int const n;) in a header file, and include that in both a.cpp and b.cpp. The linkage is determined by the first declaration the compiler sees, so the later definition in a.cpp will have the correct (external) linkage.

Alternatively, you can force the linkage in the definition:

extern int const n = 8;

Despite the extern, this is still a definition; anything with an initializer outside of a class definition is a definition.

Tax

Answer 2

const and constexpr variables in C++ have internal linkage (and thus aren't accessible in other compilation unit) if they aren't also declared extern (either in the definition or in a previous declaration).

In C, it isn't the case (well C hasn't constexpr) so your code is valid, and more you can put extern on a definition.

So if you want to write code which is both C and C++ (and the two declarations should probably come from the same header as James pointed out):

// a.cpp
extern const int n;
const int n = 8;

// b.cpp
extern const int n;

int main()
{

    int m = n; 
}

if you don't

// a.cpp
extern const int n = 8;

is also possible

Aldwon

Answer 3

Declare it extern in a.cpp and just use without extern in b.cpp:

a.h

extern const int n ;

a.cpp

#include "a.h"
...
const int n= 8

b.cpp:

#include "a.h"
...


int main()
{        
    int m = n; 
}

Alika

Hmm, used to do this with a header file. Including the header with the extern is the simplest way. – Alika

Actually, you should remove const int n; from b.cpp. The included header is whats needed. – Ranite

Answer 4

To share a const object among multiple files, you must define the variable as extern.

To define a single instance of a const variable, we use the keyword extern on both its definition and declaration(s):

From these rules you just need to add the extern keyword in your definition. you already have it in declaration.

Aliunde

Answer 5

If the other answers here do not do the trick, it may be the case that you have your definitions in different namespaces... if the compilation passes, and you get an undefined symbol linker error:

• check the namespace of the undefined symbol; that's the effective namespace for the extern const int n declaration.
• ensure that's your effective namespace where you make the const int n = 8 definition.

Transcontinental

Answer 6

I had the same problem, with extern const, but I tried using #define and it worked.

I think that declaring a constant as a variable should not be a very recommended practice, perhaps it could happen that someone tries to change the value of the variable and ends up corrupting something.

From what I understand, the use of extern is to find variables in source files (.c/.cpp), when only the header (.h/.hpp) is included.

header1.hpp file:

#define abc 1

source2.cpp file:

#include "header1.hpp"

It might be good to remember to use include guards:

#ifndef _HEADER1_HPP_
#define _HEADER1_HPP_
#include "main.hpp"

#define abc 1

#endif // #ifndef _HEADER1_HPP_

Nichy