C++ 模板特定方法

如果我有一个类

a

template <typename T>
class A { public: void print() const; };

调用print方法只会调用良好实现（编译器的）代码，如果没有特定模板的实现，请告诉我

---

现在，如果我的类

B

的模板中有多个类型

template <typename T1, typename T2>
class B { public: void print() const; };

我得到一个编译器错误：

error: invalid use of incomplete type 'class B<T1,bool>'
error: declaration of 'class B<T1, bool>'

错误：不完整类型“B类”的使用无效
错误：“B类”的声明

我做错了什么

编辑 我的真实生活

B

类包含我不想指定的其他方法（它们在一般情况下工作）

---

将部分指定的类标记为decard会使这些泛型方法在本机上不可用

您无法部分地专门化函数/方法

但是您可以部分地专门化整个类：

template <typename T1, typename T2> class B;

template<typename T1> class B<T1, bool>
{
public:
    void print() const { printf("B w/ type bool\n"); }
};

模板类B；
B类模板
{
公众：
void print（）常量{printf（“bw/type bool\n”）；}
};

使用模板，最好将专业化的每个部分分解为自己的模板函数或特征类

这里有一个干净的方法来做你想做的事：

template<typename T>
const char* type_name()
{
    return "unknown";
};

template<>
const char* type_name<int>()
{
    return "int";
}

template<>
const char* type_name<bool>()
{
    return "bool";
}

struct foo {};

template<>
const char* type_name<foo>()
{
    return "my custom foo";
}

struct bar {};

template <typename T>
class A {
    public:
    void print() const {
        cout << "A w/ type " << type_name<T>() << '\n';
    }
};

int main() {
    A<bool> ab;
    A<int> ai;
    A<foo> af;
    A<bar> abar;

    ab.print();
    ai.print();
    af.print();
    abar.print();

    return 0;

}

---

使用标记分派，您可以执行以下操作：

#include <iostream>

template<typename A, typename B>
class X
{
    private:
    template <typename U> struct Tag {};

    template <typename U>
    void print(Tag<U>) const;

    void print(Tag<bool>) const { std::cout << "bool\n"; }
    void print(Tag<int>) const{ std::cout << "int\n"; }

    public:
    void print() const { print(Tag<B>()); }
};

int main()
{
    X<void, bool>().print();
    X<void, int>().print();
}

#包括
模板
X类
{
私人：
模板结构标记{}；
模板
无效打印（标签）常数；
无效打印（标记）常量{std:：cout
我做错了什么

这是不一样的，这是为类模板部分专门化的成员函数提供定义。也就是说，它是一个模板，将用于为该部分专门化的成员生成代码，但您尚未声明任何此类部分专门化，因此无法定义其成员

您可以通过首先定义部分专门化来编译它：

// primary template
template <typename T1, typename T2>
class B { public: void print() const; };

// partial specialization
template<typename T1>
class B<T1,bool> { public: void print() const; };

template<typename T1> void B<T1,bool>::print() const { printf("B w/ type bool\n"); }

//主模板
模板
类B{public:void print（）const；}；
//部分专业化
模板
类B{public:void print（）const；}；
模板void B:：print（）常量{printf（“B w/type bool\n”）；}

然而，仅仅为了定义一个或两个成员的部分专门化，就不得不重复整个类模板定义，这通常是不方便的，因此可能值得采用其他答案中所示的备选设计之一。
您只能使用显式专门化，而不能使用部分专门化。您不能对函数进行部分专门化ion/method。这很悲哀……无论如何，谢谢你，但这不是函数的部分专用化，它是类的未声明部分专用化的成员的定义。问题是类模板部分专用化没有首先声明。但是如果
B
有另一个方法，该方法本机将不可用在
B
@Amxx中，为了使其可用，您需要在部分专门化中声明它，并在某处定义它……这通常会导致大量重复。您可能能够将公共部分移动到基类中，主模板和部分专门化都继承该基类，因此只有部分专门化才能dif在要自定义的函数中输入
A w/ type bool
A w/ type int
A w/ type my custom foo
A w/ type unknown
Program ended with exit code: 0

#include <iostream>

template<typename A, typename B>
class X
{
    private:
    template <typename U> struct Tag {};

    template <typename U>
    void print(Tag<U>) const;

    void print(Tag<bool>) const { std::cout << "bool\n"; }
    void print(Tag<int>) const{ std::cout << "int\n"; }

    public:
    void print() const { print(Tag<B>()); }
};

int main()
{
    X<void, bool>().print();
    X<void, int>().print();
}

template<> void A<bool>::print() const { printf("A w/ type bool\n"); }
template<> void A<int>::print()  const { printf("A w/ type int\n");  }

template<typename T1> void B<T1,bool>::print() const { printf("B w/ type bool\n"); }

// primary template
template <typename T1, typename T2>
class B { public: void print() const; };

// partial specialization
template<typename T1>
class B<T1,bool> { public: void print() const; };

template<typename T1> void B<T1,bool>::print() const { printf("B w/ type bool\n"); }