所学知识点总结

设计者往往对使用者抱有很多期望，希望使用者遵循一些共同的约束，但是期望总是很难得到满足的，从基础的设计原则上来说，我们不应该对设计者抱有太多的期望，宁愿予以更多的使用约束，即只有固定的路线可走。

如果你觉得某项语法规定不合理，那么请自行模拟它的种种特性，你会发现它是有道理的，只不过有时它可能会产生很多危害性，但是不应该忽略其有益的方面。

1.四种C++风格的类型转换

a. static_cast:

纯粹的内容转换，可能会造成实际内容的损失；

b. dynamic_cast:

只对有虚类型有用，因为虚表的存在才有RTTI；

c. const_cast：

去const化；

d. reinterpret_cast:

让编译器以该转换所注明的类型去看待内存段所表示的类型，一般是针对指针类型，一般来说是不怎么安全的，而且对于函数指针的转换有时是不可移植的，因为不同编译器可能有不同的函数指针表示法（命令方法和存储方法的不同？）；

2.数据类型转换：

a. double=int/int;//做法是错误的，右侧不会提升至double再进行运算的，类型提升的原则是如果不大于整型则会提升至int，但有更大类型则会继续提升，正确写法是：

double=int/(double)int;或者double=(double)int/(double)int;

b. int=usigned char;//错误，正确做法：usigned char->usignedint->int

3.new operator和operator new:

前者是个操作符名称，后者则代表某个函数。

new operator:new操作符仅仅是我们常见的new的名称，它实际代表两段操作：operator new （这是一个我们可以自行重载的函数，作用是分配内存，并返回所分配内存的首地址，换句话说，即使有意进行偏离或者像malloc一样设置一定字节进行特殊用途都是可以的）和调用构造函数。记住编译器看见new操作符时意味着它会先调用new操作函数（operator new()），然后调用构造函数。

上图说明了定位new和定位delete为何是类型对应的关系。

4.对象什么时候具有完整意义：

答案是构造函数完全执行完毕，否则析构函数是不会被调用的。

的确，析构函数里面很可能做了释放内存的操作或者断开连接等关键性只能在一定前提下执行的操作，故而语法上就不支持如果构造函数执行不完整时抛出了异常，然后还能允许去去调用析构函数，很不安全。

5.零散注意点：

a.虚函数不可以内联：内联是一种静态编译行为，虚函数的绑定是发生在动态运行时。

b.对象的初始化列表中仅允许有表达式。

c.

d.

e.带有内部链接的函数可能在程序内被复制（也就是说程序的目标（object）代码可能包含一个以上的内部链接函数的代码），这种复制也包括函数内的静态对象。结果如何？如果建立一个包含局部静态对象的非成员函数，你可能会使程序的静态对象的拷贝超过一个！所以不要建立包含局部静态数据的非成员函数。

f.私有化构造函数（指的是无可外部调用的构造函数）可以阻止继承，由此达成类似final的效果，阻止继承的理由是：派生类的基类部分将无法初始化。

g.void* operator new(delete同样如此)无论前面是否添加static字样，均会被编译器认为是静态函数。

h.拒绝将临时对象绑定为非const的引用；

i.STL库中的工具适合使用(*). 而不是–>，具体原因似乎是因为STL的具体实现约束的；

j.

k.auto_ptr不应该持有一个数组指针，因为它的析构函数中调用的是delete，而不是delete[]。

l.数组长度为0：这并不是C/C++标准所支持的，GNU的编译器是完全支持，VS系列则不一定，其应用价值在于本身不占用内存，而且可以伴随其他需要一次申请和一次释放，与指针方式相比，不需要另外处理，举例：

struct st{int a；char b[0];}

st*m=(st*)malloc(sizeof(int)+10);这时我们可以使用b[0]至b[9]（理论本质是有地址，有类型，我们就可以按照类型去访问内存，除非系统本身会阻止。。。）。释放时也仅需要对m进行一次释放就可以了。

至于new int[0];是不报错的，会返回一个地址，但是不应该利用这个地址去访问内存，因为并没有实际分配内存（强行访问，未必报错，因为数组越界本身不会报错，真的报错的话，可能是其他原因导致的）。

6.为什么说异常不应该逃出析构函数？

析构函数的调用原因有可能是因为其他地方发生了异常，比如某处发生异常，会导致该处前面位置上的所有局部对象被析构，如果析构函数的里面也传出了异常，则terminate函数将被自动调用，程序直接被终结，这是不合适的，因为局部变量也许没有全部被销毁，也许析构函数的工作很重要，但是还未执行完成：

比如连接的释放工作就应该执行，不然可能会导致对方盲等待，又如数据库事务，应该具有完整性，可能因此而丧失完整性了。

7.异常机制细节汇总：

异常和函数调用的不同之处：

异常捕捉的参数永远都是原对象的副本，指针方式则是指针的副本，并且指针所指对象应该位于堆中，而函数调用的引用方式则不一样，直接与原对象绑定，异常捕捉的引用方式则是绑定至一个临时对象身上；

异常的捕捉处理是逆着调用链而上，不会回到异常抛出处，但是函数调用不一样，调用完成后会回到调用处；

异常的捕捉处理块是最先适配原则，即前面的catch优先捕捉，尽管它后面的catch可能更适合去捕捉，但是前面的catch语句只要类型能适用，如派生类可转基类，则后面的哪怕有派生类的catch也不会执行；

异常的再次抛出，

左边的继续抛出传入的临时对象（比如widget的派生类对象），右边则是截断后的对象的副本。如果需要传出对异常对象的修改信息，那么catch语句中的传入方式应当是引用。catch语句的类型匹配原则：派生类对象可以被基类捕捉（包括对象、引用、指针等），但是诸如int->double则是不支持的，即不支持大多数常见的类型转换。

以值方式传递异常的二次拷贝(catch参数方式为传值方式)：

第一次发生于抛出异常时throw语句会导致一次拷贝的发生，传入下一个catch语句的参数时的会发生第二次。

：请参见more effective c++P69

异常规格说明：

所谓的异常规格说明就是指使用语法限制可抛出的异常类型集合。语法形式如上图。

把Unexpected异常要么显示转换成一个指定名称的异常，要么直接提供函数转接抛出（转接抛出会变成bad_exception，估计是编译器或者说是标准规定的吧，set_unexpected(convertUnexpected);这个函数是替换编译器默认的Unexpected异常抛出函数，

编译器会有一个自带的异常抛出函数版本）。

8.虚拟构造函数和虚拟拷贝构造函数：

这个两个名词并不是说构造函数和拷贝构造函数就是虚函数，实际上构造函数和拷贝构造函数也不会是虚函数的，虚函数是取适宜层，而构造函数和拷贝构造函数是自上而下的调用。虚拟的含义接近于模拟，手段是用虚函数的特性设计一个成员函数实现构造函数和拷贝构造函数的功能（实际上虚拟函数内部调用的就是构造函数和拷贝构造函数）。函数重载不限制返回类型的原因之一大概就是为了确保能够虚拟构造函数和虚拟拷贝构造函数这样的效果吧。返回类型的一种多态的确很有用，基类返回基类类型指针或引用，派生类返回派生类类型的，可以实现出多态的效果。

9.operator <<操作符的重载技巧：

该操作符在类内进行重载，但是调用形式会变成it<

10.全局对象的初始化顺序无法保证：

一般建议全局对象放入一个函数（可以是每个对象各放一个函数）中，因为函数调用的时机是我们去掌控的。

11.以计数方式控制对象个数的方法可能的误区：

基类的派生类构造对象时，初始基类部分可能会报错，因为基类部分会同样纳入基类类型对象的计数数量。

对特定类的对象数量计数难点之一在于其派生类，派生类的使用者期望派生类对象的计数和基类对象的计数是独立的，然而实际上很难。。。

12.必须堆中生成对象和不允许堆中生成对象:

前者：（异常体系中的私有析构函数就不能自动调用，实际上我们的前提就是不希望类对象分配于堆上，可以用其他类封装所述的类，在封装类的析构函数中调用所述类的伪造析构函数。私有化析构函数会阻止继承和包容---即成为某个类的数据成员。为了避免继承的缺陷，可以将私有化方式变成保护方式，为了避免不能包容的缺陷，可以使用指针和伪造析构函数的方式。具体参见effective c++ P130）

创建是可以的，但是析构是不可以的，示例如下：

后者：把operator new()重载为私有成员函数，因为new操作符会调用该函数，私有后就无法调用，从而阻断堆内分配。

13. operator new[]:

只分配一次内存，即分配函数只调用一次，但是对象的构造函数却会调用n次。

14.dynamic_cast技巧性用法：

15.同类型对象拥有完全的成员访问权限：

即不受成员自身的访问权限限制，理由如拷贝构造函数，如果存在限制，那么拷贝构造函数的内部会显得很奇怪，而且有时甚至是无法进行某些成员的拷贝的，因为专门用于返回数据成员值的public成员函数等于降低了了数据成员的访问权限限制，而且如果提供所有数据成员的读取函数，则会存在过度设计的问题，也许这就是为什么同类型对象之间，成员访问互通的原因吧。

16.灵巧指针—智能指针:

operator ->()(编译器会对operator ->()重载后的返回类型的基础上再次调用一个operator->()，当然这个时候调用的函数和之前那个operator->()很有可能不是同一个了。)

但是缺陷是：

部分程度上的解决方案是：

依旧不能应对if(op==0)

根据书中的种种分析，提供智能指针到一般指针的隐式转换很有风险，具体详见effective c++P145。

17.构造函数不可以是虚函数，拷贝构造函数也不可以。

定义了拷贝构造函数，如果需要的话，也应该定义一个默认构造函数，即拷贝构造函数就是构造函数的一种，只是参数不同。有所不同的是：构造函数自上而下执行的，拷贝构造函数是单纯的一级而定，即拷贝构造函数不会由编译器去主动调用基类部分的拷贝构造函数。一种很奇特的用法：new T(t);t也是一个T类型的对象，即new后面跟着的是拷贝构造函数。嗯，可以当成调用带参数的构造函数嘛。

18.指针行为和对象行为：

指针自己是个对象，但是由于指向另一块内存，指针自身和所指向的地方并不自动具有一致性行为：同步创建、拷贝、析构（销毁）等；对象则是一个完整的整体，各项行为具有完整的一致性。因此，为了便利地实现行为一致性时，会考虑智能指针（灵巧指针），智能指针就是个独立的对象。

19. 文件范围内的static被无名的命名空间取代：

文件范围是指作用域仅局限于某个文件内，不会在链接阶段在其他文件处可见。匿名空间则因为无名，所以不能被其他文件使用。

20.纯虚析构函数：

绝大部分纯虚函数都没有实现，但纯虚析构函数是个特例。它们必须被实现，因为它们在派生类析构函数被调用时也将被调用。

21.C/C++程序如何兼容：

22.c++无类型参数模板(non-type template parameter)：

https://www.360docs.net/doc/104161707.html,/xiexievv/article/details/8487132

22.STL中的包容器有bitset、vector、list、deque、queue、priority-queue、stack、set和map

23.旧式的using指示用法：

不写using，直接类名::指示名这样的用法。

24.cin和cout:

25.编译期检查：

注意：

1.sizeof(函数调用)实际不需要生成这个函数调用实体，而是直接针对函数的返回类型进行

求值sizeof；

2.第二个版本Test函数使用的是可变参数方式。

26.关联容器的键值不应该被直接改变（主要是指不能改变其在理论上应该具备的相对位置）：

9999999会导致12和144的查找失败。

换而言之，改变键值并不会触发重新排序，插入操作则可以。无论是map还是set，修改键值对象的部分属性是合理的行为，但是修改不能改变理论上的相对位置。

27.STL之算法的参数对象构造次数：

#include

#include

#include

usingnamespace std;

class test {

public:

test() {

cout<<"construct..."<

}

bool operator()(int i) {

cout<<"dddd"<

if (5==i)

{

returntrue;

}

returnfalse;

}

};

void main()

{

vectorstore_set;

store_set.push_back(1);

store_set.push_back(2);

store_set.push_back(5);

find_if(store_set.begin(), store_set.end(), test());

system("pause");

}

很显然仿函数对象仅构造一次，理解：find_if的参数传参后就进入了其函数体了，故而只会构造一次；其前面2个参数也是函数体里面的循环条件。

27.异常不能从构造函数逸出的理解：

function try block：用于捕捉参数列表中抛出的异常（基类初始化过程中抛出的异常和本类数据成员初始化过程中抛出的异常）和函数体中抛出的异常（实际函数体中的异常应该在函数体内进行处理，因为函数体内的临时对象名在外部不可见），catch块至多进行一定的异常转化，然后必须再次抛出一种异常（如果没有显示抛出，会按照默认方式抛出原异常），即不存在吸收异常的情况。

示例：

#include

#include

usingnamespace std;

class B {};

class A :public B{

public:

A() try {}

catch (exception e) { delete i; }

int *i=new int();

void fun()try {}

catch (exception f) {}

};

void main()

{

system("pause");

}

构造函数体里面的try block：这种方式不应该让异常逃出构造函数体，考虑的是可以确认异常和名字的作用域；

此外，异常的确不应该逃出析构函数，若不然，可以想象多个临时对象的自动析构时，前面的析构异常了，后面的临时对象则无法析构。。。

28.纯虚函数提供默认实现的四个理由：

具体参见more exception P180；

虚析构函数、不会默默使用基类的虚函数实现、作为基础操作存在、避免无意中调用了纯虚函数（在默认实现中加入cout类似效果的语句）。

29.模板化的构造函数绝对不是拷贝构造函数，对于赋值运算符同样如此：

一个是U(const&U)，一个是U(const&U)。

我们如果有自定义的需要，就应该主动自定义，去避免由编译器自动合成这2个函数。

类的各个成员函数真实名字应该是：模板名+函数名，然后根据C++名字转换规则再转换，故而模板化的成员函数并不是类自己一般意义上的那些可以自动合成的成员函数，更像是一个定义在类内的一般函数，虽然也的确算成员函数的身份。