问有没有更好的方法来做这个C++，从任何类型的文件中保存和加载变量？

EN

#pragma once
#include <boost/any.hpp>
#include <map>
#include <string>
#include <iostream>
#include <vector>

#define ADD_PARAMETER(x) _settings_loader.AddParameter(#x, x);

class SettingsLoader
{
public:
  SettingsLoader();
  template <class T> void AddParameter(std::string name, T & parameter);
  void SetParameter(std::string name, std::string value);
  std::string GetParameterValue(std::string name);
  void PrintOutParameters();
  std::vector<std::pair<std::string, std::string> > GetAllParametersAsStrings();
protected:
  std::map<std::string, boost::any>  _parameters;
  bool _debug;
};


template <class T> void SettingsLoader::AddParameter(std::string name, T & parameter)
{
  _parameters.insert(std::make_pair(name, boost::any(&parameter)));

  if (_debug)
  {
    std::cout << "Added parameter " << name << std::endl;
  }
}

#include "settingsloader.h"
#include <boost/lexical_cast.hpp>

SettingsLoader::SettingsLoader():
  _parameters(),
  _debug(false)
{
}


void SettingsLoader::SetParameter(std::string name, std::string value)
{
  try
  {
    std::map<std::string, boost::any>::iterator itterator = _parameters.find(name);
    if (itterator != _parameters.end())
    {
      boost::any boost_any = itterator->second;

      if (boost::any_cast<double*>(boost_any))
      {
        double * value_to_set = boost::any_cast<double*>(boost_any);
        *value_to_set = boost::lexical_cast<double>(value);
      }
      else if (boost::any_cast<int*>(boost_any))
      {
        int * value_to_set = boost::any_cast<int*>(boost_any);
        *value_to_set = boost::lexical_cast<int>(value);
      }
      else if  (boost::any_cast<long*>(boost_any))
      {
        long * value_to_set = boost::any_cast<long*>(boost_any);
        *value_to_set = boost::lexical_cast<long>(value);
      }
    }
    else
    {
      if (_debug)
      {
        std::cout << "Parameter " << name << " could not be set" << std::endl;
      }
    }
  }
  catch(...)
  {

  }
}

std::string SettingsLoader::GetParameterValue(std::string name)
{
  try
  {
    std::map<std::string, boost::any>::iterator itterator = _parameters.find(name);
    if (itterator != _parameters.end())
    {
      boost::any boost_any = itterator->second;

      if (boost::any_cast<double*>(boost_any))
      {
        double * value_to_get = boost::any_cast<double*>(boost_any);
        return boost::lexical_cast<std::string>(*value_to_get);
      }

      if (boost::any_cast<int*>(boost_any))
      {
        int * value_to_get = boost::any_cast<int*>(boost_any);
        return boost::lexical_cast<std::string>(*value_to_get);
      }

      if (boost::any_cast<long*>(boost_any))
      {
        long * value_to_get = boost::any_cast<long*>(boost_any);
        return boost::lexical_cast<std::string>(*value_to_get);
      }
    }
  }
  catch(...)
  {

  }
  return "";
}

std::vector<std::pair<std::string, std::string> > SettingsLoader::GetAllParametersAsStrings()
{
  std::vector<std::pair<std::string, std::string>> output_vector;
  for (auto pair : _parameters)
  {
    output_vector.push_back(std::make_pair(pair.first, GetParameterValue(pair.first)));
  }

  return output_vector;
}


void SettingsLoader::PrintOutParameters()
{
  std::cout << "+=======================+" << std::endl
            << "|Printing out parameters|" << std::endl
            << "+=======================+" << std::endl;

  std::vector<std::pair<std::string, std::string>> names_and_values = GetAllParametersAsStrings();
  for (std::pair<std::string, std::string> pair : names_and_values)
  {
    std::cout << pair.first << " = " << pair.second << std::endl;
  }
}