C++ 继承下基类的OOPS内存分配？

节目：

class A
{
    int a;
public:

    void geta()
    {
        a=10;
    }
    void puta()
    {
        cout<<"a : "<<a;
    }
};

class B : public A
{
    int b;
public:

    void getb()
    {
        geta(); b=20;
    }
    void putb()
    {
        puta(); cout<<"b : "<<b;
    }
};

int main()
{
    B ABC;
    ABC.getb();
    ABC.putb();
    return 0;
}

A类
{
INTA；
公众：
void geta（）
{
a=10；
}
无效puta（）
{
库特
基类作为公共继承，而变量“a”是私有成员，因此不会被继承

当基类成员声明为
private
时，并不意味着它不会被继承。它只是意味着成员变量将被继承（将是派生类的一部分），但将不可访问

例如，在：

class A {
private:
    int a;
    int b;
    // ...
};

class B : public A {};

auto main() -> int {
    B b;
}

当我们分配
BB；
时，我们同时分配了类
a
和
B
的成员对象
a
您将存储与访问控制混淆了

如果对象B继承自对象A，则它拥有对象A的所有方法和成员，即使它无法直接访问它们

private
和
protected
的目的是访问控制。如果将成员和方法标记为private，则外部的任何东西都无法访问这些方法和成员。但是，这些东西仍然是对象的一部分

这允许您实现类不变量，而无需公开细节，包括从基继承的类

下面的示例封装了捕获基类中对象的创建时间：

#include <time.h>
#include <iostream>

class Base
{
    private:
        time_t create_time;

    public:
        Base()
        {
            create_time = time(0);
        }

        time_t get_create_time() { return create_time; }
};

class Derived : public Base
{
    public:
        Derived() { }
};


int main()
{
    Derived D;

    std::cout << D.get_create_time() << std::endl;
}

#包括
#包括
阶级基础
{
私人：
时间不能创造时间；
公众：
Base（）
{
创建时间=时间（0）；
}
time\u t get\u create\u time（）{return create\u time；}
};
派生类：公共基
{
公众：
派生（）{}
};
int main（）
{
导出D；
std:：cout变量
a
是继承的，尽管您无法访问它。例如，以下代码可以工作：

class A {
private:
    int x;
public:
    int getXfromA() { return x; }
};

class B : public A {
public:
    int getXfromB() { return getXfromA(); }
};

但是，
x
不能从这里的B类直接访问

由于变量“a”是私有成员，它不会被继承。因此，程序不应为此变量分配内存

你的假设是错误的。公共继承模型是“is-a”关系。也就是说，类
派生的
是一个
基
。你可以用
基
做的任何事情，你都应该能用
派生的
做。为了实现这一点，它必须包含
基
包含的所有内容

在你的例子中，说：

B b;
b.put_a();

也就是说，在
B
对象上使用
A
方法。如果
A
成员不存在，这将不起作用。
很简单：
A
是继承的，并且是继承自
A
的所有类型的一部分。您只是无法从
B
访问它。但是，继承&OOP背后的目标不是只继承selecti吗VE成员，因此，降低内存成本？所以，好像内存被分配给类A作为对象，然后再次作为类对象B，但封装在B类中？不，这不是目标。至少在C++中没有。哦，好的。谢谢！谢谢！没想到过！谢谢！我明白。