0

抱歉，如果这是一个明显的问题，但我已经四处搜索，但我仍然不清楚如何解决这个问题。这是我的代码：

#include <iostream>
#include <string>
using namespace std;

class PermMagnet {
public:
    string name;
    int ac_rating;
    int dc_rating;
    int mass_kg;
    int age;
    PermMagnet(){
        // default constructor
        name = "";
        ac_rating = 0; dc_rating = 0;
        mass_kg = 0; age = 0;
    }
    PermMagnet(string c_name, int c_ac_rating, int c_dc_rating, int c_mass_kg, int c_age){
        // parameterised constructor
        name = c_name;
        ac_rating = c_ac_rating;
        dc_rating = c_dc_rating;
        mass_kg = c_mass_kg;
        age = c_age;
    }
    string get_owner(){
        return owner;
    }
    string get_classifier(){
        return classifier;
    }
    int get_coil_count(){
        return coil_num;
    }
protected:
    string location = "facility hall";
private:
    string owner = "Unspecified Staff";
    string classifier = "MAG-DP-";
    const int coil_num = 2;
};

class ElecMagnet : public PermMagnet {
public:
    // inherit base class constructors
    using PermMagnet::PermMagnet;

    string get_location(){
        return location;
    }

private:
    string owner = "Specified Staff";
    string classifier = "MAG-QD-";
    const int coil_num = 4;
};

int main() {

    // Create object using default constructor
    PermMagnet perm1;
    cout << "'perm1' age: " << perm1.age << endl;

    // Create object using parameterised constructor
    PermMagnet perm2("PermMagnet 2", 380, 400, 1500, 35);
    cout << "'perm2' age: " << perm2.age << " | 'perm2' name: " << perm2.name << endl;
    cout << "Owner of 'perm2': " << perm2.get_owner() << endl;
    cout << "Upper current bound of 'perm2': " << perm2.get_current_limit("upper") << "A" << endl;
    cout << "Number of coils in 'perm2': " << perm2.get_coil_count() << endl << endl;

    // Create a ElecMagnet (derived class) object
    ElecMagnet elec1("ElecMagnet 1", 170, 200, 850, 27);
    cout << elec1.get_classifier() << endl;
    cout << elec1.get_coil_count() << endl;

    return 0;
}

这段代码的输出是：

'perm1' age: 0
'perm2' age: 35 | 'perm2' name: PermMaget 2
Owner of 'perm2': Unspecified Staff
Upper current bound of 'perm2': 780A
Number of coils in 'perm2': 2

MAG-DP-
2

Process finished with exit code 0

如您所见，我希望“所有者”、“分类器”和“线圈编号”成为用户无法更改的私有成员。这些也因所讨论的班级而异。

问题：

问题是输出的最后两行。当派生类（ElecMagnet）继承返回这些成员的公共函数时，它返回基类的成员；不是它自己的。您可以看到这一点，因为它返回 PermMagnet 类的“分类器”和“线圈编号”。

有谁知道为什么派生类会这样？它不应该访问自己的私人成员而不是基地吗？

4

3 回答 3

0

继承使用“是”关系。意思是，您应该能够说子对象“是”基础对象。如果你不能这么说，你不应该使用继承。

这对于构建派生对象意味着它是一个复合对象，包含您的基础对象，以及通过继承添加的任何额外位。

您调用了基础对象函数，这意味着它将访问基础对象数据。在派生类中重复数据显然是行不通的，而且是一种不好的做法。如果您需要相同的数据，请使用它并且不要重复它。

为此，您的派生类构造函数总是在初始化部分首先调用基类构造函数。您根本不使用初始化部分，这可能会导致很多效率低下并最终导致错误。

随机位：所有类数据都应该是私有的。班级的protected:部分包含您希望孩子可以公开访问但不想完全公开的任何内容。如果您不希望 getter 公开可用，他们可以去那里。我放置了几个仅仅为了ElecMagnet这里而存在的构造函数。using namespace std;是不好的做法。

编码：

#include <iostream>
#include <string>

class PermMagnet {
 public:
  PermMagnet() = default;
  PermMagnet(std::string c_name, int c_ac_rating, int c_dc_rating,
             int c_mass_kg, int c_age)
      : name(c_name),
        ac_rating(c_ac_rating),
        dc_rating(c_dc_rating),
        mass_kg(c_mass_kg),
        age(c_age) {}  // Use the initialization section

  std::string get_owner() const { return owner; }  // Mark getters as const

  std::string get_classifier() const { return classifier; }

  int get_coil_count() const { return coil_num; }

  std::string get_location() const { return location; }

  int get_age() const { return age; }

  std::string get_name() const { return name; }

 protected:
  PermMagnet(std::string owner, std::string classifier, int coilNum)
      : owner(owner), classifier(classifier), coil_num(coilNum) {}

  PermMagnet(std::string name, int ac_rating, int dc_rating, int mass_kg,
             int age, std::string owner, std::string classifier, int coilNum)
      : name(name),
        ac_rating(ac_rating),
        dc_rating(dc_rating),
        mass_kg(mass_kg),
        age(age),
        owner(owner),
        classifier(classifier),
        coil_num(coilNum) {}

 private:
  std::string owner = "Unspecified Staff";
  std::string classifier = "MAG-DP-";
  const int coil_num = 2;  // const probably unnecessary here, but left it
  std::string location = "facility hall";
  std::string name = "";
  int ac_rating = 0;
  int dc_rating = 0;
  int mass_kg = 0;
  int age = 0;
};

class ElecMagnet : public PermMagnet {
 public:
  ElecMagnet() : PermMagnet("Specified Staff", "MAG-QD-", 4) {}

  ElecMagnet(std::string name, int ac_rating, int dc_rating, int mass_kg,
             int age)
      : PermMagnet(name, ac_rating, dc_rating, mass_kg, age, "Specified Staff",
                   "MAG-QD-", 4) {}

  // NO NEED FOR REPETITIVE PRIVATE SECTION
};

int main() {
  // Create object using default constructor
  PermMagnet perm1;
  std::cout << "'perm1' age: " << perm1.get_age()
            << '\n';  // Prefer '\n' over std::endl

  // Create object using parameterised constructor
  PermMagnet perm2("PermMagnet 2", 380, 400, 1500, 35);
  std::cout << "'perm2' age: " << perm2.get_age()
            << " | 'perm2' name: " << perm2.get_name() << '\n';
  std::cout << "Owner of 'perm2': " << perm2.get_owner() << '\n';
  std::cout << "Number of coils in 'perm2': " << perm2.get_coil_count()
            << "\n\n";

  // Create a ElecMagnet (derived class) object
  ElecMagnet elec1("ElecMagnet 1", 170, 200, 850, 27);
  std::cout << elec1.get_classifier() << '\n';
  std::cout << elec1.get_coil_count() << '\n';

  return 0;
}

请注意，ElecMagnet该类目前只是几个构造函数，并且您的 main 函数的行为方式符合预期。

于 2020-12-23T15:45:47.930 回答
0

发生这种情况是因为您仍在调用基类的方法，它不知道派生类的成员变量，因此不会使用它们。要归档您想要的内容，您需要get_classifier()在派生类中进行覆盖，以便通过ElecMagnet-reference 调用它将调用派生方法。当通过-reference 在 -valuevirtual上调用它时，您可以选择创建 method ，甚至调用派生版本。（通常建议创建为继承而设计的类。）ElecMagnetPermMagnetvirtual

或者，根据您的用例，using您可以编写显式构造函数来调用（可能受保护的）具有适当值的基本构造函数，而不是基本构造函数classifier。这将完全为您节省派生类中的其他成员变量。

于 2020-12-23T15:10:18.347 回答
0

私有成员只能被同一个类或朋友的成员函数访问。C++ 的行为与 Python 不同，在 Python 中，变量的搜索是根据当前指针this( self) 动态执行的。

于 2020-12-23T15:07:23.767 回答