Блог

У меня возникли проблемы с некоторыми функциями, которые я хочу реализовать в своем классе config, у меня есть некоторые значения с разными типами, и я хочу сохранить их в map. ранее я использовал класс 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 к каждому проекту, который я разрабатываю.

Одним из классических решений является boost::any , или массивный union . Но я думаю, что оба этих подхода вызывают больше проблем, чем решают. Что плохого в создании, скажем, Config класса, который имеет член для каждого параметра конфигурации?

Я бы рекомендовал использовать boost::any , поскольку похоже, что он делает то, что вы ищете. Однако, если вы действительно не хотите это использовать, вы могли бы справиться с этим примерно так. Возможно, это не лучший способ сделать это (это первое, что пришло мне в голову) — в основном это сохранение значения в том типе, который у вас был изначально, и в виде строки. Если вы попытаетесь использовать get его в качестве исходного типа, он вернет это значение, в противном случае он будет использовать std::stringstream , чтобы попытаться преобразовать его.

Примечание: Это не обрабатывает копирование / присвоение, измените d_data на ваш общий указатель по выбору, чтобы справиться с этим.

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

class ConfigValue
{
    class HolderBase
    {
      protected:
        virtual void writeValueToStream(std::ostreamamp; 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::ostreamamp; os) const
        {
            os << d_value;
        }

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

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

    HolderBase *d_data;

  public:
    template <class Type>
    ConfigValue(const Typeamp; 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;
}
  

Вместо того, чтобы хранить их все в виде строк, вы могли бы написать класс «Value», а затем написать подклассы для каждого вида значений.