C++ 通过专门化排除类成员

我有一个基类模板，在这个模板上我制作了另一个类，它是我的基类的专门版本。我知道如何从特定的专门化案例中排除一些方法，但是否有可能为类的成员这样做？我希望实现的示例代码：

template<typename T>
class Base {
  This variable exists only when T==integer VARIABLE;
}

template <Typename T>
WithVariable = using Base<int>;

template <Typename T>
Without = using Base<double>

模板
阶级基础{
此变量仅在T==整数变量时存在；
}
模板
WithVariable=使用基数；
模板
不带=使用底座

---

我认为我应该以某种方式使用std:：enable，但使用它可以在我不需要该变量时生成类型为“void”的变量。这仍然不是我想要达到的效果。

你能不能在没有多余成员的情况下专门化这门课

template <typename T>
class Base {
public:
  T t;
};

template <>
class Base<int> {
};

int main() {
  Base<int> foo;
  foo.t = 42; // Error: no member named 't' in 'Base<int>'
}

模板
阶级基础{
公众：
T；
};
模板
阶级基础{
};
int main（）{
基辅；
foo.t=42；//错误：“Base”中没有名为“t”的成员
}

你能在没有多余成员的情况下专门化这个类吗

template <typename T>
class Base {
public:
  T t;
};

template <>
class Base<int> {
};

int main() {
  Base<int> foo;
  foo.t = 42; // Error: no member named 't' in 'Base<int>'
}

模板
阶级基础{
公众：
T；
};
模板
阶级基础{
};
int main（）{
基辅；
foo.t=42；//错误：“Base”中没有名为“t”的成员
}

一种可能的方法是有条件地继承。看一看:

struct BaseWithVariable {
    int n {42};
};

struct BaseNoVariable {};


template <typename T>
struct Base : std::conditional<std::is_same<T, int>::value, BaseWithVariable, BaseNoVariable>::type {};

struct BaseWithVariable{
int n{42}；
};
结构BaseNoVariable{}；
模板
结构基：std:：conditional:：type{}；

使用方法：

Base<int> b {};
Base<double> d {};

std::cout << b.n << std::endl;
std::cout << d.n << std::endl; // error

Base b{}；
碱基d{}；
一种可能的方法是有条件地继承。看一看:

struct BaseWithVariable {
    int n {42};
};

struct BaseNoVariable {};


template <typename T>
struct Base : std::conditional<std::is_same<T, int>::value, BaseWithVariable, BaseNoVariable>::type {};

struct BaseWithVariable{
int n{42}；
};
结构BaseNoVariable{}；
模板
结构基：std:：conditional:：type{}；

使用方法：

Base<int> b {};
Base<double> d {};

std::cout << b.n << std::endl;
std::cout << d.n << std::endl; // error

Base b{}；
碱基d{}；
std:：cout您可以为使用SFINAE的base使用base

#include <type_traits>

template <typename, typename = void>
struct base_of_base;

template <typename T>
struct base_of_base<T, typename std::enable_if<std::is_integral<T>::value>::type>
 { int var; };

template <typename T>
struct base_of_base<T, typename std::enable_if<!std::is_integral<T>::value>::type>
 { };

template <typename T>
class base : public base_of_base<T>
 { };

int main()
 {
   base<int>     bi;
   base<long>    bl;
   base<float>   bf;
   base<double>  bd;

   bi.var = 1; // OK
   bl.var = 1; // OK
   // bf.var = 1; // error: ‘class base<float>’ has no member named ‘var’
   // bd.var = 1; // error: ‘class base<double>’ has no member named ‘var’
 }

#包括
模板
结构基址的基址；
模板
结构基
{int-var；}；
模板
结构base\u of_base:：type>
{ };
模板
类基：公共基
{ };
int main（）
{
碱基bi；
基带；
基本高炉；
基本bd；
bi.var=1；//确定
bl.var=1；//确定
//bf.var=1；//错误：“类基”没有名为“var”的成员
//bd.var=1；//错误：“class base”没有名为“var”的成员
}
您可以为使用SFINAE的底座使用底座

#include <type_traits>

template <typename, typename = void>
struct base_of_base;

template <typename T>
struct base_of_base<T, typename std::enable_if<std::is_integral<T>::value>::type>
 { int var; };

template <typename T>
struct base_of_base<T, typename std::enable_if<!std::is_integral<T>::value>::type>
 { };

template <typename T>
class base : public base_of_base<T>
 { };

int main()
 {
   base<int>     bi;
   base<long>    bl;
   base<float>   bf;
   base<double>  bd;

   bi.var = 1; // OK
   bl.var = 1; // OK
   // bf.var = 1; // error: ‘class base<float>’ has no member named ‘var’
   // bd.var = 1; // error: ‘class base<double>’ has no member named ‘var’
 }

#包括
模板
结构基址的基址；
模板
结构基
{int-var；}；
模板
结构base\u of_base:：type>
{ };
模板
类基：公共基
{ };
int main（）
{
碱基bi；
基带；
基本高炉；
基本bd；
bi.var=1；//确定
bl.var=1；//确定
//bf.var=1；//错误：“类基”没有名为“var”的成员
//bd.var=1；//错误：“class base”没有名为“var”的成员
}
如何
删除该类专业的功能

template <typename T>
class Base {
public:
  void notUseful();
};

template<typename T>
void Base<T>::notUseful(){
  std::cout << "not useful" << std::endl;
  return;
}

template <>
void Base<int>::notUseful() = delete;

模板
阶级基础{
公众：
无效无效（）；
};
模板
void Base:：notusable（）{
std：：cout如何
删除该类专业中的函数

template <typename T>
class Base {
public:
  void notUseful();
};

template<typename T>
void Base<T>::notUseful(){
  std::cout << "not useful" << std::endl;
  return;
}

template <>
void Base<int>::notUseful() = delete;

模板
阶级基础{
公众：
无效无效（）；
};
模板
void Base:：notusable（）{
std:：难道你不需要
std:：enable_if
只需要专门化
Base
.PS的模板化父类。你不能创建
void
类型的变量…请更具体一些。我想作为模板参数之一传递bool值。bool值将指示例如动物是否有躯干，如果是，我想在类animal\u with\u trunk中有\u trunk的成员len\u。带有\u trunk的animal\u必须是基类animal的专门化版本。我不能使用继承。你不需要
std:：enable\u if
只需对
base
的模板化父类进行专门化。你不能创建
void
类型的变量。请更具体一点。我会的我想将bool value作为模板参数之一传递。bool value将指示例如animal是否有trunk，如果是，我希望在类animal_with_trunk中有_trunk的成员len_。带_trunk的animal_必须是基类animal的专用版本。我不能使用继承。但是方法存在问题。如果我想排除如果很多成员中只有一个成员，那么我就必须复制代码。我说得对吗？你说得对，这似乎对方法不起作用，而且很可能我不知道我在说什么：但是方法than有一个问题。如果我想从许多成员中只排除一个成员，那么我就必须复制代码。我说得对吗？你说得对t、 这似乎不适用于方法，很可能我不知道我在说什么：