6.4 — Introduction to global variables

In lesson 6.3 -- Local variables, we covered that local variables are variables defined inside a function (or function parameters). Local variables have block scope (are only visible within the block they are declared in), and have automatic duration (they are created at the point of definition and destroyed when the block is exited).

In C++, variables can also be declared outside of a function. Such variables are called global variables.

Declaring and naming global variables

By convention, global variables are declared at the top of a file, below the includes, but above any code. Here’s an example of a global variable being defined:

The above example prints:


By convention, many developers prefix global variable identifiers with “g” or “g_” to indicate that they are global.

Best practice

Consider using a “g” or “g_” prefix for global variables to help differentiate them from local variables.

Global variables have file scope and static duration

Global variables have file scope (also informally called global scope or global namespace scope), which means they are visible from the point of declaration until the end of the file in which they are declared. Once declared, a global variable can be used anywhere in the file from that point onward! In the above example, global variable g_x is used in both functions doSomething() and main().

Because they are defined outside of a function, global variables are considered to be part of the global namespace (hence the term “global namespace scope”).

Global variables are created when the program starts, and destroyed when it ends. This is called static duration. Variables with static duration are sometimes called static variables.

Unlike local variables, which are uninitialized by default, static variables are zero-initialized by default.

Global variable initialization

Non-constant global variables can be optionally initialized:

Constant global variables

Just like local variables, global variables can be constant. As with all constants, constant global variables must be initialized.

Related content

We discuss global constants in more detail in lesson 6.9 -- Sharing global constants across multiple files (using inline variables).

A word of caution about (non-constant) global variables

New programmers are often tempted to use lots of global variables, because they can be used without having to explicitly pass them to every function that needs them. However, use of non-constant global variables should generally be avoided altogether! We’ll discuss why in upcoming lesson 6.8 -- Why (non-const) global variables are evil.

Quick Summary

6.5 -- Variable shadowing (name hiding)
6.3 -- Local variables

273 comments to 6.4 — Introduction to global variables

  • Nathan

    For whatever reason, the /n command won’t work.  Could you give me some possible solutions?

  • Louis Cloete

    @Alex, in your example about how the global scope resolution operator can be used to specify that the global variable should be used, you used postfix operators. It is not necessary to use the postfix operators. It also breaks a rule given in a previous tutorial (3.3 Increment/decrement operators, and side effects).

  • Piyush



    Compiler error :
    Undefined reference to 'global_g'.

    Please help

    • @global_g is never defined. "extern" means that the variable exists somewhere and it's safe to use it. Your code doesn't contain this "somewhere". You say twice that @global_g exists, but you never create it.
      Remove the "extern" is @global_g.cpp.
      Your compiler will see @global_g in @main.cpp, search for it, and find it in @global_g.cpp.

      • Piyush

        Ok i got it thanks for the reply.
        It works when i use

        Because the compiler knows that this is a declaration with external linkage and not forward declaration.
        But as i have used

        in both the files it treats both as forward declaration as it is not smart enough to automatically decide in which file i have declared global_g.

  • hussainiMagaji

    Hi Alex | nas | fellow learners!
    When I was viewing cpp on wikipedia it was said that "C" code can be written in CPP with the (extern "C") keyword and there is no mention of it here. So is there any information regarding this.

  • Shri

    is it fair to say that:

    If you need external linkage to multiple files for compile time constants, then initialize the "extern const" in header file
    otherwise, initialize the "extern const" in cpp file and forward declare it in header file

    if this is a valid point, then I think it would be good to add this into summary

    • Alex

      I recommend defining global constants in a header file (rather than a source file) unless you find some specific reason not to (e.g. you keep changing the values and it's causing your entire huge program to recompile).

      • Shri

        Follow up question on this Alex, in 4.3a section, you say this:
        Identifiers with external linkage will cause a duplicate definition linker error if the definitions are compiled into more than one .cpp file.

        would the above statement be one more reason (apart from this reason : you keep changing the values and it's causing your entire huge program to recompile) for defining global variables in their own cpp files, forward declaring these global variables in a header file and then including them in 2 cpp files.

        For example:

        file1 :


        file3: 1.cpp

        file4: 2.cpp

        • Alex

          No. Const global variables defined in the header should be defined with internal linkage (they have this by default) so you can #include them into any file that needs them without running into linker errors. Because they have internal linkage, the compiler and linker will treat each as independent, and no conflict will result.

  • Wilku

    In the summary:

    The third comment should refer to const, not variable, shouldn't it?

  • When I try to assign g_x a value in the global scope why does it give me an error?

  • limcheling

    Hi, if constants.h has

    #ifndef CONSTANTS_H
    #define CONSTANTS_H
        const double pi(3.14159);
        const double avogadro(6.0221413e23);
        const double my_gravity(9.2); // m/s^2 -- gravity is light on this planet
        // ... other related constants

    and constants.h is subsequently included by 20 over code files and each of these variables is duplicated 20 times. Would this a problem for linker as this violates One Definition rule?

    • Hi limcheling!

      > Would this a problem for linker as this violates One Definition rule?
      Constants don't fall under the one-definition-rule. If one of the variables was non-const, linking would fail.

  • Marcos

    In the above example for 'Global Symbolic Constants' why does both constants.h and constants.cpp use the namespace 'Constants'? I removed the namespace in the header and adjusted the reference but it called a linker error, presumably because the forward declarations didn't describe the namespace used in the initialization? I then tried removing the namespace from the constants.cpp and keeping the namespace in the header file and reference but it again provided the same linker error.

    • Alex

      The compiler needs to know that the forward declarations in the header are inside the namespace so it can enforce the proper syntax, and the linker needs to know that the definitions inside the code file are also inside the namespace so it can link everything up properly.

  • FCH

    Thank a lot Alex. Your C++ tutorials are great.
    I have a question about the default use of constant variables. They have by default static scope.

    The next code will not compile and i understand why :

    But why when i add a forward declaration for the const global variable in the constantes.cpp file using the keyword "extern", the program compile.

    The g_gravity variable still have a file (static) scope

    • Alex

      It looks like your declaration of g_gravity as extern is telling the compiler to modify g_gravity so that it has external linkage.

      I've never seen anybody do this in practice, and it seems like bad form to use it in this manner.

      • FCH

        Generally, we have this situation when we use a header file to define the variable forward declarations. Then we include this header file in the main.cpp file and the other cpp file (constantes.cpp)


  • Fernando

    Hello guys!
    thank you so much for such a good materials and forum!
    My question is: once I have a .cpp file, let's say the same above:

    And the .h file, which is same above in the tutorial:

    Should I have to put "#include "constants.h" in the .cpp file? Will the compiler recognize a declaration/definition just by using the "same name"(constants) for these two files?

    • Fernando

      Never mind!
      I tried to run a new program with them and it's fine. I thought I should include the name of the header file in its respective .cpp file. Thanks.

  • Andreas

    Hey Alex.
    I've been following and learning cpp here for a month now,and so far hopefully i am on good way.
    Thing is,i still dont know or better like i am not sure how to write programs shown in examples.
    I dont know exactly what to input where and when,so is it normal? Is it normal for a beginner to "not know" how to write a program in so far lectures?
    As well i am worried that after finishing this whole index i wont be able to write a bit more complexed programs. Should i worry about it?

    After finishing this index i will swap to udemy. For more courses.
    But yeah,is it normal that i dont know how to write programs properly and without looking at solutions from quiz and examples?
    I really do understand lectures,each one of these,structure and way of writing programs is still not clear.

    • Alex

      If you're generally able to at least follow the lessons and understand the examples (both syntax and structure), then you probably just need more practice in creating things on your own.

      If you're struggling to understand the structure then you may need to spend more time reading about functions and modularity. It's an important concept to get now so your programs aren't a mess later.

  • Saumitra Kulkarni

    Hi Alex, Great Tutorials!



    Now to use the x which is by default extern in ext1, I realized we cannot link them togerther(g++ ext.cpp ext1.cpp) since both have in main(), So the int x(declared in ext1) would be useless if we have main function in the program, so my doubt was to use such x do we always have to define it in a file which has no main or other functions and just the forward declarations of the global variables?

    • nascardriver

      Hi Saumitra!

      "a file which has no main or other functions and just the forward declarations of the global variables?"
      It can contain other functions, but there may only be one main function.

      • Saumitra Kulkarni

        Thanks for the reply nascardriver!

        Here by other functions(if the 2 files have same function names)i meant that it is causing multiple definitions conflict when i compile them together(g++ ext.cpp ext1.cpp) ,Even if i include just main it will cause multiple definition conflict.

        • nascardriver

          You can't have two functions with the same signature (return type, name, parameters) in the same scope. You can however have functions that have not yet been declared in the file file the extern variable.

          • Saumitra Kulkarni

            So bottom line, we cant use a extern variable if the file in which it has been defined has same function names(including int main()) as the file in which it is forward declared for usage.

            • nascardriver

              This has nothing to do with the extern variable. Take the following setup for example

              This won't compile, because @hello has been defined more than once.

              • Saumitra Kulkarni

                Yea you are right that it wont compile,I just wanted to point out that

                as Alex said here that g_y in this snippet has external linkage and it can be used by other files but technically we cant because it contains (int main()) and as we try to compile it with the file in which we want to use it, it would just wont work due to multiple declarations of(int main()) so even though it has external linkage ,we wont be able to use it.

                • Alex

                  Not true. It can be used by other files in the same project (those files shouldn't have their own main() functions, because a program can only have 1 main function).

                  So something like this:



  • Trevor

    In the example of static const double g_gravity in constants.cpp, your comment in main.cpp says that the attempt to access g_gravity would cause a compiler error. However I believe that this cannot be, as the compiler ignores the contents of constants.cpp when compiling main.cpp and thus will not know of the static keyword, and you will actually get a linker error instead. g_gravity is declared in main.cpp which is enough for the compiler. However the definition of g_gravity in constants.cpp is hidden from the linker by the static keyword and it will not find any other definition and thus fail.

  • kurtu5

    One thing to note about linking object files is that g++(C++14) can't catch this.  main() will reassign the const and crash. It doesn't realize that your forward declaration in main.cpp doesn't match the identifier in globals.cpp.



  • Hamed O.Khaled

    Because global symbolic constants should be namespaced . why ?

    • nascardriver

      Hi Hamed!
      A quick example of why having global constants/variables/functions not in a namespace is bad.
      There's a function "min" in the <algorithm> header. This function is in the "std" namespace. There's also another function (actually a macro) in some windows header which is also called "min". Both of these functions return the smaller of two numbers.
      For simplicity, we'll assume the "std::min" function wasn't in a namespace or we're "using namespace std;".
      Look at the following code

      Which function is supposed to be called here? The std::min function or the windows min function?
      I don't know if the compiler would prefer one over the other, but this is definitely problematic.
      This can be avoided by having global constants/variables/functions in a namespace and not "using namespace x;".

    • Alex

      To help avoid naming conflicts with other things in the global namespace. I've added this bit of context to the lesson.

  • Hamed O.Khaled

    Hi Alex!
    I'm trying to understand the concept of extern and static but the code gives me strange error first defined here .. why ?




    • nascardriver

      Hi Hamed O.Khaled!
      The code you posted compiles and runs without problems for me, please post the complete file content and error messages.
      Without knowing what exactly is happening I can only suggest you to not declare variables or constants in header files, this can lead to "first defined here" errors. Instead, have a forward declaration (by using "extern") in the header and have the actual declaration in the corresponding source file. I'm talking about your "pi" constant.

    • Alex

      What error are you getting? I don't see anything wrong here, and it seems to compile fine on Visual Studio 2017.

  • David

    Hi Alex. At the top, you say "variables declared outside of a block are called global variables." However, in the section about symbolic constants, you define global variables in a namespace:


    Why are namespace blocks different from other blocks?

    • Alex

      Great question -- the short answer is that my definition is clearly inadequate. I've updated my definition thusly:
      A local variable is one defined inside a function (not inside a block).
      A global variable is one defined outside a function (not outside a block).

      Under this definition, variables declared outside a function but inside a namespace block are global variables as they should be.

      Thanks for pointing out the inconsistency!

  • Jeffery

    I really appreciate your C++ tutorials, but I am a bit confused at the part "Global symbolic constants" when you say "Given the above downsides, we recommend defining your constants in the header file." Earlier on you say that this method is good for smaller programs, at least that's the method I think you're referring to. If not, could you provide an example of what it should look like? Also, in this method should I use extern when initializing the variables in the namespace?

    Thanks -Jeffery

    • Alex

      Yes, that's the method I'm referring to. You should only use extern if you're defining a global const that you want to have external access to (e.g. from some other file).

      There's a summary of scope, duration, and linkage in lesson 4.3a.

  • Jim

    This is the most confusing section so far! ;+P Final (I hope) confusion concerns "static". In your 'chart', you say:
    "// Initialized definition:
    const int g_y(1);  // defines initialized static variable (internal linkage)"
    Why is this constant variable (confusing enough!) labeled as "static"?

    Never mind. I didn't read the rest of the comments and you answered my question with "Global const variable are static by default". I just missed that in the text... several times. :wallbash:

    Thanks for your great teaching gift to us!

    • Alex

      Yes, it's super confusing. The good news is that you won't be declaring global variables very often (and if you do, they'll most likely be const values in a header somewhere).

  • Michael

    Hi Alex,
    I made a test and defined a global variable below a function definition instead of putting it at the top of the file:

    The compiler says that g_test is an undeclared identifier.

    Does this mean that global variable's scope is not exactly all of the file? Rather, it starts from the point of definition till the end of the file?

    Is that also why you should put its definition at the very top of the file?

    Thank you!

    • Alex

      Yes, even though the variable is global in nature, the parts of the file above where the variable is defined can't see the variable (unless you've forward declared it).

  • jack

    Hi Alex, excellent tutorials you made.
    so what should be put in constants.cpp , forward declarations or the actual constants and what should we do in case we need a compile-time constant.

    • Alex

      constants.cpp should contain the actual constant definitions.

      If you need a compile time constant, put the constant definition in the header file. I recommend using the header method (at least to start) anyway.

  • Cat

    Two questions: what exactly is covered by the namespace? i'm trying to parse together what the usages of namespace ought to be.
    and i have a confusion i can't quite resolve. when you say "However, there is a downside to doing this: these constants are no longer considered compile-time constants, and thus can’t be used anywhere that requires a compile-time constant."
    So what exactly would be a formidable example of compile-time constants? and how exactly does that relate to the example/method shown of symbolic constants and headers? and also how does that differ from non-compile time constants? not quite connecting the dots there and any compare and contrast will help very greatly.
    Just wanna say thank you as well! I was terribly skeptical about an all text/reading tutorial, but jeez this is way better than most video tutorials! Thank you for your service! srsly.

    • Alex

      I'm not sure I understand your first question. Anything can be put inside a namespace. Namespaces are just containers to help prevent naming collisions.

      A formidable example of a compile-time constant would be as the length of a fixed array (which we cover in chapter 6):

      Non-compile time constants would be like a const function parameter. It's treated as const within the function, but the value isn't known until runtime:

      • Cat

        Thank you kindly! I think I am starting to understand the difference between compile time vs runtime.
        In the example under symbolic constants section with the adjusted header method, why exactly would these values not be resolved at compile-time? I can see the clear difference in how the values are handled between declaring the const values directly in the header, vs. simply calling the values directly in .cpp files instead. But why does this difference mean that the const values are resolved at runtime?
        Hopefully i've worded this well enough. :p

        • Alex

          I realized I made a minor mistake: the const values in the .cpp file ARE considered compile time constants within the file in which they are defined (constants.cpp). This is because the compiler can see the actual definition for those constants.

          However, everywhere else, the compiler only sees the forward declaration, and it's up to the linker to connect the identifier with the actual definition in another file. That happens post-compile, so the compiler can't treat it as a compile time constant.

          • Cat

            AH okay that makes MUCH more sense. so the trade off for that method would just be that you would have to keep track of the values you are running through those variables i suppose?

            • Alex

              > so the trade off for that method would just be that you would have to keep track of the values you are running through those variables i suppose?

              I wouldn't consider that a trade-off. Half the point of using symbolic constants is so you don't have to remember specific values, just the name of the thing you want.

  • umang

    what is the duration of global variables having external linkage?

  • AMG

    "Variables declares outside of a block are called global variables". There are many blocks, so outside of which block? Should we say a variable, which is accessible in any block of a file, is global.
    Accessible, visible or to be used - means the same - accessible?
    About linkage … Basically linkage either extends (extern) or constrain (static) the scope.
    1. The most intuitive understanding of global scope is the example of defining constants via namespace Constants in .cpp and .h files. No forward declaration or any additional words are required, except ‘Constants::’.  
    2. Extern - is a master key to unlock access to a variable, declared in other file.
    3. Static - is master key to block access to a variable from other files.
    4. The most intuitive understanding local variable is block variable, declared and defined inside of { }.

    • Alex

      A global variable is a variable that is declared outside of _all_ blocks. A variable declared in any block is a local variable. Both global and local variables follow normal scoping rules, where they can be seen by everything after the point of declaration, to the point where they go out of scope (which for local variables is the end of the block in which they are declared, and for global variables is the end of the file).

      I have a summary of all of this stuff in a couple of lessons.

  • Curiosity

    these constants are no longer considered compile-time constants, and thus can’t be used anywhere that requires a compile-time constant.

    Why did u say this when forward declaration of constants was done in header files instead of their initialization.........??
    U said that in this :-


    Use in the code file stays the same:

    • Alex

      When the top case is included in other files, the compiler can see the initialization values, so it can treat those as compile time constants. In the bottom case, only the forward declarations are included, and the linker must link those declarations up to the actual variables. Since the linker happens after the compiler, the compiler doesn't have access to the initialization values (except in the specific .cpp file where they are defined) and thus they generally can't be used as compile time constants.

  • Ahtazaz Khan

    Hi great Teacher(Alex)!
    I have a question about static keyword, What means it? where to used it and does its value change time to time or will remain same in the whole program...? please  explain static keyword...? what here it means 'static int 6;' ,ok here it's int value of 6 but what the purpose of here static...?? i have a lot of confusion regarding this...
    Thanks in advance.

  • Dennis

    Further clarification of static globals: 'file scope' scope of the whole 'translation unit' and a translation unit includes all other files added with #include directive, not just the one single file where the static global is written in.

  • Max

    Hello. First, I want to thank you for your C++ tutorial, I really think it is the best textbook for C++, most comprehensible and concise. And I understand, that it is hard to find a balance between this two. So, I want to write about my own experience with this article, and try to figure out why it was so hard for me (and may be some other people from comments section) to understand it. May be it helps to make some fixes, that is not so obvious.

    I've read the article and comments several times, but still was deeply confused about "extern" keyword. After a couple hours of reading and thinking, I suppose I understood it, but I'm not 100% sure. So, correct me if I'm wrong.

    So, extern keyword has 2 meanings:
    1) to make a variable external (visible in other files)
    1a) but it's already external by default for normal (non-const) variables, so you don't have to use this keyword in that case
    1b) and you CANNOT use this keyword for undefined variables, because compiler/linker will think you're using the second meaning of extern keyword.
    2) forward declaration for variable, that was declared in some other file
    2a) and you HAVE TO use this keyword in order to access variable from another file
    2b) it doesn't matter if it's const or not

    Now, after (I hope) I understood this, I re-reading this article and I suprisingly see, that aricle was absolutely correct, and everything I had so much trouble with, was already there. So, I'll try to de-cypher why I had hard times understanding it. Some of this points may be obvous for everybody, but me, but I'll try to write as much details as possible.

    1) In section "Internal and external linkage via the static and extern keywords" we learn, that to make variable external (visible in other files) we should declare it with keyword extern (and it's default for non-const). But at this point of reading, we have no clue, that it is _necessary_ to use keyword "extern" second time - in other file, in which we want to use it. Yes, now I see the sentence about that in next section, but I can swear I didn't see it while I was re-reading this article several times. I think the reason is - after I read this section ("Internal and external linkage..."), I somehow assumed, that this is enough to make a variable visible in other files, so when I read next section ("Variable forward declarations via the extern keyword") I assumed it describes some other completely separate case (for example, if we didn't declared variable with extern keyword in other file). I think this is the main reason of my misunderstanding, and while article is textually correct, I think absence of some linkage (no pun intended) between this sections make it really hard to grasp.

    2) "Similarly, in order to use an external global variable that has been declared in another file, you have to use a variable forward declaration. For variables, creating a forward declaration is also done via the extern keyword (with no initialization value)." - here it is, sentence I didn't see that "you HAVE TO use a variable forward declaration". And I had some trouble with the word "also" from second sentence. For some reason (I think because it is too far away from its context) I thought "also" means "it can be done with or without extern keyword". Now I understand it means "as in previous case, from previous section", but I got it only after already started to write my first version of this long comment, describing my troubles in understanding different sentences. Only after that "clicked" in my head - I completely understood the whole thing.

    3) "Note that if you want to define an uninitialized non-const global variable, do not use the extern keyword, otherwise C++ will think you’re trying to make a forward declaration for the variable." - that is not so important, but still. Yes, it was probably my fault, that I didn't see an emphasis on the word "uninitialized". I only understood this sentence after I read an answer about this in comments. But now you can imagine how confusing it was for me when I read it the first time, after all confustions I already got before that =)

    So, I think that's the main points. I hope it can help improving this article for the next readers. Thank you for your time, spent in reading my too-long comment and thank you again for your job making this great tutorial available for people around the world =)

  • Nguyen

    Hi Alex,
    Similarly, if we want to make a global variable external (able to be used anywhere in our program), we can use the extern keyword to do so:

    extern double g_y(9.8); // g_y is external, and can be used by other files

    int main()
        return 0;
    Here is an example of using a variable forward declaration:

    // define two global variables
    int g_x;
    int g_y(2);
    // in this file, g_x and g_y can be used anywhere beyond this point

    extern int g_x; // forward declaration for g_x -- g_x can be used beyond this point in this file

    int main()
        extern int g_y; // forward declaration for g_y -- g_y can be used beyond this point in main()

        g_x = 5;
        std::cout << g_y; // should print 2

        return 0;

    I am wondering why you did not use extern keyword in global.cpp?

    Thanks, Have a great day.

Leave a Comment

Put all code inside code tags: [code]your code here[/code]