豌豆

1. 调试宏

宏是预编译的，无法 print 宏的定义。但是如果配合 gcc, 我们还是可以有限地调试宏。
在 GCC 编译程序的时候，加上 -g3 参数，就可以调试宏了。

• info macro mac_name 可查看宏定义，及位置
• macro expand mac_expr 可查看宏展开的样子

示例：

#include <iostream>
using namespace std;

#define MY_ADD(a,b) (a * 2 + b)
#define M 42
#define DM(x) (M+x) 

int main(){
        int s = MY_ADD(2,3);
        cout<<s<<endl;
        cout<<DM(s)<<endl;
        return 0;
}

调试现场如下:

(gdb) i macro M
Defined at /home/zr/code/use_gdb/src3/./test_macro.cpp:5
#define M 42
(gdb) macro expand DM(1)
expands to: (42+1)

2. 修改变量

两种方法：

1. print var_name=x
2. set var var_name=x

示例：

继续阅读

命令

GDB 是 Linux 下的命令行调试工具。
启动 GDB 有如下几种方式：

1. gdb <program> 直接启动执行程序
2. gdb <program> core 用gdb 同时调试一个可执行程序和core文件。core 是程序非法执行后 core dump 产生的文件
3. gdb <program> <PID> 指定进程， gdb会自动 attach 上去。program 应该在 PATH 环境变量中可以搜索得到。

常用的 gdb 命令如下

信息 info

info 可以简写成 i

• info args 列出参数
• info breakpoints info break i b 列出所有断点
• info break number i b number 列出序号为 number 的的断点
• info watchpoints i watchpoints 列出所在 watchpoints
• info threads 列出所有线程
• inifo registers 列出寄存器的值
• info set 列出当前 gdb的所的设置
• i frame
• i stack
• i locals
• i catch

断点和监视 break & watch

继续阅读

这一章谈 C++11 中引入的两种 “语法糖” .使用它们可以使得我们的代码更为简洁优雅。

委托构造函数

在同一个类中，一个构造函数可以调用另一个构造函数，这叫委托构造函数。这是 C++ 11 的新特性。
委托构造函数可以简化在每个构造函数中的重复代码。

class B{
public:
    B():x_(0),y_(0),z_(0){
        //Do something
    }
    B(int x): B(){
        x_ = x;
    }

    B(int x, int y): B(x){
        y_ = y;
    }

    void DoSomething(){}
private:
    int x_;
    int y_;
    int z_;
};

注意一点，委托构造函数在使用时不可以形成环：禁止套娃。

继续阅读

这一章聊一聊在面向对象的C++中，构造函数的调用顺序。

数据成员的构造顺序

一个类的数据成员的初始化顺序只与其在类中的声明顺序相关，与其它无关。

而析构时，如果成员是在堆中，析构顺序正好与构造时相反。

class M {
 public:
  M(const char* msg) {
    cout << "M " << msg << endl;
    msg_ = new char[strlen(msg)+1];
    msg_[strlen(msg)] = '\0';
    strcpy(msg_, msg);
  }
  ~M() {
    cout << "~M " << msg_ << endl;
    delete msg_;
  }

 private:
  char* msg_;
};

class A {
 public:
  A() : pm2_(new M("pm2")), m2_("m2"), pm1_(new M("pm1")), m1_("m1") {}

 private:
  M m1_;
  M m2_;
  M* pm1_;
  M* pm2_;
};

int main() {
  A a;
  return 0;
}

类A的成员的构造顺序为： m1_, m2_, pm1_, pm2_ 。析构时的顺序为 m2_, m1_ ,由于 pm1_, pm2_ 不在堆中，所以它们的析构需要类A自己管理。

继续阅读

三五零法则

我们知道，编译器会为类自动生成几个特别的成员函数：构造函数、复制构造函数、复制赋值运算符、析构函数。后三者比较特殊，我们在下面会频繁提到。

三法则

若一个类需要用户显式定义 析构函数、复制构造函数、复制赋值运算符 中的一个，那么这三个函数都需要显式定义 。如果用户显式定义了其中一个，另外两个还是会被编译器隐式定义，这种混杂的情况容易生产无法预期的错误。
如果一个类中有非基本数据类型或者非类类型的成员(如指针、文件描述符等)，则这一法则表现的更为明显：隐式析构函数无法对这种成员进行有效的释放，隐式复制构造函数和隐式复制赋值运算符无法进行深拷贝。

继续阅读

C++ 构造函数有很多有意思的小细节。这里来做一些探讨。这些内容可能会分为几章，这一章来探讨 隐式构造函数，显式空构造函数 和 =default 修饰的构造函数 ，私有构造函数和 =delete 修饰的构造函数 之间的区别。

在开始之前，我们先了解两种特殊的类：

聚合类 与 POD

聚合类 是 C++ 中的一个特殊的类型。当一个类(class, struct, union) 满足以下条件时，它是一个聚合类：

• 无显式声明的构造函数(可以是 default 或 delete 的)
• 无基类
• 无虚成员函数
• 无私有的或受保护的非静态数据成员
• 无使用 {} 或 = 直接初始化的非静态数据成员

一个普通数组也是一种聚合类型(如 int[10], char[], double[2][3])

POD ( Plain old data structure ) 则是一种特殊的聚合类，它必须满足聚合类的所有条件，且不具有以下成员：

• 指针到成员类型的非静态数据成员(包括数组)。
• 非POD类类型的非静态数据成员(包括数组)。
• 引用类型的(reference type)非静态数据成员。
• 用户定义的拷贝与赋值算子。
• 用户定义的析构函数。

可见，POD类类型就是指class、struct、union，且不具有用户定义的构造函数、析构函数、拷贝算子、赋值算子；不具有继承关系，因此没有基类；不具有虚函数，所以就没有虚表；非静态数据成员没有私有或保护属性的、没有引用类型的、没有非POD类类型的（即嵌套类都必须是POD）、没有指针到成员类型的（因为这个类型内含了this指针）

POD 一般用来在不同的模块之前传递数据使用。如一个 C++ 库向外提供 C 接口，可以使用 POD 作为参数。

隐式构造函数，显式空构造函数 和 =default 修饰的构造函数。

对于 未定义任何构造函数 的类型( struct class or union)，编译器会为该为自动生成一个 inline public 的构造函数, 如果这个类型满足 constexpr 类型的要求，则这个构造函数还会被 constexpr 修饰，这个由编译器生成的构造函数，我们称之为 隐式构造函数 或 默认构造函数。在 C++11 以前，如果用户声明了其它构造函数，则编译器不会生成默认构造函数，需要我们显式的声明。而在 C++11 以后，我们仍可用 default 关键字来强制编译器自动生成原本隐式声明的默认构造函数。

继续阅读

今天在看 cpprestsdk 的源码的时候发现一个方法的定义是这样的：

template<typename _Ty>
__declspec(noinline) auto create_task(_Ty _Param, task_options _TaskOptions = task_options())
    -> task<typename details::_TaskTypeFromParam<_Ty>::_Type>
{...}

语法为：

auto fun_name(argument-declarations...) -> return_type{}

template <typename T>
T add(T a, T b) {
  return a + b;
}

template<typename R, typename T1, typename T2>
R add(T1 a, T2 b) {
  return a + b;
}

  auto ret_val = add<float>(1.0, 2);
  auto ret_val1 = add<decltype(1.0 + 2)>(1.0, 2);

template <typename T1, typename T2>
decltype(a + b) add(T1 a, T2 b) {
  return a + b;
}

template <typename T1, typename T2>
decltype((*(T1*)0) + (*(T2*)0)) add(T1 a, T2 b) {
  return a + b;
}

继续阅读

一. 引入

简单地说： enable_shared_from_this 是为了解决 在类的内部获取自己的 shared_ptr 这件事情而存在的。

众所周知， 每一个对象都能通过this 指针来访问自己的地址。this 指针也是所有成员函数的隐含参数。然而有些时候，我们需要的不仅是 this，而是一个 “this的智能指针”。

这里有一个常见的场景：

class A {
public:
    A() :did_it_(false) {}
    ~A() {
        std::cout << "destoried" << std::endl;
    }

    void OnDo(bool did) {
        did_it_ = did;
        std::cout << "somthing did" << std::endl;
    }

    void DoSth_Async() {
        std::thread t([this]() {
            std::this_thread::sleep_for(std::chrono::seconds(5));
            //...do somthing
            OnDo(true);
        });
        t.detach();
    }
private:
    bool did_it_;
};

代码如上：在异步方法 DoSth_Async() 中调用了成员方法 OnDo(bool) . 这里存在一个问题： 当 OnDo() 被调用的时候，该类的是否还在生存中：

int main(){
    {
        std::shared_ptr<A> ptr(new A());
        ptr->DoSth_Async();
    }
    std::this_thread::sleep_for(std::chrono::seconds(5));
    return 0;
}

智能指针 ptr 在出作用域后立即被释放。所以当 OnDo() 被调用的时候，其所在的对象实际已经被释放了。如果确保在 OnDo() 被调用的时候，该对象仍然在生命周期内呢？一个方便的方法便上在构建线程的时候，将该对象的 shared_ptr 传入到线程。在该线程的生命周期内，该对象就会一直存在。这是一种利用 shared_ptr 的 保活机制 。

继续阅读