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

假设我有一个文件alpha.h:

class Alpha {
public:
    template<typename T> void foo();
};

template<> void Alpha::foo<int>() {}
template<> void Alpha::foo<float>() {}

阿尔法类{
公众：
模板void foo（）；
};
模板void Alpha:：foo（）{}
模板void Alpha:：foo（）{}

如果我在多个cpp文件中包含alpha.h并使用GCC4.4编译，它会抱怨在多个对象文件中有多个

foo

和

foo

的定义。对我来说很有意义，因此我将最后两行更改为：

template<> extern void Alpha::foo<int>() {}
template<> extern void Alpha::foo<float>() {}

template extern void Alpha:：foo（）{}
模板外部无效Alpha:：foo（）{}

但GCC说：

显式模板专门化 不能有存储类

好的。。。那么我应该如何正确地做到这一点呢？我担心C++不允许我做的事情，在这种情况下，有一个好的成语来完成同样的事情吗？< /P> < P>使用内联关键字< /P>

template<> inline void Alpha::foo<int>() {}

模板内联void Alpha:：foo（）{}

---

或者，在单独的cpp文件中提供实现，您可以转发声明以及内联选项：

// .h
template<> void Alpha::foo<int>();

//.cpp
template<> void Alpha::foo<int>() {}

/.h
模板void Alpha:：foo（）；
//.cpp
模板void Alpha:：foo（）{}

从ODR的角度来看，完全（明确）专门化的模板不再是模板，因此它与同类非模板实体遵循相同的ODR原则。（我认为，这条规则有一些例外，但就我们的目的而言，它已经足够好了）

---

在您的情况下，出于ODR目的，完全专用的函数模板是一个普通函数。因此，作为一个普通函数，它应该在头文件中声明，并且只在一个实现文件中定义。

不需要单独声明或内联键工作。PF低于工作代码

#include<iostream>

class temp
{
public:
    template <class T>
    T add1(T a, T b)
    {
            return (a + b);
    }
};

template<>
std::string temp::add1<std::string>(std::string aa, std::string bb)
{
    return aa+bb;
}

int main()
{
    temp *tc = new temp();
    std::cout << tc->add1<float>(5.7, 4.5) << std::endl;
    std::cout << tc->add1<std::string>("my ","program") << std::endl;
}

#包括
班级临时工
{
公众：
模板
T地址1（T a，T b）
{
返回（a+b）；
}
};
模板
std:：string temp:：add1（std:：string aa，std:：string bb）
{
返回aa+bb；
}
int main（）
{
温度*tc=新温度（）；
std:：cout add1（5.7，4.5）当然，如果你把所有的东西都放在一个文件中……但这不是OP的问题，他有多个对象文件的问题。也就是说，他想知道当头文件在多个编译单元中使用时，如何使它工作。