c++ Primer(4th)学习笔记

    技术2022-05-12  1

    c++ Primer(4th)学习笔记,按章节,抓重点.

    第一部分:c++基础一些重点;形参的初始化与变量的初始化一样:如果形参具有非引用类型,则复制实参的值;如果形参位引用类型,则它只是实参的别名.默认实参(string screenInit(string::size_type height=24,string::size_type width=80,char background = ''))普通形参(int): 在函数体里建立局部副本.指针形参(int*):指针值不变,所指对象在函数体里改变.如需保护(只读),则const int*引用形参(int&):将实参传入函数体,可以修改其值,还可以返回额外的值.const int&可以避免复制副本,直接只读.数组形参(int array[]):数组对象自动转换为指向数组首地址的指针函数形参():函数形参也自动转换为指向函数的指针容器形参(vector<int>::const_iterator beg)命令行选项:   应用:main -d -o ofile data0   定义:int main(int argc,char *argv[]) {...}const fun(): 是返回一个const类型的值,它要求接受类型也是const的,否则会编译错误.   fun() const: 多是用于类里面的函数,是保证在该函数中各个数据只是传值,并不发生值的变化,比如说a++就不可以.

    static fun():使得函数只能在本文件或类中可见,在其他地方是不可见的.static_cast:   一般的类型转换,no run-time check.通常,如果你不知道该用哪个,就用这个. dynamic_cast:  通常在基类和派生类之间转换时使用,run-time cast   const_cast:    主要针对const和volatile的转换.   reinterpret_cast:   用于进行没有任何关联之间的转换,比如一个字符指针转换为一个整形数.

    标准库类型  1,namespace, using声明 using std::cin; #include <iostream> 声明std标准库中的cin,  ::作用域操作符   2,string类型 using std::string;   #include <string> string标准库负责管理字符相关的内存和提供各种可变长度字符串的操作.    string标准库自带的几个构造函数: string s1;默认 string s2(s1); string s3("value");  string s4(n, 'c');     string的读写: 1,读 cin >> s1 >> s2;   输入第1个到s1,第2个到s2,去掉空格的. 2,写 cout << s1 << s2 << end1;  helloworld 3,读入无限 while( cin >> word )  cout << word << end1; 4,读入一行 while( getline( cin , word )) cout << word << end1;    string的操作: s.empty()判断 s.size()大小 s[n]下标  s1+s2相加 s1 = s2赋值 s1 == s2(!= <= >=,大小按字典排列)比较 对于string的size,它的类型必须是string::size_type(这种类型是配套类型,也叫库类型使与机器无关,unsigned型) string s3 = s1 + "," + s2 + "/n"; s[n] = '*'; 下标操作可以是左值 string中的字符处理函数:#include <cctype.h>  isalnum(c)字母或数字   isalpha(c)字母 ......

      3,vector类型    #include <vactor>    using std::vector; vector容器是同一类元素的集合,也是一个类模板(class template),包含系列类定义和函数定义,    而使用不同的元素(string,int或sales_itme类类型对象).    定义和初始化:    vactor<int> ivec1;    vactor<int> ivec2(ivec1);    vector<string> svec(10,"hi!");  一般先定义再添加,容器的优点就是动态增长.    vector<int> fvec(10);   10个元素,标准库调用默认构造函数默认值为0    vector<string> svec(10);        10个元素,默认为空string    操作:    v.empty(); v.size();安全的泛型编程概念 v.push_back(t);插入      v[n];下标只能读,不能插入元素,string可以 v1=v2,空的不能读,缓冲区溢出 v1==v2;(!=;<=或>=)

      4,迭代器    除了用下标访问容器,标准库提供了迭代器(iterator)检查容器元素并遍历元素.只有少数容器支持下标.    每种容器定义了自己的iterator类型,都支持iterator操作.    vector<int>::iterator iter;    每种容器都定义了一对begin,end函数.用于返回迭代器. vector<int>::iterator iter = ivec.begin();    迭代器的解引用操作符*和自增运算符++, *iter=0; ++iter;    ==;!=操作    for ( vector<int>::iterator iter = ivec.begin(); iter = ivec.end(); ++iter ) *iter = 0;    const_iterator用来做只读迭代器, for ( vector<int>::const_iterator iter = ivec.begin(); iter = ivec.end(); ++iter )      cout << *iter << endl;    vector和deque的iterator也支持算数操作(iterator arichmetic),其它不太支持.    iter + n ,iter - n , iter1 - iter2(difference_type,signed)    vector<int>::iterator mid = ivec.begin() + ivec.end()/2 在vector的push_back操作后,当前iter的值失效.

      5,bitset类型    是位操作的类模板. #include <bitset>  using std::bitset;    初始化:   bitset<n> b;     bitset<n> b(u); ulong的位副本   bitset<n> b(s);string中位串的副本  bitset<n> b(s,pos,n);string中pos后n个位的副本  bitset<32> bitset(0xffff);  string strval("1100");    bitset<32> bitset(strval);    操作: b.any(); b.none(); b.count() b.size() b[pos]  b.test(pos); b.set(); b.set(pos) b.reset() b.rest(pos)  b.flip();取反 b.flip(pos); b.to_ulong();返回ulong值 os << b;    输出二进制: cout << "bitvec" << bitvec << endl; 

    STL的输入输出:c++的输入输出由标准库提供.1,文件和控制窗口的IO库 2,定义了一些类(istream,ostream),使string能像文件一样操作.   istream ostream cin cout cerr >> <<  getline 1,标准库  ostream -> ofstream    -> ostringstream    ----------------->/ iostream -> stringstream (字符串操作流) char型组成的流  istream ----------------->/     -> fstream  (文件操作流) char型组成的流

        -> ifstream    -> istringstream    wostream,wistream,wiostream,wistringstream,wostringstream,wstringstream,wcin,wcout,wcerr.   加w支持wchar_t型(国际宽字符)组成的流.   iostream流不支持复制和赋值操作.只能用指针或引用.   ofstream &print(ofstream&);   while (print(out2)) { /* ... */ } 2,条件状态成员  strm::iostate  strm::badbit  strm::failbit  strm::eofbit  s.eof() s.fail() s.bad() s.good() s.clear() s.clear(flag)   s.setstate(flag) s.rdstate()  所有流对象包含一个int型iostate数据成员,其定义了3个常量值,分别定义特定的位模式.badbit,failbit,eofbit/failbit.  int ival;  while ( cin >> ival, !cin.eof() ) {    判断非空   if ( cin.bad() )      流坏了    throw runtime_error("IO stream corrupted");   if ( cin.fail() ) {      流出错    cerr << "bad data, try again";    cin.clear( istream::failbit );   清除出错标志    continue;   }  }

      istream::iostate old_state = cin.rdstate();   读取条件状态  cin.clear();  process_input();  cin.clear(old_state);

      is.setstate( ifstream::badbit | ifstream::failbit );  多状态处理

     3,输出缓冲区的管理  

     4,文件的输入输出

     5,字符串流 

    第二部分:标准库的容器与算法顺序容器  1,定义 按位置存取单一元素.容器的接口应该统一,标准库只提供少量接口,大部分由算法库提供,分3种:    1,适用于所有容器的统一接口.    2,只适用于顺序或关联容器的接口       3,只适用于顺序或关联容器的子集(部分容器)的接口 标准库提供了3种顺序容器   vector: 支持快速随机访问   list:  支持快速插入/删除   deque(double end queue): 双端队列  和3种adapter(在原始接口上定义出的新接口)     stack  后进先出LIFO的栈   queue  见进先出FIFO的队列   priority_queue 有优先级管理的队列 初始化:     #include <vector>  #include <list>  #include <deque>  1,定义     vector<string> svec;  list<int> ilist;  deque<Sales_item> items      2,定义为另一个容器的副本  vector<int> ivec2(ivec);  3,定义并初始化为一段元素的副本 list<string> slist( svec.begin(), svec.end() ); 利用迭代器       vector<string>::iterator mid = svec.begin() + svec.size()/2;       deque<string> front(svec.begin(), mid);       deque<string> back( mid, svec.end() );       list<sting> word2( words, words+word_size ); 指针就是迭代器  4,初始化指定数目的元素  list<int> ilist(list_size);       vector<string> svec( get_word_count("Chimera") ); 元素的要求:  1,可复制和赋值,内置和复合类型;容器;标准库类型可以做元素.      引用和IO库类型不能做元素.  2,有些容器操作要求有指定容器大小和单个初始化的构造函数,大部分的元素类型有这个默认的构造函数.   例如foo没默认的构造函数,但定义了一个int形参的构造函数,则可以 vector<foo> ok(10,1);  3,可以用容器作为元素. vector< vector<string> > lines; 注意> >

      2,迭代器 vector和deque迭代器多了支持+,-,>=,<=.list只支持++,--,==,!=       容器的insert,earse操作会使iterator无效.   3,容器中的操作 类型别名:  size_type;iterator;const iterator(只读);const_reverse_iterator;difference_type(存储2个it差值,带符号int);    value_type(元素类型);reference(元素的左值类型value_type&);const_reference  begin和end成员: c.begin();c.end();c.rbegin();c.rend();(返回逆序it) 添加元素:  c.push_back(T);    在尾部插入一个元素,void,会导致迭代器失效,所以不能存储v.end()到变量.    c.push_front(T);    在前部插入一个元素.    c.insert(pos,T);    指定位置添加    c.insert(pos,n,T);    c.insert(pos,pos1,pos2);    string sarray[4] = {"quasi","simba","frollo","scar"};    slist.insert(slist_iter, sarray+2,sarray+4); 删除元素:  c.earse(it); c.earese(b,e);(返回下个it) c.clear(); c.pop_bak(); c.pop_front(); (void) 关系操作符:  ==; !=; ++; >=; <= 大小操作:  c.size(); size_type     c.max_size(); size_type     c.empty(); bool是否空    c.resize(n); 改变容器大小    c.resize(n,t);改变大小并初始化为t. 访问元素:  c.front();返回引用 c.back(); c(n);下标访问 c.at(n);也是返回下标n的元素引用    iterator解引用  *it 赋值与swap:  c1=c2;   赋值后容器长度会相等    c1.swap(c2);  c1和c2互换    c1.assign(b,e) 将其他容器的b到e元素复制到c1    c1,assign(n,t) 将c1设置为n个t      4,vector自增长时内存分配: vector容器是连续存放在内存里的,超界时要申请新空间和copy.影响效率,list和deque好些,但在空间类vector增长效率最好.    ivec.capacity(); 返回现有空间    ivec.reserve(50); 将空间设为50,STL以加倍策略为vector分配新的存储空间.  5,容器的选用 list不连续,不支持随机访问,高效insert和erase,单个访问慢点. vector连续,可随机访问,insert和erase要移动右边元素慢,单个访问快. deque两端insert和erase快,中间insert和erase代价更高,可随机访问.     原则: 1,随机访问用vector和deque.  2,随机插入用list.  3,头尾插入用deque.  4,list输入,复制到vector并排序,随机读出.  5,综合考虑     6,string类型 可以看做vector,其大部分操作和顺序容器一样.不支持栈方式:fron,back,pop_back等,好多,先列纲; 1,构造和初始化 2,操作  插入删除;   vector的   特有的  substr  append  replace  find  compare  7,容器适配器 adaptor是一种事物的行为类拟另一种事物的行为的一种机制.容器适配器是容器的扩展. 标准库提供三种顺序容器适配器;   queue(FIFO先入后出),priority_queue(按优先级存入,按级取出),stack(栈). 例如:stack适配器可以使顺序容器以栈方式工作. #include <stack>  stack,queue基于deque(双端队列)实现,priority_queue基于vector #include <queue>  预定义: size_type;value_type;container_type stack<int> stk(deq);      定义并初始化 stack<string, vector<string>> str_stk(svec);  指定第二实参vector,可以覆盖原来的deque基本容器类型  stack可以基于vector,list,deque;queue要求push_front()只能基于list;priority_queue要求随机访问只能基于vector和deque. 容器适配器可以: ==  !=  <  <=  >  >=    stack操作:  s.empty() s.size() s.pop()弹出不返回 s.top()返回不弹出 s.push(item)压栈    queue/p_queue操作: q.empty() q.size() q.pop() q.top q.push(item) q.front() q.back()   

    关联容器(associative container),关联容器按"键"值存取和查找,顺序容器按位置.操作差不多.  1,pair(一对) 类型:包含2个数据值.first .secnod的集合 pair<T1, T2>       定义pair,其内有T1,T2类型 pair<T1, T2> p1(v1, v2);     创建pair,定义其包含T1,T2类型,并初始化为v1,v2 make_pair(v1, v2)      用v1,v2创建pair对象 p1 < p2       按字典顺序顺序比较 p1 == p2       顺序比较pair里每个元素相等 p.first / p.second      返回第一,第二个成员  2,操作: 关联容器的大部分操作和顺序容器一样,但也有不同.    不同点:

      3,map类型:key-value成队出现的集合,key是索引.字典里单词是键,解释就是注释.key必须有一个比较函数<定义在容器里,            此比较函数必须strick weak ordering. map<k, v>    m;    定义一个map类型 map<k, v>   m(m2);    创建m2的副本 map<k, v>   m(b, e);   创建迭代器b到e的副本到m,迭代器指向的元素必须能转换为pair<k, v>  map<k, v>::value_type   是一个pair类型, pair<const map<k,v>::key_type, map<k,v>::mapped_type> typedef map<k, v>::key_type  key_type  定义类型别名 typedef map<k, v>::mapped_type mapped_type

     map的迭代器解引用是指向一个pair型的值.   map<string, int>::iterator map_it=m.begin(); map_it->first = "new key"; ++map_it->second;    操作: 1,添加:  map::insert 2,下标访问:   map<string,int> word_count;  word_count["Anna"] = 1; 3,查找:  map.count(key);map.find(key) 4,删除:  map.erase(key);返回删除的size_type个数    map.erase(p); iterator p  void   map.erase(b,e); iterator b,e  void 5,迭代遍历: for() cout<<map_it->first<<map_it->second<<endl; 分别输出 6,实例:  单词转换

      4,set类型:key键的集合,key是const的.通过键快速读取. 将某段元素或插入一组元素到set,实际只是添加了一个key. set< string > set1; set1.insert("the"); set1.insert(ivec.begin(),ivec.end()); iset.find(5);  返回iterator或iset.end() iset.count(5); 返回1,没找到返回0

      5,multimap和multiset:一个键对应多个实例. 插入: authors.insert(make_pair(sting("Barth,John"),string("Sot-Weed Factor")));  authors.insert(make_pair(sting("Barth,John"),string("Lost in the Funhouse"))); 1对多插入 删除: multimap<string,string>::size_type cnt = authors.erase(("Barth,John"); 删除key对应所有元素,返回个数.删除迭代器只删除指定元素 查找: 以key打头,元素相邻存放.  1,使用 find(key)和count(key): iter=authors.find(search_item);        cout<<iter->second<<endl;  2,使用 lower_bound(key),upper_bound(key)     返回iter  3,使用 equal_range(key);      返回iter型pair

      6,容器的综合应用,文本查询程序.

    泛型算法:generic algorithm  1,概述:标准库为容器提供了基本操作的功能函数,还定义了泛行算法来进行排序,查找等工作.标准库有超过100种算法.   算法一般使用迭代器遍历来实现,其元素可以比较. #include <algorithm>    泛型算法 #include <numeric>    一组泛化的算术算法  2,初窥算法 1,只读算法  find(vec.beging(), vec.end(), search_value);  string sum=accumulate(vec.begin(), vec.end(), string(" ")); vec里的元素强制转换或匹配" "类型,既const char*型并相加  it = find_first_of( roster1.begin(),roster1.end(), rester2.begin(),rester2.end() );            在第二段中找出和第一段里匹配的任一元素,返回其iter 2,写  fill(vec.begin(), vec.begin()+vec.size()/2, 10);  会先检查空间再写入  fill_n(vec.begin(), 10, 0);      不检查强制写入  fill_n(back_insert(vec), 10, 0);    back_insert(vec)插入迭代器是迭代器适配器,要带一个实参指定类型           这里实参是一个容器的引用.  copy( ilst.begin(), ilst.end(), back_inserter(ivec) );  复制一段元素到目标,这个例子效率差  vector<int> ivec(ilst.begin(),ilst.end());   直接初始化会快点  replace(list.begin(), list.end(), 0, 42);    将一段元素里的0替换为42.  replace_copy(list.begin(), list.end(), back_insert(ivec), 0, 42); 先copy一个ilst副本到ivec,且所有0变成42.  3,排序实例:统计文章里的长度大于6的单词的个数  bool isShorter( const string &s1, const string &s2 )  {   return s1.size() < s2.size();  }  bool GT6( const string &s )  {   return s.size() >= 6;  }  int main()  {   vector<string> words;   string next_word;   while ( cin>> next_word ) {    words.push_back(next_word);      插入到容器   }   sort( words.begin(), words.end() );      按字典排序   vector<string>::iterator end_unique = unique(words.begin(), words.end()); 将重复的放后面   words.erase( end_unique, words_end() );   stable_sort( words.begin(), words.end(), isShorter );长短排序,isShorter谓词函数,2个元素类型实参,返回可做检测条件的值.    vector<string>::size_type wc = count_if( words.begin(), word.end(), GT6 );统计GT6个数   cout << wc << make_plural(wc, "word", "s") << "6 charactor or longer" << endl;   return 0;  }    3,再谈迭代器:#include <iterator.h>还定义了其他迭代器,insert iterator,iostream iterator,reverse iterator. 1,插入迭代器  带有3种迭代器适配器:back_inserter;front_inserter;inserter.  replace_copy( ivec.begin(), ivec.end(), insert(ilst, it), 100, 0 );  复制ivec到ilst的it位置,100换为0 2,iostream_iterator流迭代器:是类模版,所有带<<,>>操作符的类都可以使用.  定义了的构造函数:  istream_iterator<T> in(strm);  strm是关联的输入流  istream_iterator<T> in;  ostream_iterator<T> out(strm);  ostream_iterator<T> out(strm, delim); 写入时用delim做元素的分隔符,delim是以空字符结束的字符数组,也就是字符串.  定义了的操作:自增,解引用,赋值和比较  ++it;it++;*it;it->mem;it1==it2;it1!=it2  1,输入 istream_iterator<int> cin_it(cin);   istream_iterator<int> eof        定义结束符   while( in_iter != eof ) vec.push_back(*in_iter++);    2,输出 vector<int> ivec(in_iter, eof);   ostream_iterator<string> out_iter(cout, "/n");   istream_iterator<string> in_iter(cin), eof;   while( in_iter != eof )     *out_iter++ = *in_iter++;  3,类做流   istream_iterator<Sales_item> item_iter(cin), eof;   Sales_item sum = *item_iter++;   while ( item_iter != eof ) {    if ( item_iter->same_isbn(sum) ) sum = sum + *item_iter;  比较ISBN,相加    else {     cout << sum << endl;     sum = *item_iter; }    ++item_iter;   }   cout << sum << endl;  4,和算法一起使用   istream_iterator<int> cin_it(cin), eof;   vector<int> vec(cint_it, eof);   sort( vec.begin(), vec.end() );   ostream_iterator<int> output( cout, " " );   unique_copy( vec.begin(), vec.end(), output );    不重复拷贝 3,反向迭代器reverse_iterator   vector<int>::reverse_iterator r_iter;  begin()是最后一个,end()是第一个的前一个.sort(ivec.rbegin(), ivec.rend())将由大到小排序.  string::reverse_iterator rcomma = find( line.rbegin(), line.rend(), ',' );  rcomma指向','号  cout << string(rcomma.base(), line.end()) << endl;     rcomma的成员函数base()指向LAST 4,const迭代器  const后不能用这个迭代器来修改容器里的元素.  find_first_of( it, roster1.end(), roster2.begin(), roster2.end() ) 这里不用const是因为it必须roster1.end()同类型     roster1.end()返回的迭代器依赖于roster1类型.如果roster1是const对象,则迭代器是const_iterator. 5,按算法要求的功能分五种迭代器  输入迭代器:input  只读,自增  ,== * -> ,find accumulate ,istream_iterator  输出迭代器:output  只写,自增  ,*  ,copy   ,ostream_iterator  前向迭代器:forward  读写,自增  ,  ,replace  双向迭代器:bidirectrional 读写,自增自减  ,--  ,reverse  ,map,set,list自带迭代器  随机迭代器:random-access 读写,完整的算术操作 ,< <= += iter[n] ,sort  ,vector,deque,string自带迭代器.  4,泛型算法的结构,100多种算法分类 按形参模式  alg ( beg, end, other, parms );  alg ( beg, end, dest, other parms );  alg ( beg, end, beg2, other parms );  alg ( beg, end, beg2, end2, other parms ); 命名规范  sort( beg, end );  sort( beg, end, comp );  find( beg, end, val );  find_if( beg, end, pred );  reverse( beg, end );  reverse_copy( beg, end, dest );  5,容器特有的算法 因为list是双向连续而不随机的,不能sort,merge,remove,reverse,unique等标准库算法也效率不高.所以标准库定义其他算法给list. 它们用在其他容器上有相同效果.  lst.merge(lst2); lst.merge(lst2, comp);  lst.remove(val); lst.remove_if(unaryPred);  lst.reverse()  lst.sort()  lst.splice(iter, lst2) lst.splice(iter, lst2, iter2) lst.splice(iter, beg, end)  lst.unique()  lst.unique(binaryPred)第三部分:类Class类Class  1,Class的声明,定义和类对象 class Screen;      声明 class Screen{      定义类类型,定义了才能固定成员,预定存储空间. public:       类成员类型:public private protected  typedef std::string::size_type index;  定义类型别名来简化类,并允许客户使用

      char get() const { return contents[cursor]; }; 成员函数.默认为inline  inline char get(index ht, index wd) const; 可以重载,可以显式的定义为inline(类定义体内部),const是将成员函数定义为常量  index get_cursor() const;

      Screen *next;     有了类的声明,类成员就可以是自身类型的指针或引用.  Screen *prev;

      screen(): units_sold(0),revenue(0.0) { } 构造函数是与类同名的成员函数,用于对每个成员设置初始值. private:         std::string contents;    多个数据成员的私有化体现类的抽象和封装  index cursor;  index height,width; protected: };        右花括号,类定义结束,编译器才算定义了类. char Screen::get(index r, index c) const   这是成员函数的定义,Scrren::后形参表和函数体是在类作用域中,         可以直接引用类定义体中的其它成员.而返回在Screen::之前,要Screen::index使用. {  index row = r * width;  return contents[row + c]; }

     inline Screen::index Screen::get_cursor() const  或在类定义体外部指定inline,阅读方便  return corsor;   Screen screen;      定义一个类类型的对象时才分配存储空间 class Screen screen;

      2,this指针:对象到成员函数,包含一个隐含形参this,编译器会定义,成员函数可以显式的引用this指针. class Screen {  public:   Screen& move( index r, index c );   Screen& set( char );   Screen& set( index, index, char );

       Screen& display( std::ostream &os )     { do_display(os); return *this }   const screen& display( std::ostream &os ) const          在const成员函数中,this指针是指向const类对象的const指针.内容地址都不能变     { do_display(os); return *this }   ...  private:   void do_display( std::ostream &os ) const 私有成员函数,放在这简捷,好调试,好改.     { os << contents; }

       mutable size_t access_ctr;    mutable声明可变数据成员,在const对象和函数里,数据都可改变  protected: }; Screen& Screen::move( index r, index c )  本对象的引用  {  index row = r * width;  cursor = row + c;  return *this;     返回this指针的内容 } Screen& Screen::set( char c ) {  contents[cursor] = c;  return *this;      普通成员函数里,this指针是const指针,能改内容但不能改地址. }  Screen myscreen; myscreen.move(4,0).set('#').display(cout);  操作序列的使用.call non-const ver myscreen.move(4,0).display(cout).set('#');  对于const的display成员函数,这个操作违法.所以使用重载. const Screen blank.display(cout);    call const ver

      3,作用域 每个类都有自己的作用域,成员一样的也是不同的域. obj.member  obj.memfun() ptr->member  ptr->memfun() 类作用域中名字的查找:块内->类定义体内->全局,(都是查找在名字使用前的定义(块内没找到会到类定义全局里找),不能重复定义.在名字后重复定义也不行)

      4,构造函数 包括名字,形参表,初始化列表和函数体. 重载: class Sales_item   {    public:    Sales_item();     Sales_item( const std::string& ); 参数不同,不能定义为const    Sales_item( std::istream& );   ...  }  Sales_item empty;  Sales_item Primer_3rd_Ed( "0-201-138-178" ); 实参决定使用哪个构造函数  Sales_item Primer_4th_Ed( cin ); 初始化:  1,screen(): units_sold(0),revenue(0.0) { } 构造函数是与类同名的成员函数,用于对每个成员设置初始值.  2,Sales_item::Sales_item( const string &book )    {   isbn = book;     在函数体内初始化.   units_sold = 0;    isbn是隐形的初始化,使用string默认的构造函数初始化.   revenue = 0.0;    }   3,对于const数据对象和引用,只能而且必须初始化,不能在函数体里赋值.  4,初始化可以是任意表达式.  5,类类型的初始化可以是类的任一构造函数. Sales_item():isbn(10,'#'),.. { }  6,Sales_item( const std::string &book = " " ):isbn(book),units_sold(0),revenue(0.0) { }    Sales_item empty;     empty中包括一个默认实参.    Sales_item Primer_3rd_Ed( "0-201-123-189" ); 显式实参.  7,默认的构造函数   当类没定义构造函数时,编译器使用默认的构造函数.即类成员用各自的默认构造函数来初始化.   内置和复合类型成员(指针和数组),编译器只对定义在全局作用域的对象初始化.定义在局部的,不进行初始化.必须使用构造函数.  8.隐式类类型转换   string null_book = " 9-999-999-9 ";   item.same_isbn( null_book );  same_isbn()期待一个Sales_item对象做实参. string->构造函数->临时的Sales_item对象    如果把构造函数声明为explicit Sales_item( const std::string &book = " " ): 则关闭隐式转换.  9.显式类类型转换   item.same_isbn( Sales_item(null_book) ); 关闭explicit功能  10.显式初始化没有定义构造函数且全部public的类.但程序员工作量大且删除成员要改程序.   vall.ival=0; vall.ptr=0;    

      5,友元 class Screen{  friend class window_Mgr; 定义友元类,友元(成员函数,非成员函数或类)可以访问Screen类中的所有成员,包括私有成员.  ... } class Screen{  friend window_Mgr& window_Mgr::relocate(  Screen::index r, Screen::index c, Screen& s ); 其它类的成员函数成为友元  ... } window_Mgr& window_Mgr::relocate( Screen::index r, Screen::index c, Screen& s ) {  s.height += r;  s.width += c;  return *this; } 成员函数做友元要先定义。 非成员函数和类不必先声明,用友元引入的类名和函数,可以象预先声明样使用. 重载的函数要单独声明为友元.

      6,static 成员 1, 声明类的静态成员与类关联,但不与类的对象关联,没有this,不能做虚函数.便于封装. 2, 静态成员的提出是为了解决数据共享的问题.实现共享有许多方法,如:设置全局性的变量或对象是一种方法。但是,全局变量或对象是有局限性的。 在类中,静态成员可以实现多个对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,即保证了安全性。因此,静态成员是类的所有对象中 共享的成员,而不是某个对象的成员。   3, 使用静态数据成员可以节省内存,因为它是所有对象所公有的,因此,对多个对象来说,静态数据成员只存储一处,供所有对象共用。 静态数据成员的值对每个对象都是一样,但它的值是可以更新的。只要对静态数据成员的值更新一次,保证所有对象存取更新后的相同的值, 这样可以提高时间效率。

     const int account::period;     必须做 const static 的类外定义 double account::interestRate = initRate();   类外定义并初始化,可以直接引用私有成员. class account{ public:  void applyint() { amount += amount*interestRate }; 类里直接引用  static double rate() { return interestRate; }  static void rate( double ); private:  std:string owner;  double amount;  static double interestRate;  static double initRate;

      static const int period = 30;    const static 的类内初始化. }; void account::rate( double newRate )    这里不用加static,类外定义了. {  interestRate = newRate; }

     2.static 成员不是类的组成部分,他的特殊用法和成员不一样 class bar { public:  Bar& clear( char = bkground ); private:  static const char bkground = '#';    static数据成员做默认实参  static bar mem1;      定义为该类的类型 }

    其他  7,复制构造函数 类定义体里的为默认构造函数  ifstream file1( "filename" );    直接初始化  Sales_item item = string( "9-999-99999-9" );  =复制操作符,Sales_item构造函数不是显式的(explicit)  string make_plural( size_t, const string&, const string& ); const类的引用做形参,隐式的使用string复制构造函数做实参.返回复数形式  vector<string> svec(5);     先用string默认构造函数初始化svec,再使用复制构造函数复制到svec每个元素.  Sales_item primer_eds[] = {      string("0-201-16487-6"), 调用单实参构造函数      string("0-201-54848-8"),      string("0-201-82470-1"),      Sales_item()   调用完整的构造函数语法      }; 如果没有定义复制构造函数,编译器自动合成一个,内容是对逐个成员初始化. 定义复制构造函数  class foo {    public:     foo();     默认的构造函数     foo(const foo&);   声明复制构造函数,主要用于指针成员处理和消息处理.   }; 把复制构造函数定义在private区域,可以禁止复制,如果再只声明不定义,则友元和类成员中的复制也禁止.

      8,赋值操作符 = =操作符的重载 class Sales_item {  public:   Sales_item& operator=(const Sales_item &); 在类里要声明,左参数带this,右参数用const,返回右参数的引用. }; 用户没定义=操作符重载,则编译器会自动合成赋值操作符.复制构造函数和赋值操作符重载通常一起定义. Sales_item& Sales_item::operator=( const Sales_item &rhs ) {  isbn = rhs.isbn;  units_sold = rhs.units_sold;  revenue = rhs.revenue;  return *this; }

      9,析构函数 构造函数申请资源(buffer或open file),析构函数就要释放资源(buffer或close file). Sales_item *p = new Sales_item; p指向一个新Sales_item对象,调用默认构造函数 {  Sales_item item(*p);  *p复制到item  delete p;   删除指针p,调用析构函数释放p资源 }     超出作用域,调用析构函数释放item

     {  Sales_item *p = new Sales_item[10]; 动态分配  vector<Sales_item> vec( p, p+10 );  本地对象  ...  delete [] p;     删除p  ... }       vector默认析构函数,逐个逆序撤销元素(size()-1,-2,..0) 复制构造函数和赋值操作符重载,析构函数 通常一起使用. 编译器合成的析构函数按对象创建的逆序撤销每个非static成员. class Sales_item{  public :  ~Sales_item();  用户编写的析构函数,没形参,没返回.撤销本对象时会调用,再调用合成的析构函数.  { } };

      10,例子消息处理,将信息字符串message加入关联容器set:folder里 class message{ public:  message( const std::string &str = "" ):contents(str) { } 默认构造函数,单个实参(空串)并将folder初始化为空集  message( const message& );      复制构造函数声明   message& operator=( const message& );    赋值=操作符重载  ~message();        析构  void save( folders& );   void remove ( folder& ); private:  std::string contents;  std::set<folder*> folders;  void put_msg_in_folders( const std::set<folder*>& );  各个folder添加指向msg的指针,复制和赋值将调用这个函数    void remove_msg_from_folders();     各个folder删除指向msg的指针,析构和赋值将调用这个函数 }; message::message( const message &m ):content(m.contents),folders(m.folders) 用副本初始化 {  put_msg_in_folders( folders );     复制构造函数要把msg添加到folders } void message::put_msg_in_folders( const set<folder*> &rhs ) {  for( std::set<folder*>::const_iterator beg=rhs.begin(); beg!=rhs.end(); ++beg ) 利用迭代器遍历    (*beg)->addmsg(this);      *beg是folder指针,利用addmsg()成员函数实现添加 } message& message::operator=( const message &rhs )   赋值定义 {  if ( &rhs != this )       左右操作数不同   {   remove_msg_from_folders();     从folders删除msg   contents = ths.contents;   folders = rhs.folders;   put_mag_in_folders(rhs.folders);    将新msg加入folders  }  return *this; } void message::remove_msg_from_folders() {  for ( std::set<folder*>::const_iterator beg=folders.begin(); beg!=folders.end; ++beg )   (*beg)->remmsg(this); } message::~message()        析构函数 {  remove_msg_from_folders(); }

      11,指针成员管理,3种方法 1,常规指针成员  class hasptr{  public:   hasptr(int *p, int i):ptr(p), val(i) { }   构造函数,2个形参   int *get_ptr() const { return ptr; }   int get_int const { retrun val; }   void set_ptr( int *p ) { ptr = p; }   void set_int( int i ) { val = i; }   int get_ptr_val() const { retrun *ptr; }   void set_ptr_val( int val ) const { *ptr = val; }  private:   int *ptr;       指针成员   int val;  };

      int obj = 0;  hasptr ptr1( &obj, 42 );  hasptr ptr2( ptr1 );       2个对象中的2个指针成员,共享同一对象obj   这时可能出现空指针,悬垂指针.  int *p = new int(42);  hasptr ptr( p, 10 );  delete p;  ptr.set_ptr_val(0);       空指针,*p空间已经删除了

     2,智能指针成员,smart point  在析构函数中加计数器,当计数为0时,删除共享对象.避免空指针(悬垂指针).但这样在有3个引用时计数器无法同步.  可以使用计数类(一个指针指到共享空间,一个计数)来解决这个问题:  class U_Ptr {  private:      所有成员都是private   friend class HasPtr;    友元HasPtr   int *ip;     指针   size_t use;     计数   U_Ptr(int *p):ip(p),use(1) { }  构造   ~U_Ptr() { delete ip; }   析构  };  class hasptr{  public;   hasptr( int *p, int i ):ptr(new U_Ptr(p)),val(i) { }    构造   hasptr( const hasptr &orig ):ptr(orig.ptr),val(orig.val) { ++ptr->use; } 复制   hasptr& operator=( const hasptr& );      赋值   ~hasptr() { if (--ptr->use == 0 ) delete ptr; }    析构

       int *get_ptr() const { retrun ptr->ip; }      操作成员函数   int get_int() const { return val; }   void set_ptr( int *p ) { ptr->ip = p; }   void set_int( int i ) { val = i; }   int get_ptr_val() const { return *ptr->ip; }   void set_ptr_val( int i ) const { *ptr->ip = i; }  private:   U_Ptr *ptr;   int val;  };  hasptr& hasptr::operator=( const hasptr &rhs )  {   ++rhs.ptr->use;    右操作数use++   if ( --ptr->use == 0 )   左操作数use--为0,则左操作数被替换,先删除ptr.    delete ptr;   ptr = rhs.ptr;   val = rhs.val;   return *this;  }

     3,值形指针成员  不再使用共享数据,复制时把原指针的值copy到新的对象.  class hasptr{  public;   hasptr( const int &p, int i ):ptr(new int(p)),val(i) { }   构造   hasptr( const hasptr &orig ):ptr(new int(*orig.ptr)),val(orig.val) { } 复制   hasptr& operator=( const hasptr& );      赋值   ~hasptr() { delete ptr; }        析构

       int *get_ptr() const { retrun ptr; }      操作成员函数   int get_int() const { return val; }   void set_ptr( int *p ) { ptr = p; }   void set_int( int i ) { val = i; }   int get_ptr_val() const { return *ptr; }   void set_ptr_val( int i ) const { *ptr = i; }  private:   int *ptr;   int val;  };  hasptr& hasptr::operator=( const hasptr &rhs )  {   *ptr = *rhs.ptr;    直接把值copy到新对象,2个指针2个空间   val = rhs.val;   return *this;  }

    重载 操作符  1,定义  2,输入和输出操作符  3,算数和关系操作符  4,赋值操作符  5,下标操作符  6,成员访问操作符  7,++,--  8,调用 操作符和 函数对象  9,转换 与 类 类型

    第四部分:OOB编程与模板OOB  1,概述 继承,动态绑定和数据抽象的概念是OOB的基础. 模板(泛型类,泛型函数)定义了系列操作,用来定义具体类,他们都使用类似操作. 1,c++的派生类(derived class)继承基类(base class),base class中成员函数分 非虚函数std::string book();   虚函数virtual double net_price(size_t).虚函数(virtual)需要在派生类里重定义. 2,动态绑定(dynamic banding)是指应用程序会根据实参调用的继承层次中相应类 的虚函数 来执行,形参是基类的引用(或指针)const Item_base &item.  2,基类和派生类 派生类和用户程序一样只能访问基类的public,不能访问private.友元可以访问private. 为了虚函数在派生类里的重定义,虚函数用到的数据成员定义到protected,它们可以通过派生类的继承关系访问. 但不能在引用里直接访问基类对象的protected成员. class Bulk_item;      前向声明 class Item_base;       class Bulk_item : public Item_base{   Item_base必须先定义  public:   double net_price(std::size_t) const; 虚函数的声明必须和基类里一样,但返回可以是基类或派生类的引用(指针).  private:   std::size_t min_qty;   double discount; }; 派生类包括的数据成员:min_qty,discount/isbn,price. double Bulk_item::net_price( size_t cnt ) const {  if ( cnt >= min_qty )   return cnt*(1-discount)*price;  派生类里对基类protected数据成员的直接调用.  else   return cnt*price;    卖了几本书,计算总价(包括折扣) } 1,可以将基类的引用绑定到继承类,也可以用基类的指针指向派生类.   double print_total( const item_base&, size_t );   print_total( bulk, 10 ); Item_base *p=&bulk; 2,根据实参的不同,调用不同的虚函数版本.   void print_total( ostream &os, const item_base &item, size_t n )  引用和指针的静态类型和动态类型的多态性是c++的基石   {  os << "ISBN" << item.book() << item.net_price(n) << endl;  不过实参是什么item.book非虚函数都是item_base里的.            item.net_price(n)虚函数是可变的.   }   print_total( cout, base, 10 );   print_total( cout, derived, 10); 3,强制某个虚函数.   Item_base *baseP = &derived;   double d = baseP->Item_base::net_price(42);   强制使用基类的虚函数,因为继承层次的基类中一般包含公共信息. 4,虚函数也有默认实参,在基类和派生类里会有不同的默认实参,如果通过基类的引用和指针做参数,实参是派生类,这时默认参数是基类的,不是派生类的.      5,继承类型:  struct Public_derived : public Base{}    派生类继承基类public和protected  struct Protected_derived : protected Base {}   到派生类里都为protected  struct Private_derived : private Base {}    到派生类里都为private 6,恢复个别成员的访问级别   class Derived : private Base {     基类里所有成员继承为私有级别  public :    using Base::size;     使用using恢复访问级别,但改变不了原级别  protected :   using Base::n;  //... }; 7,struct D2 : Base {};      默认继承级别是public    class D3 : Base {};      默认继承级别是private 8,友元(friend class Frnd;)可以访问类的private和protected,但不能访问继承类的. 9,类的静态成员访问 static void statmem();继承层次里只能有一个静态函数.它根据访问级别被访问.可以用 :: -> .   Base::statmem();   Derived::statmem();   derived_obj.statmem();   statmem();

      3,转换及继承(比较难理解)      派生类->基类  1,派生类对象引用 -> 基类对象的引用:只是引用,派生类没变化. 2,派生类对象 -> 基类对象 :会复制派生类的基类部分到实参.  Item_base item;  Bulk_item bulk;  Item_base item(bulk); 复制,bulk(item_base部分)的引用做实参->item_base的复制构造函数(初始化)  item = bulk;  赋值,bulk(item_base部分)的引用做实参->item_base的赋值函数(赋值) 3,派生类到基类的可访问性,参照基类的public部分能否访问.  public继承, 用户和后代类    可以用此派生类访问基类.  private继承,用户和后代类都不可以.  protect继承,后代类可以,用户不可以.  派生类里的成员都可以使用 派生类到基类的装换.      基类->派生类是不合理和不存在的.但指针可以绑定.  Item_base *itemP = &bulk;  指针可以绑定,编译器会报错.  static_cast  Item_base *itemP = &bulk;   强制转换  dynamic_cast Item_base *itemP = &bulk;  申请运行是检查   4,构造函数和复制控制      构造函数 派生类也有构造,复制,赋值,撤销.在继承层次中基类要考虑其构造函数是protected或private以保证派生类使用其特殊构造函数. 默认的派生类构造函数先默认初始化基类,再默认初始化其数据成员. 用户定义的构造函数可以传递实参. Bulk_item bulk("0-201-82470-1", 50, 5, .19); class Bulk_item : public Item_base { public:  Bulk_item( const std::string book="", double sales_price=0.0, std::size_t qty=0, double disc_rate=0.0 ):默认参数       Item_base(book, salse_price),min_qty(qty),discount(disc_rate) { }   初始化 }; 这里的实参只能初始化到直接的基类数据. 重构refactoring的概念,例如在2层间加入一层以便扩展或处理其他改变时,使用上下二层类的程序不用改变,但要重新编译. 首先要定义新层的类: class Disc_item : public Item_base { public:  Disc_item(const std::string book=" ",double price=0.0, std::size_t qty=0, double dis_rate=0.0):       Item_base(book,price),quantity(qty),discount(dis_rate){ } protected:  std::size_t quantity;  double discount; } class Bulk_item : public Disc_item { public:  Bulk_item(const std::string book=" ",double price=0.0, std::size_t qty=0, double dis_rate=0.0):       Disc_item(book,price,qty,dis_rate) {}  double net_price(std::size_t) const; protected: }    复制控制 1,复制  class Derived : public Base{  public:   Derived( const Derived& d ):Base(d), , {}  派生类的复制构造函数,和构造函数不同.显式的定义了复制操作.           必须包括Base(d)来调用Base的复制函数,如果不包括,           派生类的基类复制部分将调用默认的构造函数.   ...     } 2,赋值  Derived &Derived::operator=(const Derived &rhs)  {   if ( this != &rhs ) {    Base::operator=(rhs);    基类赋值    ...   }   return *this;  } 3,析构  class Derived : public Base {  public:   ~Derived() { ... }     只析构派生类自己的成员,编译器会自动调用.  }; 基类的虚析构函数,派生类将继承虚析构函数特性,不管是显式的还是合成的.空的虚析构函数不遵循三法则(可以不需要构造,复制,赋值等复制函数). 构造和赋值操作符不能是虚函数. class Item_base { public:  virtual ~Item_base() {}      空虚析构函数 } 在构造和析构函数中最好是不要包含虚函数,因为这个过程对象不固定.

      5,继承情况下的类作用域 派生类的作用域嵌套在基类作用域中. cout << bulk.book(); 在派生类里找不到名字的定义,编译器就到下层类去找.重名的会使用上层的定义,可以用作用域操作符指定下层数据成员. struct Base {   Base():mem(0){ } protected:  int mem; }; struct Derived : Base {  Derived(int i):mem(i) { }  int get_mem() { return mem }     返回先找到的mem  int get_base_mem { return Base::mem; }    指定下层mem protected:  int mem; }; 重名的成员函数也一样,编译器使用先找到的那个,如果参数不匹配,就报错.  d.Base::memfcn(); 派生类成员函数重载,一般using基类中的所有重载成员函数(因为覆盖),再重定义本类里要定义的函数. 虚函数定义在基类,派生类应该使用同一原型(包括形参),这样才能通过基类的引用或指针访问到派生类.编译器将先在基类查找匹配的函数. 1,确定函数调用的对象,引用或指针的静态类型. 2,查找函数名,有上到下. 3,找到名字,进行常规检查,参数是不是合法. 4,合法就生成代码,虚函数且是引用和指针调用就根据实参类型调用动态特性的函数.

      6,纯虚函数pure virtual 一些类里的继承的虚函数不需要重定义(因为不使用),可以将这个类里的虚函数定义为纯虚函数,这个类(叫做abstract base class,抽象基类) 将不能创建对象,只能用于派生层次. class Disc_item : public Item_base { public:  double net_price( std::size_t ) const = 0;   纯虚函数 }

      7,容器和句柄类用于继承 容器是单一对象的集合,基类和派生类可以一起放入容器,当派生类会被切掉只剩下基类部分,也可以把基类强制装换为派生类放入容器,但派生部分没初始化. 唯一办法是将对象的指针放入容器,用指针要保证容器存在,对象就存在,容器消失,动态分配的对象要适当的释放. muitlset<Item_base> basket;   容器是base_item的集合 Item_base base; Bulk_item bulk; basket.insert(base); basket.insert(bult);    bult剪切到base部分加入集合

     为了继承和OOB,C++必须使用引用(reference)和指针(pointer),以便访问动态绑定的函数.C++使用句柄类(handle或叫cover包装类)来存储管理基类指针.    指针型句柄类 用户使用:  Sales_item item( Bulk_item("0-201-82470-1",35,3,.20) ); 用户绑定句柄类到Item_base继承层次的对象.  item->net_price();       用户使用 * -> 操作符操作Item_base,           用户不用存储和管理对象,由句柄类处理,操作是多态行为. 定义:  class Sales_item { public:  Sales_item():p(0),use(new std::size_t(1) ) { }   1,默认构造函数  Sales_item( const Sale_item &i ):p(i.p),use(i.use) { ++*use } 2,复制构造函数  Sales_item( const Item_base& );     3,接受Item_base的复制构造函数  ~Sales_item() { decr_use(); }     析构  Sales_item& operation=( const Sales_item& );   赋值函数声明  const Item_base *operation->() const {    ->符号 重定义,Sales_item返回一个item_base*.   if (p) return p;   else throw std::logic_error("unbound Sales_item"); } 无效的Sales_item,向内核抛出错误信息  const Item_base &operation*() {     *符号 重定义,Sales_item&返回一个引用 item_base&   if (p) return *p   else throw std::logic_errir("unbound Sales_item"); } private:  Item_base *p;        1,指向item_base的指针  std::size_t *use;       2,指向计数use的指针  void decr_use()   { if(--*use == 0) delete p; delete use } }; Sales_item& Sales_item::operation=( const sales_item &rhs ) {     ++*rhs.use;        use是指针,*use是内容  decr_use();  p = rhs.p;  use = rhs.use;  return *this;  } 为了支持未知类型的复制,要在基类开始定义虚函数clone,再在派生里重定义. class Item_base{ public:  virtual Item_base* clone() const   { return new Item_base(*this); } }; class Bulk_item{ public:  Bulk_item* clone() const         { return new Bulk_item(*this); }    虚函数的返回可以是派生类的指针或引用 }; Sale_itme::Sales_item( const Item_base &item ): p(item.clone()),use(new std::size_t(1)) { }           这个复制构造函数初始化,指针指到实参对象并新建use=1. 使用句柄类Sales_item和关联容器muiltset来实现继承层次中虚函数的统一操作:购物篮, 包括添加卖出的书,获得某书的卖出数量和总的卖价(折扣前和折扣后的),首先定义muitlset的比较Sales_item的方法: inline bool compare( const Sales_item &lhs, const Sales_item &rhs )  multiset容器可以指定比较函数 {  return lhs->book() < rhs->book();     Sales_item=继承层次中的某个对象的引用 } class Basket {  typedef bool (*Comp)(const Sales_item&, const Sales_item&); 将Comp定义为函数类型指针,该函数类型和compare函数相匹配 public:  typedef std::multiset<Sales_item,Comp> set_type;  类型别名set_type  typedef set_type::size_type size_type;    类型别名size_type  typedef set_type::const_iterator const_iter;   类型别名const_iter  Basket(): items(compare) { }     构造是容器items初始化,指定使用compare函数做容器对比函数  void add_item( const Sales_item &item )    接受Sales_item对象引用将其加入multiset    { items.insert(item); }  size_type size( const Sales_item &i ) const   接受Sales­_item对象引用返回该类ISBN的记录数    { retrun items.count(i); }  double total() const;      计算总的卖价 private:  std::muitlset<Sales_item,Comp> items; }; double total() const{  double sum = 0.0;  for ( const_iter iter=items.begin();     迭代器iter,是容器里定义的数据类型(指针),和下标用处差不多.        iter!=items.end();     但用下标的容器不多       iter=items.upper_bound(*iter) ) {  容器的upper_bound,形参是iter解引用(Sales_item),返回下一类isbn的iter   sum += (*iter)->net_price( items.count(*iter) ); *iter 获得Sales_item对象,*iter-> 获得句柄关联的Item_base对象指针.           net_price形参size_t,实参items.count(*iter)  }  return sum; }

      8,文本文件查询的进阶设计:     实现功能:  查询Daddy  查询非~(Alice)  查询或(hair|Alice)  查询与(hair&Alice)  复合查询((fiery&bird)|wind)     类定义:  1,定义出四个查询类: WordQuery,NotQuery,OrQuery,AndQuery,它们是兄弟类,应该共享相同的抽象接口.所以定义出一个抽象基类Query_base,   作为查询操作继承层次的根.Query_base->WordQuery    单操作数        ->NotQuery        ->BinaryQuery->AndQuery  双操作数,所以加个抽象类BinaryQuery表示两个操作数的查询           ->OrQuery 2,定义TextQuery类:  读指定文件,建立查询,查找每个单词. 3,定义Query_base类: 用来表示查询操作的类型,需要两个纯虚函数,每个派生类重定义自己的操作.  1,eval: 返回匹配的行编号集合,TextQuery对象做形参  2,display: 打印给定对象的查询结果,ostream引用做形参 4,定义句柄类Query: Query对象将隐藏继承层次,用户代码根据此句柄执行,间接操作Query_base对象.    Query必须: 定义&操作符          定义|操作符          定义~操作符          定义参数为string对象的构造函数,生成新的WordQuery  5,应用代码:  Query q = Query("fiery") & Query("bird") | Query("wind"); 6,过程:   生成10个对象,3个Wordquery,1个OrQuery,1个AndQuery,5个对应的句柄.

                /->Wordquey(fiery)            /-->Andquery    Query对象-->OrQuery      /->Wordquey(bird)            /-->Wordquey(wind)      知道了这个对象树,操作就会沿着这些链接,比如调用q,则q.eval->OrQuery.eval->AndQuery.eval ...以此类推                   ->WordQuery.eval 

    模板:OOB依赖于继承的多态性(指针多指),模板依赖于编译器对实参的实例化.  模板定义: 1,函数模板  template <class T> inline int compare(const T&, const T&);  声明为内联函数模板的定义.后接返回类型.  template <typename T,class T1, size_t T2>    定义    模板形参表(template parameter list)包括类型形参(class/template T)和非类型形参(int T),逗号分开  int compare( const T &v1, const T &V2 )  {   if ( v1 < v2 ) return -1;   return 0;  }  compare(s1, s2); 2,类模版  template <class Type> class queue {   定义  public:   Queue ();   Type &front ();   const Type &front() const;   void push(const Type &);   void pop();   bool empty() const;  private:   //...  }  queue< vector<double> > qvec;    使用 类里包括数据成员,函数成员和类型成员. typename parm::size_type *p; 加typename来显式指定p的类型,       parm::size_type *p;   而不是size_type数据成员. 3,非类型的模板形参  template <class T, size_t N> void array_init(T (&parm)[N])  包含N个T类型元素的数组的引用做形参  {   for ( size_t i = 0; i!= N; ++i ) {    parm[i] = 0;   }  }  int x[42]; array_init(x);  实例化:实参类型的推断 1,多个实参类型必须和形参相匹配. 2,实参可以受限转换:   const自动忽视和转换;数组和函数自动装换为指针,int* *func 3,非模板的实参还会做常规转换.  template <class Type> Type sum(const Type &op1, int op2) 4,函数指针推断.  template <typename T> int compare(const T&, const T&);  int (*pf1)(const int&, const int&) = compare;   函数模板对函数指针的初始化和赋值 5,不推断,显式实参:  int i, short s; sum(static_cast<int>(s), i);  int sum(int, int)  template <class T1, class T2, class T3> T1 sum(T2, T3);  long val = sum<long>(i, lng)     指定返回为long型,T1,T2,T3对应于返回,第1实参,第2实参.  template <typename T> int compare(const T&, const T&);  void func(int(*) (const string&, const string&));  void func(int(*) (const int&, const int&));  func(compare<int>);      显式指明用compare int实例做初始化  编译模型 1,包含编译模型:在.h文件中包含声明和定义. 2,分别编译模型;在.h文件中声明,在.c文件中定义.并用export template<class T> class queue扩展.  类模板的定义 1,完整的queue定义 template <class T> class Queue;     类模板声明 template <class T> std::ostream& operator<<(std::ostream&, const Queue<T>&);            std::ostream&表示形参是一个ostream型的引用,形参名在声明中省略. template <class T> class QueueItem {  friend class Queue<T>;      特定同类型模板友  friend std::ostream& operator<< <T>(std::ostream&, const Queue<T>&); 特定同类型普通友元 // private class: no public section  QueueItem(const T &t):item(t),next(0) { }    构造函数带参数和初始化,默认构造函数体  T item;  QueueItem *next;  } template <class T> class Queue {  friend std::ostream& operator<< <T>(std::ostream&,const Queue<T>& ); public:  Queue(): head(0),tail(0) { }     默认构造 Queue是Queue<T>的缩写,是类模板的非限定名  template <class It> Queue(It beg, It end):head(0), tail(0) { copy_elems(beg, end); } 模板成员  Queue( const Queue &Q ): head(0),tail(0) { copy_elems(Q); } 复制构造带形参Q Queue<T>( const Queue<T> &Q):head(0) ...  Queue& operator=( const Queue& );    赋值构造  ~Queue() { destroy(); }      析构

      template <class Iter> void assign( Iter, Iter ); 模板成员声明   T& front()  { return head->item; }     成员函数front声明  const T &front() const { return head->item; }    重载函数front  void push( const T & );      压入  void pop();        弹出  bool empty() const { return head==0; }    是否空 private:  QueueItem<T> *head;       数据成员  QueueItem<T> *tail;  void destory();       私有函数  void copy_elems( const Queue& );  template <class Iter> void copy_elems(Iter, Iter); 模板成员声明  }; template <class T> void Queue<T>::destory()    成员函数定义格式,模板形参表,作用域操作符,类后跟模板类型 {  while( !empty() )   pop(); } template <class T> void Queue<T>::pop() {  QueueItem<T>* p = head;  head = head->next;  delete p;        删除p指定内存 } template <class T> void Queue<T>::push(const T &val) {  QueueItem<Type> *pt = new QueueItem<T>(val);   申请QueueItem大小内存.  if ( empty() ) head = tail = pt;  else{ tail->next = pt;   tail = pt; } } template <class T> void Queue(T)::copy_perm(const Queue &orig){  for ( QueueItem<T> *pt=orig.head, pt, pt=pt->next ) pt在编译时其值为orig.head   push(pt->item); } 用户调用类模版的成员函数,不会进行编译器实参推断,而是由类模板的实参决定. Queue<int> qi; qi.push(s); s编译时转化为int 其实例化发生在为程序所用时,在定义的时候,实例化其默认构造函数,成员函数和模板类型.例如:顺序容器定义时,可以带没定义默认构造函数类型,但必须2个参数. 2, template <int hi, int wid> class Screen {    非类型形参 public:  Screen():screen(hi*wid, '#'), cursor(0), height(hi), width(wid) { }  ... private:  std::string screen;  std::string::size_type cursor;  std::string::size_type height, width; }; Screen<24, 80> hp2621;       用户定义

     类模板中的友元:  1,普通友元   template <class T> class Bar {    friend class FooBar;    Foobar的成员和fcn函数可以访问Bar类的    friend void fcn();    任意实例的private和protected成员,public都能访问    ...   }  2,普通的模板友元   template <class T> class Bar {    template <class T1> friend class Foo1;  Fool的任意实例都可以访问Bar实例的私有元素    template <class T2> friend void templ_fcn1(const T2&);   }  3,特定的模板友元   template <class T1> class Foo2;   template <nametype T2> void templ_fcn2(const T2&);   template <class T> class Bar {    friend class Foo2<char*>;    friend void templ_fcn2<char*>(char* const *); 指定类型char*的实例化是Bar实例的友元   }      template <class T> class Bar {    friend class Foo3<T>;    friend void templ_fcn3<T> (const T&);  和Bar同类型实参的Foo3和templ_fcn3的实例是Bar的友元   }  4,声明的依赖性   在设定模板友元之前或同时先进行友元类模板或函数模板的声明,没声明的是普通友元或编译出错.     5,新增输出成员函数并定义友元:  template <class T> ostream& operator<<(std::ostream &os, const Queue<T> &q)  书里没std::??   {         Queue的输出操作符重载   QueueItem<T> *p;   for (p=q.head, p, p=p->next)    os << p->item << " ";    3 5 8 13   return os;       }  template <class T> class QueueItem {   friend class Queue<T>;         同类型友元Queue   friend std::ostream& operator<< (T)(std::ostream&, const Queue<T>&);   同类型友元operator<<  }  template <class T> class Queue {   friend std::ostream& operator<< (T)(std::ostream&, const Queue<T>&);   同类型友元operator<<  }  输出<<操作依赖于具体类型,类型本身要有<<操作,如没有,虽可以定义对象,但输出操作时会编译出错.    类模板中的模板成员:类类型(模板或非模板)可以包括类模板和函数模板成员,叫做成员模板(member remplate)  成员模板使其他类型的数据可能导入类模板里,当然要先删除原来的类型.  定义:   template <class T> class Queue {    public:     template <class It> Queue(It beg, It end):head(0), tail(0) { copy_elems(beg, end); }     template <class Iter> void assign(Iter, Iter);    声明    private:     template <class Iter> void copy_elems(Iter, Iter);   声明   }     在类外部定义   tempalte <class T> tempalte <class Iter> void Queue<T>::assign(Iter beg, Iter end)   {    destroy();    copy_elems(beg, end);   }   成员模板的实例化   templater <class T> template<class Iter> void Queue<T>::copy_elems(Iter beg, Iter end )   {    while ( beg != end ) {     push(*beg);     ++beg; }   } static数据成员和成员函数  template <class T> size_t Foo<T>::ctr = 0;   类外声明和初始化static数据成员  tempalte <class T> class Foo{  public:   static std::size_t count() { return ctr;}  static 函数  private:   static std::size_t crt;     static 数据成员  }  Foo<int> f1,f2,f3;       实例化,f1,f2,f3共享一个static成员  Foo<string> fs;       fs实例化另外一个str数据

      泛型句柄类:句柄能够动态申请和释放相关的继承类的对象.并将实际的工作转发到继承层次的底层类.      泛型句柄类提供管理操作(计数和基础对象). 定义  template <class T> class Handle  {  public:   Handle( T *p = 0 ):ptr(0),use(new size_t(1)) { }  构造函数1   Handle( const Handle& h):ptr(h.ptr),use(h.use) {++*use;}; 构造函数2   T& operation*();       *  解引用操作符   T* operation->();       -> 成员访问操作符   const T& operation*() const;     const *   const T* operation->() const;     const ->   Handle& operation=( const Handle& );    = 赋值操作符   ~Handle() { rem_ref(); };      析构  private:   T *ptr;        继承对象指针   size_t *use;        计数   void rem_ref() { if(--*use == 0) {delete ptr; delete use;} } 无计数则释放空间  }  template <class T> inline Handle<T>& Handle<T>::operation=( const Handle &rhs )  {   ++*rhs.use;   rem_ref();   ptr = rhs.ptr;   use = rhs.use;   return *this;  }  template <class T> inline T& Handle<T>::operator*()  {   if (ptr) return *ptr;      判断一下是否为空   throw std::runtime_error( "dereference of unbound Handle" );  }  template <class T> inline T* Handle<T>::operation->()  {   if (ptr) return ptr;   throw std::runtime_error( "access through unbound Handle" );  }  template <class T> inline const ....

     使用      1,Handle<int> hp( new int(42) );  {   handle<int> hp2 = hp;   cout << *hp << " " << *hp2 << end1;    42 42   *hp2 = 10;        cout << *hp << end1;       10  }      2,class Sales_item {  public:   Sales_item (): h() { }   Sales_item( const Item_base &item ):h(item.clone()) { }   const Item_base& operator*() const { return *h; }   const Item_base* operator->() const { return h.operator->(); }  private:   Handle<Item_base> h;  }      3,double Basket::total() const   {   ...   sum += (*iter)->net_price(items.count(*iter));   (*iter)返回h,h->是继承层次对象的指针.  }   模板特化 1,函数模板特化:模板的一个或多个形参其实际类型或实际值是指定的.对于默认模板定义不适用的类型,特化非常有用.  template<> int compare<const char*>( const char* const &v1, const char* const &v2 )  {   return strcmp( v1, v2 );  } 2,类模板特化 3,特化成员而不特化类 4,类模板的部分特化  重载函数模板:匹配(带转换和隐式转换)原则,先普通函数再模板实例. template <typename T> int compare( const T&, const T& ); template <class U, class V> int compare( U, U, V );  int compare( const char*, const char* ); compare( 1, 0 );       和int实例化匹配 compare( ivec1.begin(), ivec1.end(), ivec2.begin() );   compare( ia1, ia1+10, ivec1.begin() ); compare( const_arr1, const_arr2 );     选择普通函数优先模板版本 compare( ch_arr1, ch_arr2 );     选择普通函数优先模板版本  如果有重载模板函数定义为: template <typename T> int compare2(T, T); 则不同,compare2( ch_arr1, ch_arr2 );    这时使用模板函数  compare2( const_arr1, con_arr2 );    使用普通函数,还是定义函数模板的特化好些.

    第五部分:进阶异常处理:大型程序出错情况下的处理,程序的问题检测部分抛出一个对象,通过对象的类型和数据到处理部分处理.  throw runtime_error("Data");创建一个异常对象(exception object,由编译器管理,保留在任意catch能访问的空间,处理完毕后释放),   他是被抛出表达式的副本(局部存储在抛出块的空间,在处理异常时,一般抛出块不存在了),其结果必须是可复制的副本.  catch(const runtime_error &e);可以匹配的第一个catch.

     抛出类类型的异常  异常对象及继承:一般抛出的异常对象在静态编译时就决定了,其属于一个异常对象层次及其继承.  异常指针:抛出的指针,其解引用的异常对象就是静态编译的类型,不会动态解引用到继承层次类.如果静态类型是基类,实参是派生类.     则对象被分割,只抛出基类部分.单单抛出一个指针是错误的. 栈展开(stack unwinding):在throw时,当前函数暂停,开始匹配catch语句,首先try块,再沿嵌套函数链继续向上.       catch结束后,在紧接与try相关的最后一个catch之句之后的点继续执行.  为局部对象自动调用析构函数:块的局部对象在栈展开时会调用析构函数自动释放,块直接分配单元new不会释放.  析构函数从不抛出异常:析构函数不能throw异常,因为在stack unwinding时,在析构抛出未经过处理的异常,会导致调用标准库terminate函数,     terminate调用abort函数,强制整个程序非正常退出.  构造时抛出异常:构造时异常要保证部分已初始化的对象撤销.  未捕获的异常终止程序:没匹配到得异常,编译器自动调用库函数terminate. 捕获异常catch(exception specifier)  匹配原则:比匹配实参与形参类型的规则严格.除以下区别,异常对象类型必须与catch说明符类型完全匹配.不能算数转换,不能类类型转换.   1,允许非const到const的转换.   2,允许派生类到基类的转换.   3,将数组转换为指向数组类型的指针,将函数转换为函数指针.  异常说明符:可以是异常对象的引用,或者是异常对象的副本.  异常说明符与继承:派生类的异常对象可以通过引用和指针和catch形参匹配,如果异常派生对象传递到基类说明符类型,则副本是分割的基类子对象.      catch子句的次序必须和派生层次对应,派生类的catch要在基类的catch之前. 重新抛出:在校正了一些行动后,catch一般rethrow原来的传进来的异常对象,异常对象的引用的改变可以rethrow, throw;  1,捕获的所有异常的处理代码: throw(...) { } 捕获任何类型的异常,在其他catch之后.  2,函数测试块与构造函数: 在构造函数体之前的初始化时,也可能发生异常,这时使用函数测试块(func try block).     template <class T> Handle<T>::Handle(T *p)     try : ptr(p), use(new size_t(1))     func try block     {      //empty function body     } catch( const std::bad_alloc &e )      { handle_put_of_memory(e); }  3,异常类层次: exception -> bad_cast         -> runtime_error -> overflow_error     运行错误                -> underflow_error                 -> range_error         -> logic_error   -> domain_error      逻辑错误                -> invalid_argment                 -> out_of_range                 -> length_error         -> bad_alloc   异常类的派生:    class isbn_mismatch : public std::logic_error {    public:     explicit isbn_mismatch( const std::string &s ) : std::logic_error(s) { }     isbn_mismatch( const std::string &s, const std::string &lhs, const std::string &rhs ) :          std::logic_error(s), left(lhs), right(rhs) { }     const std::string left, right;    共有的数据成员     virtul ~isbn_mismatch() throw() { }    };   派生类的使用:    Sales_item operator+( const Sales_item& lhs, const Sales_item& rhs )     {     if ( !lhs.same_isbn(rhs) )      throw isbm_mismatch( "isbn mismathc", lhs.book(), rhs.book() );     Sales_item ret(lhs);     ret += rhs;     return ret;    }    Sales_item item1, item2, sum;    While ( cin >> item1 >> item2 ) {     try {       sum = item1 + item2;      }     catch ( const isbn_mismatch &e ) { cerr << e.what() << e.left << e.right << endl; }    }   4,自动资源释放: 局部对象会自动撤销,但通过new申请的数组不会自动撤销.      通过异常安全技术(exception safe),可以定义一个类来封装资源的分配和释放.既"资源分配既初始化"RAII.    class Resource {    public:     Resource(parms p) : r(allocate(p)) { }     ~Resource() { release(r); }    private:     resource_type *r;     私有数据     resource_type *allocate(parms p);  私有成员函数allocate     void release(resource_type*);   私有成员函数resource_type    };    void fcn()    {     Resource res(args);     ...    } auto_ptr类: 是个RAII的模板,#include <memory>  auto_ptr<T> ap; auto_ptr<T> ap(p);ap拥有指针p指向的对象,explicit关闭隐形转换的. auto_ptr<T> ap(ap2);  apq = ap2; ~ap; *ap; ap->成员访问操作符 ap.reset(p); ap.release(); ap.get();  auto_ptr类型只能管理new返回的一个对象,不能管理动态分配的数组.不能将auto_ptr作为标准库容器的类型,           (其在复制和赋值时有不同于普通指针的行为).  auto_ptr类只能保存指向一个对象的指针,不能指向动态分配的数组.但其撤销时,就自动回收auto_ptr指向的动态分配对象.  1,为new申请的内存使用auto_ptr.  2,auto_ptr可以保存任意类型的指针,   3,auto_ptr<string> apl(new string("Brontosaurus"));  4,*ap1 = "TRex"; sting s = *ap1; if (ap1->empty())  5,复制和赋值后原来的右auto_ptr对象指向空.  6,左操作数指向的对象会删除.  7,auto_otr的默认构造函数初始化为0.  8,测试auto_ptr对象,if( p_auto.get() )  9,p_auto = new int(1024); //error不能直接传指针    if ( p_auot.get() ) *p_auto = 1024;    else p_auto.reset(new int(1024));  警告:1,不能用auot_ptr指向const数据 2,2个auto_ptr不能指向同一个对象3,不能指向数组4,不能存于容器. 异常说明:  定义: void recoup(int) throw(runtime_error) 异常类型列表   void recoup(int) throw();   不抛出任何异常   违反异常说明: 抛出没在异常类型表的异常,编译器没提示,会自动调用unexpected,unexpected调用terminate终止程序.  确定函数不抛出异常: throw();  成员函数异常说明: virual const char* what() const throw();  析构函数异常说明: vitual ~isbn_mismatch() thrwo() { } 析构函数不能抛出异常    异常说明与虚函数: 基类虚函数的抛出异常类型表必须大于派生类虚函数的异常类型表.这样基类指针访问派生类时不会unexpected. 函数指针的异常说明:  void recoup(int) throw(runtime_error);  void (*pf1) (int) throw(runtime_error) = recoup;    匹配,ok  void (*pf2) (int) throw(tuntime_error, logic_error) = recoup;   超出,error  void (*pf3) (int) throw() = recoup;      不抛出,ok  void (*pf4) (int) = recoup;        没异常说明,ok    命名空间:解决第三方库的多重名问题(命名空间污染 namespace pollution),库一般会在全局里定义类,函数,类别. 定义: 在全局或其他namespace定义,不能在类和函数里定义.   namespace cplus_primer{    class Sales_item { /* ... */ };   可以包括类,函数,变量及其初始化,模板,其他namespace    Sales_item operator+( const Sales_item&, const Sales_item&);    class Query {    public:     Query( const std::string& );     std::ostream &display( std::ostream& ) const;     //...     };    class Query_base { /* ... */};   }   cplusplus_primer::Query q = cplusplus_primer::Query("hello");  在其它域引用   q.display(cout);   using cplusplus_primer::Query;       声明   namespace namespace_name { }       定义和添加定义  namespace可以在.h里声明,其成员定义在.c里( namespace cplusplus_primer{ } ).保证接口和实现的分离.  定义可以在命名空间里,在全局里,但是不能在其它namespace里. 嵌套命名空间: 嵌套里同名的声明屏蔽其外围命名空间中的声明. 调用cplusplus_primer::QueryLib::Query  未命名的命名空间: namespace { 声明块 }; 适用于本文件,可以在同文件里不连续,其成员名不能和全局重名.    如果是.h里的未命名空间,则在不同的.c里定义局部实体.    c++不赞成c中的静态声明,即static func();改用namespace代替. 命名空间成员的使用: using std::map; 一次定义一个,一般定义在函数体或其他作用域的内部.在作用域结束时结束.    namespce Qlib = cplusplus_primer::QueryLib; 命名空间别名.    namespace blip{ int bi = 16, bj = 15, bk = 23; }    void main()     {     using namspace blip;  using指示,在函数里定义,表明namespace成员局部可见.     ++bi; --bj; ...    } 类,命名空间和作用域: 命名空间是作用域.其成员从声明时可见,透过嵌套和类,直至块的末尾.    std::string s; getline( std::cin, s ); 编译器会关联形参作用域到函数名.    接受类类型实参的友元和类在同一个命名空间,引用时无须使用显式命名空间限定符.    void f2() { A::C cobj; f(cobj); } 重载与命名空间: 确定候选函数集合,再匹配,再二义性.    using NS::print 引入所有的重载到候选集合,单引入某个重载函数会导致程序奇怪的行为.    using namespace 也一样. 命名空间与模板: 主要是特化的命名空间,模板特化的声明,定义和引用和其它命名空间成员一样.

    复杂的继承关系:多重继承(multiple inheritance),虚继承 多重继承:多余一个基类的派生类的能力,用于建模.   class Panda : public Bear, public Endangered { };   ZoomAnimal -> Bear   -> panda     Endangered ->   panda::panda(std::string name, bool onExhibit) :   派生类构造函数初始化所有基类.    Bear(name, onExhibit, "Panda"),     如省略,则调用默认构造函数.    Endangered(Endangered::critical) {  }   构造的次序按基类构造函数在类派生列表中出现的次序调用,与构造函数中基类出现的次序无关.    ZoomAnimal -> Bear -> Endangered -> Panda   析构的次序则反过来.~Panda,~Endangered,~Bear,~ZooAnimal. 

      多个基类的转换:对派生类的指针或引用可以转换为任何基类的指针和引用,二义性的报错.    和单继承一样,对基类的指针和引用只能访问基类的(或继承的)成员.不能访问到派生类.    无论调用继承层次中的那个虚析构函数,处理都是按构造的逆序,全部析构. 

      多重继承派生类的复制控制:合成的复制和赋值是全体的,按次序由低到高.ZoomAnimal,Bear,Endangered,Panda.         派生类自己定义的则只负责基类子部分.

      多重继承下的类作用域:成员函数中使用的名字首先在函数体内部查找,再在类里查找,再按继承层次由上往下查找.     相同的要指定名字,否则具有二义性.    多基类导致的二义性,即使是多声明,形参不同也会.使用 ying_yang.Endangered::print(cout) 可避免二义性.    为避免二义性,可以定义一个新的函数.    std::ostream& panda::print(std::ostream &os) const {  类里数据只是传值而不发生变化.     Bear::print(os);      Endangered::print(os);     return os;    }

     虚继承:在定义继承层次时,ios基类管理流的状态和读写缓冲区,istream/ostream实现流操作,iostream多重继承istream/ostream.按常规继承其有2个ios.  这时需要共享虚类子对象ios,称为虚基类(virtual base class).  声明:  class istream : public virtual ios { ... };  指定虚继承ios派生istream    class ostream : virtual public ios { ... };  虚继承不是直观的,必须在提出虚继承之前虚派生.虚继承一般不会引起问题,他通常由一个人开发.   Zooanimal  (虚)-> Bear    ->        (虚)-> Raccon  ->  Panda(前一级虚)           Endangered  ->   定义完的虚基类支持派生类对象到虚基类的转换.  虚继承的特殊的初始化语义:   Panda::Pamda( dtd::string name, bool onExhibit ) :    ZooAnimal(name, onExhibit, "Panda"),   直接初始化虚基类ZooAnimal,第1构造    Bear(name, Onexhibit),     第2构造,忽略Bear的ZooAnimal构造函数初始化列表.    Raccoon(name, onExhibit),     第3,忽略Raccoon的ZooAnimal构造函数初始化列表.    Endangered(Endangered::critical),    第4    sleeping_flag(false) {  }     第5            最后,构造Panda本身   带虚基类的继承层次,首先按先后构造虚基类(不管显式的还是合成的初始化),再按次序正常构造其他类.析构则相反.        优化内存分配: 一般是分配内存,并构造初始化.(new),但效率不高,  且vector不能预知类型;这时一般先申请一段内存,使用时在构造.优化一般实现后再做.  对未构造的对象进行操作而不是初始化,其结果是运行崩溃. allocator类: 模板,提供可知类型的内存分配操作,但不初始化. 其成员construct和destory分别在未构造内存中初始化对象和析构.   allocate<T> a;   a.allocate(n);   a.deallocate(p, n);   a.construct(p, t);   a.destroy(p);      uninitialized_copy(b, e, b2); uninitialized_fill(b, e, t); uninitialized_fill_n(b, e, t, n);未初始化构造  template <class T> class vector {  public:   Vector() : elements(0), first_free(0), end(0) {  }   void push_back(const T&);   // ...  private:    static std::allocator<T> alloc;  定义alloc   void reallocate();    声明成员函数reallocate   T* elements;     指向数组的第一元素   T* first_free;    指向第一个空的元素   T* end;     指向数组本身之后的元素   // ...  }  template<class T> vector<T>::push_back( const T& t )  {   if ( first_free == end ) reallocate(); 申请一段新的空间,并进行复制,first_free指向新空间.   alloc.construct( first_free, t );     ++first_free;  }  template <class T> vector<T>::reallocator()   {   std::ptrdiff_t size = first_free - elements;   std::ptrdiff_t newcapcity = 2 * max(size, 1);   T* newelements = alloc.allocate(newcapacity);   申请新空间   uninitialized_copy( elements, first_free, newelements ); 未初始化复制     for (T *p = first_free; p != elements; /* empty */) alloc.destory( --p );    if ( elements ) alloc.deallocate( elements, end - elements );逆序释放原空间   elements = newelements;      重定位置   first_free = elements + size;   end = elements + newcapacity;  }

     operator new/operator delete:标准库机制,new/delete调用,会分配或释放可知大小,未类型化(既未初始化)的内存,      uninitialized_fill/uninitialized_copy构造对象,析构函数析构对象.  void *operator new(size_t);  void *operator new[](size_t);  void *operator delete(void*); void *operator delete[](void*);  T* newelements = alloc.allocate( newcapacity );  和operator new功能一样,参数带类型,安全  T* newelements = static_cast<T*>( operator new[](newcapacity*sizeof(T)) ); 静态类型转换.

     定位new表达式: 接受未构造的内存的指针,并在该空间初始化一个对象或一个数组.  new (place_address) type(initializer-list)  new (first_free) T(t);

      allocator<string> alloc;  string *sp = alloc.allocate(2);   构造临时对象  new (sp) string(b, e);    一对迭代器做实参  alloc.construct(sp+1, string(b, e));  构造后的复制,有些类的复制构造函数是私有的,不能复制,必须用定位new表达式.  

     显式析构函数的调用: 要清除对象时  1, alloc.destroy( p );  2, p->~T;   直接析构成员对象,但内存还在,可以再用.

     类自定义的new和delete:  类定义或继承了自定义的operator new/operator delete,就忽略标准库的new/delete.或operator new[]/operator delete[].  void* operator new(size_t) void operator delete(void*, size_t) 只访问静态成员,默认是静态的,不用static  void* operator new[](size_t) void oeprator delete[](void*, size_t)  在类自定义了operator new/delete后,可以使用全局作用域操作符::强制使用标准库的new/delete  Type *p = ::new Type; ::delete p;

     CacheObj内存分配器基类:分配和管理已分配但未构造的自由列表(相当于在一段内存上添加和释放成员对象).希望自定义的new/delete的类可以继承CacheObj. 1,定义 template <class T> class CacheObj {  public:   void *operator new(std::size_t);   自定义new   void operator delete( void*, std::size_t ); 自定义delete   virtual ~CacheObj();    虚析构函数,因为是虚基类.  protected:   T *next;  private:   static void add_to_freelist(T*);   static std::allocator<T> alloc_mem;   static T *freeStore;   static const std::size_t chunk;  }; 2,成员 template <class T> void *CachedObj<T>::operator new(size_t sz)  {   if ( sz != sizeof(T) )    throw srd::runtime_error( "CachedObj: wrong size object in operator new" );   if ( !freestore ) {    T* array = alloc_mem.allocate(chunk);   申请chunk个T的空间    for ( size_t i=0; i!=chunk; ++i )     add_to_freelist(&array[i]);    用基类的next将其连起   }   T *p = freeStore;   freeStore = freeStore->CachedObj<T>::next;   下一个剩余空间   return p;        返回现在的地址指针  } 3, template <class T> void CachedObj<T>::operator delete(void *p, size_t)  {   if ( p != 0 )  add_to_freelist(static_cast<T*>(p));  将现在的指针指向的空间放回.  } 4, template <class T> void add_for_freelist(T *p)  {   p->CachedObj<T>::next = freeStore;   freeStore = p;  } 5, template <class T> alloctor<T> CachedObj<T>::alloc_mem;  定义静态成员  template <class T> T *CachedObj<T>::freeStore = 0;  template <class T> const size_t CachedObj<T>::chunk = 24;

     6,应用 class Screen : public CacheObj<Screen> { };      类继承模板CacheObj  template <class T> class QueueItem : public CacheObj< QueueItem<T> > { }; 模板继承模板CacheObj

    运行时的类类型识别RTTI: 通过基类的指针和引用来检索其运行时对象的实际派生类型.   带虚函数的类,在运行时执行RTTI操作符,其它的在编译时计算RTTI操作符.程序员必须知道对象强制转换为哪种类型.   要想通过基类来操作派生类,最好的办法还是虚函数,使用虚函数时,编译器会自动根据对象的实际类型选择正确的函数. dynamic_cast操作符: 将基类类型的指针和引用安全转换为派生类型的指针和引用.  if ( Derived *derivedPtr = dynamic_cast<Derived*>(basePtr) )  强制基类指针转换使用if/else  {   //use Derived object  }else{   //use Base object  }  void f(const Base &b)        强制基类引用转换  {   try {    const Derived &d = dynamic_cast<const Derived&>(b);   }catch ( bad_cast ) {      }  } typeid操作符:  返回指针或引用所指对象的实际类型.返回type_info  if ( typeid(*bp) == typeid(Derived) ) {      必须是*bp,bp所指的对象.  }         如果bp是带虚函数的类型,typeid(*bp)抛出bad_typeid异常.   RTTI的使用:  举例:在比较继承层次的对象equal时,先比较运行类型相等,再逐层调用虚函数比较.  class Base {   friend bool operator==(const Base&, const Base&);  public:  protected:   virtual bool equal(const Base&) const;  };  class Derived : public base {   friend bool operator==(const Base&, const Base&);  public:  private:   bool equal(const Base&) const;  }  bool operator==(const Base &lhs, const Base &rhs)  {   return typeid(lhs) == typeid(rhs) && lhs.equal(rhs);  }  bool Derived::equal( const Base &rhs ) const  {   if ( const derived *dp = dynamic_cast<const Derived*>(&rhs) ) {  必须强制转换   }else return false;  }

     type_info类:提供操作  t1 == t2; t1 != t2; t.name(); t1.before(t2);

     类成员指针: 对象指针通过->成员访问符访问成员,也可以先直接定义类成员的指针,再使用这个指针绑定到函数或数据成员.   static成员不是对象的组成部分,不能定义类成员的指针.  class Screen {  public:   typedef std::string::size_type index;   char get() const;   char get( index ht, index wd ) const;  private:   std::string contents;   index cursor;   index height, width;  };  数据成员的指针:  string Screen::*ps_screen = &Screen::contents;   Screen里的std::string类型成员contents的指针.  Screen::index Screen::*pindex = &Screen::width;  指针指向screen里的index类型成员,cursor,height,width.  函数成员的指针:  char (Screen::*)() const   这个类型指定Screen类的const成员函数指针,无形参,返回char类型的值.  char (Screen::*pmf2)() const = &Screen::get;   定义类成员函数指针  char (Screen::*pmf2)(Screen::index, Screen::index) const = &Screen::get;  char Screen::*p() const; //error:mon-member function p connot have const qualifier      调用操作符的优先级高于成员指针操作符,所以括号是必须的.  成员指针的类型别名:  typedef char (Screen::*Action)(Screen::index, Screen::index) const;        Action是类型"Screen类的接受两个index类型,返回char的成员函数的指针"的名字.  Action get = &Screen::get;  定义get,Action类型.复制为&Screen:get

      Screen& action(Screen&, Action = &Screen::get);  声明函数action带形参Screen&和Action,返回Screen&  Screen myscreen;  action(myscreen);      use the default argument  action(myscreen, get);     use the variable get taht we priviously defined  action(myscreen, &Screen::get);    pass address explicitly(明确的)

     使用类成员指针:  成员指针解引用操作符(.*) :从对象或引用获取成员.  成员指针箭头操作符(->*) :通过对象的指针获取成员.  1,使用成员函数的指针.   char c2 = (myscreen.*pmf)();  char c2 = (pScreen->*pmf)(0, 0);  2,使用数据成员的指针.   Screen::index ind2 = myScreen.*pindex; Screen::index ind2 = pScreen->*pindex;  3,应用  class Screen {   public:   Screen& home();     成员函数指针表.   Screen& forward();   Screen& back();   Screen& up();   Screen& down();

       typedef screen& (Scren::*Action)();  定义成员函数指针类型    static Action Menu[];    定义指针数组

       enum Directions { HOME, FORWARD, BACK, UP, DOWN }; 枚举   Screen& move(Directions);    操作成员函数move   };  Screen::Action Screen::Menu[] = { &Screen::home, 定义成员函数指针表.       &Screen::forward,       &Screen::back,       &Screen::up,       &Screen::down,       };  Screen& Screen::move(Directions cm)  {   (this->*Menu[cm])();     使用函数指针表.   return *this;  };  Screen myScreen;  myScreen.move(Screen::HOME);  myScreen.move(Screen::DOWN);

    嵌套类:nested class在一个类里定义一个新类,这个新类叫嵌套类.一般用于定义执行类,2个类的对象的成员互相独立,互相独立. 嵌套类的名字只在外围类的作用域可见,在其它类作用域或定义外围类的作用域不可见. template<class T> class Queue{     模板Queue private:  struct QueueItem;      私有嵌套类声明  QueueItem *head;  QueeuItem *tail; }; tempalte <class T> struct Queue<T>::QueueItem {  在外围类的外部定义嵌套类,也是一个模板(T)  QueueItem(const T &t) : item(t),next(0) { }  T item;  QueueItem *next; }; template <class T> int Queue<T>::QueueItem::static_mem = 1024;嵌套类静态成员定义    嵌套类可以直接引用外围类的静态成员,类型名和枚举成员.引用外围作用域以外的要加作用域确定操作符.  template <class T> void Queue<T>::pop() {    外围类使用嵌套类.  QueueItem *p = head;  head = p->next;  delete p; }

     实例化: Queue<int> qi; 实例化Queue,但不实例化QueueItem.当head/tail解引用时才实例化QueueItem.

     嵌套类作用域中的名字查找??? 联合类:节省空间的类,具有某些类特征:可以包括构造,析构,赋值.不能有static或引用成员. class Token {  enum Tokenkind { INT, CHAR, DBL };  TokenKind tok;  union {   char cval;   int ival;   double dval;  } val; }; switch ( token.tok ) { case Token::INT:  token.val.ival = 42;  break;    //.val. case Token::CHAR:  token.cval = 'a';  break;    //匿名联合可以直接访问其成员 };

    局部类:在函数体内可以定义局部类,再进一步封装数据.局部类不能声明static数据,可以访问外围作用域的static变量,枚举,类型名. int a, val;        全局变量 void foo( int val )       函数体定义 {  static int si;      外围作用域变量  enum Loc { a = 1024, b };     外围作用域enum  class Bar {         public:       一般都是public,不需再封装   Loc locVal;      ok,use local type name   int barVal;   void fooBar( Loc l = a )    ok   {    barVal = val;     err,val is local to foo    barVal = ::val;    ok    barVal = si;     ok,use static    locVal = b;     ok   }  }; } 类成员声明所用名字必须出现在之前的作用域中,  成员定义中所用名字可以出现在局部类作用域任何地方, 没找到在外围作用域找,再到包含函数的作用域找.

    不可移植的一些特征:支持低级编程,从gcc语言继承来的. 位域:  typedef unsigned int Bit;  位域必须是int型   class File {    Bit mode: 2;   Bit是位域,2位.    Bit modified: 1;    Bit prot_owner: 3;    Bit prot_group: 3;    Bit prot_world: 3;    ...   };   void File::write()   成员函数可以直接使用位域.   {    modified = 1;   }   enum { READ = 01, WRITE = 02 };   int main() {    File myFile;    myFile.mode |= READ;    if ( myFile.mode & READ )     cout << " myFile.mode READ is set/n";   }  &不能应用于位域,位域也不能是类的静态成员(多对象共享,省内存).

     volatile限定符:一些数据的值由程序之外的硬件所控制, 如时钟.其对象声明为volatile:      (不优化,,编译器就不会把那个变量缓存到寄存器中,对变量的每次访问都直接通过实际内存的位置).  volatile int display_register,v;  int *volatile vip;   vip is a volitile pointer to int  volatile int *ivp;   ivp is a pointer to valatile int  ivp = &v;     只能用volitile的引用初始化  类合成的复制控制不适用于volatile对象.必须重定义带volatile成员的类的复制控制.   extern "c":链接指示(linkage directive),不能出现在类定义或函数定义内部,它必须出现在函数的第一次声明上.  1,extern "C" size_t strlen(const char *);  2,extern "C" {   int strcmp( const char *, const char* );   char *strcat( char*, const char* );   }  3,extern "C" { #incldue <string.h> }   string.h必须是c或c++函数.  4,extern "C" double calc(double dparm) { /* ... */} 链接指示也可以将c++导出  5,extern "Ada"   extern "FORTRAN"  6,#ifdef __cplusplus     如果编译c++,就extern "c"    extern "C"    #endif    int strcmp( const char*, const char* );  7,c++的重载函数只能链接指示一个到c.   extern "C" double calc(double);   c/c++调用   extern SmallInt calc(const SmallInt&);  c++调用   extern BigNum calc(const BigNum&);   c++调用  8,void (*pf1)(int);      c++    extern "C" void (*pf2)(int);    c    pf1 = pf2;       //error;c和c++指针具有不同类型.  9,extern "C" void f1(void(*)(int));   应用于整个声明的链接指示    fi是个c函数,返回void,形参void(*)(int):c函数指针.    extern "C" typedef void FC(int);   类型别名   void f1(FC *);     访问

     

     

     

     

       

     


    最新回复(0)