ChatGPT解决这个技术问题 Extra ChatGPT

When to use extern in C++

I'm reading "Think in C++" and it just introduced the extern declaration. For example:

extern int x;
extern float y;

I think I understand the meaning (declaration without definition), but I wonder when it proves useful.

Can someone provide an example?

I've had to provide a definition with extern on several occasions. Microsoft tools produced a link error for missing symbols when the tables in another source file were only defined. The problem was, the table was const and the C++ compiler promoted it to static in the translation unit. See, for example, ariatab.cpp and kalynatab.cpp.
And I think Nik's answer is the correct one because he's the only one who appears to have answered a C++ question. Everyone else appears to have digressed to a C question.
As of C++17, inline may be a better way to accomplish what you want to do with extern. With inline, you can define globals in headers and not worry about multiple definition problems. stackoverflow.com/questions/38043442/…

S
Semnodime

This comes in useful when you have global variables. You declare the existence of global variables in a header, so that each source file that includes the header knows about it, but you only need to “define” it once in one of your source files.

To clarify, using extern int x; tells the compiler that an object of type int called x exists somewhere. It's not the compilers job to know where it exists, it just needs to know the type and name so it knows how to use it. Once all of the source files have been compiled, the linker will resolve all of the references of x to the one definition that it finds in one of the compiled source files. For it to work, the definition of the x variable needs to have what's called “external linkage”, which basically means that it needs to be declared outside of a function (at what's usually called “the file scope”) and without the static keyword.

header:

#ifndef HEADER_H
#define HEADER_H

// any source file that includes this will be able to use "global_x"
extern int global_x;

void print_global_x();

#endif

source 1:

#include "header.h"

// since global_x still needs to be defined somewhere,
// we define it (for example) in this source file
int global_x;

int main()
{
    //set global_x here:
    global_x = 5;

    print_global_x();
}

source 2:

#include <iostream>
#include "header.h"

void print_global_x()
{
    //print global_x here:
    std::cout << global_x << std::endl;
}

Thank you. So, if i declare a global variable in an header file without the extern keyword, the source files that include the header does not see it?
you should not declare global vars in a header, because then when 2 files include the same header file, it won't link (linker will emit an error about "duplicate symbol")
@Aslan986: No, something worse happens. Each source file that includes the header will have its own variable, so each source file will compile independently but the linker will complain because two source files will have the same global identifiers.
When you don't use the word "extern", then now the variable exists. When you use "extern", it's a "hey there is this var somewhere else". Sorry about not answering whether it's a definition or declaration, since I always get confused about these two.
@CCJ: the include guard only works for the source file that is including it. It stops the same header being included twice within the same source file (just in case other headers also include it etc). So even with include guards, each source file that includes the header will still have its own definition.
M
MByD

It is useful when you share a variable between a few modules. You define it in one module, and use extern in the others.

For example:

in file1.cpp:

int global_int = 1;

in file2.cpp:

extern int global_int;
//in some function
cout << "global_int = " << global_int;

This answer is more correct than the accepted one, as it does not make use of header file and it states clearly that it is useful only when sharing between few modules. For larger applications is better to use for example a ConfigManager class.
Is there any gotchas when namespaces are involved, global_int is in the global namespace, if I were to use it in file2.cpp in some namespace section I'd have to scope it correct? ie namespace XYZ{ void foo(){ ::global_int++ } };
@Zac: On the other hand, by not declaring a global variable in a header, you've inadvertently made it much more difficult to determine where it is actually defined. Usually if you see a global variable declared in abc.h, there's a good chance it'll be defined in abc.cpp. A good IDE will always help, but well-organised code is always a better solution.
without extern in file2.cpp , still can access to global_int after include. why i need to have it?
@TomSawyer you don't want to include in this case. file1.cpp and file2.cpp are supposed to be different compilation units. It would be very uncommon practice to include a .cpp file.
B
Brambor

It's all about the linkage.

The previous answers provided good explanations about extern.

But I want to add an important point.

You ask about extern in C++, not in C and I don't know why there is no answer mentioning the case when extern comes with const in C++.

In C++, a const variable has internal linkage by default (not like C).

So this scenario will lead to linking error:

Source 1 :

const int global = 255; //wrong way to make a definition of global const variable in C++

Source 2 :

extern const int global; //declaration

It needs to be like this:

Source 1 :

extern const int global = 255; //a definition of global const variable in C++

Source 2 :

extern const int global; //declaration

Why it's a wrong while it works in c++ without include 'extern' in the definition part ?
I don't seem to encounter that linking error in VIsual Studio with Visual Micro. What am I missing?
@lartist93 @Craig.Feied I believe you may need to check again carefully. Even in case compiler does not inform linking error, could you check that both objects in both source are same without extern in definition ? You could do that by printing out the value of global in source 2.
Confirm, in MSVS 2018 there is a linking error if extern is omitted in const int global = 255;.
I've seen extern used in C++ server code where the client is written in C. I always figured it was done to expose the C++ function to C which wouldn't otherwise be able to link to it. Is this correct ?
M
Marlon

This is useful when you want to have a global variable. You define the global variables in some source file, and declare them extern in a header file so that any file that includes that header file will then see the same global variable.


Anyway this does not sound very OOP , I would put them into a singleton class... or a function returning a local static value...