Our website uses cookies to enhance your browsing experience.
Accept
to the top
close form

Fill out the form in 2 simple steps below:

Your contact information:

Step 1
Congratulations! This is your promo code!

Desired license type:

Step 2
Team license
Enterprise license
** By clicking this button you agree to our Privacy Policy statement
close form
Request our prices
New License
License Renewal
--Select currency--
USD
EUR
* By clicking this button you agree to our Privacy Policy statement

close form
Free PVS‑Studio license for Microsoft MVP specialists
* By clicking this button you agree to our Privacy Policy statement

close form
To get the licence for your open-source project, please fill out this form
* By clicking this button you agree to our Privacy Policy statement

close form
I am interested to try it on the platforms:
* By clicking this button you agree to our Privacy Policy statement

close form
check circle
Message submitted.

Your message has been sent. We will email you at


If you haven't received our response, please do the following:
check your Spam/Junk folder and click the "Not Spam" button for our message.
This way, you won't miss messages from our team in the future.

>
>
>
Linkage

Linkage

Sep 02 2021

Linkage is an identifier's property. It allows the compiler in some cases to create one common entity for several same-name declarations in different translation units. Together with the scope, linkage determines from which translation units and their scopes you can access the entity.

There are 4 types of linkage: no linkage, internal linkage, external linkage, and module linkage.

No linkage

The following entities declared in the block scope have no linkage:

  • Local variables without the extern specifier;
  • Local classes and their methods;
  • Other identifiers, except function names, such as aliases or enumerations.

For each name with no linkage the compiler generates a separate object.

Internal linkage

Any identifier with internal linkage is accessible throughout the current translation unit. For several declarations of the same name with internal linkage within one translation unit, the compiler generates a single object. For identifiers of the same name with internal linkage in different translation units, the compiler creates different objects.

The following entities declared in a namespace have internal linkage:

  • Variables and functions declared static;
  • Non-template variables declared const and neither declared inline and volatile, nor extern. Additionally, previously such a variable should not be declared to have external linkage;
  • Data members of an anonymous union;
  • Any names in an unnamed namespace, including those declared extern.

External linkage

Any identifier with external linkage is accessible from other translation units. For the identifiers of the same name with external linkage, the compiler creates a single object.

The identifier with external linkage also has a language linkage, through which translation units written in different programming languages link together.

The following entities declared in a namespace have external linkage:

  • Functions without the static specifier;
  • Variables without the const and extern specifiers;
  • Variables declared extern;
  • Enumerations;
  • Names of classes and their methods, as well as nested classes and enumerations;
  • Functions declared in a class with the friend specifier;
  • Templates declared static unless they are function or variable templates.

The following entities declared in the block scope have external linkage:

  • Variables declared extern;
  • Functions.

Module linkage

Starting from the C++20 standard, an identifier can have module linkage. Such an identifier is accessible from the translation units belonging to the module in which it is declared. Accordingly, for several identical declarations of the same name entities with module linkage, one object will be created within the same module.

Identifiers have module linkage when they are attached to a named module and not declared with the export keyword. Code example:

// cute_module_main.h
module CuteModule:moduleVariable;

int moduleVariable = 0;

// cute_module_calculator.h
export module CuteModule;

import :moduleVariable;

export int GetSquaredModuleVariable() {
    return ::moduleVariable * ::moduleVariable;
}

Here, moduleVariable has module linkage.

Popular related articles


Comments (0)

Next comments next comments
close comment form