Effective C++ 改善程序与设计的55个具体做法笔记与心得 1

一. 让自己习惯C++

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

2. 尽量以const, enum, inline替换#define


#define CALL_WITH_MAX(a,b) f((a) > (b) ? (a) : (b))int a = 5 , b = 0;CALL_WITH_MAX(++a,b); // a = 6, b = 0 CALL_WITH_MAX(++a,b+10); // a = 8, b = 0

你观察到的这个现象是由于宏替换(C preprocessor macro substitution)的工作方式引起的。

当你写CALL_WITH_MAX(++a,b)时，预处理器将整个CALL_WITH_MAX(++a,b)表达式替换为f((++a) > (b) ? (++a) : (b))。你可以看到，这里++a出现了两次。这意味着a的值实际上被增加了两次。

对于CALL_WITH_MAX(++a,b+10)，在宏展开后的结果是f((++a) > (b+10) ? (++a) : (b+10))。在这种情况下，只有当++a小于b+10时，++a才会被调用第二次。由于++a（即6）大于b+10（即0+10），所以++a只会被调用一次。

这就是导致你观察到的现象的原因。为了防止这类问题的出现，尽量不要在宏的参数中使用有副作用（比如修改变量值）的表达式。


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

这里你看到的是C++中的模板函数。模板函数允许我们为多种数据类型编写同一套代码。换句话说，它们允许我们实现所谓的"泛型编程"。

在你给出的函数callWithMax中，它接收两个参数a和b，并调用函数f，传入的参数是a和b中的较大值。这里的T是一个模板参数，它表示一个类型。这意味着你可以使用任何类型的数据来调用callWithMax，只要这个类型支持>运算符和可以作为f的参数。

例如，如果有一个函数f接收一个int参数，你可以这样使用这个模板函数：

int a = 5, b = 10;
callWithMax(a, b);  // 这里f(10)将被调用

同样，如果f接收一个double参数，你也可以传入两个double值：

double a = 1.2, b = 3.4;
callWithMax(a, b);  // 这里f(3.4)将被调用

总的来说，这个模板函数提供了一种通用的方式，让我们可以用同样的代码处理不同类型的数据。

请记住：

对于单纯常量，最好以const对象或enums替换#defines
对于形似函数的宏（macros)，最好改用inline函数替换#defines

3. 尽可能使用const

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

const在星号左边：你不能通过指针来更改其所指向对象的值，但可以使指针指向其他对象。

int x = 10, y = 20;
const int* ptr = &x;
// *ptr = 30; //错误，无法通过ptr改变x的值
ptr = &y; //正确，可以更改ptr指向的对象

const在星号右边：你可以通过指针来更改其所指向对象的值，但不能使指针指向其他对象。

int x = 10, y = 20;
int* const ptr = &x;
*ptr = 30; //正确，可以通过ptr来改变x的值
// ptr = &y; //错误，无法更改ptr指向的对象

const出现在星号两边：既不能通过指针来更改其所指向对象的值，也不能使指针指向其他对象。

int x = 10, y = 20;
const int* const ptr = &x;
// *ptr = 30; //错误，无法通过ptr改变x的值
// ptr = &y; //错误，无法更改ptr指向的对象

每种情况下，试图违反const约束的操作都会导致编译错误。这是因为const关键字的作用就是帮助开发者避免无意或错误的更改值。

‌‌‌‌　　在C++中，如果一个对象被声明为const，那么我们只能调用它的const方法。因为const方法保证了它们不会修改对象的状态。mutable是C++中的一个存储类说明符，跟const关键字一起使用，可以使得const对象中的成员变量在const成员函数中可以被修改。
举例说明：


#include<bits/stdc++.h>
using namespace std;class MyClass {
public:MyClass() : m_val(0) {}void inc(){m_val++;  }int getVal(){return m_val;}
private:mutable int m_val;
};
int main() {const MyClass obj;obj.inc();cout << obj.getVal() << endl;  // 输出: 1return 0;
}//上面的代码会报错，因为const对象只能调用他的const方法，正确的代码如下：#include<bits/stdc++.h>
using namespace std;class MyClass {
public:MyClass() : m_val(0) {}void inc() const{m_val++;  }int getVal() const{return m_val;}
private:mutable int m_val;
};
int main() {const MyClass obj;obj.inc();cout << obj.getVal() << endl;  // 输出: 1return 0;
}

请记住：

将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。
编译器强制实施bitwise constness，但你编写程序时应该使用“概念上的常量性”。
当const和non-const成员函数有着是指等价的实现时，令non-const版本调用const版本可避免代码重复。


class MyClass { 
public: int getValue() const { return m_value; } int& getValue() { return const_cast<int&>(static_cast<const MyClass&>(*this).getValue()); } 
private:int m_value{}; 
};//在这个例子中，non-const的`getValue()`函数调用了const版本的`getValue()`函数。我们首先将当前对象（用`*this`表示）转化为`const`引用，之后调用的`getValue()`就是`const`版本的了。

4. 确定对象被使用前已先被初始化


class PhoneNumber{...};
class ABEntry{
public:ABEntry(const string& name, const string& address, const list<PhoneNumber>& phones);
private:string theName;string theAddress;list<PhoneNumber> thePhones;int numTimesConsulted;
};ABEntry::ABEntry(const string& name, const string& address, const list<PhoneNumber>& phones){theName = name;theAddress = address; // 这里的赋值操作是浅拷贝thePhones = phones;    //而非初始化numTimesConsulted = 0;
}

比较好的写法是下面这种，直接初始化：


ABEntry::ABEntry(const string& name, const string& address, const list<PhoneNumber>& phones): theName(name), theAddress(address), thePhones(phones), numTimesConsulted(0){}