为什么编译器不为类内部声明的变量分配内存？

Question

When we declare some variable inside class or struct in C/C++, we have to make an object of class or struct to allocate memory for the variable.

Why can't we just access these variables without any object?

Answer 1

Well, the answer is really: because that's the whole point of this language feature. The very idea of a data member of a class is for it to be an integral part of class object. It begins its life together with the entire class object and it ends its life together.

If you have two class objects, you have two completely independent sets of data members. If you have 50 class objects, you have 50 completely independent sets of data members. If you have zero class objects, you have no sets of data members to access. In other words, you cannot access these "variables" without a class object simply because they do not exist without a class object.

You are not really "declaring a variable" when you declaring a data member of a class in a class definition. Class definition simply describes the layout of class type. By itself it produces nothing physical, ie noting that would live in data memory, noting you can physically access.

Meanwhile, C++ language has such concept as static member of the class. Static data members of the class are not associated with specific class objects. They exist independently. In fact, static data members are just ordinary global variables covered by a fairly thin layer of C++-specific "syntactic sugar" (more elaborate naming, access control etc.) Static data members of the class can be accessed as ordinary variables, without any object.

In other words, it is not a question of "why?" but rather a question of what you need. If you want non-static data member functionality, use non-static data members. If you want static data member functionality... well, you get the idea.

Answer 2

A class is just a 'layout' used to specify how instanced object will be constructed, destroyed and how they will behave. For an imaged comparizon with buildings: a class is the plan used to build the house. The object is the house itself.

If you want variable without objects, use global variables. You can put them in a namespace:

namespace test
{
    int answer = 42; // Initialization is optional
}

// ...

void f()
{
    // Use it like this:
    test::answer = 0;
}

You can also use static members:

class MyClass
{
    public:
        static int value;
};

Answer 3

Usually, you declare a member variable inside a class precisely because you want it to be part of an object of that class type. That's what that language feature is for: to allow you to have many distinct objects, each with its own state independent of any other object.

In C++ (but not C), you can declare it static if you want a single variable, independent of any object. This will have static storage duration, just like a variable declared outside a class. In C, global variables are the only option if you want something like this.

For example:

struct thing {
    int a;         // part of a "thing" object
    static int b;  // not part of a "thing"
};

// Static variables need a definition, in exactly one source file
int thing::b;

int main() {
    thing::b = 1; // OK: no object needed
    thing::a = 2; // ERROR: object needed

    thing t1;
    t1.a = 3;     // OK: accessing object member
    t1.b = 4;     // OK: equivalent to "thing::b"

    thing t2;
    t2.a = 5;     // OK: accessing object member
    t2.b = 6;     // OK: equivalent to "thing::b"

    std::cout << t1.a;  // prints 3
    std::cout << t2.a;  // prints 5 - independent of t1.a

    std::cout << t1.b;  // prints 6
    std::cout << t2.b;  // prints 6 - same variable as t1.b (aka thing::b)
}

Answer 4

Using the static keyword:

class A {
public:
    static int varaible;
};

int A::variable = 5;

Then you can access the variable without an object anytime. As follows.

A::varaible = 25;

Things you'll need to know:

1. You will need to use the scope operator(::) to access a static member.
2. Definition of a static member must be done outside of the class. The above statement int A::variable = 5; is an definition of a static member.
3. All objects of type A (included inherited objects) share a static member. [1]

[1]

A a;
A b;
a::variable == b::variable == 25;
//if we change a::variable
a::variable = 26;
//b::variable has the same value.
b::variable == a::variable == 26;