C++中如何声明带基参数的模板类变量并在switch分支初始化

首先得明确：你原来的写法是行不通的——MyArray<int>和MyArray<double>是完全独立的类型，它们之间没有继承关系，也不能直接赋值给同一个变量a。要实现你想要的效果，得用C++的类型擦除或变体类型特性，下面给你几种常用的解决方案：

方案1：使用std::variant（C++17及以上推荐） #

std::variant是类型安全的联合体，可以存储多种指定类型中的一种，完美适配这种需要在不同分支初始化不同类型对象的场景。

示例代码 #

#include <variant>
#include <string>
#include <iostream>

// 先定义你的模板类
template<typename T>
class MyArray {
public:
    MyArray(const std::string& name) : name_(name) {}
    // 可以添加一些成员函数，比如打印类型
    void printType() const {
        std::cout << "Type: " << typeid(T).name() << ", Name: " << name_ << std::endl;
    }
private:
    std::string name_;
};

int main() {
    int var = 1;
    // 声明variant，指定可能存储的类型
    std::variant<MyArray<int>, MyArray<double>> a;

    switch(var) {
        case 1:
            a = MyArray<int>("a");
            break;
        case 2:
            a = MyArray<double>("a");
            break;
        default:
            // 处理默认情况，比如抛出异常或初始化默认值
            throw std::invalid_argument("Invalid var value");
    }

    // 使用std::visit访问variant中的值，自动匹配对应类型
    std::visit([](auto& arr) {
        arr.printType();
    }, a);

    return 0;
}

方案2：使用多态（适合需要统一接口的场景） #

如果你的MyArray模板类需要提供一套统一的操作接口，可以定义一个非模板的基类，让模板类继承它，然后用智能指针来管理对象。

示例代码 #

#include <memory>
#include <string>
#include <iostream>

// 定义抽象基类，提供统一接口
class BaseArray {
public:
    virtual ~BaseArray() = default;
    virtual void printType() const = 0;
};

// 模板类继承基类，实现统一接口
template<typename T>
class MyArray : public BaseArray {
public:
    MyArray(const std::string& name) : name_(name) {}
    void printType() const override {
        std::cout << "Type: " << typeid(T).name() << ", Name: " << name_ << std::endl;
    }
private:
    std::string name_;
};

int main() {
    int var = 2;
    // 用智能指针指向基类，实现多态
    std::unique_ptr<BaseArray> a;

    switch(var) {
        case 1:
            a = std::make_unique<MyArray<int>>("a");
            break;
        case 2:
            a = std::make_unique<MyArray<double>>("a");
            break;
        default:
            throw std::invalid_argument("Invalid var value");
    }

    // 直接调用基类接口，自动适配子类实现
    a->printType();

    return 0;
}

方案3：使用std::any（不推荐，类型不安全） #

std::any可以存储任意类型，但访问时需要手动转换类型，容易出错，仅在特殊场景下使用：

示例代码 #

#include <any>
#include <string>
#include <iostream>

template<typename T>
class MyArray {
public:
    MyArray(const std::string& name) : name_(name) {}
    void printType() const {
        std::cout << "Type: " << typeid(T).name() << ", Name: " << name_ << std::endl;
    }
private:
    std::string name_;
};

int main() {
    int var = 1;
    std::any a;

    switch(var) {
        case 1:
            a = MyArray<int>("a");
            break;
        case 2:
            a = MyArray<double>("a");
            break;
        default:
            throw std::invalid_argument("Invalid var value");
    }

    // 访问时需要手动判断类型并转换，极易出错
    if(a.type() == typeid(MyArray<int>)) {
        std::any_cast<MyArray<int>&>(a).printType();
    } else if(a.type() == typeid(MyArray<double>)) {
        std::any_cast<MyArray<double>&>(a).printType();
    }

    return 0;
}

方案选择总结 #

• 若编译器支持C++17，优先选std::variant：类型安全，无需动态内存分配，代码简洁；
• 若需要统一接口操作不同类型的MyArray，用多态+智能指针的方案；
• std::any尽量避免，除非你有特殊的灵活需求，否则类型转换的风险很高。

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