拷贝构造函数

一个类可以不定义拷贝构造函数，系统会默认提供一个拷贝构造函数，叫做合成拷贝构造函数。与默认构造函数不同的是，即使我们定义了其他构造函数，系统也会为我们生成合成拷贝构造函数。合成的拷贝构造函数会将其参数的成员逐个拷贝到正在创建的对象中。编译器从给定对象中依次将每个非static成员拷贝到正在创建的对象中。对类类型的成员，会使用其拷贝构造函数来拷贝；内置类型的成员则直接拷贝。
为了方便举例，我们手动实现一个mystring类

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

class mystring_
{
private:
    /* data */
public:
    mystring_(/* args */);
    mystring_(const mystring_ &mstr);
    mystring_(char *m_str);
    ~mystring_();

private:
    char *m_str;
};

简介

本篇利用之前介绍的智能指针，关联容器，顺序容器等知识，做一个文本查询程序。该程序读取文本中的内容，然后根据输入的单词，判断该单词出现多少次，出现在哪些行，每行的句子是什么。比如我们输入elment，输出如下

1
2
3
4
5
6

element occurs 112 times
(line 36) A set element contains only a key;
(line 158) operator creates a new element
(line 160) Regardless of whether the element
(line 168) When we fetch an element from a map,we
(line 214) If the element is not found,find returns

C++语言和标准库提供了两种一次分配一个对象数组的方法。C++语言定义了另一种new表达式语法，可以分配并初始化一个对象数组。标准库中包含一个名为allocator的类，允许我们将分配和初始化分离。使用allocator通常会提供更好的性能和更灵活的内存管理能力。

unique_ptr

unique_ptr和shared_ptr不同，unique_ptr不允许所指向的内容被其他指针共享，所以unique_ptr是不允许拷贝构造和赋值的。

1
2
3
4
5
6
7
8
9
10
11

void use_uniqueptr()
{
    //指向double类型的unique指针
    unique_ptr<double> udptr;
    //一个指向int类型的unique指针
    unique_ptr<int> uiptr(new int(42));
    // unique不支持copy
    // unique_ptr<int> uiptr2(uiptr);
    // unique不支持赋值
    // unique_ptr<int> uiptr3 = uiptr;
}

虽然我们不能拷贝或赋值unique_ptr，但可以通过调用release或reset将指针的所有权从一个（非const）unique_ptr转移给另一个unique：

指针

C++提供了对指针操作的方法，当我们用new开辟指定类型的空间后，就生成了一个指针。

1
2
3
4
5
6
7

void use_pointer()
{
    //开辟整形指针，指向一个值为5的元素
    int *pint = new int(5);
    //开辟指向字符串的指针
    string *pstr = new string("hello zack");
}

最长回文串

字符串abcbada最长的回文串为abcba,最长回文串保证首尾字符相同，并且去除首尾后的子串也是回文串,如bcb。
根据这个规律，ab就不是回文串因为首尾不同。abcbada也不是回文串，因为即使首尾相同，其子串bcbad不是回文串，所以abcbada也不是回文串。

动态规划

可以通过动态规划解决字符串的最大回文串的长度问题，其根本思路是依次列举出长度为1~n的回文串，最后返回最大长度n即可。
动态规划的思路在于找出推导公式:
1 首尾元素不同，则不是回文串。
2 首尾元素相同，且去除首尾元素后得子串仍是回文串，则该串为回文串。
假设一个字符串str，我们将上述公式写成伪代码

1
2

1  str[begin] != str[end] 则str不是回文串
2  str[begin] == str[end]， 且str[begin+1:end-1]是回文串,则str是回文串。

之前我们介绍过顺序容器，list, vector, queue等，这一篇介绍关联容器, C++关联容器主要有两大类，map和set。

map

map主要是用来管理key,value类型的结构的。

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

void use_map()
{
    map<string, size_t> word_count;
    string word;
    while (cin >> word)
    {
        word_count[word]++;
    }

    for (const auto &val : word_count)
    {
        cout << "word is " << val.first << " counts are " << val.second << endl;
    }
}

除了容器自定义的迭代器之外，标准库还提供了其他几种迭代器，包括插入迭代器，流迭代器，反向迭代器，移动迭代器。

插入迭代器

迭代器被绑定到一个容器上，可用来向容器插入元素。插入迭代器包括back_inserter, front_inserter, inserter三种。
back_inserter绑定到容器后，对该迭代器赋值，就执行了类似于push_back的操作，前提是该容器要支持push_back。
front_inserter绑定到容器后，对该迭代器赋值，就执行了类似于push_front的操作，前提是该容器支持push_front。
inserter创建一个使用insert的迭代器，此函数接受第二个参数必须是一个指向给定容器的迭代器，元素被插入到给定迭代器所表示的元素之前。

向算法传递函数

默认情况下，泛型算法还实现了另外一个版本，就是接受一个额外的参数。比如sort函数，接受第三个参数，第三个参数是一个谓词。
谓词就是一个可调用的表达式，其返回值结果是一个能用作条件的值。
标准库算法所使用的谓词分为两类：
一元谓词（unary predicate，意味着它们只接受单一参数）和二元谓词（binary predicate，意味着它们有两个参数）。
接受谓词参数的算法对输入序列中的元素调用谓词。因此，元素类型必须能转换为谓词的参数类型。
我们可以暂且将谓词理解为函数

递归反转

本文介绍递归反转单链表，和之前的循环遍历反转单链表方式略有不同，递归的方式要写出推到递归公式。并且在递归的同时修改指针的指向。
先定义Node节点

1
2
3
4
5
6
7
8

class Node
{
public:
    Node(int dt, Node *nt = nullptr) : data(dt), next(nt) {}
    Node() = default;
    int data;
    Node *next;
};