C++ 创建泛型插入函数

我试图创建一个通用函数，该函数可以接受表名和值，并将insert返回到查询中，并得出如下结论：

    struct any {
  enum type {Int, Float, String};
  any(int   e) { m_data.INT    = e; m_type = Int;}
  any(float e) { m_data.FLOAT  = e; m_type = Float;}
  any(char* e) { m_data.STRING = e; m_type = String;}
  type get_type() const { return m_type; }
  int get_int() const { return m_data.INT; }
  float get_float() const { return m_data.FLOAT; }
  char* get_string() const { return m_data.STRING; }
private:
  type m_type;
  union {
    int   INT;
    float FLOAT;
    char *STRING;
  } 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;
}

struct any{
枚举类型{Int，Float，String}；
任意（int e）{m_data.int=e；m_type=int；}
任意（float e）{m_data.float=e；m_type=float；}
任意（char*e）{m_data.STRING=e；m_type=STRING；}
类型get_type（）常量{return m_type；}
int get_int（）常量{return m_data.int；}
float get_float（）常量{return m_data.float；}
char*get_string（）常量{return m_data.string；}
私人：
m_型；
联合{
int-int；
浮动；
字符*字符串；
}m_数据；
};
样板
std:：string GetInsertString（const std:：string&tableName，Args…Args）
{
std:：string insertString=“插入”；
insertString+=表名；
insertString+=“值（”；
向量

但问题是我无法将
std:：string
type作为变量参数传递到此函数，因为我们在any类中有union，所以需要你们的帮助，才能将
std:：string
type作为参数传递，以便为插入查询构造值

typeof

您可以使用
typeof
并添加切换用例。例如，在新的java中，您可以自动执行半循环，如果我没有弄错的话，您也可以看到类似的循环。
您可以使用虚拟基类、模板包装器和智能指针编写如下内容

#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');
 }

#包括
#包括
#包括
#包括
#包括
结构任意基
{virtual int unusedVirt（）{return 0；}；}；
样板
struct anyW：公共anyBase
{ 
T值；
anyW（T常数&v0）：val{v0}{
};
构造任何
{
公众：
枚举类型{Int，Float，String}；
任何（int e）
：m_type{Int}，m_data{new anyW（e）}{}
任何（浮动e）
：m_type{Float}，m_data{new anyW（e）}{}
任意（字符常量*e）
：m_type{String}，m_data{new anyW（e）}{}
任意（标准：：字符串常量（&e）
：m_type{String}，m_data{new anyW（e）}{}
any（any const&a）：m_type{a.m_type}，m_data{nullptr}
{
开关（m_型）
{
案例Int：
m_data.reset（newanyw（a.get_int（））；
打破
案例浮动：
m_data.reset（新的anyW（a.get_float（））；
打破
大小写字符串：
m_data.reset（新的anyW（a.get_string（））；
打破
}
}
类型get_type（）const{return m_type；}
int get_int（）常量
{return dynamic_cast（m_data.get（））->val；}
float get_float（）常量
{return dynamic_cast（m_data.get（））->val；}
std:：string const&get_string（）const
{return dynamic_cast（m_data.get（））->val；}
私人：
m_型；
std：：唯一的ptr m_数据；
};
样板
std:：string GetInsertString（const std:：string&tableName，Args…Args）
{
std:：string insertString=“插入”；
insertString+=表名；
insertString+=“值（”；
向量向量={args…}；
std：：ostringstream ss；
for（无符号i=0；i这是C++，我在讨论变量模板的参数包，我找不到任何迭代的最佳方法，没有迭代参数类型。OMLY开关。