C++模板实例化限制

Question

我在类C中有一个方法foo，它可以调用foo_1或foo_2。 该方法foo（）具有在C被定义，因为FOO（）是纯在BaseClass的虚拟和我实际上 必须进行以下类型C.代码的对象：

template <class T> 
class C:public BaseClass{ 

    void foo() { 
    if (something()) foo_1; 
    else foo_2; 

    } 
    void foo_1() { 
    .... 
    } 

    void foo_2() { 
    .... 
    T t; 
    t.bar(); // requires class T to provide a method bar() 
    .... 
    } 
}; 

现在大多数类型ŤFOO_1将足够，但对于某些类型foo_2将被称为 （取决于（））。然而，编译器坚持要实例化foo_1 和foo_2，因为可能会调用它们。

这给T带来了负担，它必须提供条形方法 。

我如何告诉编译如下：

• 如果T没有吧（），仍然允许它作为一个实体化类型？

Answer 1

您可以使用boost.enable_if。是这样的：

#include <boost/utility/enable_if.hpp> 
#include <iostream> 

struct T1 { 
    static const bool has_bar = true; 
    void bar() { std::cout << "bar" << std::endl; } 
}; 

struct T2 { 
    static const bool has_bar = false; 
}; 

struct BaseClass {}; 

template <class T> 
class C: public BaseClass { 
public: 
    void foo() { 
     do_foo<T>(); 
    } 

    void foo_1() { 
     // .... 
    } 

    template <class U> 
    void foo_2(typename boost::enable_if_c<U::has_bar>::type* = 0) { 
     // .... 
     T t; 
     t.bar(); // requires class T to provide a method bar() 
     // .... 
    } 

private: 

    bool something() const { return false; } 


    template <class U> 
    void do_foo(typename boost::enable_if_c<U::has_bar>::type* = 0) { 
     if (something()) foo_1(); 
     else foo_2<U>(); 
    } 

    template <class U> 
    void do_foo(typename boost::disable_if_c<U::has_bar>::type* = 0) { 
     if (something()) foo_1(); 
     // I dunno what you want to happen if there is no T::bar() 
    } 
}; 

int main() { 
    C<T1> c; 
    c.foo(); 
} 

Answer 2

您可以为FOO_1和FOO_2创建一个接口，如：

class IFoo 
{ 
public: 
    virtual void foo_1()=0; 
    virtual void foo_2()=0; 
}; 

template <typename T> 
class C : public BaseClass, public IFoo 
{ 

    void foo() 
    { 
    if (something()) 
     foo_1(); 
    else 
     foo_2(); 
    } 
}; 

template <typename T> 
class DerivedWithBar : C<T> 
{ 
public: 
    void foo_1() { ... } 

    void foo_2() 
    { 
     ... 
     T t; 
     t.bar(); // requires class T to provide a method bar() 
     ... 
    } 
}; 

template <typename T> 
class DerivedNoBar : C<T> 
{ 
public: 
    void foo_1() { ... } 
    void foo_2() { ... } 
}; 

Answer 3

我认为最简单的方法是简单地写一个单独的函数模板“C”可以调用：

template <class T> 
void call_bar(T& /*t*/) 
{ 
} 

template <> 
void call_bar<Something>(Something& t) 
{ 
    t.bar(); 
} 

原始 'C' 类可以被相应地修改：

void foo_2() { 
    .... 
    T t; 
    call_bar(t); // does not require T to provide bar() 
    .... 
} 

这有缺点，你必须明确定义哪些类型的T提供了一个bar方法，但这几乎是不可避免的，除非你可以在编译时确定一些关于在其公共接口中提供bar方法的所有类型的东西或者修改所有这些条形支撑类型，以便它们共享可以在编译时确定的共同事物。