The C++ Programming Language 读书笔记 ch13

        御剑归来, 开始看模板一章, 感觉飘飘悠悠的

template<typename T, int n>

class A

{ };

在模板参数列表中声明的内置数据类型,属于常量.

在VS2005下面, 不支持export, 所以,模板类的声明与定义只能集中在一个文件中, 这个简单的链表模板类有待改进

/******************************************
 * 文件名:linklist.h
 * 功能:定义一个链表的界面
 * 创建日期:2007-9-17
******************************************/

#include <iostream>
using namespace std;

/* 定义链表中结点 */
template <typename T>
class myNode
{
public:
     myNode():next(NULL) { }
     myNode(const T& value):value(value),next(NULL) { }

public:
     T value;
     myNode<T>* next;
};

/*****************************************
 * 定义链表
 * 成员:myNode* front 指向链表第一个结点的指针
 * 操作:addNode() - 在表头添加结点
  deleteNodeby() - 删除结点
  searchby() - 根据具体值遍历链表
  display() - 输出链表
  getMax() - 返回链表最大值
  getSize() - 返回结点总数
  deleteAll() - 删除所有结点,释放内存空间
*****************************************/
template <typename T>
class mylist
{
public:
     mylist():front(NULL) {}
      mylist(const myNode<T>* newNode):front(newNode){}
 
      void addNode(myNode<T>* one); // 通过指针添加
      void addNode(const T& value); // 通过值添加
      bool deleteNodeby(const T& value); // 通过值删除
      bool searchby(const T& value); // 通过值查找,存在则返回该结点指针到e,函数返回true.
             // 否则e置NULL, 函数返回false
      void display(); // 输出所有结点
      myNode<T>* getMax(); // 返回最大值结点指针
      int getSize(); // 返回结点数量
      void deleteAll();

private:
      myNode<T>* front;
};

template <typename T>
void mylist<T>::addNode(myNode<T>* one)
{
      if (front == NULL)
            front = one;
      else
      {
            one->next = front;
            front = one;
      }
}

template <typename T>
void mylist<T>::addNode(const T &value)
{
      myNode<T> *p;
      p = new myNode<T>(value);
      addNode(p);
}

template <typename T>
bool mylist<T>::deleteNodeby(const T& value)
{
      myNode<T> *curr, *prev;
      bool flag; // 找到flag = true, 初始化为false
      curr = front;
      prev = NULL;
      flag = false;
      while ((curr != NULL) && (flag == false))
      {
            if (curr->value == value)
            {
                  myNode<T>* p;
                  p = curr;
                  if (prev == NULL)
                  { 
                        front = front->next;
                        curr = front;
                  }
                  prev->next = curr->next;
                  flag = true;
                  delete p;
            }
            else
            {
                  prev = curr;
                  curr = curr->next;
            }
      }

      return flag;
}

template <typename T>
bool mylist<T>::searchby(const T& value)
{
      myNode<T>* curr;
      bool flag; // 找到flag = true , 初始化为false
      curr = front;
      flag = false;

      while ((curr != NULL) && (flag == false))
      {
            if (curr->value == value)
            {
               //   e = curr;
                  flag = true;
            }
            else
                  curr = curr->next;
      }

      return flag;
}

template <typename T>
void mylist<T>::display()
{
      myNode<T>* curr;
      curr = front;
      while (curr != NULL)
      {
            cout << curr->value << " ";
            curr = curr->next;
      }
}

template <typename T>
myNode<T>* mylist<T>::getMax()
{
      myNode<T> *curr, *max;
      curr = front;
      max = curr;

      while (curr != NULL)
      {
            if (curr->value > max->value)
                  max = curr;
            else
                  curr = curr->next;
      }

           return max; // 这里要考虑一个问题, 局部变量在调用结束时会销毁,但是max所指向的是链表中某个结点的地址
    // 即使销毁了max, 它指向的地址仍然存在. 现在是这样想的
}

template <typename T>
int mylist<T>::getSize()
{
      int count;
      myNode<T>* curr;
      curr = front;
      count = 0;
      while (curr != NULL)
      {
            count++;
            curr = curr->next;
      }

      return count;
}

template <typename T>
void mylist<T>::deleteAll()
{
      myNode<T>* curr;
      while (front != NULL)
      {
            curr = front;
            front = front->next;
            delete curr;
      }
}

链表的声明与定义必要在同一个头文件中

模板这章看得有点乱, 要回头重新细看