C++ 在调用基类构造函数之前执行代码

有没有更好的方法可以做到这一点，而无需更改

Base

---

编辑-made

确定a_和b_

静态

这里可以做的是编写一个函数，返回一个

基

，并在函数中从

确定a_和b_

返回的

std:：pair

创建基。这允许您有条件地初始化成员初始化列表中的base。你会有

Derived::Derived(int k) : Base() {
    Base::init_(a, b);
}

类基{
公众：
基础（内部a、内部b）；
};
派生类：公共基{
私人：
静态std：：对确定_a_和_b_（int k）；
静态基址create_Base（const std:：pair¶ms）{返回基址（params.first，params.second）；}
公众：
显式导出（intk）；
};
派生：：派生（int k）：基（创建基（确定a和b）

在构造函数开始运行之前调用成员函数总是不可靠的。您最终会在尚未构造的对象上运行代码

另一种方法是从第二个基类派生。该基类首先初始化，选择a和b，然后使用它们初始化第二个基类：

class Base {
public:
    Base(int a, int b);
};

class Derived : public Base {
private:
    static std::pair<int, int> determine_a_and_b_(int k);
    static Base create_base(const std::pair<int, int>& params) { return Base(params.first, params.second); }
public:
    explicit Derived(int k);
};

Derived::Derived(int k) : Base(create_base(determine_a_and_b_(k)) {}

类基{
公众：
基（inta，intb）{}；
};
类参数
{
受保护的：
Params（）
{
//这取代了std：：pair determinate_a_和_b_（int k）；
//把你的逻辑放在这里
_第一个值=0；
_值。秒=1；
}
std:：pair\u值；
};
派生类：公共参数，公共基{
私人：
公众：
显式导出（intk）；
};
派生：：派生（int k）：
基础（_values.first，_values.second）
{
}

不会

确定a\u和b\u

和

创建基础
必须是
静态的
以避免依赖于未初始化的对象？很好，但这会永久性地将
派生的
转化为2
int
s。每个对象永远存储
a
和
b
。
class Base {
public:
    Base(int a, int b);
};

class Derived : public Base {
private:
    static std::pair<int, int> determine_a_and_b_(int k);
    static Base create_base(const std::pair<int, int>& params) { return Base(params.first, params.second); }
public:
    explicit Derived(int k);
};

Derived::Derived(int k) : Base(create_base(determine_a_and_b_(k)) {}

class Base {
public:
    Base(int a, int b){};
};

class Params
{
protected:
    Params()
    {
    // this replaces std::pair<int, int> determine_a_and_b_(int k);
    // put your logic here
        _values.first = 0;
        _values.second = 1;
    }
    std::pair<int, int> _values;
};

class Derived : public Params, public Base {
private:
public:
    explicit Derived(int k);
};

Derived::Derived(int k) :
    Base(_values.first, _values.second) 
{

}