Question

这是我的问题。我想要这样的东西：

class A {
protected:
int someInt;
virtual void someFunc() = 0;

};

class B : public A {
protected:
virtual void someFunc() { // uses someInt}
public:
B() {//tell the A inside of B to set someInt to whatever it wants}
};

所以基本上，someInt可以改变，它不是常数，但我希望所有实现A的类都使用A为someInt提供的值。

由于

Answer 1

您可以在构造函数中使用初始化列表来调用父构造函数：

class A {
protected:
    int someInt;
    virtual void someFunc() = 0;
    A(int x) : someInt(x) {}  // Base-class constructor (initialises someInt)
};

class B : public A {
protected:
    virtual void someFunc() {}
public:
    B() : A(10) {}  // Initialises base class via constructor
};

Answer 2

这是你想要的吗？

class A
{
protected:
    int someInt;

public:
    A(int _val) : someInt(_val)
    {
    }; // eo ctor
}; // eo class A


class B : public A
{
public:
    B() : A(5) // initialise someInt with 5
    {
    }; // eo ctor
}; // eo class B

注意，因为“someInt”受到保护，所以无论如何你都可以在B的构造函数中设置它。

    B()
    {
        A::someInt = 5;
    }; // eo ctor

Answer 3

我不确定你想要什么，但如果你在someInt的构造函数中初始化A，子类将看到该值。

class A {
public:
    A() : someInt(5) {}
protected:
int someInt;
virtual void someFunc() = 0;

};

class B : public A {
protected:
virtual void someFunc() { // uses someInt}
public:
B() {// at this point someInt will already have been initialized to 5}
};

构造子类时，首先执行基类构造函数。

Answer 4

class A {
protected:
    int someInt;
    virtual void someFunc() = 0;
    A(){//set someInt here}
};

class B : public A {
protected:
    virtual void someFunc() { // uses someInt}
public:
    B():A() {}
};

受保护的构造函数将实现此目的。如上。使用公共构造函数的解决方案也很好，但由于构造函数不能直接在thr接口上调用，我认为protected更好。

初始化一个抽象类？

4 个答案: