Effective C++学习

导读

声明式

extern int x;

std::size_t numDigits(int num);

class Person;

template<typename T>
class GraphNode;

签名式

std::size_t (int); //这个函数获得一个int，返回一个size_t

定义式

int x;

std::size_t numDigits(int num)
{
    std::size_t digitSoFar = 1;
	while((num/10) != 0)  ++digitSoFar;
	return digitSoFar;
}

class Person{
public:
    Person();
	~Person();
};

template<typename T>
class GraphNode{
public:
    GraphNode();
	~GraphNode();
};

初始化（通常由构造函数执行，所谓默认构造函数就是可以被调用但不含实参者）

class A{
public:
    A();
};
------------------------------------------------------------------------
class B{
public:
    explicit B(int x = 0; bool y = true); //explicit阻止隐式类型转换，但仍可被显式类型转换
};
------------------------------------------------------------------------
class C{
public:
    explicit C(int x); //这个就不是default默认构造函数
};
------------------------------------------------------------------------
class D{
public:
    D();                     //默认构造函数
	D（const D& d）         //拷贝构造
	D& operator=(const D& d)//拷贝赋值构造
}

D d1;             //默认
D d2(d1);         //拷贝
d1 = d2;         //拷贝赋值
D d3 = d1;       //拷贝！！！！ 区别就在于，新创建的d3是拷贝，已经存在的是拷贝赋值

class作为入参的时候，尽量不要值传递（本质上会用拷贝构造），用引用传递

条款01 视c++为一个语言联邦

何为联邦，即看作很多语言的组合

1. C语言：以C为基础，但缺少模板、异常、重载
2. object-oriented C++: 包括类(析构 构造) 封装 继承 多态 虚函数(动态绑定)
3. Template c++: 泛型编程
4. STL：包含容器 算法 迭代器 函数对象

• c一般用值传递，c++引用传递

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

1. 意思是：尽量用编译器，而不是预处理器

• 原因1：用#define A 1.2 的话，A可能不会进入记号表，后面报错不会有A，只会有1.2 并不知道具体是哪
• 原因2：用#define会导致每个地方都展开，生成很多oject code(类机器语言) 但如果用const double就不会
• 使用const的时候，一定要用指向的常量的指针

const char* str = "hello"; //指针指向一块固定的地方，但是可以改这块地址的值
char* const str = "hello"; //指针str指向常量，不能通过str修改hello的值，但是可以改变指向
const char* const str = "hello" //不能通过指针str修改hello的值，也不能改变指向


//所以 我们一般用第三个来代替#define，同时用string代替char*
const std::string str("hello")



//静态成员变量一般不允许类内初始化，可能会导致一个很尴尬的情况，如下
class Person{
privete:
	//static const int age;
	enum {age = 5};
	int score[age];         //age不能类内初始化，所以这个地方会报错，解决方案是用enum
}


//宏展开函数会带来意想不到的后果
#define CALL_WITH_MAX(a,b) f((a) > (b) ? (a) : (b))  //用 a b 较大的一个调用f(x)函数

//因为直接宏替换，会导致第一次选择b，第二次选择a
int a = 5, b = 0;
CALL_WITH_MAX(++a, b);
CALL_WITH_MAX(++a, b+10);

//使用模板+inline可以解决此问题
template <typename T>
inline void CallWithMax(cosnt T&a,const T&b)
{
	f(a > b ? a : b)
}

总结 ： 单纯变量用const/enum替换#define，形似函数的宏，用inline替换

条款03 尽量使用const