如何使用 c++ 在数组中存储不同的值类型？

Question

我想在我的配置类中实现一些功能时遇到问题，我有一些不同类型的值，我想将它们存储在地图中。以前我使用 ExtendedString 类来存储所有数据，并在需要时使用模板函数将它们转换为想要的类型。然后在我的配置类中有一个map<ExtendedString,vector<ExtendedString> > 来将所有键存储在配置文件中。这是我的 ExtendedString 类的样子：

class ExtendedString : public std::string
{
public:
    ExtenedString() : public std::string
    {
    }
    template <class T> ExtenededString(T)
    {
        std::stringstream s;
        *this = s.str();
    }
    template <class T>T as(){
        istringstream s(*this);
        T temp;
        d >> temp;
        return temp;
    }
}

现在我想在加载配置文件时解析所有值，并且还具有在需要时转换为任何可能类型的功能。例如，如果我将某个值解析为 int 并且在我的运行时我需要将该值作为字符串，我希望能够立即将其转换，而且在这种情况下我不喜欢使用 boost，它是我的基类之一，我不想将 boost 链接到我正在开发的每个项目。

Answer 1

我建议使用boost::any，因为它听起来就像您正在寻找的那样。但是，如果您真的不想使用它，您也许可以像这样处理它。这可能不是最好的方法（它首先进入我的脑海） - 基本上它将值存储在你最初拥有的类型中，并作为字符串。如果您尝试将get 作为原始类型，它会返回该值，否则，它将使用std::stringstream 尝试并转换它。

注意：这不处理复制/分配，将d_data更改为您选择的共享指针来处理。

#include <string>
#include <sstream>
#include <iostream>

class ConfigValue
{
    class HolderBase
    {
      protected:
        virtual void writeValueToStream(std::ostream& os) const = 0;

      public: 
        virtual ~HolderBase() { }

        template <class Type>
        Type getAs() const
        {
            std::stringstream ss;
            writeValueToStream(ss);

            Type temp;
            ss >> temp;
            return temp;
        }
    };

    template <class Type>
    class Holder : public HolderBase
    {
        Type d_value;

      protected:
        void writeValueToStream(std::ostream& os) const
        {
            os << d_value;
        }

      public:
        Holder(const Type& value)
        : d_value(value)
        {
            std::ostringstream oss;
            oss << value;
        }

        Type get() const
        {
            return d_value;
        }
    };

    HolderBase *d_data;

  public:
    template <class Type>
    ConfigValue(const Type& value)
    : d_data(new Holder<Type>(value))
    {
    }

    ~ConfigValue()
    {
        delete d_data;
    }

    template <class Type>
    Type get() const
    {
        if (Holder<Type> *holder = dynamic_cast<Holder<Type>*>(d_data))
        {
            return holder->get();
        }
        else
        {
            return d_data->getAs<Type>();
        }
    }
};

int main()
{
    ConfigValue cv = 10;

    std::cout << cv.get<std::string>() << std::endl;

    return 0;
}

Answer 2

一个经典的解决方案是boost::any，或大量的union。但我认为这两种方法造成的麻烦比它们解决的要多。例如，创建一个 Config 类，每个配置选项都有成员，这有什么问题？

Answer 3

您可以编写一个“值”类，然后为每种值编写子类，而不是将它们全部存储为字符串。