Templates và STL

Question

Các mã sau đây đại diện cho một container dựa trên std :: vector

template <typename Item> 
struct TList 
{ 
    typedef std::vector <Item> Type; 
}; 


template <typename Item> 
class List 
{ 
private 
      typename TList <Item>::Type items; 
    .... 
} 

int main() 
{ 
    List <Object> list; 
} 

Có thể templatize std :: vector và tạo một container chung, một cái gì đó như thế?

template <typename Item, typename stl_container> 
struct TList 
{ 
    typedef stl_container<Item>; 
}; 

nơi stl_container đại diện tiêu chuẩn :: vector, std :: list, std :: set ...? Tôi muốn chọn loại container tại thời điểm tạo ra.

List <Object, std::vector> list; //vector of objects, not a real code 
List <Object, std::vector> list; //list of objects, not a real code 

Cám ơn câu trả lời của bạn ...

câu hỏi Cập nhật:

Tôi đã thử các mã sau nhưng có những sai sót:

#include <vector> 
template <typename Item, typename Container> 
struct TList 
{ 
    typedef typename Container <Item>::type type; //Error C2059: syntax error : '<', Error C2238: unexpected token(s) preceding '; 
}; 


template <typename T> 
struct vector_container 
{ 
    typedef std::vector<T> type; 
}; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
TList <int, vector_container> v; 
TList <int, map_container> m; 
} 

Answer 1

Có và không.

Bạn có thể sử dụng một tham số template mẫu, ví dụ,

template <typename Item, template <typename> class Container> 
struct TList { /* ... */ }; 

Tuy nhiên, nói chung, các thông số template mẫu không phải là đặc biệt hữu ích bởi vì số lượng và chủng loại các thông số mẫu phải phù hợp. Vì vậy, ở trên sẽ không khớp với std::vector bởi vì nó thực sự có hai tham số mẫu: một cho loại giá trị và một cho phân bổ. Thông số mẫu mẫu không thể tận dụng bất kỳ đối số mẫu mặc định nào.

Để có thể sử dụng std::vector mẫu như một cuộc tranh cãi, TList sẽ phải được khai báo là:

template <typename Item, template <typename, typename> class Container> 
struct TList { /* ... */ }; 

Tuy nhiên, với mẫu này, bạn sẽ không thể sử dụng std::map mẫu như một đối số vì nó có thông số mẫu bốn: loại khóa và giá trị, loại cấp phát và loại so sánh.

Thông thường, việc tránh các thông số mẫu của mẫu dễ dàng hơn nhiều vì tính không linh hoạt này.

Answer 2

Có thể templatize std :: vector và tạo vùng chứa chung, một cái gì đó tương tự không?

No. Bạn sẽ phải templatize chức năng hoặc đối tượng bằng cách sử dụng vùng chứa - bạn không thể templatize chính vùng chứa đó.

Ví dụ: xem xét một điển hình std::find:

template<class InputIterator, class T> 
InputIterator find (InputIterator first, InputIterator last, const T& value) 
{ 
    for (;first!=last; first++) if (*first==value) break; 
    return first; 
} 

Điều này làm việc cho bất kỳ vùng chứa nào, nhưng không cần tempalte với container. Ngoài ra, với điều đó, có vẻ như những gì bạn đang cố gắng làm là tạo mã độc lập cho vùng chứa, bạn có thể muốn mua hoặc mượn bản sao Scott Meyers' Effective STL và đọc Mục 2: Hãy coi chừng ảo giác về mã độc lập của vùng chứa.

Answer 3

tốt, bạn có thể hack nó lên với một vĩ mô:

template <typename T, typename stl_container = std::vector<T> > 
struct TList 
{ 
    typedef stl_container Type; 
}; 

#define TLIST(T, C) TList<T, C<T> > 

TList<int> foo; 
TList<int, std::list<int> > bar; 
TLIST(int, std::list) baz; 

Answer 4

Có, nhưng không trực tiếp:

template <typename Item, template <typename> class Container> 
struct TList 
{ 
    typedef typename Container<Item>::type type; 
}; 

Sau đó, bạn có thể xác định chính sách container khác nhau:

template <typename T> 
struct vector_container 
{ 
    typedef std::vector<T> type; 
}; 

template <typename T> 
struct map_container 
{ 
    typedef std::map<T, std::string> type; 
}; 

TList<int, vector_container> v; 
TList<int, map_container> m; 

Mặc dù có một chút chi tiết. * Để thực hiện mọi việc trực tiếp, bạn cần phải thực hiện the route described by James, nhưng khi ghi chú điều này là cuối cùng rất không linh hoạt.

Tuy nhiên, với C++ 0x chúng ta có thể làm điều này chỉ tốt:

#include <map> 
#include <vector> 

template <typename Item, 
      template <typename...> class Container, typename... Args> 
struct TList 
{ 
    // Args lets the user specify additional explicit template arguments 
    Container<Item, Args...> storage; 
}; 

int main() 
{ 
    TList<int, std::vector> v; 
    TList<int, std::map, float> m; 
} 

Perfect. Thật không may là không có cách nào để tái tạo điều này trong C++ 03, ngoại trừ thông qua các lớp chính sách gián tiếp giới thiệu như mô tả ở trên.

---

* Tôi muốn nhấn mạnh rằng "Chi tiết một chút" có nghĩa là "điều này không chính thống". Giải pháp chính xác cho vấn đề của bạn là thư viện chuẩn, as Jerry explains. Bạn chỉ cho phép người dùng adapter container của bạn chỉ định toàn bộ container loại trực tiếp:

template <typename Item, typename Container = std::vector<Item>> 
struct TList 
{}; 

Nhưng vẫn để lại một vấn đề lớn: những gì nếu tôi không muốn kiểu giá trị của các container để được Item nhưng something_else<Item>? Nói cách khác, làm cách nào tôi có thể thay đổi loại giá trị của vùng chứa hiện tại thành vùng chứa khác? Trong trường hợp của bạn, bạn không nên đọc thêm, nhưng trong trường hợp chúng tôi làm, chúng tôi muốn rebind một vùng chứa.

Thật không may cho chúng tôi, các container không có chức năng này, mặc dù allocators làm:

template <typename T> 
struct allocator 
{ 
    template <typename U> 
    struct rebind 
    { 
     typedef allocator<U> type; 
    }; 

    // ... 
}; 

Điều này cho phép chúng tôi để có được một allocator<U> đưa ra một allocator<T>. Làm thế nào chúng ta có thể làm tương tự cho các thùng chứa mà không có tiện ích xâm nhập này? Trong C++ 0x, thật dễ dàng:

template <typename T, typename Container> 
struct rebind; // not defined 

template <typename T, typename Container, typename... Args> 
struct rebind<T, Container<Args...>> 
{ 
    // assumes the rest are filled with defaults** 
    typedef Container<T> type; 
}; 

Với std::vector<int>, chúng tôi có thể thực hiện rebind<float, std::vector<int>>::type, ví dụ. Không giống như C++ 0x trước giải pháp, chương trình này có thể được mô phỏng trong C++ 03 với các macro và lặp ..

---

** Chú ý cơ chế này có thể được thực hiện mạnh mẽ hơn nhiều, giống như đó nêu rõ lý lẽ để giữ , mà để rebind, mà để rebind mình trước khi sử dụng như là đối số, vv, nhưng đó là trái như là một tập thể dục cho người đọc. :)

Answer 5

Tôi hơi bối rối vì sao một số người rất thông minh (và có thẩm quyền) đang nói không.

Trừ khi tôi đã đọc sai câu hỏi của bạn, những gì bạn đang cố gắng hoàn thành hầu như giống với "bộ điều hợp vùng chứa" trong thư viện chuẩn. Mỗi giao diện cung cấp giao diện cho một số loại vùng chứa cơ bản, với loại vùng chứa sẽ được sử dụng như một tham số mẫu (có giá trị mặc định).

Ví dụ: std::stack sử dụng một số vùng chứa khác (ví dụ:, std::deque, std::list hoặc std::vector) để giữ các đối tượng và bản thân std::stack chỉ cung cấp giao diện đơn giản/bị hạn chế khi bạn chỉ muốn sử dụng các hoạt động ngăn xếp. Vùng chứa bên dưới sẽ được sử dụng bởi std::stack được cung cấp dưới dạng tham số mẫu. Dưới đây là cách mã trông trong tiêu chuẩn:

namespace std { 
    template <class T, class Container = deque<T> > 
    class stack { 
    public: 
     typedef typename Container::value_type value_type; 
     typedef typename Container::size_type size_type; 
     typedef Container      container_type; 
    protected: 
     Container c; 
    public: 
     explicit stack(const Container& = Container()); 
     bool empty() const    { return c.empty(); } 
     size_type size() const   { return c.size(); } 
     value_type& top()    { return c.back(); } 
     const value_type& top() const { return c.back(); } 
     void push(const value_type& x) { c.push_back(x); } 
     void pop()      { c.pop_back(); } 
    }; 
} 

Tất nhiên, có lẽ tôi vừa hiểu lầm câu hỏi - nếu như vậy, tôi xin lỗi trước cho những người mà tôi (loại) không đồng ý.

Answer 6

Bạn có thể sử dụng các thông số mẫu mẫu như những người khác đã đề cập ở đây. Khó khăn chính với điều này không phải là các loại container khác nhau có các tham số mẫu không giống nhau, nhưng tiêu chuẩn cho phép các thùng chứa tiêu chuẩn, như vector, có các tham số mẫu ngoài các tài liệu cần thiết.

Bạn có thể khắc phục điều này bằng cách cung cấp các loại lớp con của riêng bạn mà chấp nhận các thông số mẫu thích hợp và cho phép bất kỳ tính năng bổ sung (trong đó phải có giá trị mặc định) được lấp đầy trong việc thực hiện của tôi:

template < typename T > struct simple_vector : std::vector<T> {}; 

Hoặc bạn có thể sử dụng biểu mẫu typedated typedef:

template < typename T > struct retrieve_vector { typedef std::vector<T> type; };