Блог

Вы можете избавиться от использования new и vector достаточно легко, используя вариационный шаблон для Config конструктора, например:

 class Config
{
public:
    template<typename... Ts>
    Config(const Tsamp;... args)
    {
        const ConfigPair* arr[] = {amp;args...};
        // use arr as needed...
        for( const ConfigPair *arg: arr ) {
            // do something with arg...
        }
    }
};

int main()
{
    Config c2(
        ConfigPairInt("one", 1),
        ConfigPairDouble("two", 2.0),
        ConfigPairString("three", "3")
    );
    // use c2 as needed...
    return 0;
}
  

Живая демонстрация

Вы просто не можете избавиться от производных имен типов, если хотите использовать полиморфизм, поскольку компилятор должен знать, какие типы создавать. Само по себе использование инициализатора фигурных скобок не указывает компилятору, КАКОЙ тип создать:

 Config c2(
    {"one", 1},    // error: WHICH type?
    {"two", 2.0},  // error: WHICH type?
    {"three", "3"} // error: WHICH type?
);
  

Если вам нужен такой синтаксис, то полностью избавьтесь от полиморфизма, просто пусть ConfigPair он сам обрабатывает любой тип значения, через std::variant , std::any , или эквивалентный.

Вот сырой проект того, что я бы сделал в вашем случае (насколько описано), пояснения в комментариях:

 using ValueType = std::variant<std::string,int,double>; // To get rid of lengthy
                                                        // type names, and 
                                                        // have them
                                                        // change- and  maintainable 
                                                        // at a single point in your 
                                                        // source code
class ConfigPair {
public:
  ConfigPair( const std::stringamp; name_in, ValueType value ) : 
                              // ^^^^^^^ Ditch "Hungarian notation" for heaven's sake!
    name( name_in ) {}

  virtual ~ConfigPair() {}; // Destructor doesn't need to do anything
                            // std::string manages memory already

  std::string name; // Is compatible with const char* for initialization
  ValueType  value;
};

using PConfigPair = std::shared_ptr<ConfigPair>;
// or in case that Config should take full ownership of ConfigPair's
// using PConfigPair = std::shared_ptr<ConfigPair>;
  

 class Config {
public:
  Config( std::vector<PConfigPair> apcpair )
  {
      for( PConfigPair pcpair: apcpair )
          // do something
  }
// Maybe store the vector here as class member, if Config should take full
// ownership of those ConfigPair's
// std::vector<PConfigPair> config_pairs;
//
// In any case you don't need to care about manual memory management
};
  

 Config c2( { std::make_shared<ConfigPair>("one",1), // std::make_unique alternatively
             std::make_shared<ConfigPair>("two",2.0),
             std::make_shared<ConfigPair>("three","3") } );
  

Документы:

• std::variant
• std::shared_ptr (альтернативно вы можете использовать std::unique_ptr , в зависимости от семантики владения)

КАК указывают Реми и Панта в других ответах: вы просто не можете избавиться от имен производных типов, если хотите использовать полиморфизм, поскольку компилятор должен знать, какие типы создавать.Поскольку это наиболее типизируемый для вызывающего, его устранение является приоритетом. Таким образом, полиморфизм исключается.

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

 public:
  ConfigPair( const char* pszName_in, int iValue_in ) {
    cfgpair.type    = TypeInt64;
    cfgpair.pszName = newstring( pszName_in );
    cfgpair.u.i     = iValue_in;
  }

  ConfigPair( const char* pszName_in, double dValue_in ) {
    cfgpair.type    = TypeDouble;
    cfgpair.pszName = newstring( pszName_in );
    cfgpair.u.d     = dValue_in;
  }

  ConfigPair( const char* pszName_in, const char* pszValue_in ) {
    cfgpair.type     = TypeSz;
    cfgpair.pszName  = newstring( pszName_in );
    cfgpair.pszValue = newstring( pszValue_in );
  }
  

Учитывая, что ConfigPair теперь это единственный класс, передаваемый в Config конструктор, означает, что осведомленность компилятора о требованиях к типу этого конструктора позволяет ему определять тип объекта при вызове. Таким образом, имя класса не используется.

Кроме того, поскольку содержимое массива теперь однородно, мы можем поместить сами ConfigPair ‘ы в массив, вместо того, чтобы (как это было изначально необходимо) хранить только указатели на объекты ConfigPair подкласса. Таким образом, новая (или альтернативная и не требующая утечки памяти, но еще более подробная shared_pointer<ConfigPairXXX>() нотация).

   Config( const char* pszName_in, // name only used for debugging messages
          std::vector<ConfigPair> acpair ) :
      Config( pszName_in )
  {
      for ( const ConfigPair cpair: acpair )
          cpair.Set( this );
  }
  

И для вызывающего:

 Config c2( { { "one",   1   },
             { "two",   2.0 },
             { "three", "3" } } );
  

Наконец, это оставляет внешние фигурные скобки для списка-инициализатора-списка. Я исследовал замену вектора пакетом параметров, но тогда я не могу понять, как заставить компилятор больше знать о типе, поэтому тип снова потребуется. Продолжить с этим было бы одним шагом вперед на десять шагов назад с точки зрения простоты для вызывающего, поэтому я все-таки придерживаюсь списка braced-initializer. (Если есть другая альтернатива, чтобы избавиться от этих внешних фигурных скобок, не требуя имен классов, пожалуйста, дайте мне знать.)