Question

我有两个类PARENT和CHILD，后者从其父级继承一个使用私有常量成员值的函数。我希望它使用子元素的成员值，而是使用父元素的值，除非我再次重新定义子元素中的函数（参见CHILD2）。

一个简单的解决方案是重新定义每个孩子的功能（我希望可能有10个孩子类型），但这对我来说似乎不对。

为了使它更清楚，这是一个最小的工作示例：

#include <iostream>
#include <string>

// PARENT Class that has a function to talk
class PARENT {
public:
    void talk() {
        std::cout << "Hello my name is " << name.c_str() << "\n";
    }
private:
    const std::string name = "Parent";
};


// CHILD Class, inherits from PARENT, but should use the different name
class CHILD : public PARENT {
private:
    const std::string name = "Child";
};


// CHILD2 Class, that redefines the talk-function
class CHILD2 : public PARENT {
public:
    void talk() {
        std::cout << "Hello my name is " << name.c_str() << "\n";
    }
private:
    const std::string name = "Child2";
};


int main() {
    PARENT parent;
    CHILD child;
    CHILD2 child2;

    parent.talk(); // expected 'Hello my name is Parent' // GOOD
    child.talk();  // expected 'Hello my name is Child'  // BAD, it uses 'Parent'
    child2.talk(); // expected 'Hello my name is Child2' // GOOD
    return 0;
}

有没有办法在孩子的talk()上使用name - 函数，而无需为每个子类重新声明函数？

Answer 1

您只是不断添加std::string个成员。这开始是浪费，并且是您寻找解决方法的原因。而不是默认初始化所有这些新字符串，允许子类在父级中为它提供值。添加受保护的构造函数：

// PARENT Class that has a function to talk
class PARENT {
public:
    void talk() {
        std::cout << "Hello my name is " << name << "\n";
    }

    PARENT() = default; // To still allow default construction as before

protected:
    explicit PARENT(std::string const& name) : name(name) {}

private:
    const std::string name = "Parent";
};

并在每个子类构造函数中使用它。现在只有一个 talk函数，每个孩子都可以使用自定义点。

class CHILD : public PARENT {
public:
    CHILD() : PARENT("Child") {}
};

Answer 2

仅在父项中保留name变量，将其传递给PARENT的构造函数，将其初始化为子项中所需的名称，并且不要覆盖talk

类继承：在子成员上使用父级函数

2 个答案: