ganxiang2011的博客

C++可以看做包括以下次语言： C-based 面向对象C++ C++模板 标准模板库

Queue继承于List：#include "../List/List.h" //以List为基类template <typename T> class Queue: public List<T> { //队列模板类（继承List原有接口）public: //size()、empty()以及其它开放接口均可直接沿用 void enqueue(T const& e) { insertAsLa

二叉树结点定义：#define BinNodePosi(T) BinNode<T>* //节点位置#define stature(p) ((p) ? (p)->height : -1) //节点高度（与“空树高度为-1”的约定相统一）typedef enum { RB_RED, RB_BLACK} RBColor; //节点颜色template <typename T> struct BinNo

借助Vector实现栈，栈顶是向量末尾，栈底是向量起始：#include "../Vector/Vector.h" //以向量为基类，派生出栈模板类template <typename T> class Stack: public Vector<T> { //将向量的首/末端作为栈底/顶public: //size()、empty()以及其它开放接口，均可直接沿用 void push(T

对象复制操作operator=或copy构造函数，一定要记得复制对象每一个成份，特别是base class的成分： 注意：

auto_ptr智能指针：其析构函数自动对其所指对象调用delete 若对象auto_ptr不指向某一资源，它会设为null shared_ptr具有相同功能 但是多个shared_ptr对象能同时指向同一资源 注意：

以对象管理资源之后，某些资源不允许被复制，这时对象应该被private声明，为了资源在最后一次使用之后被释放应该使用shared_ptr并且给出对应的删除器： 注意：

**如果赋值操作=左右值相等，即自我赋值，传统做法： 证同策略：** 为防止new异常，需要在new之前不删除原先的引用： swap技术的运用： 当传递的是值不是引用时同样可用swap： 注意：

构造析构： BinTree() : _size(0), _root(NULL) { } //构造函数 ~BinTree() { if (0 < _size) remove(_root); } //析构函数插入： BinNodePosi(T) insertAsRoot(T const & e); //插入根节点 BinNodePosi(T) insertAsLC(BinNodePo

图的抽象基类：typedef enum { UNDISCOVERED, DISCOVERED, VISITED } VStatus; //顶点状态typedef enum { UNDETERMINED, TREE, CROSS, FORWARD, BACKWARD } EStatus; //边状态template <typename Tv, typename Te> //顶点类型、边类型clas

构造析构： GraphMatrix() { n = e = 0; } //构造 ~GraphMatrix() { //析构 for (int j = 0; j < n; j++) //所有动态创建的 for (int k = 0; k < n; k++) //边记录 delete E[j][k]; //逐条清除 }插入删除顶点：

template <typename VST> //操作器 void travLevel(VST& visit) { if (_root) _root->travLevel(visit); } //层次遍历 template <typename VST> //操作器 void travPre(VST& visit) { if (_root) _root->travPre(visit

tr1::shared_ptr和tr1::auto_ptr都提供一个get成员函数，返回智能指针内部的原始指针： )operator*和operator->隐式转换至底部指针： 注意：

首先看看vector不同于数组的一个地方：可以根据数据的多少扩容： 至于这里为什么要是扩充一倍，因为扩容函数执行也需要时间开销，当以增加一倍扩容时调用扩容的概率和容量的匹配要更好：template <typename T> void Vector<T>::expand() { //向量空间不足时扩容 if (_size < _capacity) return; //尚未满员时，不必扩容

查找某一结点的邻居： virtual int firstNbr(int i) { return nextNbr(i, n); } //首个邻接顶点 virtual int nextNbr(int i, int j) //相对于顶点j的下一邻接顶点 { while ((-1 < j) && (!exists(i, --j))); return j; } //逆向线性试探（改用邻接表可提

template <typename Tv, typename Te> //深度优先搜索DFS算法（全图）void Graph<Tv, Te>::dfs(int s) { //assert: 0 <= s < n reset(); int clock = 0; int v = s; //初始化 do //逐一检查所有顶点 if (UNDISCOVERED == status

无序向量区间查找：template <typename T> //无序向量的顺序查找：返回最后一个元素e的位置；失败时，返回lo - 1Rank Vector<T>::find(T const & e, Rank lo, Rank hi) const { //assert: 0 <= lo < hi <= _size while ((lo < hi--) && (e != _elem[hi]

无序去重：template <typename T> int Vector<T>::deduplicate() { //删除无序向量中重复元素（高效版） int oldSize = _size; //记录原规模 Rank i = 1; //从_elem[1]开始 while (i < _size) //自前向后逐一考查各元素_elem[i] (find(_elem[i]

无序去重：template <typename T> int List<T>::deduplicate() { //剔除无序列表中的重复节点 if (_size < 2) return 0; //平凡列表自然无重复 int oldSize = _size; //记录原规模 ListNodePosi(T) p = header; Rank r = 0; //p从首节点开始 wh

template <typename T> void List<T>::sort(ListNodePosi(T) p, int n) { //列表区间排序 switch (rand() % 3) { //随机选取排序算法。可根据具体问题的特点灵活选取或扩充 case 1: insertionSort(p, n); break; //插入排序 case 2: sele

**用成员初值列初始化成员对象： 我们习惯上的错误** 用default构造函数的方法初始化 non-local-static非成员函数内部静态变量初始化先后有要求的，则其初始化需要一个“仿真函数”: 注意：

指向常量的指针、常量指针、指向常量的常量指针 迭代器的功能就像指针，以下是常量指针、指向常量的指针 const与non-const成员函数会被重载 最好这么表述： const成员函数不能改变所有成员变量，但是如果想改变的话可以用下面方法： 用non-const成员函数去调用const成员函数： 注意：

编译器在检测到有对象创建、赋值或者以copy构造函数的方式创建对象时会自动生成函数：

1.内置类型用const替换#include 2.字符串类型用const的两种方式 3.数组的大小最好用enum这样给出 4.宏表达式#define CALL_WITHMAX（a，b） f（(a)>(b))?(a):(b))可以替换为： 注意：

下面是示例：

**在调用析构函数中出现的异常有两种方法： 一是调用abort强制结束程序：** 二是吞下异常： **更好的办法是： 针对某一个可能在析构函数中出现异常的部分，为用户提供该部分函数的调用放法从而给用户处理异常的机会：** 注意：

如果使用到了多态，则需要在base class中写一个虚析构函数目的是销毁继承类： 上面的base class通常有其他虚成员函数。如果类中没有虚成员函数，也就是类不打算作为base class使用则在类中写了个虚析构函数是错误的： 注意：

在base构造期间virtual函数不是virtual函数，因为构造函数首先从base构造函数开始执行，执行的时候继承类的对象并没有也就无从调用其成员函数，用以下这种方式能解决问题： 上面的做法，在要对继承类使用构造函数的时候通过参数传递给base构造函数。注意：

private声明copy函数和=赋值，更好的办法是用一个包含private copy或赋值运算符= 的基类，令用户类继承该基类：

对Vector元素进行遍历，将遍历结果交由传递的函数使用：template <typename T> void Vector<T>::traverse(void (*visit)(T &)) //利用函数指针机制的遍历{ for (int i = 0; i < _size; i++) visit(_elem[i]); }template <typename T> template <typenam

typedef int Rank; //秩#define DEFAULT_CAPACITY 3 //默认的初始容量（实际应用中可设置为更大）template <typename T> class Vector { //向量模板类protected: Rank _size; int _capacity; T* _elem; //规模、容量、数据区 void copyFrom(T c

构造函数：// 构造函数 Vector(int c = DEFAULT_CAPACITY, int s = 0, T v = 0) //容量为c、规模为s、所有元素初始为v { _elem = new T[_capacity = c]; for (_size = 0; _size < s; _elem[_size++] = v); } //s <= c复制构造函数：从A数组中为[lo,h

构造函数：默认构造函数： 构造一个空列表：template <typename T> void List<T>::init() { //列表初始化，在创建列表对象时统一调用 header = new ListNode<T>; //创建头哨兵节点 trailer = new ListNode<T>; //创建尾哨兵节点 header->succ = trailer; header-

各种插入操作：template <typename T> //将e紧靠当前节点之前插入于当前节点所属列表（设有哨兵头节点header）ListNodePosi(T) ListNode<T>::insertAsPred(T const & e) { ListNodePosi(T) x = new ListNode(e, pred, this); //创建新节点 pred->succ =

声明：// 遍历 void traverse(void (*)(T&)); //遍历，依次实施visit操作（函数指针，只读或局部性修改） template <typename VST> //操作器 void traverse(VST&); //遍历，依次实施visit操作（函数对象，可全局性修改）定义：template <typename T> void List<T>::tra

无序查找：template <typename T> //在无序列表内节点p（可能是trailer）的n个（真）前驱中，找到等于e的最后者ListNodePosi(T) List<T>::find(T const& e, int n, ListNodePosi(T) p) const { //0<=n<=rank(p)<_size while (0 < n--) //对于p的最近的n个前驱，

结点的定义：typedef int Rank; //秩#define ListNodePosi(T) ListNode<T>* //列表节点位置template <typename T> struct ListNode { //列表节点模板类（以双向链表形式实现）// 成员 T data; ListNodePosi(T) pred; ListNodePosi(T) succ; //数值、前

template <typename T> void Vector<T>::sort(Rank lo, Rank hi) { //向量区间[lo, hi)排序 switch (rand() % 5) { //随机选取排序算法。可根据具体问题的特点灵活选取或扩充 case 1: bubbleSort(lo, hi); break; //起泡排序 case 2: sel