Effective c++ 第一章 让自己习惯C++

条款 01：c++是一个语言联邦而不是一种单一的语言，

　　它包括：

　　　　1、C语言：没有模版、没有异常、没有重载……

　　　　2、Object-Oriented C++：class、析构函数、构造函数、封装、继承、多态、虚函数、动态绑定……

　　　　3、Template c++：唯template适用

　　　　4、STL：容器、迭代器、算法以及函数对象

　　总结：而我现在会了一点点C语言，懂了点面向对象，刚看Template c++和STL，得继续努力！

条款 02：尽量以const、enum、inline替换#define

　　总结：#define只是简单的替换，在写程序的过程中，由于简单的替换会产生许多意想不到的错误，例如：

　　　　　　#define CALL_WITH_MAX(a,b) f((a) > (b) ? (a) : (b))

　　　　　　int a = 5,b = 0;

　　　　　　CALL_WITH(++a,b);　　//a被累加两次

　　　　　　CALL_WITH(++a,b + 10);//a被累加一次

　　　　　而用const则完全不会出现以上错误，在C++中const完全替换#define

条款 03：尽可能使用const

　　总结：这里有两点需要注意

　　　　　1、指针常量和常量指针的判断

　　　　　　　在这之前常常分不清到底是指针本身是常量还是指针指向的内容为常量，这里有一个判断的好方法：

　　　　   　　如果关键字const出现在信号左边，表示被指物是常量；如果出现在星号右边，表示指针自身是常量；如果出现在星号的两边，表示被指物和指针两者都是常量。

　　　　　　　char greeting[] = "Hello";

　　　　　　　char*p = greeting;　　　　　　　　 //都不是常量

　　　　   　　char * const p = greeting; 　　　　//指针本身是常量，指向内容非常量

　　　　  　　 const char * p = greeting; 　　　　//指针本身非常量，指向内容是常量

　　　　　　　const char * const p = greeting;   //指针和指向内容都是常量

　　　　  2、const成员函数

　　　　　　   a、两个成员函数如果只是常量性不同，可以被重载，这是C++的一个重要特性；

　　　　　　　　 class TextBlock {

　　　　　　　　 public :

　　　　　　　　　　　const char & operator[] (std::size_t position) const {return test[position];}　　//operator[] for const对象

　　　　　　　　　　　char & operator[] (std::size_t position) {return test[position];}　　　　　　　　 //operator[] for non-const对象

　　　　　　　　private：

　　　　　　　　　　std::string text;

　　　　　　　　};

　　　　　　　　TextBlock tb("Hello"); 　　　　std::cout << tb[0];　　//调用non-const TextBlock::operator[]

　　　　　　　　const TextBlock ctb("Hello"); 　　　　std::cout << ctb[0];　　//调用const TextBlock::operator[]

　　　　　　　　const对象调用const函数，non-const对象调用non-const函数，这是很合理的安排，一个const对象里的成员变量肯定不能被改变，所以调用const函数(他们不会改变成员变量)。如果const函数返回的是对象的成员变量的引用时，const成员函数的返回值也要用const修饰，否则该函数还是有可能对成员变量进行赋值：

　　　　　　　　例如上面的const char & operator[] (std::size_t position) const {return test[position];}去掉前面的const，那么ctb[0] = 'x'这样的赋值操作是可以通过编译的，但是实际上它是不合理的(ctb是const对象呀).

　　　　　　　   但是，还有一种情况，如果const对象调用const函数想改变对象的成员函数那该怎么办？很简单，将该要被改变的成员变量修饰为：mutable！

　　　　　　b、在const 和 non-const成员中避免重复

　　　　　　　 如果为了供const和非non-const分别调用而设置const和no-const成员函数，使得他们代码一模一样，只是那该怎么办？

　　　　　　　 为了避免代码重复，您可以这样做：

　　　　　　　　class TextBlock {

　　　　　　　　　　　const char & operator[] (std::size_t position) const

　　　　　　　　　　　{

　　　　　　　　　　　　　　...　　　　　　　　//这里有很多代码。

　　　　　　　　　　　　　　return text[postion];

　　　　　　　　　　　}

　　　　　　　　　　  char & operator[] (std::size_t position)

　　　　　　　　　　  {

　　　　　　　　　　　　　　return const_cast<char &>(static_cast<const TextBlock &>(*this)[postion]);

　　　　　　　　　　　　　　//如果不熟悉C++的强制转换，请参考http://www.cnblogs.com/alexqdh/archive/2011/06/09/2075713.html

　　　　　　　　　　　}

　　　　　　　　};

条款 04 确定对象使用前已经被初始化

　　总结：在了解这个条款之前，希望大家已经区别了初始化和第一次赋值的区别，咱们举个例子看看

　　　　　class A {

　　　　　public:

　　　　　　　　A(int a,int b,intc):ma(a),mb(b),mc(c)　　//是初始化（列表）

　　　　　　　　{}　　　　　　　　　　　　　　　　　　　//空操作

　　　　　　　　A(int a,int b)

　　　　　　　　{

　　　　　　　　　　ma1 = a ;　　　　　　　　　　　　　//这不是初始化

　　　　　　　　　　mb1 = b;　　　　　　　　　　　　　//这是赋值

　　　　　　　　}

　　　　　private:

　　　　　　　int ma,mb,mc;

　　　　　　　int ma1,mb1;

　　　　　};

　　　　就是因为有了初始化和第一次赋值的区别，所以类中要同时定义 copy构造函数和 =运算符重载！

　　　　　　　　　

转载于:https://www.cnblogs.com/zhuwbox/p/3364481.html