第十六章 模板和泛型编程

code:

/*


第16章 模板与泛型编程 525
16.1 模板定义
16.2 实例化
16.3 模板编译模型
16.4 类模板成员
16.5 一个泛型句柄类
16.6 模板特化
16.7 重载与函数模板
小结


第16章 模板与泛型编程 525
16.1 模板定义 526
16.1.1 定义函数模板 526
16.1.2 定义类模板 528
16.1.3 模板形参 529
16.1.4 模板类型形参 531
16.1.5 非类型模板形参 533
16.1.6 编写泛型程序 534
16.2 实例化 535
16.2.1 模板实参推断 537
16.2.2 函数模板的显式实参 540
16.3 模板编译模型 542
16.4 类模板成员 545
16.4.1 类模板成员函数 548
16.4.2 非类型形参的模板实参 551
16.4.3 类模板中的友元声明 552
16.4.4 Queue和QueueItem的友元
声明 554
16.4.5 成员模板 556
16.4.6 完整的Queue类 558
16.4.7 类模板的static成员 559
16.5 一个泛型句柄类 560
16.5.1 定义句柄类 561
16.5.2 使用句柄 562
16.6 模板特化 564
16.6.1 函数模板的特化 565
16.6.2 类模板的特化 567
16.6.3 特化成员而不特化类 569
16.6.4 类模板的部分特化 570
16.7 重载与函数模板 570
小结 573
术语 574

*/



//第16章 模板与泛型编程

//16.1 模板定义 --------------------------------------------------------------------------------------------------------

 
#include <iostream>
#include <string>
using namespace std;

// returns 0 if the values are equal, -1 if v1 is smaller, 1 if v2 is smaller
int compare(const string &v1, const string &v2)
{
  if(v1 < v2)
    return  - 1;
  if(v2 < v1)
    return 1;
  return 0;
}

int compare(const double &v1, const double &v2)
{
  if(v1 < v2)
    return  - 1;
  if(v2 < v1)
    return 1;
  return 0;
}

int main()
{
  cout << compare("abc","def") << endl;
  cout << compare(3.14,3.1415) << endl;
  
  return 0;
}


// 函数模板 function template
#include <iostream>
#include <string>
using namespace std;

// implement strcmp-like generic compare function
// returns 0 if the values are equal, 1 if v1 is larger, -1 if v1 is smaller
template <typename T> int compare(const T &v1, const T &v2)
{
  if(v1<v2) return  - 1;
  if(v2<v1) return 1;
  return 0;
}

int main()
{
  cout << compare("abc","def") << endl;
  cout << compare(3.14,3.1415) << endl;
  
  return 0;
}



// in book
 
#include <iostream>
#include <string>
using namespace std;

// implement strcmp-like generic compare function
// returns 0 if the values are equal, 1 if v1 is larger, -1 if v1 is smaller
template <typename T> int compare(const T &v1, const T &v2)
{
  if(v1<v2) return  - 1;
  if(v2<v1) return 1;
  return 0;
}

int main()
{
  // T is int;
  // compiler instantiates int compare(const int&, const int&)
  cout << compare(1, 0) << endl;
  // T is string;
  // compiler instantiates int compare(const string&, const string&)
  string s1 = "hi", s2 = "world";
  cout << compare(s1, s2) << endl;
  
  return 0;
}



// inline
#include <iostream>
#include <string>
using namespace std;

// 声明
// ok: inline specifier follows template parameter list
  template <typename T> inline int compare(const T&, const T&);
// error: incorrect placement of inline specifier
//inline template <typename T> int compare(const T&, const T&);

// 定义
template <typename T> int compare(const T &v1, const T &v2)
{
  if(v1<v2) return  - 1;
  if(v2<v1) return 1;
  return 0;
}

int main()
{
  // T is int;
  // compiler instantiates int compare(const int&, const int&)
  cout << compare(1, 0) << endl;
  // T is string;
  // compiler instantiates int compare(const string&, const string&)
  string s1 = "hi", s2 = "world";
  cout << compare(s1, s2) << endl;
  
  return 0;
}


// 类模板接口
template <class Type> class Queue
{
  public:
    Queue(); // default constructor
    Type &front(); // return element from head of Queue
    const Type &front()const;
    void push(const Type &); // add element to back of Queue
    void pop(); // remove element from head of Queue
    bool empty()const; // true if no elements in the Queue
  private:
    // ...
};


// 使用类模板
Queue<int> qi;                 // Queue that holds ints
Queue< vector<double> > qc;    // Queue that holds vectors of doubles
Queue<string> qs;              // Queue that holds strings



// 非类型模板形参 
#include <iostream>
#include <string>
using namespace std;

// initialize elements of an array to zero
template <class T, size_t N> void array_init(T (&parm)[N])
{
    for(size_t i = 0; i != N; ++i)
    {
        parm[i] = 0;
    }
}

int main()
{
  int x[42];
  double y[10];
  array_init(x); // instantiates array_init(int(&)[42]
  array_init(y); // instantiates array_init(double(&)[10]
}


/*
编写泛型代码的两个重要原则：
    The parameters to the template are const references.
    模板的形参是 const 引用。
    The tests in the body use only < comparisons.
    函数体中的测试只用 < 比较。
*/



//16.2 实例化 --------------------------------------------------------------------------------------------------------


// 实参类型不同，将产生编译错误 
#include <iostream>
#include <string>
using namespace std;

template <typename T> int compare(const T &v1, const T &v2)
{
  if(v1<v2) return  - 1;
  if(v2<v1) return 1;
  return 0;
}

int main()
{
  short si;
  // error: cannot instantiate compare(short, int)
  // must be: compare(short, short) or
  // compare(int, int)
  compare(si, 1024);
  return 0;
}




// 在函数模板中，定义两个形参类型，就可以了 
#include <iostream>
#include <string>
using namespace std;

// 定义成两个类型
template <typename T, typename B> int compare(const T &v1, const B &v2)
{
  if(v1<v2) return  - 1;
  if(v2<v1) return 1;
  return 0;
}

int main()
{
  short si;
  // error: cannot instantiate compare(short, int)
  // must be: compare(short, short) or
  // compare(int, int)
  compare(si, 1024);
  return 0;
}



template <typename T> T fobj(T, T); // arguments are copied
template <typename T> T fref(const T &, const T &); // reference arguments
string s1("a value");
const string s2("another value");
fobj(s1, s2); // ok: calls f(string, string), const is ignored
fref(s1, s2); // ok: non const object s1 converted to const reference
int a[10], b[42];
fobj(a, b); // ok: calls f(int*, int*)
fref(a, b); // error: array types don't match; arguments aren't converted to pointers



// in book 
#include <iostream>
#include <string>
using namespace std;

template <class Type> Type sum(const Type &op1, int op2)
{
    return op1 + op2;
} 

int main()
{
  double d = 3.14;
  string s1("hiya"), s2(" world");
  sum(1024, d); // ok: instantiates sum(int, int), converts d to int
  sum(1.4, d); // ok: instantiates sum(double, int), converts d to int
  // sum(s1, s2); // error: s2 cannot be converted to int
}


// 函数指针
template <typename T> int compare(const T&, const T&);
// pf1 points to the instantiation int compare (const int&, const int&)
int (*pf1) (const int&, const int&) = compare;



 
#include <iostream>
#include <string>
using namespace std;

template <class T1, class T2, class T3> T1 sum(const T2 &i, const T3 &j)
{
  return i+j;
}

int main()
{
  long val3 = sum<long>(2, 3);
  cout << val3 << endl;
  cout << sizeof(val3) << endl;
  return 0;
}



//16.3 模板编译模型 --------------------------------------------------------------------------------------------------------


//16.4 类模板成员 --------------------------------------------------------------------------------------------------------


#include <iostream>
#include <string>
using namespace std;

template <class Type> class QueueItem
{
    // private class: no public section
    QueueItem(const Type &t): item(t), next(0){}
    Type item; // value stored in this element
    QueueItem *next; // pointer to next element in the Queue
};

template <class Type> class Queue
{
  public:
    // empty Queue
    Queue(): head(0), tail(0){}
    // copy control to manage pointers to QueueItems in the Queue
    Queue(const Queue &Q): head(0), tail(0)
    {
        copy_elems(Q);
    } 
    Queue &operator = (const Queue &);
    ~Queue()
    {
        destroy();
    }
    // return element from head of Queue
    // unchecked operation: front on an empty Queue is undefined
    Type &front()
    {
        return head->item;
    }
    const Type &front()const
    {
        return head->item;
    }
    void push(const Type &); // add element to back of Queue
    void pop(); // remove element from head of Queue
    bool empty()const
    {
        // true if no elements in the Queue
        return head == 0;
    }
  private:
    QueueItem < Type >  *head; // pointer to first element in Queue
    QueueItem < Type >  *tail; // pointer to last element in Queue
    // utility functions used by copy constructor, assignment, and destructor
    void destroy(); // delete all the elements
    void copy_elems(const Queue &); // copy elements from parameter
};

template <class Type> void Queue<Type>::destroy()
{
    while(!empty())
      pop();
} 

template <class Type> void Queue<Type>::pop()
{
    // pop is unchecked: Popping off an empty Queue is undefined
    QueueItem<Type>  *p = head; // keep pointer to head so we can delete it
    head = head->next; // head now points to next element
    delete p; // delete old head element
} 

template <class Type> void Queue<Type>::push(const Type &val)
{
    // allocate a new QueueItem object
    QueueItem<Type>  *pt = new QueueItem<Type> (val);
    // put item onto existing queue
    if(empty())
      head = tail = pt;
    // the queue now has only one element
    else
    {
        tail->next = pt; // add new element to end of the queue
        tail = pt;
    }
}

template <class Type> void Queue<Type>::copy_elems(const Queue &orig)
{
    // copy elements from orig into this Queue
    // loop stops when pt == 0, which happens when we reach orig.tail
    for(QueueItem<Type>  *pt = orig.head; pt; pt = pt->next)
      push(pt->item);
    // copy the element
} 

int main()
{
  return 0;
}

//  后面部分先略。

//16.5 一个泛型句柄类 --------------------------------------------------------------------------------------------------------

//16.6 模板特化 --------------------------------------------------------------------------------------------------------

//16.7 重载与函数模板 --------------------------------------------------------------------------------------------------------


// 后面两章，纯粹浏览，代码木有，或者先略。。。


141118

TOP