<<现代C++实战30讲>>打卡学习笔记—基础篇

说明

基础篇9讲主要学习内存管理、容器、迭代器、异常、C++11/14/17的新语法。
每日打卡更新。

打卡Day1：堆、栈、RAII：C++里该如何管理资源？

  • 内存管理：
    C++的堆和栈与JAVA中意思是一样的，不同的是，C++中没有垃圾回收这个概念，而是使用RAII管理内存(参考第一部分析构函数部分代码)；
    栈中的内存，在函数调用结束后，自动释放，不需要手动释放，而且由于栈的LIFO特性，保证了释放内存空间的连续性；
    堆内存分配需要使用new关键字，分配内存，并且使用delete关键字手动释放内存。
  • 和JAVA语言不同的是，C++的默认都是值定义，只有指针或者引用对象才可以new对象（new的对象才会在堆上面分配内存），不new的对象也会默认调用构造函数，但是内存并不是分配在堆上面，而是分配在栈上面。

打卡Day2：自己动手，实现C++的智能指针

  • 一些基础概念学习：
    运算符重载：C++中的运算符都可以看做是一个函数，这样就类似于Java中的函数重载。
    拷贝构造函数：通过使用另一个同类型的对象来创建一个新对象。
    拷贝赋值：重载拷贝赋值运算符。
    移动构造函数：构造新的对象后，原有对象资源清空。
    移动赋值： 重载赋值运算符。
    现代C++中尽量不要使用裸指针（原始指针），最好使用标椎库中智能指针（shared_ptr和unique_ptr）。
    根据第一讲的RAII思想，实现shared_ptr和unique_ptr。
    shared_ptr的对象使用拷贝操作；
    unique_ptr的对象使用移动操作；
    引用计数（共享计数）：shared_ptr和unique_ptr的最大区别，就是share_ptr多个智能指针同时拥有一个对象，需要一个共享计数，用来标记，是否需要删除这个对象。
    第一讲和第二讲的代码如下：
#include <iostream>
using namespace std;

// template 类似于Java中的泛型
template <typename T>
class smart_ptr {
 private:
  T *ptr_;

 public:
  // explicit 构造函数关键字;
  // ptr_(ptr)表示初始化构造函数的成员变量，这个地方由于不熟悉语法，一开始没有理解。
  // C++11起 空指针用nullprt表示，古代C++用0或者NULL
  explicit smart_ptr(T *ptr = nullptr) : ptr_(ptr) {
    cout << "调用默认构造函数，分配内存;" << endl;
  }
  //析构函数(delete 对象时，才会调用)
  ~smart_ptr() {
    cout << "调用析构函数，释放内存;" << endl;
    delete ptr_;
  }
  //拷贝构造函数(通过使用另一个同类型的对象来创建一个新对象。)
  smart_ptr(smart_ptr<T> &other) {
    cout << "调用拷贝构造函数;\n";
    ptr_ = other.rlease();
  }
  //拷贝赋值（覆盖原有的对象）
  smart_ptr<T> &operator=(smart_ptr<T> &other) {
    cout << "调用拷贝赋值，赋值对象;\n";
    smart_ptr(other).swap(*this);
    return *this;
  }

  //移动构造函数
  smart_ptr(const smart_ptr &&other) { cout << "调用移动构造函数\n"; }

  smart_ptr<T> &operator=(smart_ptr<T> other) {
    other.swap(*this);
    return *this;
  }

  void swap(smart_ptr &rhs) {
    using std::swap;
    swap(ptr_, rhs.ptr_);
  }

  //将传入引用对象赋值为空，并把该对象赋值给新创建的对象
  T *rlease() {
    T *ptr = ptr_;
    ptr_ = nullptr;
    return ptr;
  }

  // const
  // 表示该方法外部不能修改，和java不同，在C++中，const可以用来声明成员函数
  T *get() const {
    cout << "对象地址：" << this << ";get==>ptr value:" << *ptr_ << endl;
    return ptr_;
  }
  // C++中的重载运算符，类似于重载现有的运算符函数。
  T *operator->() const { return ptr_; }
  T &operator*() const { return *ptr_; }
};
//共享计数
class share_count {
 public:
  share_count() : count_(1){};
  void add_count() { ++count_; }
  long reduce_count() { return --count_; }
  long get_count() const { return count_; }

 private:
  long count_;
};

// 程序的主函数
int main() {
  string value = "share_ptr";
  string *ptr = &value;
  smart_ptr<string> ptr1{
      ptr};  // C++11起可以用大括号初始化一个对象,调用默认构造函数
  // smart_ptr<int> ptr2;
  ptr1.get();
  // delete ptr1;
  smart_ptr<string> ptr3{ptr1};  //调用拷贝构造函数
  ptr3.get();
  smart_ptr<string> ptr4;
  //ptr4=ptr1; //调用拷贝赋值，编译器会报错；
  ptr4 = std::move(ptr1);  //调用移动构造函数(C++11起)
  ptr4.get();
  // 设置长度
  return 0;
}

验证输出结果：

调用默认构造函数，分配内存;
对象地址：0x7ffffffedf08;get==>ptr value:share_ptr
调用拷贝构造函数;
对象地址：0x7ffffffedf10;get==>ptr value:share_ptr
调用默认构造函数，分配内存;
调用移动构造函数
调用析构函数，释放内存;
对象地址：0x7ffffffedf18;get==>ptr value:share_ptr
调用析构函数，释放内存;

打卡Day3：右值和移动究竟解决了什么问题？

继续理解一些基础概念

  • 左值和右值的概念好理解，例如++x是右值，是一个临时变量；一个特殊的概念是亡值，是右符号标记的有值，联系到上一讲的移动构造函数调用就是std::move(ptr1)亡值。
    拷贝构造函数和移动构造函数中的参数，一个是左值引用（T&）,一个是右值引用（T&&）。
// lvalues_and_rvalues2.cpp
int main()
{
    int i, j, *p;
    //  i 是 lvalue ， 7 是prvalue.
    i = 7;
    // 错误使用: `j * 4` 是一个 prvalue.
    7 = i; // C2106
    j * 4 = 7; // C2106

    // *p 是 lvalue.
    *p = i;

    //  ((i < 3) ? i : j) 是左值
    ((i < 3) ? i : j) = 7;
    
    // 错误使用: ci is 不能修改的左值
    const int ci = 7;
    ci = 9; // C3892
}
  • 与Java不同的是，C++中的原生类型、枚举、结构、联合、类都是值类型，只有指针和引用是引用类型。
  • C++移动的真正含义：
class A {
  B b_;
  C c_;
};

从实际内存布局的角度，很多语言——如 Java 和 Python——会在 A 对象里放 B 和 C 的指针（虽然这些语言里本身没有指针的概念）。而 C++ 则会直接把 B 和 C 对象放在 A 的内存空间里。这种行为既是优点也是缺点。说它是优点，是因为它保证了内存访问的局域性，而局域性在现代处理器架构上是绝对具有性能优势的。说它是缺点，是因为复制对象的开销大大增加：在 Java 类语言里复制的是指针，在 C++ 里是完整的对象。这就是为什么 C++ 需要移动语义这一优化，而 Java 类语言里则根本不需要这个概念。

上面的一段直接引用。

  • 返回一个本地对象意味着这个对象会被拷贝，虽然编译器会做返回值优化，因此，不要返回本地变量引用。

打卡Day4：容器汇编 I：比较简单的若干容器

  • 这一讲都是简单的顺序数据结构
    vector 类似于java中的Arraylist;
    deque 类似于java中的ArrayDeque;
    list（双链表）类似于java中的LinkedList；
    forward_list是C++11中提供的单链表。
    queue和stack没有begin和end成员函数，所以不支持迭代访问。
    在C++中有个容器适配器概念，意思是queue和stack支持定义基础容器类型，默认的基础容器类型是deque。
  • noexcept保证一个移动构造函数不抛出异常。
    如果vector的移动构造函数不能确保不抛出异常，vector 通常会使用拷贝构造函数。这种情况下对于某些自定义类型的拷贝就是灾难。
    代码如下：
#include <iostream>
#include <vector>

using namespace std;

class obj1 {
 private:
  /* data */
 public:
  obj1() { cout << "obj1 构造函数\n"; };
  ~obj1() { cout << "obj1 析构函数\n"; }
  obj1(const obj1&) { cout << "obj1 拷贝构造函数\n"; }
  obj1(obj1&&) { cout << "obj1 移动构造函数\n"; }
};

class obj2 {
 private:
  /* data */
 public:
  obj2() { cout << "obj2 构造函数\n"; };
  obj2(const obj2&) { cout << "obj2 拷贝构造函数\n"; }
  // noexcept 保证提供一个不抛异常的移动构造函数
  obj2(obj2&&) noexcept { cout << "obj2 移动构造函数\n"; }
};

int main() {
  vector<obj1> v1;
  //使用reserve 分配连续内存空间
  v1.reserve(2);
  //在尾部新构造一个元素
  v1.emplace_back();
  v1.emplace_back();
  //构造第三个对象时，内存不足，分配一个新的内存，并构造第三个对象，
  //同时调用拷贝构造函数，复制第一个和第二个对象
  v1.emplace_back();
  vector<obj2> v2;
  v2.reserve(2);
  v2.emplace_back();
  v2.emplace_back();
  // 构造第三个对象时，内存不足，需要分配一个新的内存，构造第三个对象，
  //同时调用移动构造函数（因为该函数保证了抛出异常），复制第一个和第二个对象
  v2.emplace_back();
}

输出：

#第一次调用v1.emplace_back();
obj1 构造函数
#第二次调用v1.emplace_back();
obj1 构造函数
#第三次次调用v1.emplace_back();
obj1 构造函数
obj1 拷贝构造函数
obj1 拷贝构造函数
#完成后释放旧vector中的两个对象内存
obj1 析构函数
obj1 析构函数
#第一次调用v2.emplace_back();
obj2 构造函数
#第二次调用v2.emplace_back();
obj2 构造函数
#第三次调用v2.emplace_back();
obj2 构造函数
obj2 移动构造函数
obj2 移动构造函数
#完成后释放新vector中的三个对象内存
obj1 析构函数
obj1 析构函数
obj1 析构函数

打卡Day5：容器汇编 II：需要函数对象的容器

熟悉两个概念：

  • 函数对象，我的理解是类或者结构重新定义了重载运算符"()"，则该类或者结构声明的对象就是函数对象
//less struct
template <class T>
struct less
  : binary_function<T, T, bool> {
 //重载运算符“（）”
  bool operator()(const T& x,
                  const T& y) const
  {
    return x < y;
  }
};

// hash struct
template <class T> struct hash;
template <>
struct hash<int>
  : public unary_function<int, size_t> {
  size_t operator()(int v) const
    noexcept
  {
    //static_cast类型转换函数，size_t是无符号整数类型
    return static_cast<size_t>(v);
  }
};

这一讲的容器都会带上这两个函数对象

  • priority_queue这种数据结构和stack类似，但是默认带有less函数对象，这样栈顶存储的就是最大数。
  • C++中的关联容器（ set、map、multiset和 multimap）与Java不同，不是按插入数据的顺序，会默认按key排序。为此，从C++11起定义了无序关联容器（unordered_set，unordered_map，unordered_multiset，unordered_multimap）；
  • C++ 中的set不允许存在重复的元素，要存储重复的元素，需要使用multiset和 multimap
  • 使用数组的话，不建议用C的原始数组，
    较大数组可以使用vector,较小的数组可以使用array（C++ 11）
    由于容器的输出不方便，测试的时候推荐使用 xeus-cling 在线可视化工具。
    xeus-cling online

打卡Day6：异常，用还是不用，这是个问题

  • C++标准库里面已经使用了异常，所有肯定会用，最关键的是当异常发生时，要保障不会发生内存泄露，所以要理解RAII,在JAVA中会用GC机制释放内存。
  • Google不建议使用异常，有两方面原因，一是历史原因，早期他们的编译器对异常处理不好，所有他们产生了一大堆异常不安全的代码；另一个原因是追求更高的性能（打开和关闭异常时，会产生一些二进制文件大小）
  • 第一讲有个“栈展开”，其实就是在函数执行异常之前，调用函数之前所有局部变量的析构函数，释放所有资源。

打卡Day7：迭代器和好用的新for循环

  • 迭代器是为了解耦数据结构和算法。先泛型数据容器，然后泛型数据容器的迭代器，最后泛型算法就好写了。本质上是一种将容器的访问高度抽象，Java语言编译器自动处理了这些，它底层的思想也是类似C++的指针。
  • 作者列了一些常用迭代器：
    Input迭代器，需要重载，->,==,!=运算符；
    Output迭代器，需要重载    ，->,==,!=运算符；；
    Forward迭代器：具有input和out迭代器的所有功能；
    Bidirectional迭代器，具有Forward迭代器所有功能；
    Random Access迭代器；
    下面是Input迭代器的实现：
#include <fstream>
#include <iostream>
#include <istream>   // std::istream
#include <iterator>  // std::input_iterator_tag
#include <string>

using namespace std;

class istream_line_reader {
 public:
  class iterator {
   public:
    typedef ptrdiff_t difference_type;
    //迭代器指向的对象的值类型
    typedef std::string value_type;
    //迭代器指向的对象的指针类型
    typedef const value_type* pointer;
    //迭代器指向的对象的引用类型
    typedef const value_type& reference;
    //输入迭代器
    typedef std::input_iterator_tag iterator_category;

    iterator() noexcept : stream_(nullptr) {}
    explicit iterator(istream& is) : stream_(&is) { ++*this; }

    reference operator*() const noexcept { return line_; }
    pointer operator->() const noexcept { return &line_; }
  
    iterator& operator++() {
      getline(*stream_, line_);
      if (!*stream_) {
        stream_ = nullptr;
      }
      return *this;
    }
    iterator operator++(int) {
      iterator temp(*this);
      ++*this;
      return temp;
    }
  //迭代器相等比较
    bool operator==(const iterator& rhs) const noexcept {
      return stream_ == rhs.stream_;
    }
  //迭代器不等比较
    bool operator!=(const iterator& rhs) const noexcept {
      return !operator==(rhs);
    }

   private:
    istream* stream_;
    string line_;
  };

  istream_line_reader() noexcept : stream_(nullptr) {}
  explicit istream_line_reader(istream& is) noexcept : stream_(&is) {}
  iterator begin() { return iterator(*stream_); }
  iterator end() const noexcept { return iterator(); }

 private:
  istream* stream_;
};
int main() {
  //读取文件
  ifstream ifs{"test.txt"};
  for (const string& line : istream_line_reader(ifs)) {
    //示例循环体中仅进行简单输出
    cout << line << endl;
  }
}

打卡Day8：易用性改进 I：自动类型推断和初始化

  • 类型推断，Java10 应该也支持了类型推断var；
    auto：编译器会根据表达式的类型推断变量类型，不需要手动声明。
  • 函数模板参数推导，其实auto的实现规则类似模版参数推导。根据实际调用的实参类型，推导形参类型。
    值类型参数推导；
    引用类型参数推导；
//定义一个模版函数
template<typename T>
T max(T a, T b)
{
    // if b < a then yield a else yield b
    return b < a ? a : b;
}
//调用
int const c = 42;
max(i, c); // OK ：实际调用mar（int，int）
max(c, c); // OK: 实际调用mar（int，int）
int arr[4];
max(&i, arr); // OK: 实际调用mar（int*，int*）
max(4, 7.2);    //ERROR: T 有可能是 int 或 double
std::string s;
foo("hello", s); //ERROR: T 有可能是char const[6] 或者std::string
  • 类模板推导
#include <iostream>
using namespace std;
int main() {
//推导，C++17之前的写法 auto pr = make_pair(1, 42);
//这里还用到C++11的大括号初始化写法。
pair pr{1, 2}; 
}

打卡Day9：易用性改进 II：字面量、静态断言和成员函数说明符

  • 字面量：，在Java中，会有一些标准的字面量，例如3.14f表示浮点数。这个字面量是原生支持的，在传统C++（C++11之前）中，也是如此，但是从C++11起开始支持自定义字面量。
#include <iostream>
struct length {
  double value;
  //单位
  enum unit {
    metre,
    kilometre,
    millimetre,
    centimetre,
    inch,
    foot,
    yard,
    mile,
  };
  static constexpr double factors[] = {1.0,    1000.0, 1e-3,   1e-2,
                                       0.0254, 0.3048, 0.9144, 1609.344};
  explicit length(double v, unit u = metre) { value = v * factors[u]; }
};

//重载字面量运算符（""），自定义字面量_m（注意自定义的必须以_开头）
length operator"" _m(long double v) { return length(v, length::metre); }
//自定义字面量_cm
length operator"" _cm(long double v) { return length(v, length::centimetre); }

length operator+(length lhs, length rhs) {
  return length(lhs.value + rhs.value);
}

int main() {
  length lhs = 1.0_cm;  //调用运算符 "" _m(1.0)
  length rhs = 2.0_m;   //调用运算符 "" _cm(2.0)
  length sum = lhs + rhs;
  std::cout << sum.value << std::endl;
}
  • default 和 delete 成员函数
    第二讲说过，当定义一个类类型（class，struct）时，开发者不声明构造函数，析构函数，拷贝函数，移动函数，拷贝赋值运算函数，移动赋值运算函数，编译器会自动声明这些函数。
    当类中存在用户声明的构造函数时，用户仍可以关键词 default 强制编译器自动生成原本隐式声明的默认构造函数，析构函数，拷贝函数，移动函数，拷贝赋值运算函数，移动赋值运算函数。
#include <iostream>  //std::cout

struct A {
  int x;
  A(int x = 1) : x(x) {
    std::cout << "调用A构造函数" << std::endl;
  }  // 用户定义默认构造函数
};

struct B : A {
  // 隐式定义 B::B()，调用 A::A()
};

struct C {
  A a;
  // 隐式定义 C::C()，调用 A::A()
};

struct D : A {
  D(int y) : A(y) {}
  // 不会声明 D::D()，因为存在另一构造函数
};

struct E : A {
  E(int y) : A(y) {}
  E() = default;  // 显式预置，调用 A::A()
};

struct F {
  int& ref;     // 引用成员
  const int c;  // const 成员
                // F::F() 被隐式定义为弃置
};

int main() {
  A a;
  B b;
  C c;
  // D d; // 编译错误
  E e;
  //  F f; // 编译错误
}
  • override 和 final 关键字
    这个两个关键字和Java中意义是一样的。
class A {
public:
  virtual void foo();
  virtual void bar();
  void foobar();
};

class B : public A {
public:
  void foo() override; // OK
  void bar() override final; // OK
  //void foobar() override;
  // 非虚函数不能 override
};

class C final : public B {
public:
  void foo() override; // OK
  //void bar() override;
  // final 函数不可 override
};

class D : public C {
  // 错误：final 类不可派生
  …
};
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 157,298评论 4赞 360
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 66,701评论 1赞 290
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 107,078评论 0赞 237
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,687评论 0赞 202
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,018评论 3赞 286
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,410评论 1赞 211
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,729评论 2赞 310
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,412评论 0赞 194
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,124评论 1赞 239
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,379评论 2赞 242
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 31,903评论 1赞 257
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,268评论 2赞 251
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 32,894评论 3赞 233
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,014评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,770评论 0赞 192
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,435评论 2赞 269
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,312评论 2赞 260