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

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

引言

最近在阅读这本《effective C++ 改善程序与设计的55个具体做法》这本书，为了以后忘记的时候回顾，写一些笔记，每次笔记大概记录一个章节的内容。

条款1.视C++为一个语言联邦

C++最早只是C语言的扩充，在C基础上加上了面向对象特性，但是发展了很多年后，变的庞大了很多。

现在的C++是一个多重范式编程语言，支持面向过程，面向对象，函数形式，泛型形式，元编程形式。

至少记住这四项，C，object-orented-C++，template-C++，STL，分别是C语言，面向对象的C++，C++模板，STL库（template程序库）。

条款2.尽量以enum，const，inline替换掉define

宁可以编译器替换掉预处理器

情况1

#define ASPECT_RATIO 1.653

这个记号名称可能会在编译器处理源码前被预处理器移动走了，没有进入记号表内(symbol table),于是你运行这个常量就会获得一个编译错误信息而浪费时间。

解决方法

const double AspectRatio = 1.653

const肯定会被编译器看到，当然会进入记号表内，防止编译问题。

情况2

你想创建一个class专属常量

class cl{
private:
static const int NumTurns=5; //常量的声明式
int arr[NumTurns];
}

c++要求对你所使用的都提供一个定义式，但上面的class专属常量并且static就可以例外。如果你想要获取常量的内存地址，或者有一些编译器坚持需要定义式，你需要提供定义式如下：

const int cl::NumTurns; //NumTurns的定义

如果你不想让你class专属常量内存地址被访问，你可以用enum类型去替代

class cl{
private:
enum {NumTurns=5}; //让NumTurns成为5的一个记号名称
int arr[NumTurns];
}

情况3

define创建的宏函数

template<class T>
T f(T x)
{
return x;
}
#define CALL_WITH_MAX(a,b) f((a)>(b) ? (a) : (b))

上面的宏函数作用是比较两个数大小，并且返回大的数字，但是这个宏函数很容易产生意外。

int a=5,b=0;
std::cout<<a<<" "<<b<<std::endl;   //5  0
CALL_WITH_MAX(++a,b);
std::cout<<a<<" "<<b<<std::endl;   //7  0
CALL_WITH_MAX(++a,b+20);
std::cout<<a<<" "<<b<<std::endl;   //8  0

上面的a在和比较的时候自增了两次，为了避免这种bug，我们换成inline模板函数来代替它

template<class T>
T f(T x)
{
return x;
}
template<typename T>
inline void callWithMax(const T& a,const T& b)
{
	f(a>b ? a : b);
}

int a=5,b=0;
std::cout<<a<<" "<<b<<std::endl;   //5  0
CALL_WITH_MAX(++a,b);
std::cout<<a<<" "<<b<<std::endl;   //6  0
CALL_WITH_MAX(++a,b+20);
std::cout<<a<<" "<<b<<std::endl;   //7  0

对于单纯常量，最好以const对象或者enums代替#defines

对于形似函数的宏，最好改用inline函数代替#defines

条款3.尽可能使用const

const允许你使用语义约束，告诉编译器这个值保持不变。

情景1

char str[] = "hello";
char *p = str; //不是const指针，也不是const数据
const char *p = str; //不是const指针，是const数据
char const *p=str;  //是const指针，不是const数据
const char const *p=str; //是const指针，是const数据

const的规则，const在左边，代表了指针指向的数据是const，const在右边，代表了指针本身是const。

情景2

class cl{
public:
...//省略构造函数析构函数
char& operator[](std::size_t position)const   //代表const成员函数
{
return pText[position];
}
...
private:
  char *pText;
};

上面的const成员函数看似没有修改class内部成员，其实已经发生了泄漏。

const cl class_cl("hello");
char *cp=&class_cl[0];
cp='J';   //这里修改了const的数据内容

所以请记得给上面的const成员函数加上const，并且记住const成员函数承诺任何时候都不修改其对象的逻辑状态。

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

读取未初始化的值可能导致不明确的行为，甚至在一些平台上会导致你的程序终止。

弄清楚赋值和初始化的区别:

int x=0; //初始化
x=1; //赋值

在class的构造函数中，初始化和赋值容易搞混淆

class cl{
...
  cl(int &data):num(data){}  //初始化成员变量
  cl(int *p)
  {
  num=*p;//这里num先被默认初始化一个值，然后被赋值*p
  }
...
private:
int num;
}

使用初始化列表比赋值的效率会更高,只调用了一次构造函数，而不是先调用默认构造函数再赋值。

请以local static对象代替 non-local static对象

在C++中，local static对象和non-local static对象的主要区别在于它们的生存期和作用域。

Local static对象是指在函数内部声明并使用static关键字修饰的变量或对象。它们在函数第一次被调用时创建，并一直存在于函数的整个生命周期内，直到函数结束时才被销毁。Local static对象的作用域仅限于其所在的函数，不能在其他函数中访问。

Non-local static对象是指在函数外部声明并使用static关键字修饰的变量或对象。它们在程序启动时创建，并一直存在于程序的整个生命周期内，直到程序结束时才被销毁。Non-local static对象的作用域是全局的，可以在任何函数中访问。

以local static对象代替non-local static对象意味着将non-local static对象改为在函数内部声明并使用static关键字修饰。这样做有以下几个优点：

提高代码的局部性：Local static对象的作用域仅限于其所在的函数，可以提高代码的局部性，使代码更容易理解和维护。

减少内存占用：Non-local static对象在程序的整个生命周期内都存在，即使在不再使用时也无法释放内存。而local static对象在函数结束后就会被销毁，可以减少内存占用。

提高安全性：Non-local static对象可以在任何函数中访问，这可能会导致意外修改或污染。而local static对象只能在函数内部访问，可以提高安全性。

当然，以local static对象代替non-local static对象也有一些缺点：增加了代码的复杂度 ,降低了代码的效率。

// Non-local static object
static int global_count = 0;

void foo() {
  global_count++;
  // ...
}

// Local static object
void bar() {
  static int local_count = 0;
  local_count++;
  // ...
}

在这个例子中，global_count是一个non-local static对象，在任何函数中都可以访问。而local_count是一个local static对象，只能在bar()函数中访问。

在foo()函数中，每次调用都会增加global_count的值。而在bar()函数中，每次调用只会增加local_count的值。

如果foo()函数被频繁调用，那么global_count的值会迅速增长，可能会导致内存占用过高。而bar()函数的local_count值只会在一个函数内累加，不会影响其他函数。