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 *); 访问
