让函数返回C ++类中的任何类型

Question

我有这节课：

#define TYPE_INVALID 0x00
#define TYPE_BYTE    0x01
#define TYPE_SHORT   0x02
#define TYPE_INT     0x03
#define TYPE_LONG    0x04
#define TYPE_FLOAT   0x05
#define TYPE_DOUBLE  0x06

class BASIC_TYPE
{
    private:
        int8_t  type;
        int8_t  byteValue;
        int16_t shortValue;
        int32_t intValue;
        int64_t longValue;
        float   floatValue;
        double  doubleValue;

    public:
        BASIC_TYPE();
        template<typename T> BASIC_TYPE(int8_t, T);

        template<typename T> void set(T);
        template<typename T> T    get();
};

BASIC_TYPE::BASIC_TYPE()
{
    type = TYPE_INVALID;
}

template<typename T> BASIC_TYPE::BASIC_TYPE(int8_t newType, T value)
{
    type = newType;
    set(value);
}

template<typename T> void BASIC_TYPE::set(T value)
{
    switch(type)
    {
        case TYPE_BYTE   : byteValue   = value; break;
        case TYPE_SHORT  : shortValue  = value; break;
        case TYPE_INT    : intValue    = value; break;
        case TYPE_LONG   : longValue   = value; break;
        case TYPE_FLOAT  : floatValue  = value; break;
        case TYPE_DOUBLE : doubleValue = value; break;
    }
}

template<typename T> T BASIC_TYPE::get()
{
    switch(type)
    {
        case TYPE_BYTE   : return byteValue;
        case TYPE_SHORT  : return shortValue;
        case TYPE_INT    : return intValue;
        case TYPE_LONG   : return longValue;
        case TYPE_FLOAT  : return floatValue;
        case TYPE_DOUBLE : return doubleValue;
    }
}

现在，我想使用get（）函数来输出存储的数字，如下所示：

BASIC_TYPE val1(TYPE_INT, 1234);
BASIC_TYPE val2(TYPE_DOUBLE, 3.1415926535);

val1.set(5678);
val2.set(2.7182818284);
printf("%d\n%f\n", val1.get(), val2.get());

但是g ++表示在printf no matching function call to 'BASIC_TYPE::get() ，并且template argument deduction/substitution failed （ couldn't deduce template parameter 'T' ）。

为了使代码正确编译，必须进行哪些更改？

Answer 1

“必须进行哪些更改才能使代码正确编译？”

在这种情况下，您需要明确。 写吧

printf("%d\n%f\n", val1.get<int>(), val2.get<double>());
                        // ^^^^^            ^^^^^^^^

C ++不能仅通过返回类型来区分各种get()函数实例（其他情况与set() ，其中T作为参数类型）。
在这种情况下，您需要指定类型以显式实例化模板化函数（如上所示）。

---

另请注意：我宁愿使用enum代替那些#define TYPE_xxx语句：

enum MySupportedTypes {
    TYPE_INVALID ,
    TYPE_BYTE    ,
    TYPE_SHORT   ,
    TYPE_INT     ,
    TYPE_LONG    ,
    TYPE_FLOAT   ,
    TYPE_DOUBLE  ,
};

对于get()模板函数的实现，应考虑类似于^1的操作 ，以避免为不适当的请求类型调用get()函数。

template<typename T> T BASIC_TYPE::get() {
    switch(type) {
        case TYPE_BYTE: 
            std::is_same<T,int8_t> ? return byteValue : throw std::bad_typeid;
        case TYPE_SHORT: 
            std::is_same<T,int16_t> ? return shortValue : throw std::bad_typeid;
        //  analogous ...
    }
}

甚至更好地提供了一种在编译时捕获类型不匹配的机制。

---

1）参见std::is_same的文档参考

Answer 2

您想按返回类型重载，而C ++并没有真正让您轻松地做。 但是，我要指出的是，您的最后一个示例仍然需要您告诉它所需的类型，因为参数可以是任何类型。 即使C ++让您按返回类型重载，它仍然不知道您想要什么类型。

也就是说，有一个丑陋的技巧可以用来在返回类型上重载。 在了解如何按返回类型重载时，我了解了它可以用于此目的，这里： 按返回类型重载函数？

看吧：

class BASIC_TYPE
{
    // Your stuff, then:
    operator int (){ if (type != TYPE_INT) throw std::bad_typeid; return intValue; }
    operator float (){ if (type != TYPE_FLOAT) throw std::bad_typeid; return floatValue; }
    // And so on for every supported type
}

这样，您甚至不需要get函数，只需调用值本身即可：

BASIC_TYPE val1(TYPE_INT, 1234);

//float bad = val1; // throws bad_typeid
int good = val1; // sets good to 1234

您可以使用强制类型转换来获取所需的特定类型，以防万一您将类型转换为错误的类型。

如果重载了构造函数和赋值运算符，则甚至可以摆脱声明类型的丑陋语法：

class BASIC_TYPE
{
    public:
        // Constructors
        BASIC_TYPE(int i):type(TYPE_INT),intValue(i){}
        // So on for the other types
        // Assignment
        BASIC_TYPE & operator=(int i){ if (type != TYPE_INT) throw std::bad_typeid; intValue = i; return *this;} 
}

BASIC_TYPE intType (1234); // TYPE_INT chosen autmatically
// intType = 1.0; // throws
intType = 4321; 

Answer 3

无需为六个不同的类型存储六个不同的数据成员。 它们可以合并为一个工会。 还可以使用模板元编程设置type标志。 无需在构造函数中明确地这样做。 使用联合时，有必要确保get函数的模板参数与对象的实际类型匹配。 在这种情况下，我选择仅返回模板参数类型的零初始化值（如果该类型与对象的类型不匹配）。 您可以选择引发异常。

#include <iostream>
#include <type_traits>

#define TYPE_INVALID 0x00
#define TYPE_BYTE    0x01
#define TYPE_SHORT   0x02
#define TYPE_INT     0x03
#define TYPE_LONG    0x04
#define TYPE_FLOAT   0x05
#define TYPE_DOUBLE  0x06

using namespace std;

class BASIC_TYPE
{
    private:
        int8_t  type;
        union
        {
            int8_t  byteValue;
            int16_t shortValue;
            int32_t intValue;
            int64_t longValue;
            float   floatValue;
            double  doubleValue;
        }
        data;

    public:
        BASIC_TYPE();
        template<typename T> BASIC_TYPE(T);
        template<typename T> void set(T);
        template<typename T> T    get();
};

BASIC_TYPE::BASIC_TYPE()
{
    type = TYPE_INVALID;
}

template<typename T> BASIC_TYPE::BASIC_TYPE(T value)
{
    set(value);
}

template<typename T> void BASIC_TYPE::set(T value)
{
    if (is_same<T, int8_t>::value)
    {   
        type = TYPE_BYTE;
        data.byteValue = value;
    }   
    else if (is_same<T, int16_t>::value)
    {
        type = TYPE_SHORT;
        data.shortValue = value;
    }
    else if (is_same<T, int32_t>::value)
    {
        type = TYPE_INT;
        data.intValue = value;
    }
    else if (is_same<T, int64_t>::value)
    {
        type = TYPE_LONG;
        data.longValue = value;
    }
    else if (is_same<T, float>::value)
    {
        type = TYPE_FLOAT;
        data.floatValue = value;
    }
    else if (is_same<T, double>::value)
    {
        type = TYPE_DOUBLE;
        data.doubleValue = value;
    }
    else
        type = TYPE_INVALID;

}

template<typename T> T BASIC_TYPE::get()
{
    T ret{};
    if (type == TYPE_BYTE && is_same<T, int8_t>::value)
        ret = data.byteValue;
    else if (type == TYPE_SHORT && is_same<T, int16_t>::value)
        ret = data.shortValue;
    else if (type == TYPE_INT && is_same<T, int32_t>::value)
        ret = data.intValue;
    else if (type == TYPE_LONG && is_same<T, int64_t>::value)
        ret = data.longValue;
    else if (type == TYPE_FLOAT && is_same<T, float>::value)
        ret = data.floatValue;
    else if (type == TYPE_DOUBLE && is_same<T, double>::value)
        ret = data.doubleValue;

    return ret;
}