Создание универсальной функции вставки

Вы можете использовать виртуальный базовый класс, оболочку шаблона и интеллектуальные указатели, пишущие что-то следующим образом.

#include <string>
#include <vector>
#include <memory>
#include <sstream>
#include <iostream>


struct anyBase
 { virtual int unusedVirt () { return 0; }; };

template <typename T>
struct anyW : public anyBase
 { 
   T val;

   anyW (T const & v0) : val{v0} { }
 };


struct any
 {
   public: 
      enum type { Int, Float, String };

      any (int e)
         : m_type{Int}, m_data{new anyW<int>(e)} { }

      any (float e)
         : m_type{Float}, m_data{new anyW<float>(e)} { }

      any (char const * e)
         : m_type{String}, m_data{new anyW<std::string>(e)} { }

      any (std::string const & e)
         : m_type{String}, m_data{new anyW<std::string>(e)} { }

      any (any const & a) : m_type{a.m_type}, m_data{nullptr}
       {
         switch ( m_type )
          {
            case Int:
               m_data.reset(new anyW<int>(a.get_int()));
               break;

            case Float:
               m_data.reset(new anyW<float>(a.get_float()));
               break;

            case String:
               m_data.reset(new anyW<std::string>(a.get_string()));
               break;
          }
       }

      type get_type () const { return m_type; }

      int get_int () const
       { return dynamic_cast<anyW<int>*>(m_data.get())->val; }

      float get_float () const
       { return dynamic_cast<anyW<float>*>(m_data.get())->val; }

      std::string const & get_string () const
       { return dynamic_cast<anyW<std::string>*>(m_data.get())->val; }

   private:
      type m_type;

      std::unique_ptr<anyBase> m_data;
 };


template<typename ...Args>
std::string GetInsertString(const std::string& tableName, Args... args)
 {
   std::string insertString = "INSERT INTO ";
   insertString += tableName;
   insertString += " VALUES(";
   std::vector<any> vec = {args...};
   std::ostringstream ss;
   for (unsigned i = 0; i < vec.size(); ++i)
    {
      switch(vec[i].get_type())
       {
         case any::Int:
            ss.str("");
            ss << vec[i].get_int();
            insertString += ss.str() + ",";
            break;
         case any::Float:
            ss.str("");
            ss << vec[i].get_float();
            insertString += ss.str() + ",";
            break;
         case any::String:
            ss.str("");
            insertString += "'" + std::string(vec[i].get_string()) + "'," ;
            break;
       }
    }
   insertString.pop_back();
   insertString += ");";
   return insertString;
 }


int main ()
 {
   std::cout << GetInsertString("fooTable", 1, 2.2f, "3", std::string("4"))
      << std:: endl;
   // print INSERT INTO fooTable VALUES(1,2.2,'3','4');
 }

Обратите внимание, что:

• это решение должно работать и с С++ 11

• Я объединил случаи char * и std::string; Я думаю, что это плохая идея зарегистрировать chat *

• используя std::unique_ptr, вам нужен copy_constructor, потому что конструктор копирования в std::unique_ptr удаляется, поэтому также удаляется конструктор копирования по умолчанию для любого

• лучшим решением может быть ожидание входящего (С++ 17, если я не ошибаюсь) std::variant

typeof

Вы можете использовать use typeof и добавить случаи переключения. В новой java, например, вы можете автоматизировать полуцикл и увидеть, что это тоже своего рода цикл, если я не ошибаюсь.