无法理解实例变量

Question

这是定义：

在使用类的面向对象编程中，实例变量是在类中定义的变量（即成员变量）//我得到这个部分

，该类的每个对象都有一个单独的副本。 //这部分我不明白。

对象如何具有单独的副本？什么的单独副本？

很抱歉提出基本问题，我还是个菜鸟。

谢谢

Answer 1

[评论答案] 实例变量是一个变量，它为每个声明的对象提供一个实例，其中一个类变量是一个单独的成员变量，对于所有声明该类型的对象，只有一个变量。类变量使用关键字static，其中实例变量不是！

<强> [原稿] 定义类时，它具有成员声明。

在定义该类类型的变量之前，对象不会真正实例化（或给定内存空间）。

如果然后定义了两个类类型，那些对象将被赋予自己的内存空间，实际上每个对象的每个成员都有自己的内存（因此该对象有2个独立的实例）。

现在，每个数据分组（在对象内）都可以并且真的被单独操作。

类变量：

http://en.wikipedia.org/wiki/Class_variable

实例变量：

http://en.wikipedia.org/wiki/Instance_variable

Answer 2

如果您有两个对象，则每个对象都有自己的实例变量副本。即a.x与b.x不同，即使您给它们相同的值。

Answer 3

我制作了另一张我可怕的蚀刻草图，不得不用它灼烧你的眼睛。如果它解决了任何理解问题，那太好了！

所以，我们有一个班级，称之为Foo。 Foo有一些静态成员，如图所示：
x，y，z

在顶部，您会看到非对象访问权限。这意味着我们可以在没有对象的情况下访问这些静态成员。实际上，在访问对象之前甚至不必创建对象，因为它们在main开始之前就存在了。

struct Foo {
    static int x, y, z;
};

int Foo::x = 3;
int Foo::y = 1;
int Foo::z = 8;

int main() {
    std::cout << Foo::y;
    Foo::x = 6;
}

接下来，我们有其他圈子包含两个对象的实例成员：

struct Foo {
    int a;
    int b;
    int c;

    Foo (int a2, int b2, int c2) 
        : a (a2), b (b2), c (c2){}
};

int main() {
    Foo obj1 (6, 9, 10);
    Foo obj2 (3, 2, 4);

    std::cout << obj1.a; //outputs 6
    std::cout << obj2.a; //outputs 3 - different

    obj1.z = 100;
    std::cout << obj2.z; //outputs 100 - same
    std::cout << Foo::z; //outputs 100
}

我们还可以使用成员函数和静态函数来访问变量：

struct Foo {
    int getA() const {return a;}
    void setA (int newA) {a = newA;}

    static int getX() const {return x;}
    static void setY (int newY) {return y;}
    static void setB (int newB) {
        b = newB; //error: static functions can't access instance members
    }
}

int main() {
    Foo obj1 (6, 9, 10);

    std::cout << obj1.getX(); //outputs 3
    Foo::setY (5);

    obj1.setA (98);
    std::cout << obj1.getA(); //outputs 98
}

回顾一下：

• 每个对象都可以访问自己的实例成员。一个对象的实例成员不会影响另一个对象（除非它们是指的，例如引用）。

• 两个对象共享同一个静态成员池。此池已创建，可以在创建任何对象之前使用Foo::语法或使用obj1.或obj2.语法进行操作。在某处更改静态成员会影响所有情况。

• 要控制这些成员的使用，请将其设为私有并提供访问功能。请注意，静态函数无法访问实例成员。该函数可以在没有创建任何对象的情况下使用，那么它应该对实例成员做什么呢？它没有要更改的特定对象的实例对象池！

• 为了详细说明最后一点，成员函数得到一个传递给它们的隐式this参数，告诉他们在你做什么时要修改哪个变量。 a = newA;实际上相当于this->a = newA;。但是，静态成员函数不会获得this参数，因此无法知道要修改哪个对象。