说明
提高篇11讲主要学习泛型编程、面向对象编程、元模版编程、函数式编程、并发。
每日打卡更新。
打卡Day10：到底应不应该返回对象？
- C++11 起返回对象，既可以保证性能，有能提升可读性。如果能理解RAII原理，我觉得返回对象应该是比较好的一种方式。
但需要注意返回一个本地变量时，不要返回引用和指针，这样等于把这个局部的引用暴露给函数调用栈了，会被随意更改。 - 有个半正则概念，意思是返回的这个对象的类，应该有移动，拷贝和默认构造函数。原因是返回的对象，会默认调用移动函数，如果没有移动函数，会调用拷贝函数，生成一个新的对象，返回给外部调用。代码如下：
#include <iostream>
#include <stdlib.h>
using namespace std;
// Can copy and move
class A {
public:
A() { cout << "Create A\n"; }
~A() { cout << "Destroy A\n"; }
A(const A&) { cout << "Copy A\n"; }
A(A&&) { cout << "Move A\n"; }
};
A getA_unnamed() {
A a;
return a;
}
A getA_duang()
{
A a1;
A a2;
if (rand() > 42) {
return a1;
} else {
return a2;
}
}
int main() {
// setA();
//返回值优化
//auto a = getA_unnamed();
auto a = getA_duang();
}
输出结果
Create A
Create A
#返回a1时，调用移动函数
Move A
Destroy A
Destroy A
Destroy A
打卡Day11：Unicode：进入多文字支持的世界
- 字符乱码是最常见的现象，我们来梳理一下字符编码的历史：
1.ASCII编码：最早计算机的设计是用8bit作为一个字节，由于计算机是有美帝人民发明的，他们把自己常用的127个字符编码（大小英文字母和数字等）到计算机，就是ASCII编码。
2.ISO/IEC 8859 系列：对于欧洲人民来说，他们不仅仅使用英语，还有法语，德语等语音，发现一些字符无法编码，所以欧洲国家在原来127位的基础上（8个字节最多256个字符），补充了128个字符，这些编码就是ISO 646 系列、ISO/IEC 8859 系列。
3.GBK:对于亚洲人民来说，尤其中日韩国家，汉字动辄上万，256个字符远远不够，所以我国使用2个字节编码（最多编码65535字符）收录了 6763 个常用汉字和 682 个其他符号。这就是GB2312 ,后面有扩展了繁体字符等，成为GBK标准，为了接轨美帝，同时必须兼容了ASCII编码，它用单字节表示 ASCII 字符而用双字节表示 GB2312 中的字符。
4.Unicode:
4.1 Unicode规范：上面这么多字符编码标准，如果出现多语言文本，那几本就乱套了， 因此Unicode应运而生，Unicode只是个标准,在1.0规范中，当时的人们觉得用2个字节实现肯定够了，所以就定下了16bit的编码（微软是最早采纳Unicode标准的），这就是UTF-16编码。随着计算机的发展，发现2个字节还不够，而且用UTF-16编码的时候，单字节也要用16bit，浪费了空间，所以诞生了UTF-8(1 到 4 字节的变长编码)，这样灵活多了，完全可以兼容 ASCII编码，英语字母就用单字节，汉字就用3-4个字节。随着Unicode标椎的不断编码。目前 一共可以编码 1,114,112 个字符。
| 字符 | ASCII | Unicode | UTF-8 |
|---|---|---|---|
| A | 01000001 | 00000000 01000001 | 01000001 |
| 中 | 无法编码 | 01001110 00101101 | 11100100 10111000 10101101 |
4.2 BOM的作用：Unicode实现的标准太多，为了区分，通常在Unicode 文本文件头加一个字符 U+FEFF，这个字符就是 BOM（byte order mark）字符的约定，根据这个字符区分是UTF-32 编码，还是UTF-16等。
- 主流操作系统上的编码：
Unix（包括 Linux 和 macOS 在内），已经全面转向UTF-8;
Windows系统比较特殊，英文 Windows 上是 Windows-1252，简体中文 Windows 上是 GBK，用 wchar_t 表示 UTF-16,所以经常会有编码转换，为什么会这样？因为Windows历史包袱太重，一直在做向后兼容。
打卡Day12：编译期多态：泛型编程和模板入门
如果有Java基础，这一章节是比较好理解的。
- 面向对象是Java语言的一大特点，同样C++语言也一样。做个比对，在JAVA中的多态有集中实现方式：1.是重写父类的方法；2.是重载方法；3.面向接口编程；C++完全可以实现上述多态思想（作者吧这种多态形式叫“动态”多态，其实就是在执行时蔡）
- 接着上面的说，还有一种多态形式，就是利用模版实现（我个人了理解为Java中的泛型），作者叫"静态"多态。
#include <iostream>
using namespace std;
//定义函数模版
template <typename E>
E my_gcd(E a, E b) {
while (b != E(0)) {
E r = a % b;
a = b;
b = r;
}
return a;
}
int main() {
//如果使用cl_I类型（开源库定义的cl_I
//高精度整数类型，不支持求余运算），就会报错 因此可以重载my_gcd方法
cout << my_gcd<>(3, 4) << endl;
}
- C++中的特化，类似与Java中的重载，只不过Java中只有函数重载，对于类的重载就叫特化；
- 下面是作者对C++中的多态理解，其实和我第一条讲的Java中的多态类似。
我前面描述了面向对象的“动态”多态，也描述了 C++ 里基于泛型编程的“静态”多态。需要看到的是，两者解决的实际上是不太一样的问题。“动态”多态解决的是运行时的行为变化——就如我前面提到的，选择了一个形状之后，再选择在某个地方绘制这个形状——这个是无法在编译时确定的。“静态”多态或者“泛型”——解决的是很不同的问题，让适用于不同类型的“同构”算法可以用同一套代码来实现，实际上强调的是对代码的复用。C++ 里提供了很多标准算法，都一样只作出了基本的约定，然后对任何满足约定的类型都可以工作
打卡Day13:编译期能做些什么？一个完整的计算世界
- 模版元编程：C++是一门静态语言，需要编译成可执行文件，代码在运行期执行，模版元编程是一门黑科技，让代码在编译的时候可以在执行，这个技术C++竟然默认支持（据说是C++设计是的漏洞），想想Java也可以通过插桩的方式，在编译器修改或者生成代码，但是语言自身肯定是不支持的。
- 上面说的模版元编程虽然C++语言默认支持，但是要符合一些条件，只能操作元数据（C++编译器在编译期可以操作的数据）和元函数（实际上表现为C++的一个类、模板类或模板函数）。元数据不是运行期变量，只能是编译期常量，不能修改，常见的元数据有enum枚举常量、静态常量、基本类型和自定义类型等。
int factorial(int n)
{
//控制语句元函数不能使用
if (n == 0)
return 1;
return n * factorial(n - 1);
}
void foo()
{
//运行时执行
int x = factorial(4); // == (4 * 3 * 2 * 1 * 1) == 24
int y = factorial(0); // == 0! == 1
}
模版元编程
#include <iostream>
template <int N>
struct Factorial {
//枚举是元编程可以使用的数据
enum { value = N * Factorial<N - 1>::value };
};
template <>
struct Factorial<0> {
enum { value = 1 };
};
// Factorial<4>::value == 24
// Factorial<0>::value == 1
void foo() {
//编译时执行
int x = Factorial<4>::value; // == 24
std::cout << x << std::endl;
int y = Factorial<0>::value; // == 1
std::cout << y << std::endl;
}
int main() { foo(); }
打卡Day14 SFINAE：不是错误的替换失败是怎么回事?
这一讲的内容比较晦涩，后面还要在看几遍
- 函数模板的重载决议：我理解这个概念是指有函数重载（特化）的情况下，根据实参类型去匹配形参，匹配失败的话，不会报错，继续匹配下一个函数，如果最后没有找到的话，编译器会报错；
#include <stdio.h>
struct Test {
typedef int foo;
};
template <typename T>
void f(typename T::foo) {
puts("1");
}
template <typename T>
void f(T) {
puts("2");
}
int main() {
f<Test>(10); //两个重载函数f(Test::foo) 和 f(Test),实际匹配到f(Test::foo)
f<int>(10); //两个重载函数f(int::foo) 和 f(int),实际匹配f(int)
}
- SFINAE 模板技巧:
enable_if decltype 返回值 void_t 标签分发
这几个概念在实际场景中在理解；
下面是一段其他同学的学习留言：
我自己在写数据序列化为json文本的时候，就遇到了这样头疼的问题：如何根据类型，去调用对应的函数。
如果是简单的int，bool，float，直接特化就好了。
如果是自定义的结构体呢？我的做法就是判断自定义结构体中是否有serializable和deserializable函数，就用到了文中最开始的方法判断。
然而那会儿我写得还是太简单粗暴，在代码中用的是if去判断，对于不支持的类型，直接报错，并不能做到忽略。
打卡Day15 constexpr：一个常态的世界
- constexpr 和 const区别
基本相同，不同的点constexpr是一个编译期常量， const是一个
运行时常量。
如果是编译期常量，可以改造第13讲的阶乘函数，实现编译期计算。
constexpr int factorial(int n)
{
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}
int main()
{
constexpr int n = factorial(10);
printf("%d\n", n);
}
打卡Day16 函数对象和lambda：进入函数式编程
这一讲的内容和Java语言中的内容类似；
- 函数对象：定义了函数调用运算符"（）"的类对象，参考下面代码。
- 函数指针：传递给一个函数实参，被称为函数指针，Java8以后也有这样的
- Lambda 表达式：以一对中括号开始的匿名函数；每个 lambda 表达式都有一个全局唯一的类型，要精确捕捉 lambda 表达式到一个变量中，只能通过 auto 声明的方式
#include <array> // std::array
#include <iostream>
#include <iostream> // std::cout/endl
#include <numeric> // std::accumulate
using namespace std;
struct adder {
adder(int n) : n_(n) { std::cout << n << std::endl; }
//定义函数调用运算符
int operator()(int x) const {
std::cout << x << std::endl;
return x + n_;
}
private:
int n_;
};
int add_2(int x) {
std::cout << x << std::endl;
return x + 2;
};
template <typename T>
auto test1(T fn) {
return fn(2);
}
int main() {
//定义了函数调用运算符的类对象称为函数对象
auto add = adder(1);
add(2);
//传递给一个函数的实参称为函数指针或者引用
test1(add_2);
// Lambda 表达式(以一对中括号开始)
auto add_3 = [](int x) {
std::cout << x << std::endl;
return x + 2;
};
add_3(3);
//泛型Lambda 表达式
array ary{1, 2, 3, 4, 5};
auto s = accumulate(ary.begin(), ary.end(), 0,
[](auto x, auto y) { return x + y; });
cout << s << endl;
}
打卡Day17 函数式编程：一种越来越流行的编程范式
个人对于函数式编程接触的比较多，Java8的Stream Api，RxJava的操作算子，还有搞大数据的时候，接触到的Hadoop MapReduce和Spark的各种操作算子都是经典的函数式编程。举个经典例子统计一个文本中的
例如Map将一个对象映射为另一个对象，reduce将映射后归为一个整体。参考代码
- 其实我觉得函数式编程是更高层次的抽象，实现数学意思上的纯函数，这样函数式编程最大的特点是无状态（想想Java中多线程中状态变化引起的各种问题，当然Java8也支持函数式编程，目前大家对这种编程思想使用的还是太少），这样特别适合并发编程。因此Hadoop作为最早的分布式和并行计算平台， 最先采用了这种思想。这里提一下并行和并发的区别，并发关心的是多个线程或者多个进程同时去操作一个内存或者CPU，而并行是多个CPU同时进行工作，例如现在的CPU基本都是8核，更需要充分利用起来。
- C++中的高阶函数或者操作算子
transform类似于Map
accumulate类似于Reduce
打卡Day18 应用可变模板和tuple的编译期技巧
- 可变参数模版，意思很明确可以定义任意数量和类型的实参。如下
#include <iostream>
void tprintf(const char* format) // 基础函数
{
std::cout << format;
}
//第一个实参和剩余的实参分离开来，然后对于剩余的实参递归
template<typename T, typename... Targs>
void tprintf(const char* format, T value, Targs... Fargs) // 递归变参函数
{
for ( ; *format != '\0'; format++ ) {
if ( *format == '%' ) {
std::cout << value;
tprintf(format+1, Fargs...); // 递归调用
return;
}
std::cout << *format;
}
}
int main()
{
tprintf("% world% %\n","Hello",'!',123);
return 0;
}
- tuple 一个特殊的容器，这个容器中可以存储不同类型的元素，这个功能好强，Java中没有这中类型的容器。
定义：tuple 的成员数量由尖括号里写的类型数量决定。
读写数据：可以使用 get 函数对 tuple 的内容进行读和写。
#include <tuple>
#include <iostream>
#include <string>
#include <stdexcept>
std::tuple<double, char, std::string> get_student(int id)
{
if (id == 0) return std::make_tuple(3.8, 'A', "Lisa Simpson");
if (id == 1) return std::make_tuple(2.9, 'C', "Milhouse Van Houten");
if (id == 2) return std::make_tuple(1.7, 'D', "Ralph Wiggum");
throw std::invalid_argument("id");
}
int main()
{
//初始化tuple对象
auto student0 = get_student(0);
//通过get读取数据
std::cout << "ID: 0, "
<< "GPA: " << std::get<0>(student0) << ", "
<< "grade: " << std::get<1>(student0) << ", "
<< "name: " << std::get<2>(student0) << '\n';
}
