请考虑以下示例:
struct Scanner
{
template <typename T>
T get();
};
template <>
string Scanner::get()
{
return string("string");
}
template <>
int Scanner::get()
{
return 10;
}
int main()
{
Scanner scanner;
string s = scanner.get<string>();
int i = scanner.get<int>();
}
所述Scanner类被用来提取从一些源令牌.上面的代码工作正常,但是当我尝试get其他整数类型如a char或an 时失败unsigned int.读取这些类型的代码与要读取的代码完全相同int.我可以复制我想要阅读的所有其他整数类型的代码,但我宁愿为所有整数类型定义一个函数模板.
我尝试过以下方法:
struct Scanner
{
template <typename T>
typename enable_if<boost::is_integral<T>, T>::type get();
};
这有点像魅力,但我不确定如何Scanner::get<string>()再次运作.所以,我怎么能写代码,这样我可以做scanner.get<string>()和scanner.get<any integral type>(),有一个统一的定义读取所有整数类型？
更新:奖金问题:如果我想根据某些特征接受多个课程范围怎么办？例如:如果我想要有三个get函数分别接受(i)整数类型(ii)浮点类型(iii)字符串,我应该如何处理这个问题 .
我正在编写模板类,我想允许另一种方法仅存在于某种模板类型.目前,该方法适用于所有模板类型,但会导致所有其他类型的编译错误.
使这更复杂的是它是一个重载的operator().不知道我想要做什么实际上是可能的.
这就是我现在拥有的:
template<typename T, typename BASE>
class MyClass : public BASE
{
public:
typename T& operator() (const Utility1<BASE>& foo);
typename T const& operator() (const Utility2<BASE>& foo) const;
};
我希望T&版本始终可用,但T const&只有Utility2<BASE>有效版本才可用.现在,两种方法都存在,但如果Utility2<BASE>无效,尝试使用const版本会产生奇怪的编译错误.我宁愿有一个明智的错误,甚至是"没有这样的成员函数"错误.
这可能吗？
编辑:阅读了升级文档,这是我提出的,它似乎工作:
template<typename T, typename BASE>
class MyClass : public BASE
{
public:
typename T& operator() (const Utility1<BASE>& foo);
template<typename U>
typename boost::enable_if<boost::is_same<Utility2<BASE>, U>, T>::type const &
operator() (const U& foo) const;
};
因此,除非有人试图将它与Utility2一起使用,否则它不存在,并且如果它对该BASE类型有效,则它们只能创建一个Utility2.但是当它对BASE类型无效时,MyClass不会浪费时间创建访问器方法.
我想基于布尔模板参数实现一个私有函数.像这样的东西:
#include <iostream>
using namespace std;
template <bool is_enabled = true>
class Aggregator {
public:
void fun(int a) {
funInternal(a);
}
private:
void funInternal(int a, typename std::enable_if<is_enabled>::type* = 0) {
std::cout << "Feature is enabled!" << std::endl;
}
void funInternal(int a, typename std::enable_if<!is_enabled>::type* = 0) {
std::cout << "Feature is disabled!" << std::endl;
}
};
int main()
{
Aggregator<true> a1;
Aggregator<false> a2;
a1.fun(5);
a2.fun(5);
return 0;
}
但是上面的程序没有编译:错误:'struct std :: enable_if'中没有名为'type'的类型void funInternal(int a,typename std :: enable_if :: type*= 0).
是否有可能通过enable_if实现所需的行为？
我想使用任何整数类型为类创建一个构造函数,但区分有符号和无符号.我不希望它成为类本身的模板.以下不起作用.Visual Studio只是说没有参数匹配.
class Thing{
public:
template<typename Integral>
Thing(
typename std::enable_if<
std::is_integral<Integral>::value &&
!std::is_same<Integral,bool>::value &&
std::is_signed<Integral>::value
,Integral
>::type num
){
//constructor using signed variable as input
}
template<typename Integral>
Thing(
typename std::enable_if<
std::is_integral<Integral>::value &&
!std::is_same<Integral,bool>::value &&
!std::is_signed<Integral>::value//notice this is different
,Integral
>::type num
){
//constructor using unsigned variable as input
}
};
我想定义一个类型取决于某些条件的变量.我想要这样的东西:
typedef typename enable_if<cond, int>::type Type;
typedef typename enable_if<!cond, double>::type Type;
但是这个conpiler说我重新定义了这种类型.
我怎样才能做到这一点？
我试图实现一个将泛型类型转换为字符串的函数.积分类型需要使用std::to_string(),字符串和字符使用std::string()和矢量,逐个元素,使用其他方法之一(取决于其内容)转换为字符串.
这就是我所拥有的:
//Arithmetic types
template<class T>
typename std::enable_if<std::is_arithmetic<T>::value, std::string>::type convertToString(const T& t){
return std::to_string(t);
}
//Other types using string ctor
template<class T>
typename std::enable_if<std::__and_<std::__not_<std::is_arithmetic<T>>::type,
std::__not_<std::is_same<T, <T,
std::vector<typename T::value_type, typename T::allocator_type>>::value
>>>::value, std::string>::type convertToString(const T& t){
return std::string(t);
}
//Vectors
template<class T>
typename std::enable_if<std::is_same<T, std::vector<typename T::value_type,
typename T::allocator_type>>::value, std::string>::type convertToString(const T& t){
std::string str;
for(std::size_t i = 0; i < t.size(); i++){
str += convertToString(t[i]);
}
return str;
}
问题是第二个函数没有编译.如何设计第二个函数以便它编译(和工作)并且不会产生歧义问题？
我对部分模板特化有点困惑...我有一些代码依赖于算术数据类型T,并且在一个小的整数DIM上.我希望能够为不同的DIM值指定不同的类方法.使用部分模板专业化的不可能性使我探索了enable_if.这正是我所需要的...除了我希望它返回一个数字而不是一个类型.我怎样才能做到这一点？以下代码应说明我想要的内容.
#include <stdio.h>
#include <iostream>
#include <type_traits>
template <typename T, int DIM>
class foo{
public:
T function();
};
template <typename T, int DIM>
T foo<T, std::enable_if<DIM == 1>::value>::function(){
// do something
return 1.0;
}
template <typename T, int DIM>
T foo<T, std::enable_if<DIM == 2>::value>::function(){
// do something else
return 2342.0;
}
int main(){
foo<int, 1> object;
int ak = object.function();
std::cout << ak << "\n";
return 0;
}
我有很多EnableIf特性,基本上检查输入类型是否满足接口.我试图创建一个通用Resolve特征,可用于将这些特征转换为布尔特征.
像这样的东西 - https://wandbox.org/permlink/ydEMyErOoaOa60Jx
template <
template <typename...> class Predicate,
typename T,
typename = std::void_t<>>
struct Resolve : std::false_type {};
template <template <typename...> class Predicate, typename T>
struct Resolve<Predicate, T, Predicate<T>> : std::true_type {};
现在,如果你有这样的EnableIf特质
template <typename T>
using EnableIfHasFoo = std::void_t<decltype(std::declval<T>().foo())>;
您可以非常快速地创建它的布尔版本
template <typename T>
struct HasFoo : Resolve<EnableIfHasFoo, T> {};
或类似的变量模板.
但由于某种原因,部分专业化没有按预期工作.Resolve不能按预期工作.请参阅此处的输出 - https://wandbox.org/permlink/ydEMyErOoaOa60Jx.同样的事情实现"手动"工作 - https://wandbox.org/permlink/fmcFT3kLSqyiBprm
我自己手动定义类型.是否存在我缺少的部分特化和模板模板参数的详细信息？
#include <stdio.h>
#include <type_traits>
void print()
{
printf("cheers from print !\n");
}
class A
{
public:
void print()
{
printf("cheers from A !");
}
};
template<typename Function>
typename std::enable_if< std::is_function<
typename std::remove_pointer<Function>::type >::value,
void >::type
run(Function f)
{
f();
}
template<typename T>
typename std::enable_if< !std::is_function<
typename std::remove_pointer<T>::type >::value,
void >::type
run(T& t)
{
t.print();
}
int main()
{
run(print);
A a;
run(a);
return 0;
}
上面的代码按预期编译和打印：
来自印刷的欢呼！来自A的欢呼！
我想表达的是：“如果模板是函数，那么应用这个函数，否则......”。或者在另一种表述中：具有用于函数模板的函数版本，以及用于非函数模板的默认版本。
所以，这部分似乎有些多余，可以用“其他”条件“替换”：
template<typename T>
typename std::enable_if< !std::is_function<
typename std::remove_pointer<T>::type >::value,
void >::type
run(T& …C++-14 引入std::enable_if_t.
它 和 和有什么不一样std::enable_if？使用上有什么优点或者区别吗std::enable_if_t？