重学C++学习笔记（一）

越深入底层，C/C++的作用就越大，对于底层的了解比别人更具体，工作中由于不是主要语言，用的少，近来有空，重新完整的过了一遍C++的语法和一些内存知识，在这里做一下笔记

基础语法

数据类型

int / short / long, / long long：默认都为signed，也可以加unsigned变为无符号数
1
2
3
int a = 10;
uint a = 10u;
long a = 10l;
float / double, long double：默认都为signed，也可以加unsigned变为无符号数
bool：本质是1和0
char(1个字节) / wchar_t(2个字节)
1
2
char a = 'a';
wchar_t a = L`a`;

进制表示

十进制：int a = 10;
十六进制：int a = 0xF2;
八进制: int a = 070;（以0开头）

运算符

算数运算符: +,-,*,/,%,++,--
关系运算符: ==, !=, >, <, >=, <=
逻辑运算符: &&, ||, !
位运算符: &, |, ~（取反） ^（异或）, <<, >>
赋值运算符: =, +=, -=, *=, /=, %=
其他运算符:
- 获取变量大小：sizeof（不是运算符，为编译器特性）
- 三元运算符：? :
- 取址运算符: &
- 取值运算符: *

运算符重载

class Point {
    // 友元函数，为了访问私有变量
    const Point operator-(const Point a, const Point b);
private:
    int m_x;
    int m_y;
public:
    Point(int x, int y): m_x(x), m_y(y) { }

    // 加号运算符
    cosnt Point operator+(const Point &point) const {
        return Point(m_x + point.m_x, m_y + point.m_y);
    }

    // 返回引用，用于支持（a += b） = 1
    Point &operator+=(const Point &point) {
        m_x += point.m_x;
        m_y += point.m_y;
        return *this;
    }

    // 单目运算: Point p2 = -p1;
    const Point operator-() const {
        return Point(-m_x, -m_y);
    }

    // 前置运算符: Point p2 = ++p1;
    Point &operator++() {
        m_x += 1;
        m_y += 1;
        return *this;
    }

    // 后置运算符: Point p2 = ++p1;
    const Point operator++(int) {
        Point temp(m_x, m_y);
        m_x += 1;
        m_y += 1;
        return temp;
    }
};

// 定义在外面
const Point operator-(const Point a, const Point b) {
    return Point(a.m_x - b.m_x, a.m_y + b.m_y);
}

int main() {
    auto p1 = Point(1, 2);
    auto p2 = Point(3, 4);

    // p3 = Point(4, 6);
    auto p3 = p1 + p2;

    // p4 = Point(2, 2);
    auto p4 = p2 - p1;
    return 0;
}

+运算符

第一个const：用于限制不能当成左值(p1 + p2) = Point(1, 2)
第二个const：用于让参数接受const和非const变量
第三个const：用于声明为const函数，让返回值const支持二次操作p1 + p2 + p3

+=运算符

返回引用，用于支持(a += b) = 1

关于位运算

左移：移走位补0
右移：
- 逻辑右移：移走位补0
- 算数右移：对于有符号数，正数移走位补0，负数移走位补1

具体使用逻辑右移还是算数右移，取决于编译器，所以，尽量不要使用右移运算符

流程控制

if-else
switch-case
do-while

for: C++11支持下面集合遍历

int items[] = {1, 2, 3};
for (auto item: items) {
    cout << item << endl;
}

头文件重复引用

使用#define宏防止重复导入

#ifndef __HEADER_H
#define __HEADER_H

...

#endif

在文件头使用#pragma once也可以防止重复导入（旧的编译器可能不支持），通常放在文件头
1
2
3
#pragma once

...

注释

C++的注释与C语言一样

// 单行注释

/*
    多行注释
    多行注释
*/

不支持嵌套注释

auto自动类型

在C++11添加了auto用于自动推断类型，为编译器特性，免去长长的类型声明

// 编译器会自动推断出i的类型，下面语句等价
auto i = unique_ptr<int>(new int(10));

unique_ptr<int> i = unique_ptr<int>(new int(10));

const

int age = 10;

// p1不是常量，*p1是常量
const int *p1 = &age;
// 与p1一样
int const *p2 = &age;

// p3是常量，*p3不是常量
int * const p3 = &age;

// p4是常量，*p4是常量
const int * const p4 = &age;
// 与p4一样
int const * const p5 = &age;

const修饰的是右边的内容
const还能用于修饰函数参数，让引用参数接受常量参数，见后面

头文件和实现文件分离

头文件person.h

class Person {
private:
    int m_age;
public:
    void setAge(int age);
    int getAge();
    Person();
    ~Person();
}

实现文件person.cpp

#include "Person.h"

void Person::setAge(int age) {
    m_age = age;
}
int Person::getAge() {
    return m_age;
}
Person::Person() {
    m_age = 0;
}
Person::~Person() {
    // ...
}

命名空间

namespace BM {
    class Person {
        int m_age;
        int m_height;
    }
    void func() {

    }

    // 命名空间支持嵌套
    namespace SS {
        // ...
    }
}

// 全局命名空间
// 可以通过`::func`访问
// 默认情况下不用加`::`
void func() {

}

BM::Person person = new BM::Person();

// 只用命名空间的部分成员
using BM::Person;

// 使用using之后不用加前缀
using namespace BM;

// 访问命名空间里面的方法
BM::func()
// 访问全局命名空间
::func()

命名空间不影响内存布局
命名空间可以在代码块使用
命名空间可以合并

namespace BM {
    int g_age;
}
namespace BM {
    int g_height;
}
// 上面与下面等价
namespace BM {
    int g_age;
    int g_height;
}

引用（Reference）

// 变量
int age = 10;

// 引用变量，相当于age的别名，定义的时候就要赋值
int &rage = age;

// 相当于：age = 20
rage = 20;

int height = 20;

// rage赋值后不能修改，下面相当于rage = 20，rage还是引用age
rage = height

交换两个数

void swap(int &a, int &b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int a = 10;
int b = 20;
swap(a, b);

// a为20，b为10

引用不可以修改指向，指针可以

本质：引用本质就是指针，只是从编译层面削弱了功能，增强了安全性，下面代码生成最终机器码是一样的

int age = 10;

// 指针
int *p = &age;
*p = 30

// 引用
int &ref = age;
ref = 30;

数组的引用

int array[] = {1， 2， 3};

// 需要指定数组大小
int (&ref)[3] = array;

// 使用指针接受引用
int * const &ref = array;

// 使用auto
auto &ref = array;

常引用(const reference)

int a = 10;
const int &b = a;

// 无法修改引用的值，报错
b = 20;

常引用作为函数参数时

// 使用const修饰参数，可以接受常量和变量
int sum(const int &a, const int &b) {
    return a + b
}

int p = 10;
int q = 20;

// 可以接受变量
sum(p, q);

// 可以接受常量
sum(p, 10);

指针

变量三个重要信息

变量的内容
变量存放的地址
变量的类型

指针变量：专门用来记录变量地址的变量，通过指针变量可以间接访问另一个变量的值

未初始化和非法的指针

// a未初始化
int *a;
// 直接修改a指向的值，会出现不可预测的问题
*a = 12;

NULL指针：不指向任何东西，表示一种状态，指针变量不用时，或未初始化时，应置位NULL，在C++11之后，空指针使用nullptr

int *a = nullptr;

if (a != nullptr) {
    *a = 12;
}

野指针：指向垃圾（程序逻辑上用不到的指针）内存的指针，通常是被回收资源后未置空的指针，不再使用的指针变量应置为nullptr值

指针的基本操作：

&运算符: 取变量地址
*运算符：去指针指向地址的值

指针编译成汇编

int a = 10;
// mov dword ptr [ebp-0Ch], 10         ; a的地址为[ebp-0Ch], a = 10

int *p = &a;
// lea eax, [epb-0Ch]               ; 取a的地址赋值到eax
// mov dword ptr [ebp-18h], eax     ; p的地址为[epb-18h]，把a的地址赋值给指针p，int *p = &a;

*p = 20;
// mov eax, dword ptr [ebp-18h]     ; eax = &a;
// mov dword ptr [eax], 20          ; 取出eax指向的地址，复制20，相当于 age = 20;

指针变量原理

Person person;
person.age = 10;
// mov dword ptr [ebp-14h], 0Ah
person.height = 20;
// mov dword ptr [ebp-10h], 14h

Person *p = &person;
// lea eax, [ebp-14h]               ; 将person的地址赋值给寄存器eax
// mov dword ptr [epb-20h], eax     ; 将寄存器eax的地址赋值给变量p(epb-20h)

p->age = 10;
// mov eax, dword ptr [epb-20h]     ; 将变量p存放的地址赋值给eax，eax = &person
// mov dword ptr [eax], 0Ah         ; 将eax指向对象赋值10

可以看出，通过指针针变量访问成员变量生成2条语句，一条取地址的值，第二条才是根据变量的偏移量取变量值，而普通变量访问成员变量会生成1条语句

Person person;
person.m_id = 10;
person.m_age = 20;

// 这里取的是 m_age
Person *p = (Person *)&person.m_age;
p->m_id = 30;

cout << person.m_id << endl;
cout << person.m_age << endl;
// 输出: 10, 30

汇编很多时候（对于栈空间）是通过偏移量来操作对象和字段的

内存空间管理

malloc / free：C语言的方式
new / delete：C++的方式，推荐
new[] / delete[]：数组空间

数组释放的时候和变量不一样，需要加中括号

// C语言申请空间
int *p1 = (int *)malloc(4);
*p1 = 20;
free(p1);

// C++申请空间
int *p2 = new int;
*p2 = 10;
delete p2;

// 如果是数组，delete也要加中括号
char *p3 = new char[4];
delete [] p3;

通常情况下申请的内存空间不会进行初始化（不同平台可能不一样）

int *p1 = (int *)malloc(4);
// 初始化
p1 = 0;

int size = sizeof(int) * 10;
int *p2 = (int *)malloc(size);
// 初始化，把所有空间清零
memset(p2, 0, size);

如果是对象，new创建的对象会调用构造函数，而malloc不会，在C++中，推荐使用new在堆申请空间

类型转换

C语言的类型转换

1
2
3

int a = 10;
long b = (int)a;
double c = double(a)

C++有四中类型转换符

static_cast: 通常基本数据类型转换，用于非const变量转换成const变量，由于C++有隐式转换，通常不用写

int a = 10;

// 下面两句等价
double b = static_cast<double>(a);
double b = a;

Person *p1 = new Person();

// 下面两句等价，C++默认会做隐式转换
const Person *p2 = static_cast<const Person *>(p1);
const Person *p2 = p1;

dynamic_cast: 用于多态类型转换，如果不能转换，则返回nullptr

Person *p1 = new Person();
Person *p2 = new Student();

// 父类不能赋值给子类，报错
Student *stu1 = p1;

// dynamic_cast会做运行时安全检查，类型不匹配时，会返回NULL
Student *stu2 = dynamic_cast<Student *>(p1);
Student *stu3 = dynamic_cast<Student *>(p2);

// 汇编：会调用一个函数进行
// call __RTDynamicCast(0C14ABh)        ; 调用方法判断类型，返回值放到eax，可能为NULl，可能为对象的值
// add esp, 14h
// mov dword ptr [stu1], eax

// stu2 = NULLL
// stu3 = p2

const_cast: 将const常量转换成非常量，有安全风险

const Person *p1 = new Person();
// 无法直接转换，报错
Person *p2 = p1;

// 下面两种转换等价
Person *p2 = const_cast<Person *>p1;
Person *p3 = (Person *)p1;

reinterpret_cast: 纯二进制拷贝，没有类型检查

int a = 10;
// 0A 00 00 00

double b = a;
// 00 00 00 00 00 00 24 40

// 由于double类型和int的表示10不一样，所以下面b != 10;
double c = reinterpret_cast<double&>(a);
// 0A 00 00 00 CC CC CC CC
// -9.25596e+61

多余对象拷贝

Point func() {
    // 1. 调用Point默认构造函数
    Point p;
    return p;
}

void main() {
    // 2. 从func函数栈拷贝Point到main函数栈
    // 3. 调用Point拷贝构造函数
    Point p = func();
}

上面代码如果编译器不做优化的话，会调用3次Point的构造函数

在func函数栈构造Point
从func函数栈返回到main函数栈，会把返回值，通过拷贝构造函数拷贝到main函数栈
main函数中，返回值赋值给p，会调用Point的拷贝构造函数

编译器在编译的时候会做返回值优化(RVO)，不会造成多次拷贝，可以通过-fno-elide-constructors关闭该优化

C++程序内存分布

栈
堆
全局区/静态区: 可读写
常量区: 只读
代码段: 只读

函数

函数重载

指函数名相同的函数，函数参数类型不同或函数参数顺序不同或函数参数个数不同，构成函数重载，函数重载与返回值类型无关（C语言不支持函数重载）

// 下面函数都构成重载
int sum(int a, int b);
int sum(long a, long b);
int sum(int a, int b, int c);

int sum(int a, long b);
int sum(long a, int b);

// const引用(指针)与非const引用(指针)构成重载，下面两个函数是不同函数
int sum(int &a, int &b);
int sum(const int &a, const int &b);

本质：C++使用了name mangling或name decoration的技术，C++编译器在编译的时候会对函数名进行改编，修饰，不同的编译器修饰的规则可能不同，例如上面sum函数在VC++会编译下面方法名

1	sum0, sum1, sum2, sum3, sum4, sum5, sum6

默认参数

C++支持默认参数，如果有声明和实现，默认参数必须放在声明上

int sum(int a = 1, int b = 2);

int sum(int a, int b) {
    return a + b;
}

默认参数可以是常亮，全局符号

本质：编译器在编译阶段根据默认参数补完传参，也就是sum(1)和sum(1, 2)编译后的汇编代码是一样的

extern “C”

使用extern "C"修饰的代码会按照C语言的方式编译

// func会被编译为C语言的方法
extern "C" void func() {
    // ...
}
extern "C" {
    // C语言代码
    void func() {
        // ...
    }
}

如果函数声明和实现分开，声明需要加extern "C"，实现不加
由于C++的函数有name mangling，extern "C"通常在C语言和C++混编的时候用到
C语言不支持extern "C"，可以使用__cplusplus加判断

// C语言不支持extern符号
#ifdef __cplusplus
extern "C" {
#endif
    // 引用C头文件
    #include "header.h"
#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern "C" {
#endif
    int sum(int a, int b);
    int delta(int a, int b);
    int divide(int a, int b);
#ifdef __cplusplus
}
#endif

内联函数(inline)

1	inline void add(int a, int b) { return a + b; }

函数展开，类似于define的效果，省去函数调用开辟栈空间的操作

函数代码体积小（小于10行）
函数频繁使用

递归函数不会被编译为内联函数，即使声明了

其他知识点

关于补码

对于有符号数的正负3

十进制+3: 00000000 00000000 00000000 00000011
十进制-3: 10000000 00000000 00000000 00000011

上面的表示并不方便计算（两个数想加），实际上，计算机使用补码的方式表示有符号数，在计算上有很大的优势

十进制+3: 00000000 00000000 00000000 00000011
十进制-3: 11111111 11111111 11111111 11111101

使用补码是为了：用加法计算减法，性能更优，CPU不用单独再实现一个减法运算器

字节序（Byte Ordering）

大端法（Big Endian）: 高位字节在前，低位字节在后，这是人类读写数值的方法
小端法（Little Endian）: 低位字节在前，高位字节在后

为什么会有小端字节序？

答案是，计算机电路先处理低位字节，效率比较高，因为计算都是从低位开始的。所以，计算机的内部处理都是小端字节序

为什么会有大端字节序？

人类习惯读写是大端字节序（从左到右）。所以，除了计算机的内部处理，其他的场合几乎都是大端字节序，比如网络传输和文件储存。

引用：https://www.cnblogs.com/gremount/p/8830707.html

内存对齐

typedef struct {
    int a;
    double b;
    short c;
} A;
typedef struct {
    int a;
    short b;
    double c;
} B;

sizeof(A);          // 24
sizeof(B);          // 26

C++的结构体是按变量的定义顺序进行存储的，也就是 a -> b -> c
CPU从内存中读取数据时，有一个最小读取单位，例如64位的CPU，从内存的0地址开始，0-63bit的数据可以一次IO读取出来，64-127bit的数据也可以一次读取出来，每个次读取的单位是64，CPU和内存IO的硬件限制导致没办法一次跨在两个数据宽度中间进行IO，为了提高CPU读取效率，减少IO次数，编译器在编译代码的时候，会考虑到内存对齐的情况，例如上面结构体A会被编译为24个字节

如果结构体A不进行内存对齐的话，变量b与变量a靠在一起，就会导致，读取在变量b的时候，需要两次IO

命名法

匈牙利命名法：int iMyValue，第一个小写字母表示类型
Cammel命名法：int myAge
Pascal命名法：int MyAge

编码

Unicode: 表示所有语言

ASCII: 1byte表示一个字符，存储效率高，存储的字符有限
UTF-8：1byte表示一个字符，可以兼容ASCII码，存储效率高，可变长（随机访问效率低），无字节序的问题（可作为外部编码），如网络传输普遍使用
UTF-16：2byte表示一个字符，定长（随机访问效率高），有字节序的问题（不可作为外部编码），但不能表达所有的字符
UTF-32：4byte表示一个字符，定长（随机访问效率高），有字节序的问题（不可作为外部编码），可以表达目前已存在的所有的字符

下一篇主要是面向对象相关的知识点