C++ 专门化非模板类的成员函数模板

以下成员函数模板

bar

的专门化是否有效？它在GCC4.5.3和VS.NET2008上编译。我很困惑，因为我隐约记得读到函数模板不能被专门化

struct Foo
{
    template<typename T>
    void bar();
};

template<typename T>
void Foo::bar(){}

template<>
void Foo::bar<bool>(){}

int main()
{
    Foo f;
    f.bar<char>();
    f.bar<bool>();
}

structfoo
{
模板
空心钢筋（）；
};
模板
void Foo:：bar（）{}
模板
void Foo:：bar（）{}
int main（）
{
福福；
f、 bar（）；
f、 bar（）；
}

函数模板不能部分专用，但可以显式专用，您的代码是完全正确的。

函数模板不能部分专用，但可以显式专用，您的代码是完全正确的。

函数模板不能部分专用，但可以显式专用，您的代码是完全正确的。

函数模板不能部分专用，但可以显式专用，您的代码是完全正确的。

函数模板部分专用，因为函数模板重载可用于解决相同的问题。然而，在进行此操作时，必须寻找一些方法

例如：

template <typename T> void foo(T);
void foo(int);

foo(10);   // calls void bar(int)
foo(10.f); // calls void bar(T) [with T = float]
foo(10u);  // calls void bar(T) [with T = unsigned int]!!

模板void foo（T）；
void foo（int）；
傅（10）；//调用无效条（int）
foo（10.f）；//调用无效条（T）[T=float]
foo（10u）；//调用无效条（T）[带T=unsigned int]！！

对于你的情况，这样的东西可能会有用

struct Foo
{
    template<typename T>
    void bar(T dummy);

    void bar(bool dummy);
};

template<typename T>
void Foo::bar(T dummy) { }

void Foo::bar(bool dummy) { }

int main()
{
    Foo f;
    f.bar('a');
    f.bar(true);
}

structfoo
{
模板
空心钢筋（T型假人）；
空心杆（bool假人）；
};
模板
void Foo:：bar（T dummy）{}
void Foo:：bar（bool dummy）{}
int main（）
{
福福；
f、 酒吧（‘a’）；
f、 巴（真）；
}

函数模板部分专门化，因为函数模板重载可用于解决相同的问题。然而，在进行此操作时，必须寻找一些方法

例如：

template <typename T> void foo(T);
void foo(int);

foo(10);   // calls void bar(int)
foo(10.f); // calls void bar(T) [with T = float]
foo(10u);  // calls void bar(T) [with T = unsigned int]!!

模板void foo（T）；
void foo（int）；
傅（10）；//调用无效条（int）
foo（10.f）；//调用无效条（T）[T=float]
foo（10u）；//调用无效条（T）[带T=unsigned int]！！

对于你的情况，这样的东西可能会有用

struct Foo
{
    template<typename T>
    void bar(T dummy);

    void bar(bool dummy);
};

template<typename T>
void Foo::bar(T dummy) { }

void Foo::bar(bool dummy) { }

int main()
{
    Foo f;
    f.bar('a');
    f.bar(true);
}

structfoo
{
模板
空心钢筋（T型假人）；
空心杆（bool假人）；
};
模板
void Foo:：bar（T dummy）{}
void Foo:：bar（bool dummy）{}
int main（）
{
福福；
f、 酒吧（‘a’）；
f、 巴（真）；
}

函数模板部分专门化，因为函数模板重载可用于解决相同的问题。然而，在进行此操作时，必须寻找一些方法

例如：

template <typename T> void foo(T);
void foo(int);

foo(10);   // calls void bar(int)
foo(10.f); // calls void bar(T) [with T = float]
foo(10u);  // calls void bar(T) [with T = unsigned int]!!

模板void foo（T）；
void foo（int）；
傅（10）；//调用无效条（int）
foo（10.f）；//调用无效条（T）[T=float]
foo（10u）；//调用无效条（T）[带T=unsigned int]！！

对于你的情况，这样的东西可能会有用

struct Foo
{
    template<typename T>
    void bar(T dummy);

    void bar(bool dummy);
};

template<typename T>
void Foo::bar(T dummy) { }

void Foo::bar(bool dummy) { }

int main()
{
    Foo f;
    f.bar('a');
    f.bar(true);
}

structfoo
{
模板
空心钢筋（T型假人）；
空心杆（bool假人）；
};
模板
void Foo:：bar（T dummy）{}
void Foo:：bar（bool dummy）{}
int main（）
{
福福；
f、 酒吧（‘a’）；
f、 巴（真）；
}

函数模板部分专门化，因为函数模板重载可用于解决相同的问题。然而，在进行此操作时，必须寻找一些方法

例如：

template <typename T> void foo(T);
void foo(int);

foo(10);   // calls void bar(int)
foo(10.f); // calls void bar(T) [with T = float]
foo(10u);  // calls void bar(T) [with T = unsigned int]!!

模板void foo（T）；
void foo（int）；
傅（10）；//调用无效条（int）
foo（10.f）；//调用无效条（T）[T=float]
foo（10u）；//调用无效条（T）[带T=unsigned int]！！

对于你的情况，这样的东西可能会有用

struct Foo
{
    template<typename T>
    void bar(T dummy);

    void bar(bool dummy);
};

template<typename T>
void Foo::bar(T dummy) { }

void Foo::bar(bool dummy) { }

int main()
{
    Foo f;
    f.bar('a');
    f.bar(true);
}

structfoo
{
模板
空心钢筋（T型假人）；
空心杆（bool假人）；
};
模板
void Foo:：bar（T dummy）{}
void Foo:：bar（bool dummy）{}
int main（）
{
福福；
f、 酒吧（‘a’）；
f、 巴（真）；
}