【C++ Primer 第16章】1. 定义模板 （一）

类模板

 #include<iostream>
 #include<vector>
 #include<memory>
 using namespace std;

 template <typename T> class BlobPtr;
 template <typename T> class Blob;
 template <typename T> bool operator==(const Blob<T>&, const Blob<T>&);

 template<typename T> class Blob {
 friend class BlboPtr;
 friend bool operator==(const Blob<T>&, const Blob<T>&);
 public:
     typedef typename vector<T>::size_type size_type;

     Blob();
     Blob(initializer_list<T> il);

     size_type size() const     { return data->size(); }
     bool empty() const         { return data->empty(); }
     void push_back(const T&)   { data->push(t); }
     void push_back(T &&t)      { data->push_back(std::move(t)); }

     void pop_back();
     T& back();
     T& opearator[](size_type i);

 private:
     shared_ptr<vector<T>> data;
     void check(size_t i, const string &msg)
 };

 template <typename T>
 Blob<T>::Blob(): data(make_shared<vector<T>>()) {}

 template <typename T>
 Blob<T>::Blob(initializer_list<T> il): data(make_shared<vector<T>>(il)) {}

 temlate <typename T>
 void Blob<T>::check(size_type i, const string &msg) const
 {
     if (i >= data->size())
         throw out_of_range(msg);
 }
 template <typename T>
 void Blob<T>::pop_back()
 {
     check(, "pop_back on empty Blob");
     data->pop_back();
 }

 template <typename T>
 T& Blob<T>::back()
 {
     check(, "back om empty Blob");
     return data->back();
 }

 template <typename T>
 T& operator[](size_type i)
 {
     check(i,"subscript out of range");
     return (*data)[i];
 }

 /*--------------------------BlobPtr----------------------------------------------*/

 template <typename T> BlobPtr {
 public:
     BlobPtr(): curr() {}
     BlobPtr(Blob<T> &a, size_r sz = ): wptr(a.data), curr(sz) {}

     T& opearator*() const;

     BlobPtr& operator++();      //后缀自增
     BlobPtr& opearator--();
     BlobPtr& opearator++(int);  //前缀自减
     BlobPtr& opearator--(int);

 private:
     size_t curr;
     weak_ptr<vector<T>> wptr;
     shared_ptr<vector<T>> check(size_t, const string&) const
 };

 template <typename T>
 shared_ptr<vector<T>> BlobPtr<T>::check(size_t i, const string &msg) const
 {
     auto ret = wptr.lock();
     if (!ret)
         throw runtime_error("unbind BlobPtr");
     if (i >= ret->size())
         thow out_of_range(msg);
 }

 template <typename T>
 T& BlobPtr*() const
 {
     auto p = check(curr, "dereference past end");
     return (*p)[curr];
 }

 template <typename T>
 BlobPtr<T>& BlobPtr<T>::operator--()
 {
     --curr;
     check(curr, "decrement past bengin of BlobPtr");
     return *this;
 }

 template <typename T>
 BlobPtr<T>& BlobPtr<T>::opearator++()
 {
     check(curr, "unbound BlobPtr");
     ++curr;
     return *this;
 }

 template <typename T>
 BlobPtr<T>& BlobPtr<T>::operator++(int)  //后缀
 {
     BlobPtr ret = *this;
     ++*this;
     return ret;
 }

 template <typename T>
 BlobPtr<T>& BlobPtr<T>::operator--(int)
 {
     BlobPtr ret = *this;
     --*this;
     return ret;
 }

 template <typename T> class Pal;    // 前置申明，在将模板的一个特例声明为友元关系时要用到
 class C {                           // C是一个普通的非模板类
 friend class Pal<C>;                // 用C实例化的Pal是C的一个友元

 template <typename T> friend class Pal2;   // pal2的所有实例都是C的友元;这种情况无需前置申明
 };

 template <typename T> class C2 {   // C2本身是一个类模板
 friend class Pal<T>;               // C2的每个实例将相同实例化的Pal声明为友元
 template <typename X> friend class Pal2;  // Pal2的所有实例都是C2的每个实例的友元，不需要前置声明
 friend class Pal3;         // pal3是一个非模板类，它是C2所有实例的友元
                            // 不需要Pal3的前置声明
 };

控制实例化

• 模板在使用时才会被实例化，相同的实例可能出现在对各对象文件中。

• 当多个独立编译的源文件使用了相同的模板，并提供了相同的参数。那么每个文件都会有该模板的一个实例，在大系统中，这会增加额外开销。

• 通过显示实例化，避免这种开销。

extern template class Blob<string>             //声明
template int compare(const int&, const int&)   //定义