在类构造函数中使用模板化类型

问题描述

我想知道如何做到这一点。

I am wondering how to accomplish this.

template <class T>
class dynamic
{
    friend myclass;
    T dyn_data;
    dynamic() : dyn_data(0) { }
    dynamic(T Data) : dyn_data(Data) { }
}

class myclass
{
private:
    void * m_data;
public:
    myclass() : m_data(nullptr) { }
    ~myclass() { if (m_data != nullptr) delete m_data; }
    template <typename Type> myclass(Type data) { SetData<Type>(data); }
    template <typename Type> void SetData(Type data)
    {
        m_data = new dynamic<Type>(data);
    }
    template <typename Type> void GetData() const
    {
        dynamic<Type> * data;
        data = static_cast <dynamic<Type>*> (m_data);
        return (Type) data->dyn_data;
    }
}

int main()
{
    //This code works as designed
    myclass data1;
    data1.SetData<int>(12);
    int x = data1.GetData<int>();

    //This code also works but defaults the type to a double
    myclass data2(123.4);
    float y = data2.GetData<float>();

    //But intellisense flags this for errors
    myclass<float> data3(234.5);  //class 'myclass' cannot have a template argument list
    float z = data3.GetData<float>(); // multiple errors on this line

    //This is also flagged as an error
    myclass * data4 = new myclass<float>(345.6);
}

简而言之，我试图将模板化类型传递给类构造函数，以便内部模板化类可以构造。

通过使用默认构造函数创建类并通过模板函数填充数据是可能的。

Internet搜索template和constructor返回除了实现模板类的链接之外什么都没有。



我想我的问题是，是否可以在类构造函数中传递模板参数？

我已经尝试了有错误的线路的多种配置但我找不到有效的。



如果是的话，我做错了什么。

如果没有，那么这是一个有趣的想法。

In a nutshell, I am trying to pass templated types into a class constructor so that an internal templated class can be constructed.
It was possible by creating the class with the default constructor and populating the data through a template function.
Internet searches for "template" and "constructor" return nothing but links to implementing template classes.

I guess my question is, is it possible to pass template arguments in a class constructor?
I've tried multiple configurations of the line that has the error but I cannot find one that works.

If it is, what am I doing wrong.
If not, well it's an interesting idea.

推荐答案

class base_data
{
public:
    // This virtual "method" will make sure that the base class has a vtable and in turn, RTTI typeinfo.
    // We need the virtual destructor here anyway because we destruct the data using a pointer to the base class...
    // Deleting a base class pointer when the base class doesn't have a virtual destructor is always a BUG.
    virtual ~base_data() {}
};

template <class T>
class dynamic : public base_data
{
    friend class myclass;
    T dyn_data;
    dynamic() : dyn_data(0) { }
    dynamic(T Data) : dyn_data(Data) { }
};

class myclass
{
private:
    base_data* m_data;
public:
    ~myclass()
    {
        delete m_data;
    }
    myclass() : m_data(nullptr) {}

    template <typename Type>
    myclass(Type data)
    {
        m_data = new dynamic<Type>(data);
    }

    template <typename Type>
    void SetData(Type data)
    {
        delete m_data;
        m_data = new dynamic<Type>(data);
    }

    // This seems to be a useless method in this form...
    template <typename Type>
    Type GetData() const
    {
        dynamic<Type> * data;
        // slow, but it doesn't crash at least...
        data = dynamic_cast<dynamic<Type>*>(m_data);
        return data ? data->dyn_data : Type();
    }
};

void test()
{
    //This code works as designed
    myclass data1;
    data1.SetData<int>(12);
    // the compiler finds out that Type is int
    data1.SetData(12);
    int x = data1.GetData<int>();

    // the compiler finds out that Type is float
    myclass data2(123.4f);
    float y = data2.GetData<float>();

    myclass data3(234.5f);
    float z = data3.GetData<float>();

    // the compiler finds out that Type is double
    myclass * data4 = new myclass(345.6);
    delete data4;
}

这篇关于在类构造函数中使用模板化类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！