在if语句内声明可变类型变量并在外部使用的编译问题

我写了一个读取命令行参数来选择三种算法之一的程序，但不同参数对应不同的模板变量类型，没法在if语句前声明空变量。提前声明变量再覆盖又会出现逻辑混乱，怎么调整才能让程序编译通过？

原代码示例 #

std::string argType = argv[1];
if (argType =="Type_A") {
    outPrint="Ty_A";
    AlgoPick<Type_A> algorithm = AlgoPick<Type_A>();
} else if (argType =="Type_B") {
    outPrint="Ty_B";
    AlgoPick<Type_B> algorithm = AlgoPick<Type_B>();
} else {
    outPrint="Ty_O";
    AlgoPick<Type_O> algorithm = AlgoPick<Type_O>();
}

std::cout << algorithm.eval() << std::endl;

预声明变量的异常情况 #

AlgoPick<Type_A> algorithm;

AlgoPick<Type_B> algorithm = AlgoPick<Type_B>();
/*这么做会同时混入Type_A和Type_B的逻辑，而不是只保留Type_B的逻辑*/

可行解决方案 #

方法1：多态基类+虚函数 #

给所有AlgoPick<T>定义一个公共基类，包含纯虚的eval()方法，让AlgoPick<T>继承并实现这个方法。用基类指针或引用统一管理不同类型的算法实例，就能跨作用域调用统一接口。

示例代码：

// 定义公共基类，必须包含虚析构函数避免内存泄漏
class AlgoBase {
public:
    virtual ~AlgoBase() = default;
    virtual int eval() const = 0; // 返回值类型根据实际需求调整
};

// 修改AlgoPick模板类，继承基类并实现虚函数
template<typename T>
class AlgoPick : public AlgoBase {
public:
    int eval() const override {
        // 原有的eval逻辑，比如调用T的计算方法
        return T::compute();
    }
};

// 主函数中使用智能指针管理基类对象
std::string argType = argv[1];
std::unique_ptr<AlgoBase> algorithm;

if (argType == "Type_A") {
    outPrint = "Ty_A";
    algorithm = std::make_unique<AlgoPick<Type_A>>();
} else if (argType == "Type_B") {
    outPrint = "Ty_B";
    algorithm = std::make_unique<AlgoPick<Type_B>>();
} else {
    outPrint = "Ty_O";
    algorithm = std::make_unique<AlgoPick<Type_O>>();
}

std::cout << algorithm->eval() << std::endl;

方法2：用std::variant（C++17及以上） #

std::variant是C++17引入的类型安全联合体，可以存储多种指定类型的对象。配合std::visit就能对不同类型的实例调用统一的eval方法。

示例代码：

#include <variant>

// 定义包含所有可能算法类型的variant
using AlgoVariant = std::variant<AlgoPick<Type_A>, AlgoPick<Type_B>, AlgoPick<Type_O>>;

std::string argType = argv[1];
AlgoVariant algorithm;

if (argType == "Type_A") {
    outPrint = "Ty_A";
    algorithm = AlgoPick<Type_A>();
} else if (argType == "Type_B") {
    outPrint = "Ty_B";
    algorithm = AlgoPick<Type_B>();
} else {
    outPrint = "Ty_O";
    algorithm = AlgoPick<Type_O>();
}

// 使用std::visit访问variant中的对象并调用eval
std::visit([](const auto& algo) {
    std::cout << algo.eval() << std::endl;
}, algorithm);

方法3：将分支逻辑封装到独立函数 #

把每个参数分支的逻辑（创建算法实例+调用eval+输出）单独封装成函数，不用跨作用域访问不同类型的变量，直接在分支里调用对应函数即可。

示例代码：

void runAlgoA() {
    outPrint = "Ty_A";
    AlgoPick<Type_A> algorithm;
    std::cout << algorithm.eval() << std::endl;
}

void runAlgoB() {
    outPrint = "Ty_B";
    AlgoPick<Type_B> algorithm;
    std::cout << algorithm.eval() << std::endl;
}

void runAlgoO() {
    outPrint = "Ty_O";
    AlgoPick<Type_O> algorithm;
    std::cout << algorithm.eval() << std::endl;
}

// 主函数中直接根据参数调用对应函数
std::string argType = argv[1];
if (argType == "Type_A") {
    runAlgoA();
} else if (argType == "Type_B") {
    runAlgoB();
} else {
    runAlgoO();
}

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