Hạn chế mẫu C++

Question

Tôi tự hỏi có cách nào để đặt hạn chế đối với lớp mẫu không?
Chỉ định rằng mọi loại được thay thế trong mẫu phải có tổ tiên cụ thể (nhận ra một số giao diện).

template < class B > //and every B must be a child of abstract C 
class A { 
public: 
    B * obj; 
    int f() { 
     return B::x + this->obj->f(); 
    } 
}; 

Giống như => trong Haskell

func :: (Ord a, Show b) => a -> b -> c 

Answer 1

Bạn có thể use BOOST_STATIC_ASSERT hoặc một thư viện tương tự để khẳng định giới hạn của bạn trên mẫu tham số.

Ví dụ:

#include <limits> 
#include <boost/static_assert.hpp> 

template <class UnsignedInt> 
class myclass 
{ 
private: 
    BOOST_STATIC_ASSERT((std::numeric_limits<UnsignedInt>::digits >= 16) 
         && std::numeric_limits<UnsignedInt>::is_specialized 
         && std::numeric_limits<UnsignedInt>::is_integer 
         && !std::numeric_limits<UnsignedInt>::is_signed); 
public: 
    /* details here */ 
}; 

EDIT: Ví dụ, bạn có thể viết

template < class B > 
class A { 
    BOOST_STATIC_ASSERT(boost::is_base_of<C, B>); 

public: 
    B * obj; 
    int f() { 
     return B::x + this->obj->f(); 
    } 
}; 

Answer 2

Bạn có thể sử dụng một thủ thuật như thế này (nếu bạn không muốn sử dụng Boost) :

class Base 
    { 
    public: 
     static const int TEMPLATE_REQUIRES_BASE_CLASS = 0; 
    }; 

class Correct : public Base 
    { 
    }; 

class Incorrect 
    { 
    }; 

template <typename T> 
class TMPL 
    { 
    static const int TEMPLATE_REQUIRES_BASE_CLASS = T::TEMPLATE_REQUIRES_BASE_CLASS; 
    T *m_t; 
    }; 

void main() 
{ 
TMPL<Correct> one;  // OK 
TMPL<Incorrect> two; // Will not compile 
} 

Dòng đầu tiên sẽ biên dịch. Thông tin thứ hai sẽ không biên dịch và sẽ cung cấp cho lỗi sau:

test.cpp 
test.cpp(18) : error C2039: 'TEMPLATE_REQUIRES_BASE_CLASS' : is not a member of 'Incorrect' 
     test.cpp(12) : see declaration of 'Incorrect' 
     test.cpp(25) : see reference to class template instantiation 'TMPL<T>' being compiled 
     with 
     [ 
      T=Incorrect 
     ] 
test.cpp(18) : error C2065: 'TEMPLATE_REQUIRES_BASE_CLASS' : undeclared identifier 
test.cpp(18) : error C2057: expected constant expression 

Answer 3

Phiên bản tương lai của C++ sẽ hỗ trợ các khái niệm nguyên gốc này (không đưa vào C++ 11).

Một cách để tiếp cận vấn đề là sử dụng chuyên môn về một tham số mẫu giả:

class C {}; 
template <class B, class dummy=void> 
class A; 

template <class B> 
class A<B, typename enable_if<is_base_and_derived<C, B> >::type> 
{ 
    // class definition here 
}; 

struct D : C {}; 

A<D> d;  // fine 
A<int> n; // compile error - undefined class A<B> 

Tôi đã đặt định nghĩa độc lập của enable_if và is_base_and_derivedhere.

Answer 4

Mẫu là loại nhập vịt trong C++.

Nếu lớp học của bạn hỗ trợ mọi thứ mà mẫu sử dụng, thì nó có thể được sử dụng làm đối số mẫu, nếu không thì nó không thể.

Nếu trong mẫu của bạn, bạn có cái gì đó như

C *instance; 

void foo(T *t) 
{ 
    instance = t; 
} 

sau đó bạn đang thực thi mà T có nguồn gốc từ C (hoặc ít nhất assignement tương thích cho con trỏ)

Answer 5

Các tác phẩm sau đây trong VC10 sử dụng static_assert. Tôi đã nhìn thấy điều này được sử dụng và chưa thực sự đào sâu vào những gì static_assert thực sự làm - có lẽ ai đó khác có thể trả lời điều đó.

#include <type_traits> 

class Base 
{ 

}; 

class Derived : public Base 
{ 

}; 

class SomeRandomClass 
{ 

}; 

template<typename T> 
class A 
{ 
    static_assert(std::tr1::is_base_of<Base, T>::value, "T not derived from Base"); 
}; 



int _tmain(int argc, _TCHAR* argv[]) 
{ 
    argc; argv; 

    // 
    // This will compile 
    A<Derived> a; 

    // 
    // This will throw a compilation error 
    A<SomeRandomClass> b; 

    return 0; 
} 

Trình biên dịch ra hạnh phúc:

1>d:\temp\aaa\aaa\aaa.cpp(25): error C2338: T not derived from Base 
1>   d:\temp\aaa\aaa\aaa.cpp(41) : see reference to class template instantiation 'A<T>' being compiled 
1>   with 
1>   [ 
1>    T=SomeRandomClass 
1>   ]