#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&)   //定义