Effective_C++读书笔记
学习知识只写在本子上也不方便记忆，这里做份记录方便后续查看
- 视C++为一个语言联邦
C++ 支持多语言范式:
- procedural，过程式
- object-oriented 面向对象式
- functional 函数式
- generic 范形式
- metaprogramming 元编程
- 使用const ，enum，inline 代替#define
#define是一个容易检查的预处理指令，将更多的工作交给编译器而不是预处理骑
对于单纯的常量使用是const 和 enum更合适
对于内联函数使用inline更合适，在其他 情况才使用MACROS
- 更多的使用const
- 对于参数仅仅const不同其实也是重载的，
- const能接受 non-const 和const 如果成员方法是logical contenes，可以使用mutable 也去掉 const对编译器加上的 bitwess contess
- 当const 和non const方法内容一样时 可以使用 non-const调用const方法 ，内部使用 static_caste<> 转换加上const，然后使用 const_caste<>去掉const
-
确定对象先出初始化再使用
- 为内置数据类型手动初始化
- 使用成员初始化列表初始化 ，而不是赋值，提升效率
- 如果有不同的static有初始化顺序依赖关系。使用local-static代替 全局 static对象
-
了解C++默默编写并调用了那些函数
- 默认构造函数
- 拷贝构造函数
- 析构函数(系统默认生成的是非virtual 除非有base声明为virtual)
- 拷贝赋值运算符
- 移动构造函数 (c11新增)
- 移动赋值运算符 (c11新增)
如果类里面有引用或者const成员 系统是不会生成 copy = 和 移动=函数的
有动态内存管理的类需要自己实现方法 避免内存泄漏或者重复释放内存导致问题
- 如果不想使用编译器自动生成的函数，就拒绝它
- 在类的private声明一个 拷贝构造函数和赋值运算符(只有声明) ，其他调用就会编译出错，但是友元和其他成员调用没事 ，但是会产生链接错误， 引入第二种方法。
- 建立一个base类 将 拷贝构造函数和赋值运算符(只有声明)声明为私有，然后当前类私有继承自 base即可
- 为多态基类声明virtual析构函数
- 当作基类的 如果有一个virtual成员函数 一般就有一个Virtual析构函数
- 动态内存管理的也适合有个virtual析构函数(系统的std::string 的析构函数不是 virtual 所以集成的话如果有多态体现就会有内存泄漏的风险 STL很多这样，)
- 不适合做基类的不要实现virtual 析构函数，因为有了虚函数表 效率会降低
- 需要抽象类的时候 一般声明析构函数为纯虚函数是最好的 ，你还必须给析构函数提供
定义不定义在有子类的时候链接会出错
- 别让异常逃离析构函数(析构函数不要
抛出异常)假设 vector
ts (10,0) 10个元素有一个有异常 后续了能造成内存泄漏
- 析构函数绝对不能抛出异常 如果有这样的需求 比如数据库链接对象 在析构时要关闭链接 可能抛出异常 可以使用两种方案
- 使用try{} catch (...){ std::abort(); }
- 使用try{} catch (...){ someLog()); }
- 如果用户需要对异常作出反应，可以重新设计一个对外可以暴露的方法让用户去操作 如 public clos()
- 绝对不要在构造函数和析构函数中调用virtual函数
java系列不同，请注意
因为在继承构造顺序中，假设你在构造函数中调用virtual函数，其实这时候子类还没有实例化，virtual调用的还是非virtual 的，这时候即使使用了dynamic_cast 拿到的也是父类， 在析构函数调用virtual，子类已经被释放。还有的时候非常难意识到你调用virtual函数，如多个构造函数调用了某个抽取出来的方法，但是这个方法里面调用了virtual函数，这也是有问题的，而且难以debug
如何解决，建议一种方案 ，比如 在构造函数调用的virtual函数 更改为non-virtual，并指定参数，用子类在构造函数初始化时传递。
class Transcation {
public :
explicit Transcation(const std::string & info) {
// .....
log(info);
}
void logT(const std::string & info) { // non-virtual
// do something
}
}
class SubT : public Trancastion {
public :
explicit SubT(XX,const std::string &info) : someInstanceVar(XX), Transcation(info) {}
}
- 在赋值运算符中返回一个 refresence to *this
如何实现 连锁赋值，
class T { T & operator=(const T & t) { ... return *this;
} }
- - - - ---
11. 在operator= 处理 “自我赋值”
> 假设在赋值运算符中 *this 和 传递进来的对象执行的是同一个对象时，可能会出现问题，比如 delete old， new Type(param) , param 可能是old 这时候会出问题。
通常做法是
```cpp
T& operator= (const T & t ) {
if t == *this { return *this}
delete this->xxval
this-> xxxval = new XXXVal(xxval)
return *this
}
这个代码在有异常的时候也算有问题的 因为在new的时候发生异常可能导致后续的return 失败 *this执行了一个被释放的内存
新的实现
T & operator=(const T &t) {
XXXval * xxxvalOriginal = this-> xxxVal // 保留原本的xxxval
this->xxxVal = new XXXVal(t.xxxval); // new copy 如果失败了 也不影响
delete xxxValOriginal; // delete old
return *this;
}或者使用新的 copy swap技术
class Widget {
void swap(widget &rhs); {交换*this 和rhs 详情参见条款29 }
Widget & operator=(const Widget rhs){ // by Reference
Widget temp(rhs) // copy cons
swap(temp);
return *this)
}
或者可以重写 接受参数为值传递的赋值运算符
Widget & operator=(Widget rhs){ // by value
// 已经copy过了
swap(rhs
);
return *this)
}
}总结: 要注意异常性安全 ，通常会解决自我赋值安全。
-
复制对象时不要忘记每一个成员
copy constructor 和 copy assignmaent成为copying函数，
-
新增了成员变量，要修改所有的构造函数，拷贝构造函数，赋值运算符，赋值运算符变种+=
-
如果是继承的有基类，需要在拷贝构造函数的成员初始化列表调用父类的拷贝构造函数()，如果不写调用默认的构造函数，(不是没有调用)， 在赋值运算符 手动调用一次 基类的赋值运算符
BASECLASS::operator=(rhs) -
以对象管理资源
在使用工厂方法创建对象时一般会返回一个指针， 这就依赖调用者再使用完毕后delete这个指针， 但是使用的函数如果出现 early return 或者 异常等会导致delete语句无法调用， 所以我们可以使用只能指针来管理 auto_ptr
这个指针在自己释放后会调用包含数据的析构函数
auto_ptr指针是单一只能指针，在出现copy 赋值或者copy构造函数时旧的指针会清空为null 避免重复释放内存，但是这个指针在使用时会有其他复制多次出现的问题，而且无法支持stl容易， 更好的办法是使用引用计数指针 ，share_ptr,而且能用在stl容器中
但是但是 这些智能指针都不使用 delete []，使用的是delete版本class Investement {} Investement *factory(); void caller() { Investement *ptr = factor() // xxxxx 假设这里出现return throw 可能就会有问题 delete ptr; } void caller1() { std::auto_ptr<Investement> ptr = factor()
}
void caller2() {
// 1 较好的办法
std::shared_ptr
}
std::shared_prt
14. 在资源管理时小心copying行为
> 1 禁止复制
> 使用引用技术式的只能指针，注意可以使用 std::tr1::share_ptr，因为在某些时刻我们可能是在引用计数为0时做个额外操作，而不是析构这个对象、
15. 在资源管理类中提供对原始资源的访问
> 有时候我们使用了智能指针，但是在某些API的调用他们需要的是原始指针，那么我们可以通过shard_ptr.get()返回原始指针。
> 这就引出了一个问题
> 1 提供get方法转换
> 2 实现一个隐式转换 operartor TOClass() const;但是这种可能带来隐藏问题的方式需要提供斟酌考虑是否采用
16. 成对使用new和delete时要采取匹配的形式
> new 和 delete ，new []和delete[] 配合
17. 用独立的语句来将指针放进智能指针中
> 举个例子
>void process(std::tr1::shared_prt<Widget>,int priority)
> 在调用时你可能这样
>
> process(std::tr1::shared_prt<Widget>(new Widget),XXXprority())
> 系统给你出现的顺序可能是
> 1. new Widget
> 2. call XXXprority()
> 3. std::tr1::shared_ptr的构造函数
but 这时候 2 的函数调用出现了异常， 就会出现内存泄漏 ，因此更合适的办法应该是这样
```cpp
void process(std::tr1::shared_prt<Widget>,int priority){}
// 不实用匿名指针
std::tr1::shared_ptr<Widget> w1(new Widget);
process(w1,XXpriority());
- 让接口容易被正确使用
- 促进正确使用的办法包括接口的一致性，以及与内置类型的行为兼容
- 组织误用的方法包括简历新的类型，限制类型上的操作。束缚对象值，以及消除客户的资源管理在责任
- shared_ptr支持定制删除器(custom deleter),这可防范DLL问题，可被用来自动解除互斥锁。
-
设计class犹如设计type
- 新的对象如何被创建和销毁 (构造函数和析构函数，自定义new运算符)
- 对象的初始化和对象的赋值的差别(赋值和拷贝构造函数)
- 新的对象如果被passwd By Value传递如何书写
- 新的对象的合法值(需要约束数据是否合理)
- 新的type的继承体系 比如析构函数
- 新的Type和其他类型的转换
- 什么杨的函数和操作符是合理的
- 访问控制符
- 是否应该抽象与类型 类型模板
-
宁以pass-By-ference-to-const 替换pass-by-Value
copy value的代价非常昂贵 一般可以使用reference代替 ，为了避免别人修改 可以指定const
还可以避免对象分割， 假设一个函数接受的是父类对象 那么传递一个子类的话经过 copy，子类信息会丢失 。没有多态性体现class Window{} class DebugWidow: public Widow{} void dosomething(Window w) {} // pass By Value // doSomethng(DebugWindow()) 改写为const reference void dosomething(const Window & w)系统内置类型和stl一般建议使用 pass by value
-
必须返回对象时，别妄想返回去reference
绝不要返回一个指向localStack对象的指针引用，也不要返回heap-Allocated的指针或者引用，这种时候 直接返回对象就好了 copy by value 也无所谓
-
将成员变量声明为private
封装的思想不再赘述
-
宁以non-member。non-friend替换member函数
封装指的是封装数据。越多的函数可以访问数据，封装性就越低。
外部的函数做的事情够用就好，没必要声明为成员函数，因为成员函数可以访问所有数据
在组织代码结构时可以将class和 对class操作的函数放在同一个命名空间，但是不放在同一个文件中，这样在需要的时候才需导入头文件。 -
若所有参数皆需类型转换，请为此采用non-member函数
如果你需要为某个函数的所有参数(包括 被this指针所值的那个隐喻参数)进行类型转换，那么这个函数必须是个non-member函数
class Rational { // 如果是成员运算符 Rational(int numerator = 0, int denominator = 1); //这里没有explicit const Rational operator*(const Ration &rhs) const; 调用Rational oneEight(1,8) Rational OneHalf(1,2) Ration result = oneEight * 2//成功 ， 因为当前相当于 oneEight.operator*(Ration(2)) 2位于已有对象的参数列表里 Ration result = 2 * oneEight// 这里失败 因为2没有成员函数调用，也没有全局函数可供调用，隐式转换必须位于已有对象 这里没有已有对象 所以不能转换将2转换为Rational对象
}
改写为non-member函数
const ration operator*(const Rational &lhs, const Rational &rhs){}
这时候调用皆能通过
25. 考虑写出一个不抛出异常的swap函数
如果std::swap效率不够或者是不满足使用条件可以考虑以下几种事情。
1. 提供一个public swap成员函数，让它搞笑的置换你的类型的2个对象值，(必须不能抛出异常)
2. 在你的class 或者 class template所在的命名空间内提供一个non-member swap并令他调用上述swap成员函数。
3. 如果你编写的是一个class 而不是class Template 为你的class具体化一个std::swap并令它调用你的swap函数。
4. 客户如果调用swap函数 请使用using::std::swap 然后直接调用swap函数 ，系统会为你寻找最合适的swap函数