Question

程序：

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;
}

问题：上面的程序为派生类对象＆amp;分配内存。称其相关方法。基类继承为public，而变量'a'是私有成员，它不会被继承。

因此，程序不应为此变量分配内存。但是，当执行上述操作时，即使它没有被继承，也会分配'a'变量。

有人能帮我理解吗？谢谢。

Answer 1

因为变量'a'是私有成员，所以它不会被继承。因此，程序不应为此变量分配内存。

你的假设是错误的。公共继承模拟“is-a”关系。也就是说，课程Derived 是-a Base。您可以使用Base执行任何操作，您应该可以使用Derived。为了使其成为现实，必须必须包含Base包含的所有内容。

在你的例子中，说完是合法的：

B b;
b.put_a();

即在A对象上使用B方法。如果a成员不在，这将无效。

Answer 2

基类继承为public，而变量'a'是私有成员，它不会被继承。

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

例如，在：

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

class B : public A {};

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

当我们分配B b;时，我们正在分配班级a的{{1}}和b成员对象。

Answer 3

您将存储与访问控制混淆。

如果对象B继承自对象A，它具有对象A的所有方法和成员，即使它不能直接访问它们。

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

这允许您实现类不变量而不暴露细节，包括从基类继承的类。

这是一个封装捕获对象在基类中的创建时间的示例：

#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;
}

Derived不知道或不需要知道如何捕获创建时间。它是从Base派生而继承的类不变量。

这是一个非常简单的例子，但你可以想象更复杂的例子。

Answer 4

变量a 是继承的，但您无法访问它。例如，以下代码可以使用：

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

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

但是，无法在此处直接从B类访问x。

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

4 个答案: