The C++ Programming Language 读书笔记 ch13

原创 2007年09月18日 22:48:00

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

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;
      }
}

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

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

 

《The C++ Programming Language》第四章读书笔记之忠告

【1】保持较小的作用域; 4.9.4节。 【2】不要在一个作用域和他外围的作用域里使用同样的名字; 4.9.4节。         例如: int x; //局部变量 x = 1; { in...
  • wyrhero
  • wyrhero
  • 2012年06月23日 15:39
  • 301

The Java Programming Language4th读书笔记-第十四章 线程

main方法本身就是通过运行时系统创建的线程而执行的;

The Java Programming Language4th读书笔记-第五章 嵌套类和接口

嵌套类型主要有两个用途: 嵌套类和嵌套接口使多个类型可以组织成逻辑上相关的组,并具有相应的作用域; 更重要的一点,嵌套类可以简单而有效地连接逻辑上相关的对象;该能力被广泛地用于事件框架;例如Java...

The Go Programming Language(读书笔记)

The Go Programming Language 目录  [隐藏]  1 Tutorial2 程序结构3 基本数据类型4 复合类型5 函...
  • cteng
  • cteng
  • 2015年12月20日 01:36
  • 1051

The Java Programming Language4th读书笔记-第九章 运算符和表达式

浮点除法和取余运算可能会产生无穷大或NaN的结果,但是绝不会抛出异常: x y x/y x%y 无穷 ±0.0 ±∞ NaN 无穷 ±∞ ±0.0 x ...

The C Programming Language 第三章控制流 读书笔记

程序语言中的控制流语句用于控制各计算操作执行的次序。 3.1语句与程序块 表达式之后加上一个分号(;)就变成了语句。 在C语言中,分号是语句结束符。 用一对花括号把一组声明和语句括在一...
  • wtrnash
  • wtrnash
  • 2015年07月28日 21:23
  • 484

TCPL(The C Programming Language)读书笔记 第六章 结构

1、           结构的基本知识struct point{    int x;    int y;};    关键字struct引入结构声明。结构声明由包含在花括号内的一系列声明组成。stru...

The Java Programming Language4th读书笔记-第十二章 异常与断言

异常主要分为: 检查型异常:编译器将检查我们的方法是否只抛出了它们声明自己会抛出的异常;虽然这种情况是异常的,但是一定程度上它的发生是可以预计的,而且一旦这种情况确实发生了,就必须以某种方式来处理;...

TCPL(The C Programming Language)读书笔记 第七章 输入与输出

1、           标准输入/输出最简单的输入机制是使用getchar函数从标准输入中(一般为键盘)一次读取一个字符:int getchar(void)  getchar函数在每次被调用时返回下...

The C Programming Language 第四章函数与程序结构 读书笔记

函数可以把大的计算任务分解成若干个较小的任务,程序设计人员可以基于函数进一步构造函数,而不需要重新编写一些代码。一个设计得当的函数可以把程序中不需要了解的具体操作细节隐藏起来,从而使得整个程序结构更加...
  • wtrnash
  • wtrnash
  • 2015年08月03日 21:15
  • 687
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:The C++ Programming Language 读书笔记 ch13
举报原因:
原因补充:

(最多只允许输入30个字)