Question

我正在尝试了解继承以及私有，受保护和公共变量的工作方式。

我的理解是，一个类的私有变量只能由该类的成员读取，而受保护的变量只能由该类的成员以及派生类读取。

我正在实现一些代码，以确保我正确地理解了这一点，并且我似乎能够访问我原本无法期望的变量。

我有一个类Polygon和一个派生类Triangle。我在这些类的公共区域编写了一组read（）函数来读取其变量。这些函数被重载，因此不带任何参数的read（）将返回调用对象的变量，或者，read（＆Poly）可以将另一个多边形作为参数并返回另一个多边形的变量。

#include <iostream>
using namespace std;

class Polygon;
class Triangle;

class Polygon {
private:
    int privatePoly = 1;
protected:
    int protectedPoly = 10;
public:
    int publicPoly = 100;


    // Setters
    void setPrivate (int x) { privatePoly = x; }
    void setProtected (int x) { protectedPoly = x; }

    // Read
    int readPrivate (const Polygon& inPoly) { return inPoly.privatePoly; }
    int readProtected (const Polygon& inPoly) { return inPoly.protectedPoly; }
    int readPublic (const Polygon& inPoly) { return inPoly.publicPoly; }
};

class Triangle : public Polygon {
private:
    int privateTriangle = 3;
protected:
    int protectedTriangle = privateTriangle*10;
public:
    int publicTriangle = privateTriangle*100;


    // Read Triangle variables
    int readPrivate_Tri () { return privateTriangle; }
    int readProtected_Tri () { return protectedTriangle; }
    int readPublic_Tri () { return publicTriangle; }

    int readPrivate_Tri (const Triangle& inTri) { return inTri.privateTriangle; }
    int readProtected_Tri (const Triangle& inTri) { return inTri.protectedTriangle; }
    int readPublic_Tri (const Triangle& inTri) { return inTri.publicTriangle; }

};

我实例化了每种类型的一个对象，即多边形P1和三角形T1，并尝试从派生类T1读取P1的私有变量，并期望这样做会失败，因为私有变量不能被派生类读取。没有。

int main(int argc, const char * argv[]) {

    Polygon P1;
    Triangle T1;

    // To make sure T1's polygon variables are different from P1's.
    T1.setPrivate(2);
    T1.setProtected(20);

    // T1 reading P1
    cout << "T1.readPrivate(P1): " << T1.readPrivate(P1) << endl;
    cout << "T1.readProtected(P1): " << T1.readProtected(P1) << endl;
    cout << "T1.readPublic(P1): " << T1.readPublic(P1) << endl << endl;

    return 0;
}

这产生

T1.readPrivate（P1）：1
T1.readProtected（P1）：10
T1.readPublic（P1）：100

我认为这可能与以下事实有关：读取函数最初是在父Polygon类中声明的（并且私有/受保护的说明符引用了声明函数的位置，而不是调用对象是谁），所以我给Triangle类自己的readPolygon（＆Polygon）变量副本。在Triangle类的定义中添加了以下内容：

// Read Polygon variables with separate function unique to Triangle class
int readProtected_P_from_T (const Polygon& inPoly) { return inPoly.protectedPoly; }
int readPublic_P_from_T (const Polygon& inPoly) { return inPoly.publicPoly; }

其中添加了readPublic_P_from_T（）函数以检查函数格式。

这无法编译，并显示错误： “'protectedPoly'是'Polygon'的受保护成员”

我希望它能起作用，因为我认为派生类可以看到受保护的变量。

当我从派生类中调用时，我希望第一个readPrivate函数不起作用。

有人可以解释一下这些访问说明符如何工作吗？

Answer 1

类中的任何函数都可以访问其私有变量。它也可以从继承的类中访问受保护的变量和公共变量。

如果函数本身是公共的，则任何人都可以调用它。

通常，私有变量通过其成员函数用于类的内部需求，而不是面向公众的。但是，公共成员函数可以使用它们来执行特定操作。

在您的情况下，所有成员函数都是公共的。因此，您可以调用它们来访问类中的任何内部数据。

如果要失败，请尝试不使用该功能直接访问成员数据。例如

class A {
   int a = 0;
public:
   int b = 1;
   int getA() {
       return a;
   }
};


 A c1;
 cout << c1.a << c1.b;

由于a是私有的，编译器将无法进行成员访问。

另一方面，如果您使用getA()函数，它将起作用，因为该函数本身可以访问私有成员：

cout << c1.getA() << c1.b;

Answer 2

我的理解是，该类的私有变量只能由该类的成员读取，而受保护的变量只能由该类的成员以及派生类读取。

这种理解是正确的。

我实例化了每种类型的一个对象，即多边形P1和三角形T1，并尝试从派生类T1读取P1的私有变量，并期望这会失败，因为私有变量不能被派生类读取。没有。

readPrivate()是Polygon的成员，因此阅读Polygon的内部结构没有问题。

（公共）继承也允许Triangle具有这些功能，但是由于它们实际上处于Polygon级别，因此没有问题。

无法编译，错误为：“'protectedPoly'是'Polygon'的受保护成员”

您遇到this situation。该链接比我能更好地解释该问题及其答案，所以我将其保留在那里。

有人可以解释一下这些访问说明符如何工作吗？

除了一些微小的差异外，您似乎已经对这个主题有了很好的掌握。但是，如果您想了解有关继承的更多信息，请访问a useful resource on it。

不了解私有/受保护的变量。我的实现未达到我的预期

2 个答案: