c++ - 尝试使用类 C++ 创建通用数据类型的问题

Question

我的 C++ 程序有问题。现在我只是想利用运算符重载创建一个通用的“变量”。所以问题是当我确定传递的数据类型。 (我必须这样做，因为我稍后要重载 << 运算符以便 ostream 可以输出正确的数据)条件语句没有按预期工作。这是代码

#include <iostream>
#include <vector>
#include <istream>
#include <ostream>

class SLVar
{
    public:
        friend std::ostream& operator<<(std::ostream& os, const SLVar& var);
        const char* str;
        char ch;
        int in;
        float fl;
        double dl;
        const char* type; //Later initialized
        template <typename T>
        T operator=(T var)
        {
            if (typeid(T).name() == typeid(int).name())
            {
                type = "int"; in = var;
            }
            else if (typeid(T).name() == typeid(const char*).name())
            {
                type = "string"; str = var;
            }
            else if (typeid(T).name() == typeid(float).name())
            {
                type = "float"; fl = var;
            }
            else if (typeid(T).name() == typeid(double).name())
            {
                type = "double"; fl = var;
            }
            else if (typeid(T).name() == typeid(char).name())
            {
                type = "char"; ch = var;
            }
        }
};
std::ostream& operator<<(std::ostream& os, SLVar& var)
{
    if (var.type == "string")
    {
        os << var.str;
    }
    else if (var.type == "int")
    {
        os << var.in;
    }
    else if (var.type == "float")
    {
        os << var.fl;
    }
    else if (var.type == "double")
    {
        os << var.dl
    }
    else if (var.type == "char")
    {
        os << var.ch;
    }
    return os;
}
int main()
{
    SLVar var;
    var = 5;
    std::cout << var << std::endl;
    return 0;
}

这应该是该类(class)完成后的最终代码。但是当我尝试设置 var = blah 时错误仍然存​​在。它给出了 cannot convert const char* to int 或不能将 char 转换为 int 或任何类似的东西。我的印象是，如果该代码不正确，则根本无关紧要。如果我注释掉这部分我在其中设置了正确的变量，它可以毫无问题地运行

#include <iostream>
#include <vector>
#include <istream>
#include <ostream>

class SLVar
{
    public:
        friend std::ostream& operator<<(std::ostream& os, const SLVar& var);
        const char* str;
        char ch;
        int in;
        float fl;
        double dl;
        const char* type; //Later initialized
        template <typename T>
        T operator=(T var)
        {
            if (typeid(T).name() == typeid(int).name())
            {
                type = "int"; //in = var;
            }
            else if (typeid(T).name() == typeid(const char*).name())
            {
                type = "string"; //str = var;
            }
            else if (typeid(T).name() == typeid(float).name())
            {
                type = "float"; //fl = var;
            }
            else if (typeid(T).name() == typeid(double).name())
            {
                type = "double"; //fl = var;
            }
            else if (typeid(T).name() == typeid(char).name())
            {
                type = "char"; //ch = var;
            }
        }
};
std::ostream& operator<<(std::ostream& os, SLVar& var)
{
    if (var.type == "string")
    {
        os << var.str;
    }
    else if (var.type == "int")
    {
        os << var.in;
    }
    else if (var.type == "float")
    {
        os << var.fl;
    }
    else if (var.type == "double")
    {
        os << var.dl;
    }
    else if (var.type == "char")
    {
        os << var.ch;
    }
    return os;
}
int main()
{
    SLVar var;
    var = "Hello world";
    std::cout << var << std::endl;
    return 0;
}

这会运行，但只有在我如上所示注释 var = blah 时才会运行。那么我该如何解决呢？同样，我的理解是如果 if 语句不正确里面的代码甚至不会运行。但它似乎无论如何。我不明白为什么会这样。有人可以阐明一下吗？基本上都是我想要的要做的是创建一个“通用数据类型”并使用 operator=() 来设置它。

Answer 1

我理解需要能够声明:

SLVar var;

然后决定分配整数、字符串、 float ，而不需要通过模板固定类型(一种动态类型)

我提出了一个有很多妥协的解决方案，根本没有类型信息，也没有模板(模板在这里没用，因为你必须在函数中执行类型检查)

或者，为了简单起见，我只保留了 const char * 和 int 类型，但它们可以很容易地扩展。

分配时，类型设置在枚举中，稍后由控制台写入函数使用。

#include <iostream>
#include <vector>
#include <istream>
#include <ostream>

class SLVar
{
    private:
        const char* str;
        int in;
        enum TheType { TYPE_INT, TYPE_CHARPTR, TYPE_UNKNOWN };
        TheType type;

    public:
        SLVar() : type(TYPE_UNKNOWN)
        {}

        friend std::ostream& operator<<(std::ostream& os, const SLVar& var);

        SLVar & operator=(int var)
        {
            in = var;
            type=TYPE_INT;
            return *this;
        }
        SLVar &operator=(const char *var)
        {
            str = var;
            type=TYPE_CHARPTR;
            return *this;
        }

};
std::ostream& operator<<(std::ostream& os, const SLVar& var)
{
    switch (var.type)
    {
    case SLVar::TYPE_CHARPTR:
        return os << var.str;            
    case SLVar::TYPE_INT:
        return os << var.in;           
    default:
      return os;  // not printing anything
      }       
}
int main()
{
    SLVar var;
    var = "Hello world";
    std::cout << var << std::endl;    
    var = 35;    // kind of dynamic typing through assignment
    SLVar var2;
    var2 = 56;
    std::cout << var << " " << var2 << std::endl;

}

结果:

Hello world
35 56

它仍然缺少很多东西，比如默认构造函数、复制构造函数……但原理是可行的。