1.C++函数库
Algorithms
C Library Wrappers
Containers
Sequence
、
Ordered Associative
,
Unordered Associative
Adaptor
Error Handling
Input/Output
Iterators Library
Localization
Math and Numerics
Memory Management
Multithreading
Other Utilities
Strings and Character Data
1.C++命名空间
C++只有一个命名空间std，包含了所有的C++库。关于命名空间，同一个命名空间的名字可以在不同的文件或同一文件中多次出现，也可以出现在头文件里面，表示同一命名空间的不同部分代码。
2.C++引用与指针
C++的引用一般用于函数入参和函数返回值。引用和指针其实存在本质的区别，引用就是一个对象的别名，没有分配存储对象指针的存储空间；而指针需要分配一个存储对象指针的存储空间。所以指针和引用一般情况下是没有办法相互转换的。在C++中，如果对象没有名字（如用new分配的对象）那么它也不可能有别名，而其他语言（如C#）可以只有别名。
3.C++的模板：针对类型的一种统一操作
C++的模板分为函数模板和类模板，两者声明的形式都一样。
template
{
函数体或类体
}
函数模板在调用时自动实例化，而类模板必须先实例化（指明类型），才能调用。
4.关于throw的栈展开
在throw进行栈展开时会调用很多析构函数或进行很多函数的局部变量回收，直到遇到了catch为止。
5.操作符重载
操作符的本质是一个函数，其重载有两种情况：第一种操作符在类中作为成员函数重载；第二种操作符作为全局函数重载。两种重载方式有一点区别：1）在类中作为成员函数重载，将默认第一个函数入参（双目时为左操作数）为this指向的本类对象，所以在类中重载操作符时，双参在形式上变成了单参。2）基于第一条规则，有些左操作数特殊的操作符（如<<或>>等要求左操作数必须为流对象）不能在类中重载。在众多的运算符中，大多对左右操作数是敏感的，不允许左右操作数交换。第一个入参是左操作数，第二个入参是右操作数。
6.友元
在类中定义一个友元函数（或重载的操作符）或友元对象，那么在该友元中可以以‘.’访问该类对象的私有成员，这是在其他非友元作用域里做不到的。
Class A{private :int a ;friend void myfunc(void);}
void myfunc(void)
{
A myA;
cout<
}
7.容器
所有容器提供的内置方法绝大部分是与迭代器有关的，大部分泛型算法也与迭代器有关。
迭代器和指针是完全一样的，但是迭代器更安全。
容器在构造时可以使用其他不同类型的容器的迭代器或指针来构造，但是需要保证两种容器或数组的数据类型是一致的。
8.流
流 |
||
头文件 |
容器 |
说明 |
istream |
Wistream,wostream,wiostream 从流中读写数据 |
|
ostream |
||
iostream |
||
ifstream |
Wifstream,Wofstream,wiofstream 从文件中读写数据 |
|
ofsteram |
||
fsteram |
||
istringstream |
Wistringstream,Wostringstream,wstringstream 从字符串流中读取数据（底层没有字符串） |
|
ostringstream |
||
stringstream |
||
在流对象使用中，如果产生任何失败，则其对象为0，否则为非0，相应的错误状态被记录在该对象中。
例：Int a;Cin>>a;如果输入了一个字符，那么将产生错误。则cin==0。If (cin) 将为false。其它流都有这种用法。
流的作用：->本质上是字符处理。将字符从不同的底层以多种格式（或方式）输入到内存中来，或者相反。以下是例举的几种流的作用：
（1）以单个字符、字符串、行任意形式存取字符
（2）以×××、浮点型等形式存取字符
9.lambda 函数
返回值类型[可使用的全局变量列表]（形参列表）{函数体}
如果“可使用的全局变量列表”为“=”，则能使用所有的全局变量
10.顺序容器
特点：根据位置存储和访问容器，容器元素的排列次序与元素值无关，而由元素添加到容器里的次序决定。标准库只定义了三种顺序容器:vector,list,deque.
和三种顺序容器适配器(适配器是以基本的容器类型为底层，通过定义新的操作接口，实现不同的数据操作)：stack,queue,priority_queue
容器和容器适配器都只提供了少量操作，大部分操作由泛型算法库提供。
容器的长度都是动态可增长缩短的。
容器元素的类型约束有两点：元素类型必须支持赋值运算和元素类型对象必须可复制。（即不能为引用和流）
迭代器的范围为[iter.begin,iter.end),其编程意义为：当iter.begin== iter.end迭代器范围为空。
容器内置的操作主要有：
任意位置任意方式增减元素个数的操作，迭代操作，交换元素操作。
11.关联容器
基本的有4种：map,set,multimap,multiset
在map中有个不好的地方：
Map
Int occurs=word_count[“foobar”];
这样的查找如果“foobar”键不存在于word_count容器中，那么将会增加一个“foobar”键，并返回值为0。这是编译语言与解释语言的区别。.find方法提供了判断该键是否存在的方法。
.count方法提供了判断map和multimap中键个数的方法。
在python中能实现的操作，在C++中基本上都有这些功能。没有相应的语法支持，但是可以提供对象内置方法来解决（反射除外）
Set容器提供了insert,count,find,erase等操作。可以使用其他容器的迭代器来构造set容器，只保留不重复的元素集合。
除了容器内置的迭代器以外，C++还提供了3类独立迭代器：
1）插入迭代器
back_inserter,front_inserter,inserter.使用容器构造
2）流迭代器
istream_iterator,ostream_iterator
3）反向迭代器
reverse_iterator
12.指向类成员的指针
Class screen{;}
定义指向数据成员的指针：Int screen::*ptr；定义了一个指向screen类int类型成员的指针。
定义指向函数成员的指针：void (screen::*ptr)(void);定义了一个指向类函数的指针
指向类成员的指针可以定义在类中也可以定义在类外。
使用定义在类中的指向类成员的指针：两个新的解引用操作符->*和.*，他们能够将成员指针绑定到实际对象。
成员函数指针列表 :typedef void (*action)(void);
screen::action screen::menu[]={&screen::home,...}
13.auto自动数据类型
Auto 和int,double不同，他能推断数据的类型，从而将其转化为推断出的类型。
14.序列for循环
所有能使用iterator的序列都能使用序列for循环
Map
For(auto p:m){cout <
15.c98和c11的智能指针-为分配的对象提供异常安全
（1）auto_ptr 能够代理new，能赋值（与unique_ptr的区别），但同一时刻只能有一个auto_ptr管理指针,不带有引用计数（c98），能管理任意非数组指针对象
（2）unique_ptr 能够代理new[]和new，不能转让，不允许拷贝构造和拷贝赋值(不能放在容器中,但unique_ptr能保存容器指针)，不带有引用计数,可以完全代替scoped_ptr和scoped_array(c11)
（3）shared_ptr能够代理new的指针，实现了引用计数（应该是new int了一个内存用来保存引用计数，当发生shared_ptr赋值时将引用计数加1并将引用计数指针赋给另外一个shared_ptr），支持拷贝和赋值，可以放入容器中且可以保存容器指针（make_share模板函数）（最有价值的指针）(c11)
（4）shared_array代理new[]的指针，shared_array能力有限。一般使用shared_ptr
（5）weak_ptr 该指针是辅助shared_ptr的，shared_ptr给weak_ptr赋值不会增加引用计数(c11)
（6）boost/smart_ptr.hpp
scoped_ptr 接受new的指针，不能转让（不支持拷贝和复制（私有拷贝和复制函数实现），不放入作容器），且只能在本作用域内使用，与auto_ptr基本相同
scoped_array接受new[]的指针，不能转让（不支持拷贝和复制（私有拷贝和复制函数实现），不能用作容器），且只能在本作用域内使用，可以用vector替代
16.一些需要注意的C++编程细节
（1）环形缓存：
#define SIZE 100
int Buffer[SIZE];
Buffer[i%SIZE]='X'
（2）类的复制控制：
定义private的复制构造函数（如IO类），可以保证该对象只有一个副本。通过设计模式还可以使得该类只被构造一次。
classfa a;
classfa b=a;//其实是调用了classfa的默认复制构造函数 classfa(const classfa &)
string c="ancd" //调用了字符构造函数和复制构造函数。
（3）顺序容器：string，vector,list都可以使用.erase()和insert()在任意位置删除和插入指定迭代器的节点。
（4）友元friend 是不支持继承的。即类A是BASE的友元，但它不会是该BASE 的CHILD的友元。
（5）一个C标准函数：将从流中读出的数据，重新压入流的缓存中，可以通过此函数实现peek()函数
ungetc( char ch, FILE* f); //向IO缓存中压入数据
一次只能压入一个字符
（6）递归：（连接2个链表）
已知两个链表head1 和 head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。
Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
return head2
if ( head2 == NULL)
return head1
Node *head = NULL
if ( head1->data < head2->data )
{
head = head1
head->next = MergeRecursive(head1->next,head2);
}
else
{
head = head2
head->next = MergeRecursive(head1,head2->next);
}
return head
}
（7）引用：
常引用:不能通过引用改变变量的值
int b=1;
const int & a=b;
a=2;//错
b=2;//对
string foo( );
void bar(string & s);
那么下面的表达式将是非法的：
bar(foo( ));
bar("hello world");
foo()的返回值必然是const string型的，“hello world”也被编译器构造为const string,而把他们用于非const函数入参，编译器将会报错。函数的引用入参应尽量指明为const，这样const和非const的实参都不会报错。
引用作为函数返回值类型的好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!
（8）求一个数中包含的二进制1的个数：
def func(x):
cont=0;
while(x):
x=x&(x-1)
cont=cont＋1
return cont
求任意数据由二进制表示时包含的1的个数
（9）虚析构函数作用：
将析构函数定义为virtual 这样在用delete删除基类指针时可以运行子类的析构函数。
（10）mutable关键字：在const变量中被改变
c＋＋ 中 mutable关键字申明的变量可以在const申明的函数中改变。
class M
{mutable int a;
void set() const
{a=10;}
}
（11）静态成员：
class M
{
static M a; //correct
M *b; //correct
M c; //error
}
静态成员是类的一部分，而不是对象的一部分。
（12）const 用法：
const对象不能调用非const的成员函数和变量；为了使const对象和非const对象都可以调用一个同名函数，可以重载该非const和const成员函数。
（13）c数组：
在c/C＋＋中数组是一种完整的数据类型，同结构体，对象一样：
main( ){
using namespace std;
int num[5]={1，2，3，4，5};
cout <<*((int *)(&num＋1)-1) <
}
在C语言中，一维数组名表示数组的首地址，而且是一个指针.如上例num，
对&num，表示指针的指针.意味着这里强制转换为二维数组指针.
这样 &num＋1 等同于 num[5][1]，为代码空间. (&num＋1)-1表示 num[4][0].即num[4].
char (*a)[3][4] 定义一个数组指针
（14）switch的入参：
switch的参数不能是不能自动转化为整型的参数。
因为switch后面只能带自动转换为×××(包括×××)的类型,比如字符型char，unsigned int等,实数型不能自动转换为×××.可以手动强转实数型(int)double，但是会导致精度的丢失.如果后面要对实数型做选择的话,可以乘以10的倍数,然后进行选择,这样不会丢失精度.但是这样的话就要靠你去手动的控制乘以多少了
(15)sizeof
使用sizeof对变量求所占内存长度时，是对该变量直接求内存长度，需要搞清楚，sizeof的对象是谁。
char *p=“dk4m7”;//sizeof(p),p内存为4字节
char p[]="dk4m7";//sizof(p),p内存为6字节,(p符号相当于一个引用，本身不占内存)
（16）多维数组
char a[2][3][4]={{{1,2,3,4},{5,6,7,8},{9,10,11,12}},{{13,14,15,16},{17,18,19,20},{21,22,23,24}}};
a符号表示一个引用，不占内存。其指向的地址为a[0],a[0][0],&a[0][0][0]
a表示一个3维数组，a+1表示最高维加1，相当于a[1]的首地址
*a表示一个2维数组，*a+2,表示2维数组加1，相当于a[0][2]的首地址
*(a+1)+2相当于a[1][2]的首地址
*(*(a+1)+2)+3相当于a[1][2][3]的首地址
c11新特征
1.列表初始化
任何对象或对象数组都可以使用列表初始化，列表赋值不支持任何形式的类型转化，包括浮点到×××的转化。
例子：以下4种等价
int s=0;
int s={0};
int s{0};
int s(0);
vector
vector
vi={5,6};//任何形式的列表赋值
map
pair
2.constexpr 编译时验证，赋值表达式是否为常量赋值
constexpr int mf=20;
constexpr int linit=mf+1; //正确，编译时计算
constexpr 也可用于函数，要求函数只用一个return语句，并且形参类型必须是字面值类型
3.类型别名申明
typedef double base,*p; /旧方法。 base是double的别名；p是double*的别名
using double=base
using double*=p //新标准使用USING申明变量别名
4.auto 自动推断赋值表达式的左值类型
auto b=20;
auto &a=b;
5.decltype 作用同auto，只能推断表达式的类型。但是可以灵活的指定表达式
const int ci=0,&cj=ci,p=&ci;
decltype(ci) x=0;
decltype(cj) y=x; //指定推断cj表达式的类型，推断的类型为引用
decltype(*p) z=10; //对×解引用推断的结果是引用，必须初始化
decltype((ci)) m=ci; //强制推断为引用 （3种引用推断方式）
6.类实例化时，使用()和不使用()的区别
classA a;//不会进行处理为显式初始化的成员
classA a();//会将a的未初始化的成员默认初始化为0
7.范围for
string str("some string");
for(auto c:str)
8.initializer_list
a.initializer_list函数形参列表
void error_msg(ErrCode e,initializer_list
for( const auto &elem:il){
cout< } } 调用： error_msg(ErrCode(42),{"func1","ok","sd"}); b.initializer_list函数返回值 vector if(expected.empty()){ return {}; }else if(expected==actual){ return {"fun","ok"}; else{ return {"fun","ok","lk"}; } } } 9.函数的尾置返回类型 对于函数的返回值类型较长的函数可以使用尾置返回类型 auto func(int i) -> int(*)[10] //返回一个指向10个元素的数组指针 10. =default 申明默认构造函数 有时在含有有参构造函数时，也需要默认构造函数，这是就需要使用=default申明 Sales_data()=default; 11.c11支持的所以顺序容器 vector,deque,list,forward_list(单向链表),array,string 都可以使用列表初始化 12.lambda函数 形式： [捕获参数列表]（形参列表）{...；[return]} //无需指定返回值类型 捕获参数列表中有2个特殊的符号 &：表示所有外部变量的捕获使用引用 =：表示所有外部变量的捕获使用值 13.bind函数 用于绑定函数名及其参数，可以交换参数位置。bind的返回值一般直接赋给auto 14.智能指针 shared-ptr 实现引用计数，可以转移或赋值 unique-ptr 不能转移或赋值,取代auto-ptr 但允许swap（因为该函数实现的是转移） scoped-ptr 可以转移或赋值，但是同时只可能有一个对象持有指针 weaked-ptr 解决share-ptr的循环链中发生内存泄露的问题。 15.移动构造函数，右值引用，标准库中的move函数，移动赋值 Quote& operator=(Quote&&){...} //移动赋值 16.final 通过定义类的final来阻止继承 class NoDerived final{...} 17.模板的类型别名 template twin c11补充 1.异常 （1）throw可以抛出异常对象和异常对象的指针，当抛出指针是必须保证catch处该指针变量还有效（一般必须在同一函数中处理）。 range_error r("error"); throw r; 抛出异常对象 exception *p=&r; throw *p;抛出异常对象的指针 （2）栈展开 栈展开：抛出异常时将暂停当前函数的执行，开始查找匹配的catch子句。首先检查throw本身是否在try块内部，如果是，检查与该try相关的catch子句，看是否其中之一能与被抛出的对象匹配，如果找到匹配的catch，就处理异常；找不到，就退出当前函数，并且继续在调用函数中查找。 （3）栈展开要执行的操作 a.为局部对象调用析构函数：当一个包含throw的函数由于异常提早退出时，该函数的栈上的局部存储会被释放，将释放在throw调用前创建的所有栈对象。如果局部对象是类类型的，就直接调用对象的析构函数。new分配的对象不能释放。 b.析构函数应该从不抛出异常：栈展开期间会经常执行析构函数，如果析构函数再次抛出自己没有处理的异常，将导致系统调用terminate函数，使整个程序崩溃。所以编程者不要在析构函数中抛出异常，并且必须处理析构函数中的默认异常。 c.构造函数常常抛出异常：如果在构造对象的时候发生异常，则对象可能部分被构建而一些成员可以没有被初始化。需要保证适当的撤销以构造的元素。 d.异常被抛出到线程入口时还没有被捕获，则程序将调用terminate终止程序。 （4）catch a.catch中可以使用throw;不加对象或rethrow重新抛出异常。被抛出的异常是原来的异常对象而不是形参。如果想改变抛出的异常对象的成员，形参可以使用&引用 （5）容器与数组 void fun(){ vector while(cin>>s){ v.push_back(s); } string *p=new string[20]; //do something delete[] p; } 如果在do something发生了任何异常，那么Vector的内存能够正常释放，但数组p的内存无法释放。因为不管何时发生异常析构函数总是会被调用的。 （6）用类来分配资源 将分配资源的额动作一定要写在类中，而不是单个的函数中，这样在析构函数中写释放资源的操作，保证资源总能被释放。 这种通过定义类来封装资源的分配和释放的技术称为RAII(资源分配即初始化)。原理就在于无论是否发生异常，类的析构函数总是会被调用的。 （7）auto_ptr类（保证异常安全-new出的对象自动释放） auto_ptr类是RAII技术的一个例子。auto_ptr类可以接收任意一个非数组类型或模版的形参，为动态分配的对象(new)提供异常安全。auto_ptr可以保存任何类型指针。auto_ptr类的对象唯一持有指向的对象(不提供引用计数)，这也决定了它不能放在容器中。 auto_ptr对象的复制和赋值是破坏性操作,将改变右操作数。 auto_ptr auto_ptr ap1=ap2; //将对ap1以前指向的对象执行析构（虽然ap1没有指向对象） 此时将解除右操作数对指针指向的对象的绑定，同时对左操作数原来指向的对象执行析构。（左右操作数都将有影响） auto_ptr赋值时不能直接将一个地址赋给auto_ptr对象 p_auto=new int(1024);//error 而必须调用auto_ptr的reset函数来重新赋值 if(p_auto.get())//判断该指针是否为0 *p_auto=1024; else p_auto.reset(new int(1024)); //可以用0来重置p_auto.reset(0)。调用reset方法可以使多个auto_ptr指针指向同一对象。 自动指针赋值(ap1=ap2;)的过程为:对左边执行析构;左边得到右边的值;对右边执行解除绑定 auto_ptr指针释放对象时使用的是delete而不是deleted[]，所以他不能管理数组。 由于auto_ptr不满足复制和复制操作，所以他不能放置在容器中。auto_ptr作为形参时，必须使用引用。 （相当于auto_ptr在内存中是静止的，不能移动） （8）函数的异常说明 void fun(void) throw (runtime_error，logic_error) {;}//表明该函数只可能抛出一个runtime_error的类及其子类 void fun(void) throw () {;}//表明该函数不会抛出异常 如果函数抛出了其他没有说明的异常，那么系统将会调用unexpected函数，将会异常终止程序。 类继承时，在虚函数中，子类抛出的异常说明必须比基类可能抛出的异常少，且必须是基类异常的一个子集。 （9）函数指针的异常说明 void (*pf)(int) throw(runtime_error); 表明pf只能指向一个只可能抛出runtime_errorauto_ptr类的函数。 2.运行时类型识别(RTTI) c++通过一下2个操作符提供RTTI功能 （1）typeid操作符，返回指针或或引用所指向对象的实际类型。（基类和子类是相等的） （2）dynamic_cast操作符，将基类类型的指针或引用安全的转换为派生类型的指针或引用。 3.c++11的移动语义与右值引用 C++ 11中引入的一个非常重要的概念就是右值引用。理解右值引用是学习“移动语义”（move semantics）的基础。而要理解右值引用，就必须先区分左值与右值。 对左值和右值的一个最常见的误解是：等号左边的就是左值，等号右边的就是右值。【左值和右值都是针对表达式而言的】，左值是指表达式结束后依然存在的持久对象，右值是指表达式结束时就不再存在的临时对象。【一个区分左值与右值的便捷方法是：看能不能对表达式取地址，如果能，则为左值，否则为右值。】下面给出一些例子来进行说明。 移动语义体现在2点： 1. g++ -std=c++11 main.cpp c++11标准使用了赋值的移动语义 object a=foo();即将a与foo()返回的零时对象内存指针交换，然后释放零时变量指向的内存。 2. 定义的&&对零时变量进行引用（右值引用），常作为函数入参。用于获取临时变量中可以复用的内存。 例如： container& operator = (container&& other) //移动赋值 { delete value; //假如value是一个使用new分配的内存指针，此时就可以复用这个内存。 value = other.value; other.value = NULL; return *this; } 转移语义的定义 右值引用是用来支持转移语义的。转移语义可以将资源 ( 堆，系统对象等 ) 从一个对象转移到另一个对象，这样能够减少不必要的临时对象的创建、拷贝以及销毁，能够大幅度提高 C++ 应用程序的性能。临时对象的维护 ( 创建和销毁 ) 对性能有严重影响。 转移语义是和拷贝语义相对的，可以类比文件的剪切与拷贝，当我们将文件从一个目录拷贝到另一个目录时，速度比剪切慢很多。 通过转移语义，临时对象中的资源能够转移其它的对象里。 在现有的 C++ 机制中，我们可以定义拷贝构造函数和赋值函数。要实现转移语义，【需要定义转移构造函数，还可以定义转移赋值操作符】。对于右值的拷贝和赋值会调用转移构造函数和转移赋值操作符。如果转移构造函数和转移拷贝操作符没有定义，那么就遵循现有的机制，拷贝构造函数和赋值操作符会被调用。 普通的函数和操作符也可以利用右值引用操作符实现转移语义。 char* _data; size_t _len; void _init_data(const char *s) { _data = new char[_len+1]; memcpy(_data, s, _len); _data[_len] = '\0'; } MyString(const MyString& str) { _len = str._len; _init_data(str._data); std::cout << "Copy Constructor is called! source: " << str._data << std::endl; } MyString(MyString&& str) { std::cout << "Move Constructor is called! source: " << str._data << std::endl; _len = str._len; _data = str._data; str._len = 0; str._data = NULL; } 和拷贝构造函数类似，有几点需要注意： a. 参数（右值）的符号必须是右值引用符号，即“&&”。 b. 参数（右值）不可以是常量，因为我们需要修改右值。 c. 参数（右值）的资源链接和标记必须修改。否则，右值的析构函数就会释放资源。转移到新对象的资源也就无效了。 转移语义的目的：实现零时对象中申请的资源的复用。 4.c++的成员指针调用成员函数（非virtual函数，实现基类调用子类的函数） 方法1：非静态map存储子类的成员函数，并遍历。原理类似于虚函数（可见：只要基类有子类成员函数的指针就可以调用到子类的成员函数） #include "stdafx.h" #include #include #include using namespace std; class Inr{ public: virtual void display(void){;} }; class Myview :public Inr{ public: typedef void (Myview::*memfun)(void); map public: void Myview::display(void){ map for(;itr!=sav.end();itr++){ (this->*(itr->second))(); } } }; class Childview :public Myview{ public: Childview(){ sav["disview"]=(memfun)disview; } public: void disview(void){ cout<<"this is child view"< } }; int main(int argc, char* argv[]) { Childview Am; Am.display(); return 0; } 方法2：静态数组存储子类的成员函数，并遍历。 #include using namespace std; interface Base1{ public: virtual void ExeFunc(void)=0; }; typedef void (Base1::*Pfunc)(int); typedef struct typefunclink{ Pfunc * PFmen; typefunclink *MemLink; }TypeFuncLink; class Base2: public Base1{ public: Base2(){;}; ~Base2(){;}; static Pfunc Memfunc[]; static TypeFuncLink LkupList; void B2Printf(int); virtual void ExeFunc(void); }; Pfunc Base2::Memfunc[2]={(Pfunc)(&B2Printf),0}; TypeFuncLink Base2::LkupList={Base2::Memfunc,0}; void Base2::B2Printf(int){ cout<<"This Base2 Class Print"< } void Base2::ExeFunc(void) { TypeFuncLink LkLink=Base2::LkupList; while(LkLink.PFmen||LkLink.MemLink) {int i=0; while(LkLink.PFmen[i]) { Pfunc am=LkLink.PFmen[i]; (this->*am)(0); i＋＋; } if(LkLink.MemLink) LkLink=*(LkLink.MemLink); else break; } } class Base3: public Base2{ public: Base3(){;}; ~Base3(){;}; static Pfunc Memfunc[]; static TypeFuncLink LkupList; void B3Printf(int); virtual void ExeFunc(void); }; Pfunc Base3::Memfunc[2]={(Pfunc)(&B3Printf),0}; TypeFuncLink Base3::LkupList={Base3::Memfunc,&Base2::LkupList}; void Base3::B3Printf(int){ cout<<"This Base3 Class Print"< } void Base3::ExeFunc(void) { TypeFuncLink LkLink=Base3::LkupList; while(LkLink.PFmen||LkLink.MemLink) {int i=0; while(LkLink.PFmen[i]) { Pfunc am=LkLink.PFmen[i]; (this->*am)(0); i＋＋; } if(LkLink.MemLink) LkLink=*(LkLink.MemLink); else break; } } void main(void) { Base3 cl; cl.ExeFunc(); system("pause"); } 5.线程中join和detach的作用 无论在windows中，还是Posix中，主线程和子线程的默认关系是：无论子线程执行完毕与否，一旦主线程执行完毕退出，所有子线程执行都会终止。这时整个进程结束或僵死（部分线程保持一种 终止执行但还未销毁的状态，而进程必须在其所有线程销毁后销毁，这时进程处于僵死状态），需要强调的是，线程函数执行完毕退出，或以其他非常方式终止，线程进入终止态，但千万要记住的是，进入终止态后，为线程分配的系统资源并不一定已经释放，而且可能在系统重启之前，一直都不能释放。终止态的线程，仍旧作为一个线程实体存在于操作系统中。（这点在win和unix中是一致的。）而什么时候销毁线程，取决于线程属性。通常，这种终止方式并非我们所期望的结果，而且一个潜在的问题是未执行完就终止的子线程，除了作为线程实体占用系统资源之外，其线程函数所拥有的资源（申请的动态内存，打开的文件，打开的网络端口等）也不一定能释放。所以，针对这个问题，主线程和子线程之间通常定义两种关系： （1）可会合(joinable)。这种关系下，主线程需要明确执行join等待操作。在子线程结束后，主线程的等待操作执行完毕，子线程和主线程会合。这时主线程继续执行等待操作之后的下一步操作。主线程必须会合可会合的子线程，Thread类中，这个操作通过在主线程的线程函数内部调用子线程对象的wait()函数实现。这也就是上面加上三个wait()调用后显示正确的原因。必须强调的是，即使子线程能够在主线程之前执行完毕，进入终止态，也必需显示执行会合操作，否则，系统永远不会主动销毁线程，分配给该线程的系统资源（线程id或句柄，线程管理相关的系统资源）也永远不会释放。 （2）相分离(detached)。顾名思义，这表示子线程无需和主线程会合，也就是相分离的。这种情况下，子线程一旦进入终止态，系统立即销毁线程，回收资源。无需在主线程内调用wait()实现会合。Thread类中，调用detach()使线程进入detached状态。这种方式常用在线程数较多的情况，有时让主线程逐个等待子线程结束，或者让主线程安排每个子线程结束的等待顺序，是很困难或者不可能的。所以在并发子线程较多的情况下，这种方式也会经常使用。缺省情况下，创建的线程都是可会合的。可会合的线程可以通过调用detach()方法变成相分离的线程。但反向则不行。 6.运算符重载 运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，惟一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下： <返回类型说明符> operator <运算符符号>(<参数表>) { <函数体> } 规则： （1）不可重载的5个运算符：类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、三目运算符"?:" 和sizeof运算符 （2）重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符 （3）重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。 （4）... 在进行对象之间的运算时，程序会调用与运算符相对应的函数进行处理，所以运算符重载有两种方式：成员函数重载方式和友元函数重载方式。成员函数的形式比较简单，就是在类里面定义了一个与操作符相关的函数。友元函数因为没有this指针，所以形参会多一个。 class A { public: A(int d):data(d){} A operator+(A&);//成员函数 A operator-(A&); A operator*(A&); A operator/(A&); A operator%(A&); friend A operator+(A&,A&);//友元函数 friend A operator-(A&,A&); friend A operator*(A&,A&); friend A operator/(A&,A&); friend A operator%(A&,A&); bool operator == (const A& ); bool operator != (const A& ); bool operator < (const A& ); bool operator <= (const A& ); bool operator > (const A& ); bool operator >= (const A& ); bool operator || (const A& ); bool operator && (const A& ); bool operator ! (); A& operator + (); //这里的+、-是正负的意思，放在对象前面。 A& operator - (); A* operator & (); A& operator * (); //取对象运算 A& operator ++ ();//前置++ A operator ++ (int);//后置++ ,这个int是没有意义的，仅仅与前置做区分 A& operator --();//前置-- A operator -- (int);//后置-- ，返回不能是“引用”，因为返回的是一个右值对象 A& operator ++ ();//前置++ //++和–根据位置的不同有四种情况，都可以重载。 A operator ++ (int);//后置++ A& operator --();//前置-- A operator -- (int);//后置-- A operator | (const A& ); A operator & (const A& ); A operator ^ (const A& ); A operator << (int i); A operator >> (int i); A operator ~ (); A& operator += (const A& ); A& operator -= (const A& ); A& operator *= (const A& ); A& operator /= (const A& ); A& operator %= (const A& ); A& operator &= (const A& ); A& operator |= (const A& ); A& operator ^= (const A& ); A& operator <<= (int i); A& operator >>= (int i); void *operator new(size_t size); void *operator new(size_t size, int i); void *operator new[](size_t size); void operator delete(void*p); void operator delete(void*p, int i, int j); void operator delete [](void* p); A& operator = (const A& ); char operator [] (int i);//返回值不能作为左值 const char* operator () (); T operator -> (); //类型转换符 operator char* () const; operator int (); operator const char () const; operator short int () const; operator long long () const; friend inline ostream &operator << (ostream&, A&);//输出流 这些只能以友元函数的形式重载 friend inline istream &operator >> (istream&, A&);//输入流 private: int data; }; A& A::operator++( ) //前置 { data++; return *this; } A A::operator++( int ) //后置 { A temp(*this); data++; return temp; } //成员函数的形式 A A::operator+(A &a) { return A(data+a.data); } A A::operator-(A &a) { return A(data-a.data); } A A::operator*(A &a) { return A(data*a.data); } A A::operator/(A &a) { return A(data/a.data); } A A::operator%(A &a) { return A(data%a.data); } //友元函数的形式 A operator+(A &a1,A &a2) { return A(a1.data+a2.data); } A operator-(A &a1,A &a2) { return A(a1.data-a2.data); } A operator*(A &a1,A &a2) { return A(a1.data*a2.data); } A operator/(A &a1,A &a2) { return A(a1.data/a2.data); } A operator%(A &a1,A &a2) { return A(a1.data%a2.data); } 运算符函数的特点： （1）一般都会有返回值 （2）入参一般为尽量使用“引用” （3）尽量返回*this对象，而不要构造一个对象返回 （4）返回值是“引用”的，一般都返回*this对象 （5）第一个操作数是stream的，只能以友元的形式重载 6.c11多线程与异步任务 (1)线程创建 c11的线程创建比任何一种语言都要简单. void foo(int x,int y) { // x = 4, y = 5. } void main() { std::thread t(foo,4,5); //foo可以是匿名函数 t.join(); //t.detach(); } (2)异常简单的mutex和recursive_mutex std::mutex m; //std::recursive_mutex int j = 0; void foo() { m.lock(); // 进入临界区域 j++; m.unlock(); // 离开 } void main() { std::thread t1(foo); std::thread t2(foo); t1.join(); t2.join(); // j = 2; } (3)异常简单的线程本地存储(线程退出时,不改变该变量的值) thread_local int j = 0; void foo() { m.lock(); j++; // j is now 1, no matter the thread. j is local to this thread. m.unlock(); } void main() { j = 0; std::thread t1(foo); std::thread t2(foo); t1.join(); t2.join(); // j still 0. The other "j"s were local to the threads } (4)异常简单的条件变量 std::condition_variable c; // 我们使用mutex而不是recursive_mutex是因为该锁需要一次性获取和释放 std::mutex mu; void foo5() { std::unique_lock lock(mu); c.notify_one(); } void main() { std::unique_lock lock(mu); std::thread t1(foo5); c.wait(lock); t1.join(); } 5.异常简单的future实现异步任务 int GetMyAnswer() { return 10; } int main() { std::future int answer = GetAnAnswer.get(); // answer = 10; // If GetMyAnswer has finished, this call returns immediately. // If not, it waits for the thread to finish. } 你也可以使用 std::promise。该对象可以提供一些 std::future以后需求的特性。如果在任何东西放入承诺（promise）之前你调用 std::future::get(),将会导致等待，直到承诺值（promised value）出现。如果 std::promise::set_exception()被调用， std::future::get()则会抛出异常。如果 std::promise销毁了，而你调用 std::future::get()，你将会产生 broken_promise 异常。 例子: std::promise void foo() { // 在下面的调用之后，future::get()将会返回该值 sex.set_value(1); // After this call, future::get() will return this value. // 调用之后，future::get()将会抛出这个异常 sex.set_exception(std::make_exception_ptr(std::runtime_error("TEST"))); } int main() { future std::thread t(foo); // do stuff try { makesex.get(); hurray(); } catch(...) { // She dumped us :( } } 6.bind绑定成员函数和非成员函数 #include < functional> (1)绑定非成员函数 int Func(int x, int y); auto bf1 = std::bind(Func, 10, std::placeholders::_1); bf1(20); ///< same as Func(10, 20) (2)绑定成员函数(bind成员函数的第一个入参必须是对象本身) class A { public: int Func(int x, int y); }; A a; auto bf2 = std::bind(&A::Func, a, std::placeholders::_1, std::placeholders::_2); bf2(10, 20); ///< same as a.Func(10, 20) std::function< int(int)> bf3 = std::bind(&A::Func, a, std::placeholders::_1, 100); bf3(10); ///< same as a.Func(10, 100) C程序存储分成4段： a.代码段：存储每一个函数包括main函数的二进制代码 b.数据段：分3种 b.a只读数据段：存储只读全局变量和只读局部变量，以及所有常量 b.b.已初始化读写数据段：存储已经初始化的全局变量和局部静态变量 b.c.未初始化读写数据段：运行时才会产生该段，存储未经过初始化的数据，该段不是目标文件的一部分 c.栈：存储程序运行时的函数内部使用的变量、函数的参数以及返回值 d.堆：存储程序运行时malloc分配的空间