代码和私人成员
我想要做这样的事情：
template <typename T>
class Foo
{
...
public:
void DoSomething()
{
compile_time_if (T is ClassA)
{
m_T.DoThingOne();
m_T.DoThingTwo();
}
DoSomeFooPrivateThing();
m_T.DoThingThree();
}
T m_T;
};
在这种情况下，我知道所有有效的T实现DoThingThree ，但只有ClassA实现DoThingOne和DoThingTwo 。 这不是一个鸭子打字的事情，我只想为ClassA做这个额外的部分，我不想将这些方法添加到其他可能的T s中。 我不能铸造，因为可能的T不是继承类型。
我知道我可以使用外部辅助模板来适应这种情况：
template <typename T>
void Foo_DoSomething(T& t)
{
t.DoThingThree();
}
template <>
void Foo_DoSomething(ClassA& t)
{
t.DoThingOne();
t.DoThingTwo();
t.DoThingThree();
}
template <typename T>
class Foo
{
...
public:
void DoSomething()
{
Foo_DoSomething(m_T);
}
...
};
然而，现在这个外部模板无法访问Foo私人成员（不能调用DoSomeFooPrivateThing ），这限制了它的功能，并且它公开地公开给外部，这并不美观。 （使外部方法成为朋友只会让事情变得更糟。）
另一个看似合理的选择是在内部实施它：
template <typename T>
class Foo
{
...
public:
void DoSomething()
{
DoSomethingImpl(m_T);
}
...
private:
template <typename T2>
void DoSomethingImpl(T2& t)
{
DoSomeFooPrivateThing();
t.DoThingThree();
}
template <>
void DoSomethingImpl(ClassA& t)
{
t.DoThingOne();
t.DoThingTwo();
DoSomeFooPrivateThing();
t.DoThingThree();
}
...
};
但是这需要复制外部模板类型和参数。 这可能是可以接受的，但它仍然有点奇怪。 可悲的是，它实际上并没有编译（至少不在GCC中，因为它反对在类内专门化）。
有一个更好的方法吗？
我认为你最后的选择是最好的选择。
代替
template <>
void DoSomethingImpl(ClassA& t)
{
t.DoThingOne();
t.DoThingTwo();
DoSomeFooPrivateThing();
t.DoThingThree();
}
你可以使用（不需要在这里使用template ）：
void DoSomethingImpl(ClassA& t)
{
t.DoThingOne();
t.DoThingTwo();
DoSomeFooPrivateThing();
t.DoThingThree();
}
第一个解决方案：正如你所说，我们可以这样做：
template <typename T> class Foo{
public:
void doSomething(){
doSomething(std::is_same<T,A>());
}
private:
void doSomething(std::true_type){
cout<<"A do"<<endl;
}
void doSomething(std::false_type){
cout<<"any other do"<<endl;
}
};
第二种解决方案：因为模板类Foo只有一个模板参数，所以我们可以直接做出像这样的明确的特殊化。
template <typename T> class Foo{
public:
void doSomething(){
cout<<"any other do..."<<endl;
}
};
template<> void Foo<A>::doSomething(){
cout<<"A do"<<endl;
}
Thrid解决方案：可能不是一个好方法，我们可以这样做，这种方式（SFINAE）使用C ++ 11或boost_if。当类型与A相同时，编译器会自动选择期望的类。
#include <iostream>
using namespace std;
class A {};
template <typename T,typename Enable = void>
class Foo
{
public:
void DoSomething()
{
cout<<"anyother do"<<endl;
}
private:
T m_T;
};
template <typename T> class Foo<T, typename enable_if<is_same<T,A>::value>::type >
{
public:
void DoSomething()
{
cout<<"A do"<<endl;
}
private:
T m_T;
};
更多：
如果两个Foo有许多相同的东西，我们可以像这样为它创建基类：
template <typename T> class BaseFoo{
...
};
和两个从BaseFoo派生的模板类，如下所示：
template <typename T,typename Enable = void>
class Foo:public BaseFoo<T>{...}
template <typename T> class Foo<T, typename enable_if
<is_same<T,A>::value>::type >:public BaseFoo<T>{...}
我已经习惯了你的最后解决方案，所以对我来说这并不奇怪。
如果你喜欢，你可以随时做
void DoSomethingImpl(T&t, std::true_type){...}
和
void DoSomethingImpl(T&t, std::false_type){...}
接着
DoSomethingImpl(m_T, std::is_same<T, ClassA>{});
这在功能上是等同的，但如果功能需要扩展，也可以做出更复杂的决策。
链接地址: http://www.djcxy.com/p/84247.html