Question

我有一个基类，一个从该基类派生的类，以及另一个派生类派生的类。我的问题来自于使用构造函数来确定如何构造下一个类。

这是我使用继承时遇到的问题的简化版本。我是c ++的新手。

基类：

class Grandfather
{
    public:
        Grandfather(int A, int B, int C) : a(A), b(B), c(C)
        {}

        virtual ~Grandfather();
        virtual int getA();
        virtual int getB();
        virtual int getC();

    private:
       int a,b,c;

};

派生的父类：

class Father : public Grandfather
{
    public:
        Father(int d);
        virtual ~Father();
    private:
        int c; // i know this at compile time. How to define?

};

在Father.cpp中，构造函数定义如下：

Father::Father(int d){
    int a,b; //Father takes a parameter that then determines what a and b are

    switch(d){
       case 1:
          a=2;
          b=5
       case 2:
          a=6;
          b=9;
       default:
          a=10;
          b=2;
    }


   Grandfather(a,b,c); // where c is a known constant for this class
}

派生的派生Child类：

class Child : public Father
{
    public:
        Child() : Father(int d) // d is a known constant for this class
        {}
        virtual ~Child();
    private:
        int d; // how do i define d, if it is known at compile time?

};

因此，Child在编译时具有已知的整数值。创建Child对象时，它会自动使用其变量调用Father构造函数。 Father(in d)构造函数查看已从Child传递的此变量，执行快速操作，然后使用自己已知的int c调用GrandFather构造函数，再调用两个{{1}这是基于给出的int a,b创建的。这显然不起作用，因为默认的int d构造函数被自动调用

Answer 1

这显然不起作用，因为默认的Grandfather（）构造函数被自动调用

好捕获，Grandfather(a,b,c);创建一个单独的临时实例。

你能做什么：

Father::Father(int d) :
Grandfather(determine_a(d), determine_b(d), c) // c is static constexpr
{
}

它可能是两个函数，或者您可以使用std::array和一个determine_ab函数重构它。这是你的选择。

Answer 2

如果您不需要int c类中的Father值，并且您在编译时知道它，只需在调用Grandfather的构造函数中对其进行硬编码。与int d类中的Child值相同。要在调用A的构造函数之前确定B和Grandfather的值，我认为LogicStuff有正确且最美的答案。我给你写了一个简短的例子，我缩短了原始代码，并且只使用了TS代码中最相关的部分。随意添加其余部分。

class Grandfather
{
        public:
                Grandfather ( int A, int B, int C ) : a ( A ), b ( B ), c ( C ) { }
        private:
                int a, b, c;
};

class Father : public Grandfather
{
        public:
                Father ( const int d ) : Grandfather ( determine_a ( d ), determine_b ( d ), 4 ) { }
                int determine_a ( const int );
                int determine_b ( const int );
};

class Child : public Father
{
        public:
                Child ( ) : Father ( 3 ) { }
};

int Father::determine_a ( const int d )
{
        if      ( d == 1 )      { return 2; }
        else if ( d == 2 )      { return 6; }
        else                    { return 10; }
}

int Father::determine_b ( const int d )
{
        if      ( d == 1 )      { return 5; }
        else if ( d == 2 )      { return 9; }
        else                    { return 2; }
}

c ++继承和类成员

2 个答案: