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 *); 访问
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
