C++ 在traits模板中声明静态自动函数指针_C++_Templates_C++11

C++ 在traits模板中声明静态自动函数指针

c++ templates c++11

C++ 在traits模板中声明静态自动函数指针,c++,templates,c++11,C++,Templates,C++11,根据模板参数的数据类型，我有两个用于不同数据类型的函数，希望在模板中使用这些函数。我声明了一个helper模板structtraits，并为相应的数据类型专门化了它我的问题是：是否有可能避免在这些专门化中编写精确的函数签名？此外，是否可以避免在模板声明之外定义这些函数，并且仍然使它们保持静态下面是我想做的一个非常简单的例子。我想使用的语法被注释掉了，但它显然无法编译 #include <iostream> int f() { return 1; } double g() { r

根据模板参数的数据类型，我有两个用于不同数据类型的函数，希望在模板中使用这些函数。我声明了一个helper模板struct

traits

，并为相应的数据类型专门化了它

我的问题是：是否有可能避免在这些专门化中编写精确的函数签名？此外，是否可以避免在模板声明之外定义这些函数，并且仍然使它们保持静态

下面是我想做的一个非常简单的例子。我想使用的语法被注释掉了，但它显然无法编译

#include <iostream>

int f() { return 1; }
double g() { return 2.3; }

template<typename T>
struct traits;

template<>
struct traits<int> {
    // static auto func = f;
    int(*func)() = f;
};

template<>
struct traits<double> {
    // static auto func = g;
    double(*func)() = g;
};

template<typename T>
struct traits_user {
    void output() {
        // std::cout << traits<T>::func() << " ";
        std::cout << traits<T>().func() << " ";
    }
};


int main()
{
    traits_user<int>().output();
    traits_user<double>().output();
}

#包括
int f（）{return 1；}
双g（）{return 2.3；}
模板
结构特征；
模板
结构特征{
//静态自动函数=f；
int（*func）（=f；
};
模板
结构特征{
//静态自动函数=g；
双（*func）（=g；
};
模板
结构特征用户{
无效输出（）{
//std:：cout您可以使用：
static auto constexpr func = f;

及
当我试图在没有constexpr
的情况下编译时，我在g++中遇到了以下错误
g++-std=c++11-Wall socc.cc-o socc
socc.cc:17:24:错误：“constexpr”需要在类内初始化非整数类型[-fppermissive]的静态数据成员“double（*traits:：func）（）”
静态自动函数=g；

如果不支持constexpr
，一种解决方法是：
template<>
struct traits<int> {
   static double func()
   {
      return f();
   }
};

template<>
struct traits<double> {
   static double func()
   {
      return g();
   }
};

模板
结构特征{
静态双func（）
{
返回f（）；
}
};
模板
结构特征{
静态双func（）
{
返回g（）；
}
};
您可以使用：
static auto constexpr func = f;

及
当我试图在没有constexpr
的情况下编译时，我在g++中遇到了以下错误
g++-std=c++11-Wall socc.cc-o socc
socc.cc:17:24:错误：“constexpr”需要在类内初始化非整数类型[-fppermissive]的静态数据成员“double（*traits:：func）（）”
静态自动函数=g；

如果不支持constexpr
，一种解决方法是：
template<>
struct traits<int> {
   static double func()
   {
      return f();
   }
};

template<>
struct traits<double> {
   static double func()
   {
      return g();
   }
};

模板
结构特征{
静态双func（）
{
返回f（）；
}
};
模板
结构特征{
静态双func（）
{
返回g（）；
}
};
您可以使用：
static auto constexpr func = f;

及
当我试图在没有constexpr
的情况下编译时，我在g++中遇到了以下错误
g++-std=c++11-Wall socc.cc-o socc
socc.cc:17:24:错误：“constexpr”需要在类内初始化非整数类型[-fppermissive]的静态数据成员“double（*traits:：func）（）”
静态自动函数=g；

如果不支持constexpr
，一种解决方法是：
template<>
struct traits<int> {
   static double func()
   {
      return f();
   }
};

template<>
struct traits<double> {
   static double func()
   {
      return g();
   }
};

模板
结构特征{
静态双func（）
{
返回f（）；
}
};
模板
结构特征{
静态双func（）
{
返回g（）；
}
};
您可以使用：
static auto constexpr func = f;

及
当我试图在没有constexpr
的情况下编译时，我在g++中遇到了以下错误
g++-std=c++11-Wall socc.cc-o socc
socc.cc:17:24:错误：“constexpr”需要在类内初始化非整数类型[-fppermissive]的静态数据成员“double（*traits:：func）（）”
静态自动函数=g；

如果不支持constexpr
，一种解决方法是：
template<>
struct traits<int> {
   static double func()
   {
      return f();
   }
};

template<>
struct traits<double> {
   static double func()
   {
      return g();
   }
};

模板
结构特征{
静态双func（）
{
返回f（）；
}
};
模板
结构特征{
静态双func（）
{
返回g（）；
}
};
如果不能使用auto，您可能仍然可以使用decltype和类型别名：
template<> struct traits<int> {
    using F  = decltype(&f); 
    const static F func; 
}; 
const traits<int>::F traits<int>::func= f;

模板结构特征{
使用F=decltype（&F）；
常数静态F函数；
}; 
常量特征：：F特征：：func=F；

这比显式方法好还是坏，由您自己决定
当然，如果您在其他地方不需要类型别名，也可以省略它：
template<> struct traits<int> {
    const static decltype(&f) func;
};
const decltype(&f) traits<int>::func = f;

模板结构特征{
常量静态decltype（&f）func；
};
常量decltype（&f）traits:：func=f；
如果不能使用auto，您可能仍然可以使用decltype和类型别名：
template<> struct traits<int> {
    using F  = decltype(&f); 
    const static F func; 
}; 
const traits<int>::F traits<int>::func= f;

模板结构特征{
使用F=decltype（&F）；
常数静态F函数；
}; 
常量特征：：F特征：：func=F；

这比显式方法好还是坏，由您自己决定
当然，如果您在其他地方不需要类型别名，也可以省略它：
template<> struct traits<int> {
    const static decltype(&f) func;
};
const decltype(&f) traits<int>::func = f;

模板结构特征{
常量静态decltype（&f）func；
};
常量decltype（&f）traits:：func=f；
如果不能使用auto，您可能仍然可以使用decltype和类型别名：
template<> struct traits<int> {
    using F  = decltype(&f); 
    const static F func; 
}; 
const traits<int>::F traits<int>::func= f;

模板结构特征{
使用F=decltype（&F）；
常数静态F函数；
}; 
常量特征：：F特征：：func=F；

这比显式方法好还是坏，由您自己决定
当然，如果您在其他地方不需要类型别名，也可以省略它：
template<> struct traits<int> {
    const static decltype(&f) func;
};
const decltype(&f) traits<int>::func = f;

模板结构特征{
常量静态decltype（&f）func；
};
常量decltype（&f）traits:：func=f；
如果不能使用auto，您可能仍然可以使用decltype和类型别名：
template<> struct traits<int> {
    using F  = decltype(&f); 
    const static F func; 
}; 
const traits<int>::F traits<int>::func= f;

模板结构特征{
使用F=decltype（&F）；
常数静态F函数；
}; 
常量特征：：F特征：：func=F；

这比显式方法好还是坏，由您自己决定
当然，如果您在其他地方不需要类型别名，也可以省略它：
template<> struct traits<int> {
    const static decltype(&f) func;
};
const decltype(&f) traits<int>::func = f;

模板结构特征{
常量静态decltype（&f）func；
};
常量decltype（&f）traits:：func=f；
谢谢！不幸的是，我现在只能使用VS2013，它不支持constexpr。还有其他想法吗？我编辑了答案，然后+1告诉了你。所以我想没有办法重复函数签名（在我的真实代码中，它们当然要复杂得多）。这是对的吗？@Rostislav，由于VS2013不支持所有C++11功能，我发现很难提出不同的解决方案。我没有快速访问，这没有帮助