int f1(int* i) {
  *i = 2;
}

int f2(int i){
  i = 3;
}

int main(){
  int num = 0;
  f1(&num);
  std::cout << num << std::endl;  ///< 此处num为2
  f2(num);
  std::cout << num << std::endl;  ///< 此处num仍为2
}

void f1(int& num) {
  num = 100;
}

int main() {
  int i = 0;
  int &r = i;
  r = 1;
  std::cout << i << std::endl;  ///< i这里为1
  std::cout << r << std::endl;  ///< r这里为1
  f1(r);
  std::cout << i << std::endl;  ///< i这里为100
  std::cout << r << std::endl;  ///< r这里为100
}

#include <iostream>
#include <memory>
#include <string>
#include <vector>

class observer;
class subscriber : public std::enable_shared_from_this<subscriber> {
public:
  subscriber(const std::string& user_name) : user_name_(user_name) {
  }

  void callback(const std::string& str) {
    std::cout << user_name_ << ": " << str << std::endl;
  }
private:
  std::string user_name_;
};

class observer {
public:
  void boardcast(const std::string& message) {
    for (auto it = vec.begin(); it != vec.end();) {
      auto sp = it->lock();
      if (sp) {
        sp->callback(message);
        it++;
      } else {
        it = vec.erase(it);
      }
    }
  }

  void regist(std::weak_ptr<subscriber> wp) {
    if (wp.lock()) {
      vec.push_back(wp);
    }
  }
private:
  std::vector<std::weak_ptr<subscriber>> vec;
};

int main() {
  auto ob = std::make_shared<observer>();
  auto sp1 = std::make_shared<subscriber> ("subscriber1");
  ob->regist(sp1->weak_from_this());
  auto sp2 = std::make_shared<subscriber> ("subscriber2");
  ob->regist(sp2->weak_from_this());
  {
    auto sp3 = std::make_shared<subscriber> ("subscriber3");
    ob->regist(sp3->weak_from_this());
    auto sp4 = std::make_shared<subscriber> ("subscriber4");
    ob->regist(sp4->weak_from_this());
    ob->boardcast("start boardcast!");
  }
  ob->boardcast("boardcast again!");
  return 0;
}

Widget w1;  ///< 调用默认构造函数
Widget w2 = w1; ///< 调用复制构造函数
w1 = w2;  ///< 赋值运算符

class Widget {
private:
int x{0}; ///< 可行
int y = 0;  ///< 可行
int z(0); ///< 不可行
};

std::atomic<int> ai1{0}; ///< 可行
std::atomic<int> ai2(0); ///< 可行
std::atomic<int> ai3 = 0; ///< 不可行

Widget w1(10);  ///< 调用Widget的构造函数，传入形参10

Widget w2();  ///< 最令人苦恼之解析语法现身

Widget w3{};  ///< 调用没有形参的Widget构造函数

class Widget {
  public:
  Widget(int i, bool b);
  Widget(int i, double d);
  Widget(std::initializer_list<long double> il);
};

Widget w1(10, true);  ///< 调用第一个构造函数
Widget w2{10, true};  ///< 使用最后一个构造函数, 10, true 被强制转化为long double

Widget w4({});  ///< 带有std::initializer_list型别形参地构造函数
Widget w5{{}};  ///< 同上

std::vector<int> v1(10, 20);  ///< 创建了一个拥有十个元素，每个元素值都为20的vector
std::vector<int> v1(10, 20);  ///< 创建了一个拥有两个元素，值分别为10、20 的vector

#include <memory>
int main()
{
  {
    int* p = new int(0);  ///< 分配一个int的内存，其值为0
    std::unique_ptr<int> up = std::unique_ptr<int>(p);  ///< 使用指针p来创建一个智能指针对象
    /*
      /// 由于std::unique_ptr对象不可复制，所以下面三句话编译不过
      std::unique_ptr<int> up_copy1(up);
      std::unique_ptr<int> up_copy2;
      up_copy2 = up;
    */
  } ///< 在这个地方智能指针up被析构，up的析构函数对指针p执行delete操作，从而达到智能回收内存的作用

  {
    auto up = std::make_unique<int>(0); ///< 这句话等价于上面的两句话
  }
}

template<typename OBJECT>
class unique_ptr {
  public:
  /// 构造函数
  unique_ptr(OBJECT* p) : p_(p) {}
  /// 析构函数
  ~unique_ptr(){
    if(p_ != nullptr){
      delete p_;
    }
  }
  /// 删除拷贝构造函数, 标识这个类不可拷贝
  unique_ptr(const unique_ptr<OBJECT>& other) = delete;
  /// 删除拷贝构造赋值符, 标识这个类不可拷贝
  unique_ptr<OBJECT>& operator=(const unique_ptr<OBJECT>& other) = delete;
  /// 移动构造函数
  unique_ptr(unique_ptr&& other) {
    p_ = other.p_;
    other.p_ = nullptr;
  }

  /// 移动赋值符
  unique_ptr<OBJECT>& unique_ptr(unique_ptr&& other) {
    if (&other == this) {
      return *this;
    }
    delete p_;
    p_ = other.p_;
    other.p_ = nullptr;
  }
private:
  OBJECT* p_ = nullptr;
};

class object {
public:
  object() {
    std::cout << "object()" << std::endl;
  }
  ~object() {
    std::cout << "~object()" << std::endl;
  }
};

int main() {
  {
     unique_ptr<object> p(new object);
     unique_ptr<object> other(std::move(p));  ///< 调用移动构造函数
     /// 此时other智能指针拥有对象的管理权，而p失去了该对象的管理权
  }
  return 0;
}

template <typename OBJECT>
class shared_ptr {
  public:
  /// 构造函数
  shared_ptr(OBJECT* object):p_(object), count_(new int(0)) {
    ++(*count_);
  }

  /// 析构函数
  ~shared_ptr() {
    if(--(*count_) == 0) {  ///< 如果自己是最后一个管理该对象的人，自己被析构时负责做善后工作即delete对象
      delete p_;
      delete count_;
    }
  }

  /// 拷贝构造函数
  shared_ptr(const shared_ptr& other) {
    count_ = other.count_;  ///< 把引用计数的指针复制过来
    ++(*count_);  ///< 所有shared_ptr中的count_都自加一下
    p_ = other.p_;  ///< 复制管理对象的指针
  }

  /// 拷贝赋值运算符
  shared_ptr<OBJECT>& operator=(const shared_ptr& other) {
    if (&other == this) {
      return &this; ///< 如果复制的对象是自己，则直接返回
    }
    count_ = other.count_;  ///< 把引用计数的指针复制过来
    ++(*count_);  ///< 所有shared_ptr中的count_都自加一下
    delete p_;
    p_ = other.p_;  ///< 复制管理对象的指针
    return &this;
  }

private:
  OBJECT* p_ = nullptr; ///< 指向管理对象的指针
  int* count_ = nullptr;  ///< 引用计数, 之所以使用指针是为了让管理同一个对象的引用计数
};

class object {
public:
  object() {
    std::cout << "object()" << std::endl;
  }

  ~object() {
    std::cout << "~object()" << std::endl;
  }
};

int main() {
  {
    shared_ptr<object> sp(new object);

    auto sp1(sp);
    auto sp2(sp);
    auto sp3(sp);
    auto sp4(sp);
    auto sp5(sp);
    auto sp6(sp);
  }
  return 0;
}

int main() {
  {
    object* p = new object();
    shared_ptr<object> sp1(p);
    shared_ptr<object> sp2(p);
  }
  return 0;
}

std::shared_ptr<object> sp = std::make_shared<object>();
/// 代替下面的初始化的方法
/// std::shared_ptr<object> sp = std::shared_ptr<object>(new object);

class error_object {
public:
  std::shared_ptr<error_object> get_sp() {
    return std::shared_ptr<error_object>(this);
  }
};

class correct_object : public std::enable_shared_from_this<correct_object> {
};

int main() {
  auto instance = std::make_shared<correct_object>();
  std::shared_ptr<correct_object> sp1 = instance.shared_from_this();
  std::shared_ptr<correct_object> sp2 = instance.shared_from_this();
  return 0;
}

class object {
public:
  object() {
    std::cout << "object()" << std::endl;
  }
  ~object() {
    std::cout << "~object()" << std::endl;
  }
};

int main()
{
  std::weak_ptr<object> weak;
  {
      auto sp = std::make_shared<object>();
      weak = sp;
      std::shared_ptr<object> sp1 = weak.lock();
      if(sp1){
         sp1->doSomeThing();
      }
  }
  if (weak.expired()) {
    std::cout << "资源没有释放" << std::endl;
  } else {
    std::cout << "资源已经释放" << std::endl;
  }
}

class list_node {
public:
  list_node() {
    std::cout << "list_node()" << std::endl;
  }

  ~list_node() {
    std::cout << "~list_node()" << std::endl;
  }
  std::shared_ptr<list_node> next;
};

int main()
{
  {
    auto sp0 = std::make_shared<list_node>();
    auto sp1 = std::make_shared<list_node>();
    auto sp2 = std::make_shared<list_node>();
    sp0->next = sp1;
    sp1->next = sp2;
    sp2->next = sp0;
  }
  return 0;
}

class list_node {
public:
  list_node() {
    std::cout << "list_node()" << std::endl;
  }

  ~list_node() {
    std::cout << "~list_node()" << std::endl;
  }
  std::weak_ptr<list_node> next;
};

int main()
{
  {
    auto sp0 = std::make_shared<list_node>();
    auto sp1 = std::make_shared<list_node>();
    auto sp2 = std::make_shared<list_node>();
    sp0->next = sp1;
    sp1->next = sp2;
    sp2->next = sp0;
  }
  return 0;
}

#include <iostream>
#include <memory>
#include <string>
#include <vector>

/// 订阅者
class subscriber {
 public:
  /// 订阅者被观察器调用的函数
  void read(const std::string& str) { std::cout << str << std::endl; }
};

/// 广播者
class boardcaster {
 public:
   /// 广播者注册订阅者
  void regist(std::shared_ptr<subscriber> sp) { vec.push_back(sp); }

  /// 广播事件
  void boardcast(const std::string& str) {
    for (auto it = vec.begin(); it != vec.end();) {
      auto sp = it->lock();
      if (sp) {
        /// 让订阅者接受消息
        sp->read(str);
        it++;
      } else {
        std::cout << "subscriber is delete!" << std::endl;
        it = vec.erase(it);  ///< 擦除这个订阅者的指针
      }
    }
  }

 private:
  std::vector<std::weak_ptr<subscriber>> vec; ///< 用于保存订阅者的智能指针
};

int main() {
  boardcaster obj;
  auto reader0 = std::make_shared<subscriber>();
  obj.regist(reader0);
  {
    auto reader1 = std::make_shared<subscriber>();
    obj.regist(reader1);
    auto reader2 = std::make_shared<subscriber>();
    obj.regist(reader2);

    obj.boardcast("start boardcast!");
  }

  obj.boardcast("reader1 and reader2 is deleted， boardcast angin!");
  return 0;
}

#ifdef _WIN32
    #include <crtdbg.h>
    #ifdef _DEBUG

    #define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
    #endif
#endif

#ifdef _WIN32
	_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG)|_CRTDBG_LEAK_CHECK_DF);
#endif

class object {};

class object {
public:
  object() = default;
  ~object() = default;
  object(const object& other) = default;
  object(object&& other) = default;
  object& operator=(const object& other) = default;
  object& operator=(object&& other) = default;
};

class object {
public:
  object() = default; ///< 构造函数 #1
  ~object() = default;  ///< 析构函数 #2
  object(const object& other) = default;  ///< 拷贝构造函数 #3
  object(object&& other) = default; ///< 移动构造函数 #4
  object& operator=(const object& other) = default; ///< 拷贝赋值符 #5
  object& operator=(object&& other) = default;  ///< 移动赋值符 #6
};

int main() {
  /// 构造函数#1示例
  object x; ///< 调用默认构造函数#1

  /// 析构函数#2示例
  {
    object x2;
  } ///< 超出作用域临时变量x2,调用析构函数#2

  object* p3 = new object();
  delete p3;  ///< 调用析构函数#2

  /// 拷贝构造函数#3示例
  object base;
  object copy1(base);  ///< 调用拷贝构造函数 #3
  object copy2 = base;  ///< 调用拷贝构造赋值符#3

  /// 移动构造函数#4示例
  object base_move;
  object copy_move(std::move(base_move)); ///< 由于入参为右值, 调用移动构造函数#4

  /// 拷贝构造赋值符#5示例
  object base_operator;
  object copy_operator;
  copy_operator = base_operator;  ///< 调用拷贝构造赋值符#5

  /// 移动构造赋值符#6示例
  object move_base;
  object move_operator = std::move(move_base);  ///< 调用移动构造赋值符#6
  return 0;
}

class object1 {
private:
  ~object() = default;
};


int main() {
  object1* p = new object1; ///< 编译通过
  /// delete p; ///< 编译错误
  /// object1 obj;  ///< 编译错误
  return 0;
}

class object2 {
public:
  ~object() = delete;
};

class a
{
private:
  ~a() {}
};

int main()
{
    a obj0; ///< 没有默认构造函数, 编译错误
}

class a
{
  const int i;   ///< 未赋值的 const 变量
  int& j;        ///< 未指向的引用变量
};

int main()
{
    /// a obj0; ///< 没有默认构造函数, 编译错误
}

class a
{
  const int i = 0;
};

int main()
{
  a obj0;
  a obj1;
  obj0 = obj1;  ///< 编译错误
}

class object{
  std::string* p;
  public:
  object& operator=(const object& other) {
    if(&other != this) {
      delete p;
      p = new std::string(*other.p);  ///< 当传入对象就是自己时会出错。
    }
    return *this;
  }
};

class object {
public:
  object() = default;
  object&& operator=(object&& other) {}
  object(object&& other) {}
};

int main() {
  object obj;
  auto obj_copy1 = std::move(obj);
  auto obj_copy2 = obj;
  return 0;
}

class object{
  public:
  object() = default;
  object(const object& obj) = default;  ///< #1
};

int main(){
  object obj1;
  object obj2(std::move(obj1));
}

class a
{
public:
  ///  默认构造函数
  a() {}
  /// 拷贝构造函数
  a(const a& other){}
};

int main()
{
  a obj0;
  a obj1 = std::move(obj0); ///< 此处会调用拷贝构造函数
}

#define NULL 0

void f1(int i){}
void f1(int* p){}

int main(){
  f1(NULL); ///< 调用函数不确定，编译器警告或报错
}

void f1(int i){}  ///< #1
void f1(int* p){} ///< #2

int main(){
  f1(nullptr); ///< 明确调用#2函数
}

void f(Widget&& param); ///< 右值引用
Widget&& var1 = Widget(); ///< 右值引用
auto&& var2 = var1; ///< 非右值引用

template<typename T>
void f(std::vector<T>&& param)  ///< 右值引用

template<typename T>
void f(T&& param) ///< 非右值引用

template<typename T>
void f(T&& param);  ///< param是个万能引用

auto&& var2 = var1; ///< var2是个万能引用

void f(Widget&& param); ///< 不涉及型别推导

template<typename T>
void f(const T&& param);

template<class T, class Allocator = allocator<T>>
class vector {
public:
  void push_back(T&& x);
};

class Widget {
public:
  template<typename T>
  void setName(T&& newName) {
    name = std::move(newName);  ///< 可以编译但糟糕透顶
  }
private:
  std::string name;
  std::shared_ptr<SomeDataStructure> p;
};

std::string getWidgetName();  ///< 工厂函数

Widget w;

auto n = getWidgetName(); ///< n是个局部变量

w.setName(n); ///< 将n移入了w

... ///< n的值变得未知了

Widget makeWidget() {
  Widget w;
  ... ///< 对w进行操作
  return w; ///< 没有任何东西被复制
}

Widget makeWidget() {
  Widget w;
  ...
  return std::move(w);  ///< 将w移入返回值, 千万不要这么做
}

template<typename T>
void logAndAdd(T&& name) {
  logAndAddImpl(std::forward<T>(name), std::is_integral<T>());  ///< std::is_integral不够正确
}

template<typename T>
void logAndAdd(T&& name) {
  logAndAddImpl(std::forward<T>(name), std::is_integral<std::remove_reference_t<T>>());
}

void f(const std:vector<int>& v);

f({1,2,3})

template<typename... Ts>
void fwd(Ts&&... params){
  f(std::forward<Ts>(params)...);
}

class Widget{
  public:
  static const std::size_t MinVals = 28;
}

f(Widget::MinVals); ///< 没问题, 当f(28)处理
fwd(Widget::MinVals); ///< 错误，无法链接

void f(int (*pf)(int)); ///< 一个接受函数指针入参的函数f
int processVal(int value);
int processVal(int value, int priority);

/// 然后调用
f(processVal);

fwd(processVal);  ///< 编译不过

struct IPV4Header {
  std::uint32_t version:4,
  IHL:4,
  DSCP:6,
  ECN:2,
  totalLength:16;
};

f(h.totalLength); ///< 没问题
fwd(h.totalLength); ///< 错误！

auto length = static_cast<std::uint16_t>(h.totalLength);
fwd(length);

std::vector<std::function<int(int)>> vec;

int f() {
  int divisor = 0;
  vec.push_back([&](int val){ return val / divisor;});
}

int f2() {
  auto lamdba = vec.at(0);
  lambda(1);  ///< 此处可能会出现空悬引用。
}

  std::vector<std::function<int(int)>> vec;
class object {
public:
  int f() {
    int divisor = 0;
    vec.push_back([=](int val){ return val / divisor;});  ///< 这里是引用捕获
  }

  private:
  int  divisor = 0;
}

class object {
public:
  int f() {
    int divisor = 0;
    vec.push_back([=](int val){ return val / divisor;});
    /// 等价于下面这句
    /// vec.push_back([this](int val){ return val / this->divisor;});
    /// 默认捕获列表捕获的是this的副本，而不是divisor的副本
  }

  private:
  int  divisor = 0;
}

auto setSoundB = std::bind(setAlarm, steady_clock::now() + 1h, _1, 30s);