Question

我想做这样的事情：

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。我无法进行投射，因为可能的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中没有，因为它反对类中的特化）。

有更好的方法吗？

Answer 1

我认为你的最后一个选择是最好的。

而不是

template <>
void DoSomethingImpl(ClassA& t)
{
    t.DoThingOne();
    t.DoThingTwo();
    DoSomeFooPrivateThing();
    t.DoThingThree();
}

你可以使用（这里不需要使用template）：

void DoSomethingImpl(ClassA& t)
{
    t.DoThingOne();
    t.DoThingTwo();
    DoSomeFooPrivateThing();
    t.DoThingThree();
}

Answer 2

第一个解决方案：正如您所说，我们可以这样做：

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 enable_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>{...}

Answer 3

我已经习惯了你的最后解决方案，所以对我来说并不奇怪。
如果您愿意，可以随时

    void DoSomethingImpl(T&t, std::true_type){...}

和

    void DoSomethingImpl(T&t, std::false_type){...}

然后

    DoSomethingImpl(m_T, std::is_same<T, ClassA>{});

这在功能上是等效的，但如果需要扩展功能，还可以进行更复杂的决策。

模板元代码和私有成员

3 个答案: