C++ 基类，继承类sizeof（）

在下面的代码中，为什么

sizeof（X）==4

和

sizeof（Y）==8

此外，在类

X

中，为什么成员函数不占用任何内存空间

class X {
    int i;
public:
    X() { i = 0; }
    void set(int ii) { i = ii; }
    int read() const { return i; }
    int permute() { return i = i * 47; }
};

class Y : public X {
    int i; // Different from X's i
public:
    Y() { i = 0; }
    int change() {
        i = permute(); // Different name call
        return i;
    }
    void set(int ii) {
        i = ii;
        X::set(ii); // Same-name function call
    }
};


    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "sizeof(Y) = " << sizeof(Y) << endl;

X类{
int i；
公众：
X（）{i=0；}
空集（intⅡ）{i=ii；}
int read（）常量{return i；}
int permute（）{return i=i*47；}
};
Y类：公共X类{
int i；//与X的i不同
公众：
Y（）{i=0；}
int change（）{
i=permute（）；//不同的名称调用
返回i；
}
无效集（int ii）{
i=ii；
X:：set（ii）；//同名函数调用
}
};
类
Y
的对象不能有两个整数成员；类
X
的对象有一个。您的评论表明，
Y
的
i
与
X
的
i
不同，因此看起来您已经知道答案了

有关类
Y
的对象如何实际具有两个
i
成员的示例，请参见

此处重复代码：

#include <iostream>
using namespace std;

class X {
  int i;
public:
  X(): i(4) {}
  int getI() {return i;}
};

class Y: public X {
  int i;
public:
  Y(): i(10) {}
  int getMyI() {return i;}
};

int main() {
  Y y;
  cout << y.getI() << ' ' << y.getMyI() << '\n';
}

main
中只有一个对象称为
y
。请注意，
y
必须有两个
i
字段才能使输出有意义。
类
y
的对象有两个整数成员；类
X
的对象有一个。您的评论表明，
Y
的
i
与
X
的
i
不同，因此看起来您已经知道答案了

有关类
Y
的对象如何实际具有两个
i
成员的示例，请参见

此处重复代码：

#include <iostream>
using namespace std;

class X {
  int i;
public:
  X(): i(4) {}
  int getI() {return i;}
};

class Y: public X {
  int i;
public:
  Y(): i(10) {}
  int getMyI() {return i;}
};

int main() {
  Y y;
  cout << y.getI() << ' ' << y.getMyI() << '\n';
}

main
中只有一个对象称为
y
。请注意，
y
必须有两个
i
字段才能使输出有意义。
X的大小是4，因为它有一个int i

Y的大小是8，因为基类i+派生类i

成员函数不取大小，除非您有一个虚拟函数，那么用于存储vpointer的它将有4个字节。
X的大小是4，因为它有一个int i

Y的大小是8，因为基类i+派生类i

成员函数不采用大小，除非您有一个虚拟函数，那么用于存储vpointer，它将有4个字节。
X是基类。只有一个数据成员，即：
int i
。Y是从X派生出来的，它有自己的和派生的数据成员。ie:2个
inti
s
 X是基类。只有一个数据成员，即：
int i
。Y是从X派生出来的，它有自己的和派生的数据成员。ie:2个
inti
s

此外，在类X中，为什么成员函数不占用任何内存空间

class X {
    int i;
public:
    X() { i = 0; }
    void set(int ii) { i = ii; }
    int read() const { return i; }
    int permute() { return i = i * 47; }
};

class Y : public X {
    int i; // Different from X's i
public:
    Y() { i = 0; }
    int change() {
        i = permute(); // Different name call
        return i;
    }
    void set(int ii) {
        i = ii;
        X::set(ii); // Same-name function call
    }
};


    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "sizeof(Y) = " << sizeof(Y) << endl;

我想还没有人讨论过这一部分。类的成员函数不存储在对象本身中，因为它们属于类而不是对象。没有理由在每个对象中存储函数的副本，因为代码始终保持不变

sizeof（X）
返回存储类型为X的实例而不是整个类所需的字节数

此外，成员函数与内存中的任何其他普通c函数一样存储。它只需要一个指向调用它的对象的指针：

int X::permute() { return i = i * 47; }
...
someX.permute();

变成：

int permute(X* _x) { return _x->i = _x->i * 47; }
...
permute(&someX);

成员函数的概念只是我们可以使用的抽象概念。一个对象实际上只包含一个成员变量，可能还有一个虚拟函数表

此外，在类X中，为什么成员函数不占用任何内存空间

class X {
    int i;
public:
    X() { i = 0; }
    void set(int ii) { i = ii; }
    int read() const { return i; }
    int permute() { return i = i * 47; }
};

class Y : public X {
    int i; // Different from X's i
public:
    Y() { i = 0; }
    int change() {
        i = permute(); // Different name call
        return i;
    }
    void set(int ii) {
        i = ii;
        X::set(ii); // Same-name function call
    }
};


    cout << "sizeof(X) = " << sizeof(X) << endl;
    cout << "sizeof(Y) = " << sizeof(Y) << endl;

我想还没有人讨论过这一部分。类的成员函数不存储在对象本身中，因为它们属于类而不是对象。没有理由在每个对象中存储函数的副本，因为代码始终保持不变

sizeof（X）
返回存储类型为X的实例而不是整个类所需的字节数

此外，成员函数与内存中的任何其他普通c函数一样存储。它只需要一个指向调用它的对象的指针：

int X::permute() { return i = i * 47; }
...
someX.permute();

变成：

int permute(X* _x) { return _x->i = _x->i * 47; }
...
permute(&someX);

成员函数的概念只是我们可以使用的抽象概念。一个对象实际上唯一包含的是成员变量，可能还有一个虚拟函数表。
我从一本书的代码中复制。：）现在我知道了。但我不太清楚如何使用这两个不同的答案。希望有帮助。我从一本书的代码中抄写。：）现在我知道了。但我不太清楚如何使用这两个不同的答案。希望能有帮助。