Global scope vs global namespace

by

In C++, every name has its scope outside which it doesn’t exist. A scope can be defined by many ways : it can be defined by namespace, functions, classes and just { }.

So a namespace, global or otherwise, defines a scope. The global namespace refers to using ::, and the symbols defined in this namespace are said to have global scope. A symbol, by default, exists in a global namespace, unless it is defined inside a block starts with keyword namespace, or it is a member of a class, or a local variable of a function:

int a; //this a is defined in global namespace
       //which means, its scope is global. It exists everywhere.

namespace N
{
     int a;  //it is defined in a non-global namespace called `N`
             //outside N it doesn't exist.
}
void f()
{
   int a;  //its scope is the function itself.
           //outside the function, a doesn't exist.
   {
        int a; //the curly braces defines this a's scope!
   }
}
class A
{
   int a;  //its scope is the class itself.
           //outside A, it doesn't exist.
};

Also note that a name can be hidden by inner scope defined by either namespace, function, or class. So the name a inside namespace N hides the name a in the global namspace. In the same way, the name in the function and class hides the name in the global namespace. If you face such situation, then you can use ::a to refer to the name defined in the global namespace:

int a = 10;

namespace N
{
    int a = 100;

    void f()
    {
         int a = 1000;
         std::cout << a << std::endl;      //prints 1000
         std::cout << N::a << std::endl;   //prints 100 
         std::cout << ::a << std::endl;    //prints 10
    }
}

More Related Contents:

  1. scope of using declaration within a namespace
  2. Why does C++ parameter scope affect function lookup within a namespace?
  3. Why ‘&’ reference in not required in classes in C++?
  4. What is the meaning of prepended double colon “::”?
  5. Why do multiple-inherited functions with same name but different signatures not get treated as overloaded functions?
  6. Namespace + functions versus static methods on a class
  7. Why are unnamed namespaces used and what are their benefits?
  8. Superiority of unnamed namespace over static?
  9. What’s the scope of inline friend functions?
  10. Why are two different concepts both called “heap”? [duplicate]
  11. Why is including “using namespace” into a header file a bad idea in C++?
  12. Scope of variables in if statements
  13. Is there any way to access a local variable in outer scope in C++?
  14. Is it a good idea to wrap an #include in a namespace block?
  15. Why is my log in the std namespace?
  16. How to forward declare a class which is in a namespace
  17. Why are some functions in not in the std namespace?
  18. Adding types to the std namespace
  19. What exactly is the difference between “pass by reference” in C and in C++?
  20. Why does everybody use unanchored namespace declarations (i.e. std:: not ::std::)?
  21. C++ When is it OK to extend the `std` namespace?
  22. Scope of exception object in C++
  23. What is half open range and off the end value
  24. Why can’t we declare a namespace within a class?
  25. Why and how should I use namespaces in C++?
  26. How to access variables defined and declared in one function in another function?
  27. namespaces for enum types – best practices
  28. Mixing extern and const
  29. Scope and return values in C++
  30. Scope resolution operator being used twice

Leave a Comment