C++类的重载成员函数能否依赖对应重载构造函数的执行结果？

原代码核心问题 #

你原本的写法无法运行，有两个致命错误：

• C++ 函数重载仅根据参数列表、const/volatile修饰符、引用限定符区分，多个无参、返回值相同的calcVal属于重复定义，编译阶段就会报错。
• 构造函数的输入参数in1~in5是构造函数的局部变量，构造执行完就销毁，calcVal中直接访问这些变量属于非法操作，应该访问类的私有成员var1~var5。

这个需求完全可以实现，以下是两种常用的实现方案：

方案1：标记位法（轻量场景首选） #

在类中新增一个私有标记变量，记录构造对象时调用的构造函数版本，calcVal中根据标记值走不同运算逻辑，实现成本极低：

#include <iostream>
class someClass {
private:
    double var1 = 0, var2 = 0, var3 = 0, var4 = 0, var5 = 0;
    int construct_type; // 标记调用的构造函数版本
public:
    someClass(double in1) : var1(in1), construct_type(1) {}
    someClass(double in1, double in2) : var1(in1), var2(in2), construct_type(2) {}
    someClass(double in1, double in2, double in3) : var1(in1), var2(in2), var3(in3), construct_type(3) {}
    someClass(double in1, double in2, double in3, double in4) : var1(in1), var2(in2), var3(in3), var4(in4), construct_type(4) {}
    someClass(double in1, double in2, double in3, double in4, double in5) : var1(in1), var2(in2), var3(in3), var4(in4), var5(in5), construct_type(5) {}

    double calcVal() {
        switch(construct_type) {
            case 1: return var1 + var3; // 对应第一个构造的运算逻辑
            case 2: return var1 + var2; // 对应第二个构造的运算逻辑
            case 3: return var1 + var2 + var3; // 对应第三个构造的运算逻辑
            case 4: return var1 + var2 + var3 + var4; // 对应第四个构造的运算逻辑
            case 5: return var1 + var2 + var3 + var4 + var5; // 对应第五个构造的运算逻辑
            default: return 0;
        }
    }
};

// 测试代码
int main() {
    someClass obj1(10);
    std::cout << "单参数构造calcVal结果：" << obj1.calcVal() << std::endl; // 输出10+0=10

    someClass obj2(10, 20);
    std::cout << "双参数构造calcVal结果：" << obj2.calcVal() << std::endl; // 输出10+20=30

    someClass obj3(10,20,30);
    std::cout << "三参数构造calcVal结果：" << obj3.calcVal() << std::endl; // 输出60
    return 0;
}

方案2：多态实现（适合需要频繁扩展逻辑的场景） #

如果后续会新增更多构造和运算逻辑，可以用继承+多态的方式，把不同运算逻辑拆分到不同子类中，避免calcVal里的分支代码越来越臃肿：

#include <iostream>
// 抽象基类
class someBase {
protected:
    double var1 = 0, var2 = 0, var3 = 0, var4 = 0, var5 = 0;
public:
    virtual double calcVal() const = 0; // 纯虚函数，子类必须重写
    virtual ~someBase() = default;
};

// 单参数构造对应的子类
class Type1 : public someBase {
public:
    Type1(double in1) { var1 = in1; }
    double calcVal() const override {
        return var1 + var3;
    }
};

// 双参数构造对应的子类
class Type2 : public someBase {
public:
    Type2(double in1, double in2) { var1 = in1; var2 = in2; }
    double calcVal() const override {
        return var1 + var2;
    }
};

// 三参数构造对应的子类
class Type3 : public someBase {
public:
    Type3(double in1, double in2, double in3) { var1 = in1; var2 = in2; var3 = in3; }
    double calcVal() const override {
        return var1 + var2 + var3;
    }
};

// 测试代码
int main() {
    someBase* obj1 = new Type1(10);
    std::cout << "单参数构造calcVal结果：" << obj1->calcVal() << std::endl; // 输出10

    someBase* obj2 = new Type2(10,20);
    std::cout << "双参数构造calcVal结果：" << obj2->calcVal() << std::endl; // 输出30

    delete obj1;
    delete obj2;
    return 0;
}

内容的提问来源于stack exchange，提问作者drakon101