con trỏ làm thông số mẫu?

Question

Tôi có một lớp container, chúng tôi sẽ gọi nó là

template <class T> CVector { ... } 

tôi muốn làm một cái gì đó khác nhau với lớp này khi T là một kiểu con trỏ, ví dụ một cái gì đó dọc theo các dòng:

template <class T*> CVector< SomeWrapperClass<T> >; 

trong đó SomeWrapperClass đang chờ loại thông tin được trỏ đến làm thông số của nó. Thật không may, cú pháp này không hoàn toàn làm việc và với một số đào, tôi đã không tìm thấy một cách tốt để có được một cái gì đó như thế này làm việc.

Tại sao thực hiện theo cách này? Tôi muốn thay đổi, trong một ứng dụng rất lớn, cách một số thùng chứa của chúng tôi hoạt động khi loại chúng chuyên biệt là con trỏ chứ không phải con trỏ - và lý tưởng, tôi muốn làm điều đó mà không thay đổi ~ 1.000 địa điểm trong mã có những thứ như CVector<Object*> vs CVector<int> hoặc một số trò chơi như vậy và chơi với các chuyên môn từng phần dường như là cách để đi.

Tôi có bị nứt ở đây không?

Answer 1

Tôi không nghĩ rằng bạn có thể chuyên môn một lớp bằng cách sử dụng cú pháp bạn mô tả ... Tôi không biết làm thế nào mà có thể có thể làm việc. Những gì bạn có thể làm là chuyên lớp cho con trỏ và thực hiện lại các đường ruột của nó bằng cách sử dụng lớp wrapper quanh các con trỏ thô. Tôi không chắc chắn nếu nó sẽ giúp đỡ, nhưng this article mô tả các mẫu chuyên cho con trỏ.

Answer 2

Tôi không nghĩ rằng các mẫu khá linh hoạt.

Một phương pháp tiếp cận rất mạnh sẽ là chuyên cho tất cả các loại con trỏ của bạn ... đánh bại vấn đề sử dụng mẫu.

Bạn có thể có lớp CVector khác chỉ được sử dụng cho vectơ của con trỏ không?

Answer 3

Nếu tôi hiểu bạn một cách chính xác, điều này có thể làm những gì bạn muốn:

template<typename T> 
class CVector { ... }; 

template<typename T> 
class CVector<T*> : public CVector< SomeWrapperClass<T> > { 
public: 
    // for all constructors: 
    CVector(...) : CVector< SomeWrapperClass<T> >(...) { 
    } 
}; 

Nó cho biết thêm thêm một lớp thừa kế để lừa CVector<T*> ra đời một CVector< SomeWrapperClass<T> >. Điều này cũng có thể hữu ích trong trường hợp bạn cần thêm các phương thức bổ sung để đảm bảo khả năng tương thích đầy đủ giữa giao diện được mong đợi cho T* và giao diện được cung cấp cho SomeWrapperClass<T>.

Answer 4

này chỉ hoạt động tốt trong C++ ...

#include <iostream> 

template <class T> 
class CVector 
{ 
public: 
    void test() { std::cout << "Not wrapped!\n"; } 
}; 

template <class T> 
class CVector<T*> 
{ 
public: 
    void test() { std::cout << "Wrapped!\n"; } 
}; 

int main() 
{ 
    CVector<int> i; 
    CVector<double> d; 
    CVector<int*> pi; 
    CVector<double*> pd; 
    i.test(); 
    d.test(); 
    pi.test(); 
    pd.test(); 
} 

Answer 5

Các Boost type traits library có thể giúp bạn đạt được điều này. Hãy xem đặc điểm loại is_pointer.

#include <boost/type_traits.hpp> 
#include <iostream> 
#include <vector> 

using namespace std; 

template <class T> 
class CVector { 
    public: 
    void addValue(const T& t) { 
     values_.push_back(t); 
    } 

    void print() { 
     typedef boost::integral_constant<bool, 
     ::boost::is_pointer<T>::value> truth_type; 

     for (unsigned int i = 0; i < values_.size(); i++) 
     doPrint(values_[i], truth_type()); 
    } 


    private: 
    void doPrint(const T& t, const boost::false_type&) { 
     cout << "Not pointer. Value:" << t << endl; 
    } 

    void doPrint(const T& t, const boost::true_type&) { 
     cout << "Pointer. Value: " << *t << endl; 
    } 

    std::vector<T> values_; 
}; 


int main() { 
    CVector<int> integers; 
    integers.addValue(3); 
    integers.addValue(5); 
    integers.print(); 

    CVector<int*> pointers; 
    int three = 3; 
    int five = 5; 
    pointers.addValue(&three); 
    pointers.addValue(&five); 
    pointers.print(); 
} 

Answer 6

Tôi đồng ý với câu trả lời của rlbond. Tôi đã sửa đổi nó một chút cho phù hợp với nhu cầu của bạn. CVector có thể là một lớp dẫn xuất của chính CVector. Sau đó, bạn có thể sử dụng các thành viên và chức năng khác nhau cho nó.

#include <iostream> 
#include <string> 
template <class T> 
class CVector 
{ 
public: 
    void test() { std::cout << "Not wrapped!\n"; } 
    void testParent() { std::cout << "Parent Called\n";} 
}; 

template <class T> 
class CVector<T*>: 
    public CVector<T> 
{ 
public: 
    void test(std::string msg) { std::cout << msg; testParent(); } 
}; 

int main() 
{ 
    CVector<int> i; 
    CVector<double> d; 
    CVector<int*> pi; 
    CVector<double*> pd; 
    i.test(); 
    d.test(); 
    pi.test("Hello\n"); 
    pd.test("World\n"); 
    system("pause"); 
}