Variant类，实现单链表原型中节点可存储任意类型

首先做一个Variant类，其实在Boost库中有Variant类，但是还是自己实现一个功能比较简单的小规模的类。

当然如果想要一个存储任意类型的数据的类，肯定要用到指针，这个是第一点。比较难的点是任意数据类型的析构，在这里本来想用std::allocator来实现。现在自己写了一个简单的，废话不多说，上代码。

这个是我自己的variant类的实现(Variantjmy)，my_variant.h头文件：

/*
realize the logic of variant,we could store any type
of value in the variant type
*/
#ifndef MY_VARIANT_H
#define MY_VARIANT_H

#include <iostream>
#include <string>
#include <memory>
class IAllocator
{
public:
    virtual ~IAllocator() {};
    virtual void construct(void* p) = 0;
    virtual void destroy(void* p) = 0;
};

//IAllocator::~IAllocator(){}

template<typename T>
class myAllocator: public IAllocator
{
public:
    void construct(void* p)
    {
        new (p)T();         //new T from the address of p
    }

    void destroy(void* p)
    {
        ((T*)p)->~T();      
    }
};

class Variantjmy
{
private:
    union u_value
    {
        int u_i;
        double u_d;
        float u_f;
        char u_c;
    };
    //accept the normal type of data
    u_value my_union;
    //point to the abnormal type of data
    void *m_pstr;

    std::shared_ptr<IAllocator> m_alloc;

public:
    Variantjmy():m_pstr(nullptr){}

    ~Variantjmy()
    {
        if (m_alloc.get() != nullptr)
        {
            m_alloc->destroy(m_pstr);
        }        
    }
    //setValue 
    template<typename T>
    void setValue(const T inValue)
    {
        m_alloc.reset(new myAllocator<T>());

        void* pmem = malloc(sizeof(T));
        m_alloc->construct(pmem);
        m_pstr = pmem;

        *(T*)m_pstr = inValue;
    }
    //setValue's template specialize
    template<>
    void setValue(const int inValue)
    {
        my_union.u_i = inValue;
    }
    template<>
    void setValue(const double inValue)
    {
        my_union.u_d = inValue;
    }
    template<>
    void setValue(const float inValue)
    {
        my_union.u_f = inValue;
    }
    template<>
    void setValue(const char inValue)
    {
        my_union.u_c = inValue;
    }

    //getValue  function
    template<typename T>
    T getValue()
    {
        return *(T*)m_pstr;
    }
    template<>
    int getValue<int>()
    {
        return my_union.u_i;
    }
    template<>
    double getValue<double>()
    {
        return my_union.u_d;
    }
    template<>
    float getValue<float>()
    {
        return my_union.u_f;
    }
    template<>
    char  getValue<char>()
    {
        return my_union.u_c;
    }
};


#endif // MY_VARIANT_H

上面的代码就实现了存储任意类型的类，下面当然是用单链表来包一下数据，但是里面的函数我没有多写，只是简单的插入，删除。如果大家有兴趣可以发掘更多的功能。

代码variant_list.h

/*
realize the single-list and the node of the
list is a vector that fulled with variant 
type value
*/
#ifndef VARIANTLIST_H_
#define VARIANTLIST_H_

#include <vector>
#include "my_variant.h"
class Variantlist
{
private:
    struct LNode 
    {
        Variantjmy value;
        LNode* next;
    };
    LNode* header;

public:
    Variantlist():header(nullptr){}
    ~Variantlist()
    {
        while (header != nullptr)
        {
            LNode* tempNode = header->next;
            delete header;
            header = tempNode;
        }
    }
    //get the header
    LNode* getheader()
    {
        return header;
    }

    //insert one kind of type value
    template<typename T>
    void insertNode(T data);

    //deleteNode
    bool deleteNode(LNode* delNode);    
};

template<typename T>
void Variantlist::insertNode(T data)
{
    Variantjmy tempvt;
    tempvt.setValue(data);

    LNode* newNode = new LNode;
    newNode->value = tempvt;
    if (header == nullptr)
    {
        header = newNode;
    }
    else
    {
        LNode* tempNode = header;
        while (tempNode->next != nullptr)
        {
            tempNode = tempNode->next;
        }
        tempNode->next = newNode;
    }
    newNode->next = nullptr;
}

bool Variantlist::deleteNode(LNode* delNode)
{
    if (header == nullptr || delNode == nullptr)
    {
        return false;
    }

    Variantjmy tempvt;
    LNode* tempNode = new LNode;
    tempNode = header;
    while (tempNode->next != delNode)
    {
        tempNode = tempNode->next;
        if (delNode->next == nullptr)
        {
            tempNode->next =nullptr;
        }
        else
        {
            tempNode->next = delNode->next;
        }
        delete delNode;
        return true;
    }
    return false;
}


#endif