C++ 如果函数定义为不应'；不可能

作为一个实验，我试图使一个没有参数的void成员函数基于类模板参数更改行为：

#include <iostream>
#include <limits>

template<typename T>
class MyClass
{
public:
  void MyFunc(const typename std::enable_if<std::is_fundamental<T>::value, T> dummy = T());
  void MyFunc(const typename std::enable_if<!std::is_fundamental<T>::value, T> dummy = T());

};

template<typename T>
void MyClass<T>::MyFunc(const typename std::enable_if<std::is_fundamental<T>::value, T> dummy)
{
}

template<typename T>
void MyClass<T>::MyFunc(const typename std::enable_if<!std::is_fundamental<T>::value, T> dummy)
{
}

class Simple {};

int main(int argc, char *argv[])
{
  MyClass<int> myClass;
  myClass.MyFunc();

//   MyClass<Simple> myClass2;
//   myClass2.MyFunc();

  return 0;
}

#包括
#包括
模板
类MyClass
{
公众：
void MyFunc（const typename std:：enable_if dummy=T（））；
void MyFunc（const typename std:：enable_if:：value，T>dummy=T（））；
};
模板
void MyClass:：MyFunc（const typename std:：enable_if dummy）
{
}
模板
void MyClass:：MyFunc（const typename std:：enable_if:：value，T>dummy）
{
}
类简单{}；
int main（int argc，char*argv[]）
{
MyClass MyClass；
myClass.MyFunc（）；
//MyClass myClass2；
//myClass2.MyFunc（）；
返回0；
}

然而，我得到：错误：重载的“MyFunc（）”的调用是不明确的。难道不应该只定义其中的一个或另一个函数吗？因为除了一个函数外，所有函数都是相同的！在其中一个句子中，你可以说：

std::enable_if<std::is_fundamental<T>::value, T>::type
//                                              ^^^^^^

std:：enable\u if:：type
//                                              ^^^^^^

说：

std:：enable\u if:：type
//                                              ^^^^^^

否，首先您需要实际访问

：键入
enable_的
类型定义（如果
），其次，您的代码将无法工作，因为您的成员不是模板。其中一个总是以无效声明告终

在应用必要的
：：type
fix之后，在尝试调用成员之前很久，实例化
MyClass
时，代码就会失败

使您的成员成为成员模板，并使
启用取决于成员模板的参数，而不是封闭类模板的参数。
否，首先您需要实际访问
：：键入
启用的
类型定义，然后，您的代码将无法工作，因为您的成员不是模板。其中一个总是以无效声明告终

在应用必要的
：：type
fix之后，在尝试调用成员之前很久，实例化
MyClass
时，代码就会失败

使您的成员成为成员模板，如果
依赖于成员模板的参数而不是封闭类模板的参数，则启用
。
您必须创建虚拟模板参数来执行我的要求：

#include <iostream>
#include <limits>

template<typename T>
class MyClass
{
public:
  template <typename U = T>
  void MyFunc(const typename std::enable_if<std::is_fundamental<U>::value, U>::type dummy = U());
  template <typename U = T>
  void MyFunc(const typename std::enable_if<!std::is_fundamental<U>::value, U>::type dummy = U());
};

template<typename T>
template<typename U>
void MyClass<T>::MyFunc(const typename std::enable_if<std::is_fundamental<U>::value, U>::type dummy)
{
}

template<typename T>
template<typename U>
void MyClass<T>::MyFunc(const typename std::enable_if<!std::is_fundamental<U>::value, U>::type dummy)
{
}

class Simple {};

int main(int argc, char *argv[])
{
  MyClass<int> myClass;
  myClass.MyFunc();

  MyClass<Simple> myClass2;
  myClass2.MyFunc();

  return 0;
}

#包括
#包括
模板
类MyClass
{
公众：
模板
void MyFunc（const typename std:：enable_if:：type dummy=U（））；
模板
void MyFunc（const typename std:：enable_if:：value，U>：：type dummy=U（））；
};
模板
模板
void MyClass:：MyFunc（const typename std:：enable_if:：type dummy）
{
}
模板
模板
void MyClass:：MyFunc（const typename std:：enable_if:：value，U>：：type dummy）
{
}
类简单{}；
int main（int argc，char*argv[]）
{
MyClass MyClass；
myClass.MyFunc（）；
MyClass myClass2；
myClass2.MyFunc（）；
返回0；
}
您必须创建虚拟模板参数才能执行我的要求：

#include <iostream>
#include <limits>

template<typename T>
class MyClass
{
public:
  template <typename U = T>
  void MyFunc(const typename std::enable_if<std::is_fundamental<U>::value, U>::type dummy = U());
  template <typename U = T>
  void MyFunc(const typename std::enable_if<!std::is_fundamental<U>::value, U>::type dummy = U());
};

template<typename T>
template<typename U>
void MyClass<T>::MyFunc(const typename std::enable_if<std::is_fundamental<U>::value, U>::type dummy)
{
}

template<typename T>
template<typename U>
void MyClass<T>::MyFunc(const typename std::enable_if<!std::is_fundamental<U>::value, U>::type dummy)
{
}

class Simple {};

int main(int argc, char *argv[])
{
  MyClass<int> myClass;
  myClass.MyFunc();

  MyClass<Simple> myClass2;
  myClass2.MyFunc();

  return 0;
}

#包括
#包括
模板
类MyClass
{
公众：
模板
void MyFunc（const typename std:：enable_if:：type dummy=U（））；
模板
void MyFunc（const typename std:：enable_if:：value，U>：：type dummy=U（））；
};
模板
模板
void MyClass:：MyFunc（const typename std:：enable_if:：type dummy）
{
}
模板
模板
void MyClass:：MyFunc（const typename std:：enable_if:：value，U>：：type dummy）
{
}
类简单{}；
int main（int argc，char*argv[]）
{
MyClass MyClass；
myClass.MyFunc（）；
MyClass myClass2；
myClass2.MyFunc（）；
返回0；
}
我首先尝试了这个方法（现在已编辑到原始帖子中），但我得到了错误：“struct std:：enable_if'@DavidDoria:Correct”中没有名为“type”的类型。当bool为false时，没有类型。这是一个在SFINAE中不是错误的错误。实际上，这是一个错误，因为在非模板中没有模板替换。@访问者：事实上，OP仍然必须将此构建块集成到正确的SFINAE构造中。我只是想指出替换失败的地方。我先尝试了一下（现在已编辑到原始帖子中），但我得到了错误：“struct std:：enable_if'@DavidDoria:Correct”中没有名为“type”的类型。当bool为false时，没有类型。这是一个在SFINAE中不是错误的错误。实际上，这是一个错误，因为在非模板中没有模板替换。@访问者：事实上，OP仍然必须将此构建块集成到正确的SFINAE构造中。我只是想指出换人失败的地方。。。您应该避免将问题更改为包含我们告诉您的修复。这会让每个人都感到困惑。请撤消该操作。向下投票。。。您应该避免将问题更改为包含我们告诉您的修复。这会让每个人都感到困惑。请解开它。好的，有什么方法可以做到这一点吗？是否有基于类的模板参数的非模板成员函数更改行为？@DavidDoria调用重载<代码>返回MyFuncImpl（std:：is_basical（））。在
std:：true\u type
和
std:：false\u type
参数上重载它。好的，有什么方法可以做到这一点吗？是否有基于类的模板参数的非模板成员函数更改行为？@DavidDoria调用重载<代码>返回MyFuncImpl（std:：is_basical（））。重载
std:：true_type
和
std:：false_type
参数上的。