Commit ce019b2

title: "extern (C++) | Microsoft Docs"

ms.custom: ""

ms.date: "04/12/2018"

ms.reviewer: ""

ms.suite: ""

ms.technology: ["cpp-language"]

ms.tgt_pltfrm: ""

ms.topic: "language-reference"

f1_keywords: ["extern", "extern_CPP"]

dev_langs: ["C++"]

helpviewer_keywords: ["extern keyword [C++], linkage to non-C++ functions", "declarations, external", "external linkage, extern modifier"]

ms.assetid: 1e2f0ae3-ae98-4410-85b5-222d6abc865a

caps.latest.revision: 11

author: "mikeblome"

ms.author: "mblome"

manager: "ghogen"

ms.workload: ["cplusplus"]

The **extern** keyword is applied to a global variable, function or template declaration to specify that the name of that thing has *external linkage*. For background information on linkage and why the use of global variables is discouraged, see [Program and linkage](program-and-linkage-cpp.md).

The **extern** keyword has four meanings depending on the context:

1. in a non-const global variable declaration, **extern** specifies that the variable or function is defined in another translation unit. The **extern** must be applied in all files except the one where the variable is defined.

1. in a const variable declaration, it specifies that the variable has external linkage. The **extern** must be applied to all declarations in all files. (Global const variables have internal linkage by default.)

1. **extern "C"** specifies that the function is defined elsewhere and uses the C-language calling convention. The extern "C" modifier may also be applied to multiple function declarations in a block.

1. in a template declaration, it specifies that the template has already been instantiated elsewhere. This is an optimization that tells the compiler that it can re-use the other instantiation rather than creating a new one at the current location. For more information about this use of **extern**, see [Templates](templates-cpp.md).

When the linker sees **extern** before a global variable declaration, it looks for the definition in another translation unit. Declarations of non-const variables at global scope are external by default; only apply **extern** to the declarations that don't provide the definition.

int i = 42; // declaration and definition

extern int i; // declaration only. same as i in FileA

extern int i; // declaration only. same as i in FileA

int i = 43; // LNK2005! 'i' already has a definition.

extern int i = 43; // same error (extern is ignored on definitions)

A **const** global variable has internal linkage by default. If you want the variable to have external linkage, apply the **extern** keyword to definition as well as to all other declarations in other files:

extern const int i = 42; // extern const definition

extern const int i; // declaration only. same as i in FileA

In Visual Studio 2017 version 15.3 and earlier, the compiler always gave a constexpr variable internal linkage even when the variable was marked extern. In Visual Studio 2017 version 15.5, a new compiler switch ([/Zc:externConstexpr](../build/reference/zc-externconstexpr.md)) enables correct standards-conforming behavior. Eventually this will become the default.

extern constexpr int x = 10; //error LNK2005: "int const x" already defined

If a header file contains a variable declared extern constexpr, it needs to be marked **__declspec(selectany)** in order to correctly have its duplicate declarations combined:

extern constexpr __declspec(selectany) int x = 10;

If a function has more than one linkage specification, they must agree; it is an error to declare functions as having both C and C++ linkage. Furthermore, if two declarations for a function occur in a program — one with a linkage specification and one without — the declaration with the linkage specification must be first. Any redundant declarations of functions that already have linkage specification are given the linkage specified in the first declaration. For example:

extern "C" int CFunc1();

...

int CFunc1(); // Redeclaration is benign; C linkage is

// retained.

int CFunc2();

...

extern "C" int CFunc2(); // Error: not the first declaration of

// CFunc2; cannot contain linkage

// specifier.

title: "Header files (C++) | Microsoft Docs"

ms.custom: ""

ms.date: "04/20/2018"

ms.reviewer: ""

ms.suite: ""

ms.technology: ["cpp-language"]

ms.tgt_pltfrm: ""

ms.topic: "language-reference"

dev_langs: ["C++"]

helpviewer_keywords: ["header files [C++]"]

author: "mikeblome"

ms.author: "mblome"

manager: "ghogen"

ms.workload: ["cplusplus"]

The names of program elements such as variables, functions, classes, and so on must be declared before they can be used. For example, you can't just write `x = 42` without first declaring 'x'.

int x; // declaration

x = 42; // use x

The declaration tells the compiler whether is an **int**, a **double**, a **function**, a **class** or some other thing. Furthermore, each name must be declared (directly or indirectly) in every .cpp file in which it is used. When you compile a program, each .cpp file is compiled independently into a compilation unit. The compiler has no knowledge of what names are declared in other compilation units. That means that if you define a class or function or global variable, you must provide a declaration of that thing in each additional .cpp file that uses it. Each declaration of that thing must be exactly identical in all files. A slight inconsistency will cause errors, or unintended behavior, when the linker attempts to merge all the compilation units into a single program.

To minimize the potential for errors, C++ has adopted the convention of using *header files* to contain declarations. You make the declarations in a header file, then use the #include directive in every .cpp file or other header file requires that declaration. The #include directive inserts a copy of the header file directly into the .cpp file prior to compilation.

The following example shows a common way to declare a class and then use it in a different source file. We'll start with the header file, **my_class.h**. It contains a class definition, but note that the definition is incomplete; the member function `do_something` is not defined:

namespace N

{

class my_class

{

public:

void do_something();

};

}

Next, create an implementation file (typically with a .cpp or similar extension). We'll call the file my_class.cpp and provide a definition for the member declaration. We add an `#include` directive for "my_class.h" file in order to have the my_class declaration inserted at this point in the .cpp file, and we include **\<iostream>** to pull in the declaration for `std::cout`. Note that quotes are used for header files in the same directory as the source file, and angle brackets are used for standard library headers. Also, many standard library headers do not have .h or any other file extension.

In the implementation file, we can optionally use a **using** statement to avoid having to qualify every mention of "my_class" or "cout" with "N::" or "std::". Don't put **using** statements in your header files!

#include "my_class.h" // header in local directory

#include <iostream> // header in standard library

using namespace N;

using namespace std;

void my_class::do_something()

{

cout << "Doing something!" << endl;

}

Now we can use `my_class` in another .cpp file. We #include the header file so that the compiler pulls in the declaration. All the compiler needs to know is that my_class is a class that has a public member function called `do_something()`.

#include "my_class.h"

using namespace N;

int main()

{

my_class mc;

mc.do_something();

return 0;

}

After the compiler finishes compiling each .cpp file into .obj files, it passes the .obj files to the linker. When the linker merges the object files it finds exactly one definition for my_class; it is in the .obj file produced for my_class.cpp, and the build succeeds.

Typically, header files have an *include guard* or a **#pragma once** directive to ensure that they are not inserted multiple times into a single .cpp file.

// my_class.h

#ifndef MY_CLASS_H // include guard

#define MY_CLASS_H

namespace N

{

class my_class

{

public:

void do_something();

};

}

#endif /* MY_CLASS_H */

Because a header file might potentially be included by multiple files, it cannot contain definitions that might produce multiple definitions of the same name. The following are not allowed, or are considered very bad practice:

- built-in type definitions at namespace or global scope

- non-inline function definitions

- non-const variable definitions

- aggregate definitions

- unnamed namespaces

- using directives

Use of the **using** directive will not necessarily cause an error, but can potentially cause a problem because it brings the namespace into scope in every .cpp file that directly or indirectly includes that header.

The following example shows the various kinds of declarations and definitions that are allowed in a header file:

#pragma once

#include <vector> // #include directive

#include <string>

namespace N // namespace declaration

{

inline namespace P

{

//...

}

enum class colors : short { red, blue, purple, azure };

const double PI = 3.14; // const and constexpr definitions

constexpr int MeaningOfLife{ 42 };

constexpr int get_meaning()

{

static_assert(MeaningOfLife == 42, "unexpected!"); // static_assert

return MeaningOfLife;

}

using vstr = std::vector<int>; // type alias

extern double d; // extern variable

#define LOG // macro definition

#ifdef LOG // conditional compilation directive

void print_to_log();

#endif

class my_class // regular class definition,

{ // but no non-inline function definitions

friend class other_class;

public:

void do_something(); // definition in my_class.cpp

inline void put_value(int i) { vals.push_back(i); } // inline OK

private:

vstr vals;

int i;

};

struct RGB

{

short r{ 0 }; // member initialization

short g{ 0 };

short b{ 0 };

};

template <typename T> // template definition

class value_store

{

public:

value_store<T>() = default;

void write_value(T val)

{

//... function definition OK in template

}

private:

std::vector<T> vals;

};

template <typename T> // template declaration

class value_widget;

}