C++ 特定成员的模板专门化？

是否可以专门化模板类的特定成员？比如：

template <typename T,bool B>
struct X
{
    void Specialized();
};

template <typename T>
void X<T,true>::Specialized()
{
    ...
}

template <typename T>
void X<T,false>::Specialized()
{
    ...
}

模板
结构X
{
void（）；
};
模板
void X:：Specialized（）
{
...
}
模板
void X:：Specialized（）
{
...
}

---

当然，这个代码是无效的。

这就是我想到的，还不错：）

//通用模板默认为'flag==false'
模板
构造某物
{
无效剂量测定法（）
{
std：：cout这是我想到的，还不错：）

//通用模板默认为'flag==false'
模板
构造某物
{
无效剂量测定法（）
{
std:：cout只能通过提供所有模板参数显式地对其进行专门化。不允许对类模板的成员函数进行部分专门化

template <typename T,bool B>
struct X
{
    void Specialized();
};

// works
template <>
void X<int,true>::Specialized()
{
    ...
}

我认为有时候，遵从另一个模板更好（当涉及到数组和指针等情况时，重载可能会很棘手，而仅仅转发到类模板对我来说更容易），有时只在模板中重载会更好-尤其是如果您确实转发函数参数，并且如果您触及类的成员变量。
您只能通过提供所有模板参数显式地对其进行专门化。不允许对类模板的成员函数进行部分专门化

template <typename T,bool B>
struct X
{
    void Specialized();
};

// works
template <>
void X<int,true>::Specialized()
{
    ...
}

我认为有时候，遵从另一个模板更好（当涉及到数组和指针等情况时，重载可能会很棘手，而仅仅转发到类模板对我来说更容易），有时只是在模板中重载会更好-尤其是如果你真的转发函数参数，并且如果你触及类的成员变量。
这里的意思还不完全清楚。你的意思是强制模板参数成为某个类型的后代吗？就像你在Java中专门化模板类，他必须为整个类提供不同的实现。在我看来，他希望在专门化之间共享公共代码，除了少数函数。这个问题应该说“成员函数”而不是“成员函数”吗？为了不让任何人认为这是关于数据成员的。现在还不完全清楚您在这里的意思。您的意思是强制模板参数成为某个类型的后代吗？就像您在Java中使用@Alcon一样？@Alcon在专门化模板类时，他必须为整个类提供不同的实现。在我看来，他希望在专门化之间共享公共代码，除了少数几个函数。这个问题应该说“成员函数”而不是“成员函数”吗？为了不让任何人认为这是关于数据成员的。既然C++11已经推出，这应该使用
std:：integral_constant
me thinks。我会编辑自己，但在iPodtouch的移动视图中这是一个真正的麻烦…+1太多的可能性，其中任何一种都可能比另一种更适合OP。写得非常好。既然C++11已经推出，t他应该用
std:：integral_constant
me思考。我会编辑我自己，但在iPodtouch上的移动视图中真的很麻烦…+1太多的可能性，其中任何一种都可能比另一种更适合OP。写得很好。你没有覆盖，你只是隐藏。你没有覆盖，你只是隐藏。
// "maps" a bool value to a struct type
template<bool B> struct i2t { };

template <typename T,bool B>
struct X
{
    void Specialized() { SpecializedImpl(i2t<B>()); }

private:
    void SpecializedImpl(i2t<true>) { 
      // ...
    }

    void SpecializedImpl(i2t<false>) { 
      // ...
    }
};

template<typename T, bool B>
struct SpecializedImpl;

template<typename T>
struct SpecializedImpl<T, true> {
  static void call() { 
    // ...
  }
};

template<typename T>
struct SpecializedImpl<T, false> {
  static void call() { 
    // ...
  }
};

template <typename T,bool B>
struct X
{
    void Specialized() { SpecializedImpl<T, B>::call(); }
};

template <typename T,bool B>
struct X
{
private:
    // maps a type and non-type parameter to a struct type
    template<typename T, bool B>
    struct SpecializedImpl { };

public:
    void Specialized() { Specialized(SpecializedImpl<T, B>()); }

private:
    template<typename U>
    void Specialized(SpecializedImpl<U, true>) {
      // ...
    }

    template<typename U>
    void Specialized(SpecializedImpl<U, false>) {
      // ...
    }
};