6.11 — Scope, duration, and linkage summary

By Alex on April 19th, 2016 | last modified by nascardriver on May 29th, 2020

The concepts of scope, duration, and linkage cause a lot of confusion, so we’re going to take an extra lesson to summarize everything. Some of these things we haven’t covered yet, and they’re here just for completeness / reference later.

Scope summary

An identifier’s scope determines where the identifier can be accessed within the source code.

• Variables with block scope / local scope can only be accessed within the block in which they are declared (including nested blocks). This includes:
• Local variables
• Function parameters
• User-defined type definitions (such as enums and classes) declared inside a block
• Variables and functions with global scope / file scope can be accessed anywhere in the file. This includes:
• Global variables
• Functions
• User-defined type definitions (such as enums and classes) declared inside a namespace or in the global scope

Duration summary

A variable’s duration determines when it is created and destroyed.

• Variables with automatic duration are created at the point of definition, and destroyed when the block they are part of is exited. This includes:
• Local variables
• Function parameters
• Variables with static duration are created when the program begins and destroyed when the program ends. This includes:
• Global variables
• Static local variables
• Variables with dynamic duration are created and destroyed by programmer request. This includes:
• Dynamically allocated variables

Linkage summary

An identifier’s linkage determines whether multiple declarations of an identifier refer to the same identifier or not.

• An identifier with no linkage means the identifier only refers to itself. This includes:
• Local variables
• User-defined type definitions (such as enums and classes) declared inside a block
• An identifier with internal linkage can be accessed anywhere within the file it is declared. This includes:
• Static global variables (initialized or uninitialized)
• Static functions
• Const global variables
• Functions declared inside an unnamed namespace
• User-defined type definitions (such as enums and classes) declared inside an unnamed namespace
• An identifier with external linkage can be accessed anywhere within the file it is declared, or other files (via a forward declaration). This includes:
• Functions
• Non-const global variables (initialized or uninitialized)
• Extern const global variables
• Inline const global variables
• User-defined type definitions (such as enums and classes) declared inside a namespace or in the global scope

Identifiers with external linkage will generally cause a duplicate definition linker error if the definitions are compiled into more than one .cpp file (due to violating the one-definition rule). There are some exceptions to this rule (for types, templates, and inline functions and variables) -- we’ll cover these further in future lessons when we talk about those topics.

Also note that functions have external linkage by default. They can be made internal by using the static keyword.

Variable scope, duration, and linkage summary

Because variables have scope, duration, and linkage, let’s summarize in a chart:

Type	Example	Scope	Duration	Linkage	Notes
Local variable	int x;	Block	Automatic	None
Static local variable	static int s_x;	Block	Static	None
Dynamic variable	int *x { new int{} };	Block	Dynamic	None
Function parameter	void foo(int x)	Block	Automatic	None
External non-constant global variable	int g_x;	File	Static	External	Initialized or uninitialized
Internal non-constant global variable	static int g_x;	File	Static	Internal	Initialized or uninitialized
Internal constant global variable	constexpr int g_x { 1 };	File	Static	Internal	Must be initialized
External constant global variable	extern constexpr int g_x { 1 };	File	Static	External	Must be initialized
Inline constant global variable	inline constexpr int g_x { 1 };	File	Static	External	Must be initialized
Internal constant global variable	const int g_x { 1 };	File	Static	Internal	Must be initialized
External constant global variable	extern const int g_x { 1 };	File	Static	External	Must be initialized at definition
Inline constant global variable	inline const int g_x { 1 };	File	Static	External	Must be initialized

Forward declaration summary

You can use a forward declaration to access a function or variable in another file:

Type	Example	Notes
Function forward declaration	void foo(int x);	Prototype only, no function body
Non-constant global variable forward declaration	extern int g_x;	Must be uninitialized
Const global variable forward declaration	extern const int g_x;	Must be uninitialized
Constexpr global variable forward declaration	extern constexpr int g_x;	Not allowed, constexpr cannot be forward declared

What the heck is a storage class specifier?

When used as part of an identifier declaration, the static and extern keywords are called storage class specifiers. In this context, they set the storage duration and linkage of the identifier.

C++ supports 4 active storage class specifiers:

Specifier	Meaning	Note
extern	static (or thread_local) storage duration and external linkage
static	static (or thread_local) storage duration and internal linkage
thread_local	thread storage duration	Introduced in C++11
mutable	object allowed to be modified even if containing class is const
auto	automatic storage duration	Deprecated in C++11
register	automatic storage duration and hint to the compiler to place in a register	Deprecated in C++17

The term storage class specifier is typically only used in formal documentation.

6.12 -- Using statements

Index

6.10 -- Static local variables

C++ Tutorial |  Print This Post

103 comments to 6.11 — Scope, duration, and linkage summary

• learning

  June 23, 2019 at 2:04 am · Reply

  "Second, astute readers may note that global types have external linkage, but their definitions don’t cause a linker error when included in multiple files. This is because types, templates, and extern inline functions have an exemption that allows them to be defined in more than one file, so long as the definitions are identical. Otherwise, they wouldn’t be of much use."
  I don't get this, can someone explain this using a example please?

  • nascardriver

    June 23, 2019 at 2:12 am · Reply

    class.hpp

    1 2 3 4

    // global type class C {};   int i{};

    learning.cpp

    1	#include "class.hpp"

    main.cpp

    1 2 3 4 5 6

    #include "class.hpp"   int main(void) {   return 0; }

    class.hpp was included in multiple files, so `C` and `i` are defined multiple times.
    `i` causes an error, because variables can only be defined once.
    `C` is fine, because types can be defined in multiple files.

    Have there even been any custom types up to this point?

    • learning

      June 23, 2019 at 2:27 am · Reply

      No but now I understand this, thanks a lot!

• Enso

  April 11, 2019 at 6:54 am · Reply

  Lesson 4.2 (Global variables and linkage) states:

  „A variable with internal linkage is called an internal variable (or static variable).“

  And this lessons states:

  „A static duration variable (also called a “static variable”)“

  So „static variable“ has actually two different meanings? Very confusing..

  • Alex

    April 11, 2019 at 8:51 am · Reply

    Static variable normally refers to static duration, not internal linkage. I've amended lesson 4.2.

    • Enso

      April 12, 2019 at 12:56 am · Reply

      Ok, thank you for the clarification and also for creating and maintaining this awesome website!

• maatrix

  March 22, 2019 at 1:43 am · Reply

  globals.cpp :

  1 2 3

  namespace globals {     constexpr double pi{ 3.1415 }; }

  globals.h :

  1 2 3 4 5 6 7 8

  #ifndef GLOBALS_H #define GLOBALS_H   namespace globals{     extern double pi; }   #endif

  main.cpp :

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  #include <iostream> #include <cmath> #include "globals.h"   double vStozka(double r, double h) {     return (((globals::pi * pow(r, 2)) * 1/3) * h); }   int main() {         std::cout << "Podaj r: ";     double h{}, r{};     std::cin >> r;     std::cout << "Podaj h: ";     std::cin >> h;     std::cout << "V stozka wynosi: " << vStozka(r, h);     return 0; }

  I'm getting this error:
  Error    LNK2001    unresolved external symbol "double globals::pi" (?pi@globals@@3NA)    learncpp    C:\Users\matri\Desktop\learncpp\learncpp\learncpp\main.obj    1    
  If I make pi non const everything is ok, but I want pi to be constant, what should I do?

  • nascardriver

    March 22, 2019 at 8:17 am · Reply

    @pi in globals.cpp and @pi in globals.h are different. If you want it to be constexpr, you don't need to declare it extern.

    1 2 3 4 5 6 7 8 9

    #ifndef GLOBALS_H #define GLOBALS_H namespace globals {   constexpr double pi{ 3.1415 }; } #endif

• Benur21

  January 18, 2019 at 12:12 pm · Reply

  "Variables with static duration are created when the program begins and destroyed when the program ends. This includes:
  Global variables
  Static local variables"

  Static local variables are created when their line is executed first time, right? Not when the program begins.

  • nascardriver

    January 19, 2019 at 8:14 am · Reply

    Memory is reserved when the program starts. They are initialized when execution reaches their declaration.

    1 2 3 4 5 6 7 8 9 10

    #include <iostream>   int main(void) {   // @s_i exists already, but doesn't have a value     static int s_i{ 123 }; // s_i gets the value 123     return 0; }

• Daniel Hogg

  November 8, 2018 at 5:22 am · Reply

  Hi Alex,

  I can't figure out why the following statements seem to contradict.

  "
  #Identifiers with external linkage will cause a duplicate definition linker error if the definitions are compiled into more than one .cpp file.

  #Second, astute readers may note that global types have external linkage, but their definitions don’t cause a linker error when included in multiple files. This is because types, templates, and extern inline functions have an exemption that allows them to be defined in more than one file, so long as the definitions are identical. Otherwise, they wouldn’t be of much use "

  Please help clarify.

  • Alex

    November 10, 2018 at 9:01 am · Reply

    What part seems to contract? Maybe try re-reviewing the one-definition rule in lesson 1.7 and see if that helps clarify.

• Shri

  October 17, 2018 at 8:33 am · Reply

  Are Static duration variables created at the start of program or at the place where they are initialized? I do not understand how they can be created before they are initialized.

  For example if you have this program:

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  int functiona() { some code }   int functionb() { static int num2{0}; return ++num2; }   int main () { int a{functiona()}, b {functionb()}; int c = a+b; }

  shouldn't variable num2 be created only when functionb() is called?

  • Alex

    October 17, 2018 at 1:11 pm · Reply

    The C++ spec gives a lot of leeway as to when variables are created and initialized, and this is no exception.

    Static duration local variables are generally "created" at the start of the program. By created, I mean that memory is set aside for those variables.

    Static duration local variables may be initialized before the block containing them is entered, or they may be initialized on first entry.

    > shouldn't variable num2 be created only when functionb() is called?

    No, memory for num2 is typically reserved at the start of the program, and the initialization can happen upon creation (if the initializer is a constant) or on first call.

    • Shri

      October 17, 2018 at 9:24 pm · Reply

      Thanks for replying Alex!

      I have a followup question. Would initialization happen on creation for any type of constant or only compile time constants?

      • Alex

        October 18, 2018 at 9:35 am · Reply

        Initialization could happen on creation for any type of constant if creation were deferred to the point of initialization.

        That said, the compiler has a huge amount of leeway in terms of when constants are created and initialized, and different compilers may do different things in different cases. The compiler also has leeway to not create compile-time constants as objects at all, and instead just embed the constant value directly in the code. This isn't something you really need to worry about, as the compiler will just "make it work", though it's certainly an interesting line of inquiry.

        • Shri

          October 22, 2018 at 7:43 pm · Reply

          Thanks a lot for the reply Alex!

• Matt

  March 31, 2018 at 12:15 am · Reply

  With chapter 8 introducing additional meanings for several things, I decided to come back and review scope, duration, and linkage, etc. and their associated keywords (const, constexpr, static, extern, etc.)

  Here's some code I wrote while studying the behavior of various variables/definitions/uses.  Maybe someone will find it useful.

  Regards,
  Matt

  example.cpp

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

  #include "stdafx.h" #include <iostream>   // GLOBAL VARIABLES OUTSIDE OF MAIN.CPP // All have file scope and static duration, but linkage varies   // external linkage, non constant // value can be changed from outside this file // requires forward declaration using keyword extern int test1{ 1 };   // internal linkage (constant) // cannot be seen in other files even with forward declaration const int test2{ 2 };   // external linkage (constant) // requires forward declaration using keyword extern extern const int test3{ 3 };   // internal linkage (value can be changed from within this file) // cannot be seen in other files even with forward declaration static int test4{ 4 };   // static keyword unnecessary, const global variable already has internal linkage // this has the same functionality as test2 static const int test5{ 5 };   // Note: test1, test2, test3, test4, and test5 all have definitions in this file // All conflicting definitions (definitions with the same variable name that have external linkage) // in main.cpp have been commented out, so this function will print the definitions in this file. // HOWEVER: we changed test1 from main() which affected our global variable here! void exampleCppPrint() {     std::cout << "example.cpp test1= " << test1 << '\n'; // prints test1 from example.cpp     std::cout << "example.cpp test2= " << test2 << '\n'; // prints test2 from example.cpp     std::cout << "example.cpp test3= " << test3 << '\n'; // prints test3 from example.cpp     std::cout << "example.cpp test4= " << test4 << '\n'; // prints test4 from example.cpp     std::cout << "example.cpp test5= " << test5 << '\n'; // prints test5 from example.cpp }   //Note: this function cannot be called from another file even if a forward declaration provided static void exampleCppStatic() {     std::cout << "We can't call a static function from another file.\n"; }

  main.cpp

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

  #include "stdafx.h" #include <iostream>   // FORWARD DECLARATIONS (or attempted forward declarations) and GLOBAL VARIABLES: // For each test variable, we check if it can be seen from exampleVariables.cpp (external linkage). // If it can, we print it, if it cannot (internal linkage), we give it a new definition here.   extern int test1; // Okay, test1 has external linkage (seen from example.cpp) //int test1{ 11 }; // Linker error (multiple definitions)   //extern const int test2; // Linker error (test2 has internal linkage) const int test2{ 22 }; // We can't see test2 in example.cpp so we can define it here   extern const int test3; // Okay, test3 has external linkage //extern const int test3{ 33 }; // Linker error (multiple definitions)   //extern int test4; // Linker error (test4 has internal linkage) static int test4{ 44 }; // We can't see test4 in example.cpp so we can define it here   //extern const int test5; // Linker error (test5 has internal linkage) static const int test5{ 55 }; // We can't see test5 in example.cpp so we can define it here   // Forward declaration for function in example.cpp void exampleCppPrint();   // Forward declaration for function in example.cpp void exampleCppStatic();   // FUNCTION PARAMETER: // x: block scope, automatic duration, no linkage // Note: printSum()'s x and getInteger()'s x don't conflict because they have no linkage and block scope void printSum(int x) // x created here {     std::cout << "The sum is: " << x << '\n'; } // x destroyed here   // FUNCTION PARAMETER: // input: block scope, automatic duration, no linkage void sumInputs(int input) // input created here {     // STATIC LOCAL VARIABLE:     // sum: block scope, static duration, no linkage     static int sum{ 0 }; // sum created at start of program     sum += input;     printSum(sum); } // input destroyed here, sum is not destroyed!   // LOCAL VARIABLE: // x: block scope, automatic duration, no linkage // Note: printSum()'s x and getInteger()'s x don't conflict because they have no linkage and block scope int getInteger() {     std::cout << "Enter an integer: ";     int x{ 0 }; // x created here     std::cin >> x;     return x; } // x destroyed here   int main() { // sum created here, all copies of test1-test5 created here     int n{ getInteger() }; // n created here     sumInputs(n);     sumInputs(getInteger()); // Note: sum wasn't destroyed       int *p{ new int{5} }; // dynamic duration, p created here     delete p; // p destroyed here       std::cout << "In main, test1= " << test1 << '\n'; // prints test1 from example.cpp     test1 += 100; // attempt to change test1's value     std::cout << "In main, test1= " << test1 << '\n'; // test1 not const, change successful       std::cout << "In main, test2= " << test2 << '\n'; // prints test2 from main.cpp     //test2 += 100; // Error: expression must be a modifyable value (cant change a const)       std::cout << "In main, test3= " << test3 << '\n'; // prints test3 from example.cpp     //test3 += 100; // Error: expression must be a modifyable value (can't change a const)       std::cout << "In main, test4= " << test4 << '\n'; // prints test4 from main.cpp     test4 += 100; // attempt to change test4's value     std::cout << "In main, test4= " << test4 << '\n'; // test4 not const, change successful       std::cout << "In main, test5= " << test5 << '\n'; // prints test5 from main.cpp     //test5 += 100; // Error: expression must be a modifyable value (can't change a const)       exampleCppPrint(); // We can call this function because it is not a static function       //exampleCppStatic(); // Linker error: cannot call a static function from another file       return 0; } // n destroyed here, sum destroyed here, all copies of test1-test5 destroyed here

• David

  March 29, 2018 at 9:53 am · Reply

  Hi Alex! Here's a question: is it good practice to give variables the most limited scope as necessary? For example, take the following snippet:

  1 2 3 4 5 6

  for (int i{0}; i < 10; ++i) { // do something 10 times to tmp }   // tmp no longer needed for the rest of the program

  Would it be better to
  a) declare tmp inside the loop (but then tmp gets created each iteration -- is that bad?)
  b) declare tmp before the loop and assign tmp in the loop (but then tmp does not go out of score after its no longer needed)
  c) create a block around the loop and assign tmp at the top of the block (e.g. put the loop in a function)

  • nascardriver

    March 29, 2018 at 10:02 am · Reply

    Hi David!

    Choose option a. Your compiler is smart enough not to create @tmp every loop.

    • David

      March 29, 2018 at 10:06 am · Reply

      Hi nascardriver! Thank you! Ok so if I do this:

      1 2 3 4 5

      for (int i{0}; i < 10; ++i) { double tmp{0.}; // do something 10 times to tmp }

      Does the compiler define tmp once and then assign it to 0 each time at the top of the loop? Or do I need a separate assignment statement?

      • nascardriver

        March 29, 2018 at 10:20 am · Reply

        @tmp will be set to 0.0 every cycle

• Silvia

  March 14, 2018 at 3:42 am · Reply

  Hi Alex,

  I am trying to understand how the standard library writes the implementation for rand() and I have come accross extern in this way:

  1 2 3 4 5 6 7 8 9 10 11 12 13

  struct random_data   {     int32_t *fptr;        /* Front pointer.  */     int32_t *rptr;        /* Rear pointer.  */     int32_t *state;        /* Array of state values.  */     int rand_type;        /* Type of random number generator.  */     int rand_deg;        /* Degree of random number generator.  */     int rand_sep;        /* Distance between front and rear.  */     int32_t *end_ptr;        /* Pointer behind state table.  */   };   extern int random_r (struct random_data *__restrict __buf,              int32_t *__restrict __result) __THROW __nonnull ((1, 2));

  What is the extern keyword doing here together with a function? Aren't functions supposed to be extern anyway?
  Thanks!

  (by the way, you do an amazing job of explaining C++! Thanks!)

• Fernando

  March 2, 2018 at 12:27 pm · Reply

  Hello Guys!
  in the chart above, where it states:
  External non-const global variable | int g_x; | File scope | Static duration | External linkage | Initialized or uninitialized
  Should we use 'extern int g_x;' instead of 'int g_x;' as quoted above? Please help me to clarify that, because I've understood so far that, in order to make a global variable visible to be used in other files, we have to use the word 'extern', am I wrong? Thx

  • Alex

    March 3, 2018 at 8:45 pm · Reply

    Non-const global variables are extern by default. If you use the extern keyword in this case, the compiler will think you're defining a forward declaration to a global variable that is defined somewhere else, which probably isn't what you want.

• Robby die Robbe

  January 31, 2018 at 1:37 pm · Reply

  Is a global const variable automatically static and a normal global variable extern?

  • Alex

    February 1, 2018 at 10:35 am · Reply

    Const global variables have static duration and internal linkage by default.
    Non-const global variables have static duration and external linkage by default.

• Katrina

  November 14, 2017 at 1:32 pm · Reply

  Why would you use a static global variable instead of defining a local variable in the first line of the main function? From my understanding, both would be destroyed at the end of the program and both could be accessed anywhere in the program.

  Thanks!

  • Alex

    November 14, 2017 at 11:38 pm · Reply

    A local variable in the first line of the main function could only be used within main() (although you could pass it to other functions, it couldn't be accessed directly from outside main()).

• arhan sharma

  November 8, 2017 at 1:47 am · Reply

  sir i have one doubt that can you tell me the best site or tutorial by these i can grasp the full knowledge about data structure and algorithms by these i can  learn and grasp the knowledge. please send these on my mail please. it's an humble request.

• Ivan

  October 15, 2017 at 4:51 am · Reply

  From IBM site (https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_72/rzarg/cplr081.htm#cplr081):
  Internal linkage:
  Identifiers declared in the unnamed namespace

  From your site:
  External linkage:
  Non-const global variables (initialized or uninitialized)

  Where is true?

  • Alex

    October 20, 2017 at 1:57 pm · Reply

    When they say unnamed namespace, they don't mean the global namespace, they mean something like this:

    1 2 3 4

    namespace {     int x; }

• phong nguyen

  October 8, 2017 at 1:40 pm · Reply

  Thank you, I really like this page. It summarizes everything beginning of chapter 4 up til now perfectly. I think it would really benefits other beginners if you could do one like this for the other previous chapters

• CrazyL

  July 17, 2017 at 6:20 am · Reply

  Hello Alex,

  I really like your precise distinction between scope and linkage. I already tried two other books and one tutorial on that matter -- only one of those books went into detail as much and its explanations were convoluted (though in the end they were the same as in this tutorial, as far as I can tell)...

  That said, from a beginners point of view, I would prefer it if only file scope and block scope were used in the tutorial instead of global and local scope, which could be mentioned only once as common alternatives to the former. In my opinion file scope and block scope are more precise and tell the reader exactly what they are supposed to mean, unlike local and (especially) global scope.

  I used to mix up global scope with external linkage, but the expression "file scope" did the trick to distinguish between the two. Perhaps I'm not the only one with that problem ;)

  Thank you so much for your amazing work here!

  • Alex

    July 17, 2017 at 2:38 pm · Reply

    I get it. It confused me too, and people tend to use the terms inconsistently in casual conversation. When people talk about "global scope", they usually mean "file scope and external linkage", which makes the identifier accessible globally throughout the program (hence the name).

• Ahmed Hamzah

  June 24, 2017 at 10:16 am · Reply

  Hello Alex!
  Thanks for teaching me C++!
  I'm sorry if this is rather trivial but....there's a grammatical error in the first line of 'Scope summary'.
  Its supposed to be 'An identifier' rather than 'A identifier'. Sorry for my bad English - English isn't my first language!
  Thanks!

  • Alex

    June 24, 2017 at 2:57 pm · Reply

    Thanks for pointing that out. Fixed!

• Curiosity

  May 29, 2017 at 7:18 am · Reply

  When We Use main function in multiple files in a project it produces a linker error,
  is it due to the multiple definition of main function ? I am asking because my code::blocks linker produces an error when i try to do so !

  Second, astute readers may note that global types have external linkage, but their definitions don’t cause a linker error when included in multiple files. This is because types, templates, and extern inline functions have an exemption that allows them to be defined in more than one file, so long as the definitions are identical. Otherwise, they wouldn’t be of much use.
  Explain Me this too using an example !

  • Alex

    May 29, 2017 at 11:28 am · Reply

    1) A program is only allowed to have one main() function.

    2) Define an enum in a header file, then include that header file into two different .cpp files. Each .cpp file will get a copy of the enum definition, but this will not cause a linker error.

    • Curiosity

      May 29, 2017 at 11:31 am · Reply

      Ok So U Talked about enums in this example too....i thought u only referred to vars.....Thanks

• James Ray

  February 23, 2017 at 7:49 pm · Reply

  "This is because types, templates, and extern inline functions have an exemption that allows them to be defined in more than one file, so long as the definitions are identical." What is the point of allowing them to be defined them more than once, provided that the definitions are identical? Just so you don't get a linker error and thus avoid crashing the program? It seems like it is best to avoid defining them more than once at all. Is there any cases where it would be useful to define them more than once (with the same definition)?

  Maybe also change the example of the static local variable in the table to int s_x?

  • James Ray

    February 23, 2017 at 8:40 pm · Reply

    Looks like the next lesson covers why it is not necessary to use std::cout every time with cout, so long as using std::cout is used in the first instance, or using namespace std is used (although it's best to avoid doing this.

  • Alex

    February 24, 2017 at 10:40 am · Reply

    For this conversation, let's be more precise about how we use the term "define".

    You should only define your types in one place (most often, in a header file) -- redundant code is bad. However, in any program of sufficient complexity, that header file will be #included into multiple .cpp files. This propagates that type definition into multiple code files, each of which will be independently compiled and linked. Without this exemption, the linker would note that a definition has been defined (actually propagated) in multiple places, and flag an error.

    So basically, this exemption allows us to propagate types, templates, and inline function definitions from a single header out to multiple code files, where they can be used.

    Also, updated the static local variable per your suggestion. Thanks!

    • James Ray

      February 27, 2017 at 12:05 am · Reply

      Ah OK, that makes sense. Thanks Alex!

• Varun

  February 3, 2017 at 6:28 am · Reply

  Give the man a knighthood.

• Nguyen

  January 11, 2017 at 3:54 pm · Reply

  Hi Alex,

  I don't understand the second row (Static local variable) in the chart.

  Example:  static int x;
  Scope:    Block scope
  Duration: Static duration
  Linkage:  No linkage
  Note:  

  I believe "Static Local Variable" is covered in the very last section 4.3.  

  I think "Static Local Variable" has Static duration if I both define a variable AND give it an initial value in the same step(for example: static int x = 1;).  

  In the above example, x is not initialized.  I am not sure if x has Static or automatic duration? If x has static duration then why the output of the following code is different from another?

  #include <iostream>

  void incrementAndPrint()
  {
      using namespace std;
      static int s_value = 0; // static duration variable initialized
      ++s_value;
      cout << s_value << endl;
  }

  int main()
  {
      incrementAndPrint();
      incrementAndPrint();
      incrementAndPrint();

      return 0;    
  }

  Which outputs:

  1
  2
  3

  Declaring a static duration variable, then assigning a literal to it:

  #include <iostream>

  void incrementAndPrint()
  {
      using namespace std;
      static int s_value; // static duration variable declared
      s_value = 0; // static duration variable assigned
      ++s_value;
      cout << s_value << endl;
  }

  int main()
  {
      incrementAndPrint();
      incrementAndPrint();
      incrementAndPrint();

      return 0;    
  }

  Which outputs:

  1
  1
  1

  • Alex

    January 16, 2017 at 6:33 pm · Reply

    Static variables have static duration regardless of whether you initialize them or not. In your example, you're not initializing the static (which would only happen once, when the static is created). Instead, you're assigning a value to the static variable, which happens every time the function runs. So even though your static s_value is keeping its value between function calls, you're resetting it back to 0 via assignment every function call.

    This is why we typically initialize static variables, not assign values to them.

  • Walter Johnson

    March 14, 2018 at 2:05 pm · Reply

    Indianapolis IN a quic k eep https://edmondscommerce.github.io/index.smp #945482899063326634NAW Walterjacobs89@gmail.com@gmail.com password 1431st

• nikos-13

  December 29, 2016 at 6:09 am · Reply

  " (initialized or uninitialized) "

  Why do you use this prenthesis

  • Alex

    December 29, 2016 at 2:09 pm · Reply

    Just to be explicit that this covers both cases.

    • nikos-13

      December 30, 2016 at 11:33 am · Reply

      Ok

• John

  November 25, 2016 at 3:03 am · Reply

  Can you please explain how "Extern const global variable"  has external linkage ? can we access any variable defined as const in other file without using namespace?

  a.cxx:
  extern const int a(5);

  b.cxx:

  extern const int a;
  int main(){
      std::cout << a << std::endl;
  }

  It gives an error as "b.cxx:(.text+0x6): undefined reference to `a' "

  • Alex

    November 25, 2016 at 12:12 pm · Reply

    Worked fine for me on Visual Studio 2015. Are you sure both a.cxx and b.cxx got compiled and linked properly?

• Matt

  October 31, 2016 at 1:40 am · Reply

  In section "Duration summary", the listings for automatic duration and static duration (local variables) should be updated to reflect that the variables are created during definition, not when the block is entered.

  • Alex

    October 31, 2016 at 9:59 am · Reply

    Updated. Thanks for pointing that out.

• kris

  July 28, 2016 at 10:35 am · Reply

  This is very helpful. Thank you

• Don jose

  July 3, 2016 at 4:53 am · Reply

  Thanks Alex,
  I need to clear one more thing, Consider I have 2 Task  and I called a common function from both the task which having a static local variable , So from one task I am accessing and set one value to that static variable, and through another task I read that value. So In both case am accessing the same local static variable. My doubt is ,am accessing the same memory ? able to consider that variable as a shared variable or shared memory?

  • Alex

    July 3, 2016 at 5:05 pm · Reply

    In both cases, you're accessing the same local static variable, which uses the same memory. It's not really shared memory -- it's just a variable that you can access whenever you're inside the function (doesn't matter which function it was called from).

    • Don jose

      July 3, 2016 at 11:04 pm · Reply

      Hi Alex

      Why it's not shared memory? As per my knowledge shared memory is the memory in which a common memory get accessed from 2 different task, is it correct ?  Would you please give me the definition of Shared memory?

      • Alex

        July 6, 2016 at 8:22 am · Reply

        Maybe I'm misunderstanding what you mean by task. If by task you mean "process" or "thread" (or anything else that can run in parallel), then yes, the memory would be shared.

        • Don jose

          July 8, 2016 at 12:30 am · Reply

          Yes, I meant Task as two separate Process that may or may not be run parallel.

          Now everything is clear

          Thanks Alex.

          The effort you put in this site is really worth for learner

• Don jose

  July 2, 2016 at 6:52 am · Reply

  Hi Alex,
  Thanks a lot for the replay

  I tried indirectly, Like address of a static local variable assigned to a global pointer and deferred at another function. Compiler not showing any error and I am getting the expected result as well. As per my knowledge the lime time of the static local variable till up to the end of the program ,  is it correct? then why can't access the local static variable outside that function(indirectly)? is any risk involved in this way like data overwriting?

  • Alex

    July 2, 2016 at 3:14 pm · Reply

    Yes, the lifetime of a local static variable is until the end of the program. But the scope of a local static variable is still only within the function in which it is declared, the same as a local non-static variable. The scope governs where you can access the variable, which is why you can't use it directly outside the function.

    You can access the variable outside the function indirectly (via a pointer or reference), but even though you can do this, it's not advised.

• Don jose

  June 25, 2016 at 5:19 am · Reply

  Hi, I have one doubt.
  is it possible to access a static local variable in a function from the main function. if it possible to access, then that data is safe or not?

  • Alex

    June 26, 2016 at 11:01 am · Reply

    No, it is not possible (at least not directly). Static local variables are only visible within the function in which they are declared.

• Robert Hannah

  May 24, 2016 at 2:18 pm · Reply

  Wow. I was literally just about to write some kind of summary like this to supplement notes I've taken from your website. Thanks! I've been using this site for years: Perhaps the best non-book resource that there is on C++.

• The Vip

  April 24, 2016 at 2:22 am · Reply

  Got cleared all of my former doubts...Bro Thankyou so much for this awsome site...