大端: 低位的数据存放在高地址,高位的数据存放在低地址
小端: 低位的数据存放在低地址,高位的数据存放在高地址

现在的CPU一般都是小端. 网络编程中,TCP/IP统一采用大端方式传送数据，所以有时我们也会把大端方式称之为网络字节序

结合union理解这个概念比较容易,看下面程序:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

union my{
    int a;
    char bytes[4];
};

my un;
un.a = 135201034;
// a为4个字节, 二进制表示就是: 00001000  00001111  00000001  00001010
// 分别转化为十进制就是 8   15   1   10
int a0 = static_cast<int>(un.bytes[0]) ;
int a1 = static_cast<int>(un.bytes[1]) ;
int a2 = static_cast<int>(un.bytes[2]) ;
int a3 = static_cast<int>(un.bytes[3]) ;

cout<< "address a0: "<< &a0 <<"  "<<a0 <<endl;
cout<< "address a1: "<< &a1 <<"  "<<a1 <<endl;
cout<< "address a2: "<< &a2 <<"  "<<a2 <<endl;
cout<< "address a3: "<< &a3 <<"  "<<a3 <<endl;

运行结果:

1
2
3
4

address a0: 0x7fff768cc180  10
address a1: 0x7fff768cc184  1
address a2: 0x7fff768cc188  15
address a3: 0x7fff768cc18c  8

智能指针三个优点:

• 明确资源的所有权
• 避免忘记delete，造成内存泄露
• 对于 exception 情况，执行内存释放(Effective C++ 中的条款)

智能指针类重载了解引用运算符（*）和成员指向运算符（->）,同时为了能够在堆中管理各种类型，几乎所有的智能指针都是模板类，包含其功能的泛型实现。

C++11 中的auto_ptr已经废弃. 现有的 unique_ptr，shared_ptr，weak_ptr和原生指针加起来构成了指针的完整四件套。它们都在头文件<memory>里面,最常用的是原生指针（没所有权语义的时候），其次是unique_ptr，后两个除非特定场合需求，能不用就不用。 拷贝shared_ptr、 weak_ptr都涉及到atomic操作，其开销比起拷贝、解引用一个指针都是大很多的。

unique_ptr

unique_ptr代表的是专属所有权，之所以叫这个名字，是因为它只能指向一个对象，即当它指向其他对象时，之前所指向的对象会被摧毁,不能进行复制操作只能进行移动操作。两个unique_ptr也不能指向一个对象. 看源码发现，拷贝构造函数和赋值运算符都加了delete:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

template <typename T, typename D = default_delete<T> >
class unique_ptr
{
    public:
        explicit unique_ptr(pointer p) noexcept;
        ~unique_ptr() noexcept;    
    T& operator*() const;
        T* operator->() const noexcept;
    unique_ptr(const unique_ptr &) = delete;
        unique_ptr& operator=(const unique_ptr &) = delete;
    unique_ptr(unique_ptr &&) noexcept;
    unique_ptr& operator=(unique_ptr &&) noexcept;
                    // 省略 ...
    private:
        pointer __ptr;
};

这里需要注意: 既然不能拷贝, 就不能在函数中将unique_ptr作为参数了，因为传参是一个产生副本的过程，用 move(unique_ptr)取代

• unique_ptr内部存储一个原生指针，当unique_ptr析构时，它的析构函数将会负责析构它持有的对象，还可以使用自定义的 删除器
• unique_ptr提供了operator*() 和 operator->()成员函数，像 raw pointer 一样，我们可以使用*解引用unique_ptr，使用->来访问unique_ptr所持有对象的成员。
• unique_ptr并不提供 copy 操作，但提供了 move 操作，因此可以用std::move()来转移unique_ptr, 把一个unique_ptr的内存交给另外一个unique_ptr对象管理,。转移之后，当前对象不再持有此内存，新的对象将获得专属所有权
• C++14 提供了std::make_unique<T>()函数用来直接创建unique_ptr，但 C++11 没有

unique_ptr和原生指针的大小是一样的，内存上没有任何的额外消耗，性能是最优的

如果没有为unique_ptr指定对象，get()返回0

常用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Test
{
public:
    Test() { cout<< "construct" <<endl; }
    ~Test() { cout<< "destruct" <<endl; }
};

std::unique_ptr<Test> p1(new Test());
cout<< "p1: "<<p1.get()<<endl;      // 0x19b7c20
// std::unique_ptr<Test> p2(p1)   // 错误用法, 不支持拷贝构造函数
std::unique_ptr<Test> p2 = std::move(p1);
// 转移所有权到p2
cout<< "p1: "<<p1.get()<<endl;   // 0
cout<< "p2: "<<p2.get()<<endl<<endl;    // 0x19b7c20

// p2释放所有权, 只剩p3原生指针
// release并不会摧毁其指向的对象，不执行析构,与reset不同
Test* p3 = p2.release();
cout<< "after release "<<endl;
cout<< "p2: "<<p2.get()<<endl;      // 0
cout<< "p3: "<<p3 <<endl<<endl;    // 0x19b7c20

move不执行析构，否则新的智能指针无法指向对象了.

reset

reset有两种用法

• 如果不加参数，就会销毁对象(执行析构函数)，重置智能指针

• 如果加原生指针做参数，就会先销毁原来指向的对象，然后指向原生指针指向的对象

  1 2 3 4 5 6 7 8

  Test* p3 = new Test(); std::unique_ptr<Test> p4(new Test()); cout<<"p4: "<<p4.get()<<endl; p4.reset(p3); cout<< "after reset "<<endl; cout<< "p4: "<<p4.get()<<endl; cout<< "p3: "<<p3 <<endl;

运行结果:

1
2
3
4
5
6
7
8

construct   // p3
construct   // p4
p4: 0x7adc50
destruct   // 
after reset 
p4: 0x7acc20
p3: 0x7acc20
destruct

需要注意: release不执行析构, reset执行析构

自定义删除器

unique_ptr的定义删除器方式和shared_ptr不同,因为模板的参数不同,前者还需要指定删除器类型.

原型有:

• std::unique_ptr up(t,d);
• std::unique_ptr up(d); // 空的指针

T为指针管理的对象类型, D为删除器类型, t为管理的对象, d为删除器函数名称

1
2
3
4
5
6
7

void myclose(Test* t)
{
    cout<< "close func"<<endl;
}

Test t;
std::unique_ptr<Test, decltype(myclose)*> p1(&t, myclose);

运行结果:

1
2
3

construct
close func
destruct

make_unique 不是‘std’的成员 ， 原因是make_unique为C++14才特有的， 如果使用gcc版本小于6.2，编译就会报错，vs2015 msvc 也可以

参考:
深入 C++ 的 unique_ptr
C++ 智能指针的正确使用方式

单链表程序如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

struct LinkedList
{
    int data;
    LinkedList* next;
};

LinkedList* root, *second, *third;
root = new LinkedList;
second = new LinkedList;
third = new LinkedList;

root->data = 10;
root->next = second;
second->data = 20;
second->next = third;
third->data = 30;
third->next = nullptr;

LinkedList* guy = new LinkedList;
guy->data = 90;
guy->next = second->next;
second->next = guy;
while(root)
{
    cout<< root->data <<endl;
    root = root->next;
}

deque可以看做是vector和list的折中容器，类似vector，它支持随机访问(其实是假象)，即支持[]以及at()，但是性能没有vector好。

deque和vector的区别：

1. 在头部插入删除元素的时间复杂度是O(1)
2. 没有容量的概念，所以没有reserve, capacity函数。因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来，不像 vector 那样，当旧空间不足而重新配置一块更大空间，然后复制元素，再释放旧空间

deque还是不如list的任何位置插入删除，它的中间部分插入和删除元素和vector一样，时间复杂度还是O(n)。所以没有list的reverse函数

底层机制

这下问题就来了，既然没有reserve和capacity，显然它和vector的底层机制不同。

deque采用类似索引的结构管理内存，采用一块所谓的map(不是数据结构的map )作为中控器，map是一块连续的内存空间，每个元素(称之为节点)都是指针，指向另一块连续的线性空间，称为缓冲区，map实际上是指针的指针T**。

deque的迭代器包含4个：

• cur：迭代器当前所指元素

• first：此迭代器所指的缓冲区的头

• last：缓冲区尾

• node：指向管控中心

deque的最初状态是有一个缓冲区，调用clear函数的作用就会清除整个deque，释放所有空间而只保留一个缓冲区。如果调用erase清楚某个元素，而这个元素是所在缓冲区唯一的元素，会将此缓冲区释放。

与vector不同，deque的内存大小是可缩减的。deque的内存区块不再被使用时，会被释放。

deque维护start和finish两个迭代器，分别指向第一缓冲区的第一个元素和最后一个缓冲区的最后元素的下一个位置。它还要记住当前map的大小，如果map的节点不足，就需要重新配置。

为了指定缓冲区的大小，必须指定 alloc 为空间配置器。比如指定数据int类型，缓冲区大小为4的deque: deque<int, alloc, 4>。 map的初始大小至少是8，最多是所需节点数+2，按刚才的例子，要存放50个元素，就需要13个节点，那么map的初始大小就是15。 如果插入的元素太多，map会不够大，需要扩充，和vector的内存扩充一样，先配置一块更大的，把原来的节点全拷贝过来，再释放原来的map。 对于平时的空间扩充，如果缓冲区中还有备用的空间，那么直接使用备用的空间；否则另外配置一个缓冲区，将其信息记录到缓冲区地址表里

在除了首尾两端的其他地方插入和删除元素，都将会导致指向deque元素的任何pointers、references、iterators失效。

特点

• deque的元素存取和迭代器操作会比vector稍微慢一些，因为它的内部结构会多一个间接过程

• deque迭代器是特殊的指针，而不是vector那样的一般指针，它需要在不同的区块之间跳转

• 不支持对内存分配时机的控制，也就是没有reserve

• 缓冲区的内存地址是连续的，但不同缓冲区之间不是连续的

• 中间添加元素，会使迭代器、指针、引用失效

• 头尾添加元素，现有元素的内存地址不变，指针和引用不失效，但迭代器可能失效，因为可能分配新的内存块

最好采用deque的情形

• 需要在两端插入和删除元素

• 随机访问元素的情况较少，主要是访问两端元素

• 要求容器释放不再使用的元素

cartographer中的成员变量，凡是以queue结尾的，基本都是deque类型。 比如timed_pose_queue，它的使用只有back, front, pop_back, pop_front几个函数，根本没有用到遍历和随机访问

1
2
3

deque<std::unique_ptr<Constraint>>   constraints_;
constraints_.emplace_back();
auto* const constraint = &constraints_.back();

constraints_是个vector，可先添加一个空元素，然后再对最后一个元素进行赋值，其实为添加一个新元素（cartographer中很多都是如此做法，目的可减省一个变量空间和赋值时间）

queue

单向队列中的数据是先进先出，queue只是进一步封装别的数据结构，并提供自己的接口，如果不指定容器，默认是用deque来作为其底层数据结构的

单向队列一共6个常用函数front()、back()、push()、pop()、empty()、size()，不支持随机访问，所以没有[]运算符和at

1
2
3
4
5
6
7
8
9
10
11
12

#include <queue>

queue<int>  q;
q.push(1);
q.push(2);
q.push(3);
q.push(4);

qDebug()<< q.size() << "  "<< q.empty();
qDebug() <<q.front() << "  " << q.back() ;
q.pop();
qDebug() <<q.front() << "  " << q.back() ;

1
2
3

4    false
1    4
2    4

list底层数据结构为双向链表，以结点为单位存放数据，结点的地址在内存中不连续，每次插入或删除一个元素，就增加或释放一个元素空间，占用内存比vector多

list不支持随机访问，适用于对象数量变化频繁，插入和删除频繁。随机访问元素的时间复杂度为O(n)，插入删除为O(1)，后两者只需要改变元素的指针

list删除迭代器时，其后面的迭代器都不会失效，将前面和后面连接起来即可。

list插入和删除数据，需要对现有数据进行遍历，但在首部插入数据，效率很高。

list的迭代器不是普通指针，因为节点在内存中不是连续存在的。它是一个结构体，内部有一个普通指针指向节点，实现递增递减、解引用、取值等运算符。

常用方法

直接赋值

1
2
3
4
5
6
7
8
9
10
11

std::list<int> list1={5,2,4,39,1};
std::list<int> list2={7,6,1,9};
cout<< list1.size()<<endl;		// 5
list1 = list2;		// 直接赋值
cout<< list1.size()<<endl;		// 4 

list<int>::iterator ite;
for(ite=list1.begin(); ite!=list1.end(); ite++)
{
    cout<< *ite <<endl;
}

排序和反转

1
2
3
4
5

std::list<int> list1={5,2,4,39,1};
list1.sort();
print(list1);		// 1  2  4  5  39
list1.reverse();
print(list1);		// 39  5  4  2  1

merge函数有点问题，list1.merge(list2);应当是将list2与list1合并再排序，但是我发现list2插入到了list1中间的部分，把list1分割开了，可能是编译器的问题，最好还是不要使用。

其他

• 对list中连续而相同的元素去重，移除到只剩一个，不连续的不处理

• clear 函数的作用是清楚整个list的所有节点， 析构节点的对象，释放节点的空间

• remove 函数的作用是将数值为value的所有元素移除

文件amcl_node.cpp最主要的几个函数是构造函数，handleMapMessage, laserReceived。尤其是最后一个

杂项

sigintHandler回调函数在关闭程序之前只有一句amcl_node_ptr->savePoseToServer();，也就是关闭前把最近一次的机器人位姿存入参数服务器，这就可以理解为什么关掉程序后，用rosparam get获得的initial_pose_x等位姿仍然是以前的。

amcl根据输入参数来决定运行方式。从代码中可以看到amcl支持数据回放的，运行时只需要通过参数--run-from-bag指定bag文件即可

从main函数可以看出，amcl的所有业务逻辑都是由AmclNode类的构造函数完成

AmclNode构造函数

通过参数服务器，根据launch文件里的大量参数，对各类变量赋值

成员函数updatePoseFromServer，该函数就是用来从参数服务器上获取机器人的初始位姿和位姿误差的协方差矩阵的。

发布amcl_pose和particlecloud两个主题，分别用于输出机器人位姿估计和粒子集合。

接着注册三个服务：global_localization用于获取机器人的全局定位，request_nomotion_update则用于手动的触发粒子更新并发布新的位姿估计，set_map用于设定机器人位姿和地图信息。 这几个平时都用不到

接下来构建激光传感器的消息过滤器对象和tf2的过滤器，并注册回调函数laserReceived。

1
2
3
4
5
6
7
8

laser_scan_sub_ = new message_filters::Subscriber<sensor_msgs::LaserScan>(nh_, scan_topic_, 100);
laser_scan_filter_ = new tf::MessageFilter<sensor_msgs::LaserScan>(
                                  *laser_scan_sub_, 
                                  *tf_, 
                                  odom_frame_id_, 
                                  100 );
laser_scan_filter_->registerCallback(boost::bind(&AmclNode::laserReceived,
                                                 this, _1));

订阅用于初始化机器人位姿估计的主题initialpose

根据运行参数use_map_topic_获取地图，或者订阅地图主题，或者通过requestMap请求static_map服务。因为一般取false，所以后面我们直接看requestMap函数，也就是如下逻辑：

定义m_force_update为false，后面会用到

最后定义一个计时器用于每隔15s检查一次激光雷达的接收数据，如果期间没有收到新的数据给出告警

requestMap 和 handleMapMessage

requestMap函数请求static_map服务成功后，调用函数handleMapMessage处理接收到的地图数据，进一步完成AmclNode的初始化工作，内容庞大的其实是handleMapMessage

handleMapMessage的流程图在这里

释放了与地图相关的内存和对象之后，通过函数convertMap将地图消息转换成amcl中的地图数据结构。

接着构建粒子滤波器对象，并完成初始化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// 构建粒子滤波器对象
pf_ = pf_alloc(min_particles_,
               max_particles_,
               alpha_slow_,
               alpha_fast_,
               (pf_init_model_fn_t)AmclNode::uniformPoseGenerator,
               (void *)map_ );
pf_->pop_err = pf_err_;
pf_->pop_z = pf_z_;

// 从参数服务器获取初始位姿及方差放到pf中
updatePoseFromServer();
pf_vector_t pf_init_pose_mean = pf_vector_zero();
pf_init_pose_mean.v[0] = init_pose_[0];   // initial_pose_x
pf_init_pose_mean.v[1] = init_pose_[1];   // initial_pose_y
pf_init_pose_mean.v[2] = init_pose_[2];   // initial_pose_a

pf_matrix_t pf_init_pose_cov = pf_matrix_zero();
pf_init_pose_cov.m[0][0] = init_cov_[0];
pf_init_pose_cov.m[1][1] = init_cov_[1];
pf_init_pose_cov.m[2][2] = init_cov_[2];

// 初始化高斯粒子滤波器
pf_init(pf_, pf_init_pose_mean, pf_init_pose_cov);
pf_init_ = false;

构建里程计对象，根据launch文件里的参数配置里程计模型

构建雷达传感器对象，根据运行参数laser_model_type_构建不同模型的雷达

最后考虑到，在接收到地图数据之前，有可能已经接收到了机器人的初始位姿，这里调用函数applyInitialPose处理

pf_alloc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// Create a new filter
pf_t *pf_alloc(int min_samples, int max_samples,
               double alpha_slow, double alpha_fast,
               pf_init_model_fn_t random_pose_fn, void *random_pose_data)
{
  int i, j;
  pf_t *pf;
  pf_sample_set_t *set;
  pf_sample_t *sample;
  
  srand48(time(NULL));

  pf = calloc(1, sizeof(pf_t));

  pf->random_pose_fn = random_pose_fn;
  pf->random_pose_data = random_pose_data;

  pf->min_samples = min_samples;
  pf->max_samples = max_samples;

  // Control parameters for the population size calculation.  [err] is
  // the max error between the true distribution and the estimated
  // distribution.  [z] is the upper standard normal quantile for (1 -
  // p), where p is the probability that the error on the estimated
  // distrubition will be less than [err].
  pf->pop_err = 0.01;
  pf->pop_z = 3;
  pf->dist_threshold = 0.5; 
  pf->current_set = 0;
  for (j = 0; j < 2; j++)
  {
    set = pf->sets + j;

    set->sample_count = max_samples;
    set->samples = calloc(max_samples, sizeof(pf_sample_t));

    for (i = 0; i < set->sample_count; i++)
    {
      sample = set->samples + i;
      sample->pose.v[0] = 0.0;
      sample->pose.v[1] = 0.0;
      sample->pose.v[2] = 0.0;
      sample->weight = 1.0 / max_samples;
    }

    // HACK: is 3 times max_samples enough?
    set->kdtree = pf_kdtree_alloc(3 * max_samples);

    set->cluster_count = 0;
    set->cluster_max_count = max_samples;
    set->clusters = calloc(set->cluster_max_count, sizeof(pf_cluster_t));

    set->mean = pf_vector_zero();
    set->cov = pf_matrix_zero();
  }

  pf->w_slow = 0.0;
  pf->w_fast = 0.0;
  pf->alpha_slow = alpha_slow;
  pf->alpha_fast = alpha_fast;

  //set converged to 0
  pf_init_converged(pf);
  return pf;
}

pf_init

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Initialize the filter using a guassian
void pf_init(pf_t *pf, pf_vector_t mean, pf_matrix_t cov)
{
  int i;
  pf_sample_set_t *set;
  pf_sample_t *sample;
  pf_pdf_gaussian_t *pdf;
  
  set = pf->sets + pf->current_set;
  
  // Create the kd tree for adaptive sampling
  pf_kdtree_clear(set->kdtree);

  set->sample_count = pf->max_samples;

  pdf = pf_pdf_gaussian_alloc(mean, cov);
    
  // Compute the new sample poses
  for (i = 0; i < set->sample_count; i++)
  {
    sample = set->samples + i;
    sample->weight = 1.0 / pf->max_samples;
    sample->pose = pf_pdf_gaussian_sample(pdf);

    // Add sample to histogram
    pf_kdtree_insert(set->kdtree, sample->pose, sample->weight);
  }

  pf->w_slow = pf->w_fast = 0.0;

  pf_pdf_gaussian_free(pdf);
    
  // Re-compute cluster statistics
  pf_cluster_stats(pf, set); 

  //set converged to 0
  pf_init_converged(pf);

  return;
}

这个就是Effective C++条款23，假如类有多个成员函数，现在需要在一个函数里调用这几个函数，那么最好不要把它定义为成员函数，而是类外的普通函数。

最常见的做法是定义一个namespace，把类和普通函数都放到里面，namespace可以跨越多个文件，但类不能。这正是C++标准库std的风格，std有数十个文件，每个声明std的部分机能，这样能 降低编译的依存性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// 头文件
namespace test {

class Base
{
public:
    Base();
    ~Base();
    void setA(int a);
    void setB(int b);
private:
    int m_a;
    double m_b;
};
//  这里声明，但不能定义函数体，否则编译不通过
void setAB(Base& obj, int a, int b);
}

// 源文件
test::Base::Base():
    m_a(0),
    m_b(0)
{
    cout<<"base constructor"<<endl;
}

test::Base::~Base()
{
    cout<<"base destructor"<<endl;
}

void test::Base::setA(int a)
{
    m_a = a;
}

void test::Base::setB(int b)
{
    m_b = b;
}
//必须加test:: ，否则编译不通过
void test::setAB(Base& obj, int a, int b)
{
    obj.setA(a);
    obj.setB(b);
}

// 调用
test::Base b;
test::setAB(b, 43, 23);

setAB函数在类Base之外，这样的封装性比作为成员函数要好，它并不增加能访问类private成员的函数数量，有较低的编译相依度。

类放到命名空间后，继承类可以像平常那样继承，不必也放到这个命名空间里。

内联函数最初的目的:

1. 代替部分#define 宏定义
2. 替代普通函数:提高程序的运行效率

如果一些函数被频繁调用，不断地有函数进入函数栈，会造成栈空间的大量消耗。因此引入了内联函数。

函数调用是有时间和空间开销的。执行一个函数之前要将实参、局部变量、返回地址等压入栈中，然后执行函数体中，执行完毕后还要让之前压入栈中的数据都出栈。如果函数体代码比较多，需要较长的执行时间，那么函数调用机制占用的时间可以忽略:如果函数只有一两条语句，那么调用机制的时间开销就就不容忽视。

内联函数是在编译阶段将函数展开，而不用将函数地址压入栈，避免调用的开销，但增大了可执行程序的体积。因此内联函数一般比较小，用于大量调用的场合。如果在类体内定义实现，那么就是内联函数；也可以在类内用inline声明，在体外实现。

其实上面这些还没触及到本质，还有以下几条:

1. inline只是我们对编译器提出的一个申请，是否真按内联函数处理取决于编译器，比如开启优化选项时才考虑内联函数

2. 函数不能有循环和递归，不能太大，否则仍是普通函数

3. 编译器的内联看起来就像是代码的复制与粘贴，这与预处理宏是很不同的：宏是强制的内联展开，可能将会污染所有的命名空间与代码，将为程序的调试带来困难，所以最好用内联函数代替宏

• 内联函数无法随程序库升级而升级，比如修改了一个内联函数，那么所有用到它的地方都要重新编译，而普通函数做修改后，程序只需要重新链接它，效率比重新编译高

• 如果一个内联函数会在多个源文件中被用到，那么最好把它定义在头文件中，否则必须在调用该函数的每个文件中定义

• 构造函数和析构函数不适合做内联函数，编译器在编译期间会给你的构造函数和析构函数额外加入很多的代码，像成员函数的构造和析构等代码，所以通常构造和析构函数比表面上看起来的要多，并不适合作为内联函数

内联函数和宏的区别：

1. 内联函数展开在编译阶段，宏在预处理阶段

2. 内联函数会经过编译器安全检查，宏定义的参数没有类型的概念，只有在宏展开以后，才由编译器检查语法，这就存在很多的安全隐患

详细内容看《Effective C++》条款30

最近重读了《Effective C++》，对一些复杂的知识点会专门写文章分析，这里将一些小的知识点总结一下，但不会涵盖书里的所有内容。

条款2

• 良好的用户自定义类型的特征是它尽量能与内置类型兼容

• 宁可用编译器替换预处理器

• 尽量多用const,而不是宏定义.宏属于模块化的设计概念,会破坏封装性

• 常量可能比#define产生较小量的代码.

• 如果类需要用到多个常量,不要用const数组,而是改用枚举

• 对于宏形式的函数,最好用内联函数取代

条款3

• 希望迭代器指向的东西不可改动,需要const_iterator

条款4

• 永远在使用对象前初始化.对于int x;,有些编译器会将x初始化为0,有些却不会,所以无论之后有没有用到x,都要先对其初始化,比如int x=0;

• 成员变量如果是const或引用,它们只能用成员列表初始化的方法进行初始化

条款5

• 编译器自动生成的析构函数不是virtual,除非这个类的基类的析构函数是virtural

• 编译器自动生成的4个函数都是public

• 如果基类的copy构造函数和copy运算符是private,编译器不会为派生类生成它们

• 派生类的copy构造函数可以尽量不定义

条款6

• 定义uncopyable类是很好的禁止使用copy构造函数和copy运算符的方法，它的析构函数可以不是virtual,派生类不必以public继承它,也没有成员变量,也可以用于多重继承

• 类的不可拷贝特性是可以继承的，例如凡是继承自uncopyable的类都不能使用copy构造函数和赋值运算符

条款7

• 如果基类析构函数不声明为virtual，析构时不会调用派生类的析构，可查看原因分析

• 如果一个类不做基类，就不要有virtual析构函数或其他虚函数，因为虚指针会增大类的体积。 反过来，只要一个类做基类，就要有virtual函数

• 当类至少有一个虚函数时，为它声明virtual析构函数，否则编译器有报警
  

• 对于抽象类，可以将析构函数声明为pure virtual析构函数

条款8

• 析构函数里不要抛出异常，否则会导致不确定行为

条款9

• 构造函数和析构函数中都不要调用virtual函数，因为基类构造时，virtual函数不会下降到派生类阶层，或者说此时的virtual函数还不是virtual函数

• 对于存在多个构造函数的情况，为避免代码重复，要把同样的代码放到一个函数里，比如init

条款10

• 赋值运算符(包括+= -= *=)的返回最好是return *this，这符合STL等标准库的风格

条款12

• 自定义copy构造函数或运算符时，需要复制所有的成员变量，如果少复制了，编译器不会报警或报错

• 派生类的copy构造函数或运算符，无法像平时那样对基类的private成员变量赋值，因为无法访问private的变量，只能显式调用基类的operator =， 比如： Base::operator=(obj);

条款15

• 多使用智能指针shared_ptr，它可以返回原始指针，显式方法是get()函数，隐式方法是取指针操作符->

条款16

• new和delete必须配对，[]必须都有或都没有。千万避免new没有[]，delete有[]，这会导致程序不停运行析构函数

条款18

• 有时的形参可以用wrapper类型，而不是内置类型

• 保证接口的一致，比如STL容器都有个size的成员函数

• 可以让一些返回指针的函数返回智能指针，比如工厂函数

条款21

• 函数内返回对象时，不要返回其引用。因为引用指向局部变量，而局部变量在函数退出前销毁，所以会出现无定义行为。

条款22

• 成员变量应该都是private，将它们隐藏在函数接口的背后，如果放到public，直接使用成员变量会降低封装性。如果破坏了成员变量，会破坏太多的客户码

• 成员变量的封装性和成员变量的内容改变时破坏的代码量成反比

• protected变量被消灭时，所有用到它的派生类的代码都要破坏，所以封装性也很差

条款24

• 若函数参数都要进行类型转换，应该使用非成员函数

• 成员函数的反面是非成员函数，不是friend函数，friend应该尽量避免

条款26

• 如果某个类的对象没有用到，就不应该声明，否则运行构造和析构函数都会耗费成本

• 对象初始化用构造函数比=运算符的效率高

• 对变量定义后应马上初始化，然后马上使用，中间不要隔太远

• 变量定义在循环内比外面更好，后者造成作用域更大，对程序维护性不好

条款27

• 代码中尽量避免dynamic_cast，它会降低效率

• 避免连续的cast转型，尤其是dynamic_cast

条款32

• public继承是一种is-a的关系，每一个派生类的对象也是基类的对象

• 程序的错误最好能在编译期检测出来，而不是运行期

条款34

• public继承涉及到函数接口继承和实现的继承

• 纯虚函数实际上是可以提供定义的，这个用法比较罕见，知道即可

• 虚函数使派生类继承了其缺省实现，但这可能造成危险

条款36

• 不要重新定义继承而来的non-virtual函数，虽然没有错误，但违反了is-a原则，这种情况下干脆不要使用public继承

根据 Effective C++，类的成员变量最好 都用成员列表初始化 的方法进行初始化，对内置类型没什么不同，但对类对象会提高效率。 成员初始化顺序是其声明的顺序,不是初始化列表中的顺序,二者最好一致

构造函数内赋值成员变量，先调用默认构造函数，再调用赋值运算符。 如果用成员列表初始化， 只调用拷贝构造函数，提高了效率

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Derived : public Base
{
public:
    Derived();
    Derived(Base obj)
    {
        m_b = obj;
        cout<<"derived constructor"<<endl;
    }
    ~Derived();
    Derived(const Derived& obj);
    Derived& operator=(const Derived& obj);

private:
    Base m_b;
};

实际调用:

1
2
3

Base b;
cout<<"----------------"<<endl;
Derived d(b);

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13

base constructor
----------------
base copy constructor
base constructor
base constructor
base operator =
derived constructor
base destructor
----------------
derived destructor
base destructor
base destructor
base destructor

但实际中一般不这么用，Derived的成员变量会是Base* m_b，此时的调用是这样的:

1
2
3
4
5

Base *b = new Base();
Derived d(b);

delete b;
b = NULL;

结果是:

1
2
3
4
5
6
7
8

base constructor
----------------
base constructor
derived constructor
base destructor
----------------
derived destructor
base destructor