如何实现支持多数据类型的C++链表？现有单类型链表待扩展

你的需求完全可以实现，C++有多种方式支持这种存储不同类型数据的链表，下面是几种常用的可行方案：

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

std::variant是C++17引入的类型安全联合体，能在编译期指定允许存储的所有类型，既满足类型检查要求，又能让不同节点存储不同数据。

修改后的核心代码示例：

#include <variant>
#include <string>

struct node{
  // 指定允许存储的类型，可按需扩展（比如添加double等）
  std::variant<int, std::string> key;
  node* next;
  node* previous;
};

class linkedList{
public:
    linkedList();
    ~linkedList();

    // 重载push，支持直接传入int或string
    void push(int key);
    void push(const std::string& key);
    void pop();
    
    // 返回variant，调用方需自行处理类型判断
    std::variant<int, std::string> get(int index);

    void print();
    void sort();

private:
    node* root;
    void push(std::variant<int, std::string> key, node* n);
    void pop(node* n);
    void destroy_list();
};

访问数据时可通过std::get或std::visit处理：

auto val = list.get(1);
if (std::holds_alternative<int>(val)) {
    int num = std::get<int>(val);
} else if (std::holds_alternative<std::string>(val)) {
    std::string str = std::get<std::string>(val);
}

优点：类型安全，编译期检查，无额外运行时开销；缺点：可存储类型必须在编译期确定，无法动态添加新类型。

2. 基类+多态（传统面向对象实现） #

通过定义抽象基类，派生对应不同数据类型的节点类，链表存储基类指针，利用多态实现统一操作。

核心代码示例：

#include <string>
#include <iostream>

// 抽象基类
struct BaseNode {
    BaseNode* next;
    BaseNode* previous;
    virtual ~BaseNode() = default; // 虚析构保证派生类正确析构
    virtual void print() const = 0; // 纯虚函数，派生类实现具体打印逻辑
};

// 存储int的节点
struct IntNode : BaseNode {
    int key;
    IntNode(int k) : key(k) {}
    void print() const override {
        std::cout << key;
    }
};

// 存储string的节点
struct StringNode : BaseNode {
    std::string key;
    StringNode(const std::string& k) : key(k) {}
    void print() const override {
        std::cout << key;
    }
};

class linkedList{
public:
    linkedList();
    ~linkedList();

    // 模板push，自动创建对应类型的节点
    template<typename T>
    void push(T key);
    void pop();
    
    // 返回基类指针，调用方需动态转换到具体类型
    BaseNode* get(int index);

    void print();
    void sort();

private:
    BaseNode* root;
    void push(BaseNode* newNode, BaseNode* n);
    void pop(BaseNode* n);
    void destroy_list();
};

// 模板push的实现示例
template<typename T>
void linkedList::push(T key) {
    BaseNode* newNode = nullptr;
    if constexpr (std::is_same_v<T, int>) {
        newNode = new IntNode(key);
    } else if constexpr (std::is_same_v<T, std::string>) {
        newNode = new StringNode(key);
    }
    // 后续链表插入逻辑
}

优点：可在运行时动态添加新的节点类型；缺点：存在虚函数调用开销，需注意内存管理（建议用std::unique_ptr替代裸指针避免泄漏），类型转换需谨慎。

3. 使用std::any（C++17及以上） #

std::any是更灵活的类型擦除工具，可存储任意类型数据，但类型检查只能在运行时进行。

核心代码示例：

#include <any>
#include <string>

struct node{
    std::any key;
    node* next;
    node* previous;
};

class linkedList{
public:
    linkedList();
    ~linkedList();

    // 模板push，支持任意类型
    template<typename T>
    void push(T key);
    void pop();
    
    // 返回std::any，调用方需用any_cast转换
    std::any get(int index);

    void print();
    void sort();

private:
    node* root;
    void push(std::any key, node* n);
    void pop(node* n);
    void destroy_list();
};

访问数据时需处理转换失败的情况：

auto val = list.get(2);
try {
    std::string str = std::any_cast<std::string>(val);
} catch (const std::bad_any_cast& e) {
    // 转换失败的处理逻辑
}

优点：极度灵活，可存储任意类型；缺点：运行时类型检查易出错，存在一定性能开销。

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