Class vs Namespace scope

what exactly does 'namespace' mean?

Say I write this:

namespace ns1
{
    class foo{}
}
namespace ns2
{
    class foo{}
}

Now even the name of both class is same the compiler would treat them as: ns1::foo and ns2::foo i.e. they are different class.

Class Scope and namespace scope:

namespace ns1{
    int a; // a has existence from here
    class foo{
        int b; // b has existence from here
    }          // b has existence upto here
}  //a has existence upto here

A class is a group of variables and procedures that are related to each other. They are tied together by the class. Example:

class Human {
public:
    int age;
    string name;
    void GrowOlder() { age += 1; }
};

All of the items inside that class definition are in the class scope. In order to use the class you may do something like this:

Human grendan;
grenden.name = "grenden";
grenden.GrowOlder();

The "name" and "GrowOlder" members of the "Human" class are used in this example. If you just write

name = "grenden"

that will be an error if you're currently outside of the "Human" class scope.

A problem happens when many libraries or applications try to interact with each other. Each one may have its own string library, its own vector math library, and so on, and so there may be duplicate class names. Namespaces are a solution to this problem. You can place your class in a namespace, in order to qualify it better.

namespace foo
{
    class Human {
    public:
        int age;
        string name;
        void GrowOlder() { age += 1; }
    };
};

Now the "Human" class is inside the "foo" namespace scope. If you're working from outside the namespace, "Human" doesn't mean anything anymore. Now in order to use the "Human" class the code looks like:

foo::Human grendan;
grenden.name = "grenden";
grenden.GrowOlder();

Notice the extra "foo::". This tells the compiler to look inside the "foo" namespace scope in order to find the "Human" class.

In general, you're inside a class scope if you're inside one of the procedures of that class.

You're inside a namespace scope if either you're inside a namespace {} block, or there is a "using namespace foo;" statement somewhere higher up in your code file.

Example:

void test()
{
    std::string example = "testest";
}

Or, with using namespace:

using namespace std;

void test()
{
    string example = "testest";
}

Differences between class/struct and namespace that I can think of:

1. A class definition cannot be used multiple times. A namespace can be used multiple times to extend its contents.

   class A { int a; };
   class A { int b; };   // This is not allowed.
                         // You can extend the class by creating
                         // a sub-class and adding new members to
                         // the derived class but you cannot add
                         // members to a class by defining it again.
   
   
   namespace A { int a; }
   namespace A { int b; }   // Perfectly fine.
                            // b is an additional member of the namespace.
   

2. You can create objects of a class. You cannot create objects of a namespace. A class has storage requirements, a namespace does not.