侯捷课程笔记（一）（传统c++语法，类内容）

2023-09-03更新：
本小节已经完结，只会进行小修改
埋下了一些坑，后面会单独讲或者起新章节讲

最近在学习侯捷的一些课程，虽然其中大部分内容之前也都已经了解过了，不过还是收获颇丰，特别是独立与所谓语法之外的，还有许多与设计相关的。

这一章内容比较简单，也就直接摆出内容吧，相关重点内容就提一提，大部分都直接掠过了。然后会加入一些自己的侯捷没有讲到的内容。

那就直接开始吧

类设计时头文件防止重复包含

通常用法就是

#ifndef FOO_H__
#define FOO_H__
// ... 主体内容#endif // FOO_H__

因为这个很常用，但是每次都要写三行，也就有了简化版本

#pragma once

不过这个可能需要编译器支持（大部分肯定都是没问题的）

类内成员函数默认就是inline

inline就是内联，inline允许我们在头文件中定义函数重复包含时而不会发生重复定义问题
由于很多时候我们写类是在头文件中（声明在头文件），这时候，如果成员函数定义在类内，不也就是把函数放在了头文件吗，编译器比较智能，也就默认给类内定义的成员函数自动加上了inline属性
如果我们要把类的成员函数写在类外，就没有inline这个属性了，这时候如果还在头文件，我们就要手动加上inline了

类使用初始化列表对成员进行初始化

初始化列表其实也就只有两个需要注意的点：

初始化的顺序不是按照写的顺序来的，而是按照成员变量定义的顺序来的
如果父类没有默认构造函数，也就是子类必须显式调用函数初始化父类，这时候也就必须要使用初始化列表初始化父类

类内对函数加上const（常函数）

正常的成员函数是可以更改类的，所以对于一个const属性的类，编译器考虑到这个类不可以更改，也就不允许它调用普通的成员函数，只能调用常函数（带const属性的函数）
一个良好的变成习惯是：对于一些不会更改成员变量/类属性的函数，都应该加上const属性，比如获取变量GetVal类似的函数

ps：使用const实例化一个对象，这个类一定要有用户定义的构造函数

对于第一点，比如下面的代码：

struct A {int a;int b;A() : b(1), a(2) {}
};

在这里初始化的顺序实际上是先执行a=2，再执行b=1，因为a是先定义的那个
看起来好像无所谓，但是下面的代码

struct A {int a;int b;A() : b(1), a(b) {}
};

就会出现a先初始化，但是这时候b还没有初始化的问题

对于第二点，比如

struct Base {int a;Base(int){}
};
struct Derive : public Base {Derive(){};
};

父类没有默认的构造函数，子类必须要也只能通过初始化列表初始化父类

struct Derive : public Base {Derive():Base(10){};
};

对于一个类来说，常用的构造函数或者基本架构是什么样的

在侯捷的课程中，常写的是

构造函数
析构函数
拷贝构造函数
拷贝赋值函数

其中如果类中包含指针，常常会自己写拷贝构造和拷贝复制，并会在析构函数中对指针进行处理

而在c++11后引入右值的概念
增加了

移动构造函数
移动复制函数

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

类中使用友元和重载cout

我们通常会这么写，并且也可以直接把重载函数写在类内

struct A {public:friend std::ostream& operator<<(std::ostream& os,const A& obj) {os << obj.a;return os;}private:int a;
};

可以注意几点：

加上friend就可以访问类中的私有变量
输入的os没有加上const，是因为os执行<<会更改内部内容，无法使用const
输入的引用是为了避免不必要的拷贝，obj加上const是加上&后也可以传入右值
返回引用是可以使用链式编程

带有指针的类的结

如果类内带有指针，比如类的构造函数里会new一块内存。

需要在析构函数内释放对应的内存
需要注意深拷贝和浅拷贝的问题
- 拷贝构造函数和复制构造函数需要重写，重新开辟内存来进行深拷贝
在赋值构造前需要注意是否是自身赋值（自己赋值给自己），需要判断这种特殊情况以防止bug

比如下面这个示例，注意关注一下前面提到的几点

template <typename T>
struct A {public:A(int n) {size = n;str = new T[n];}~A() { delete[] str; }A(const A& obj) { Copy(obj); }A& operator=(const A& obj) {if (&obj == this) return *this;Copy(obj);return *this;}void Copy(const A& obj) {if (str) delete[] str;size = obj.GetSize();str = new T[size];std::memcpy(str, obj.str, size * sizeof(T));}int GetSize() const { return size; }private:int size = 0;T* str = nullptr;
};

内存分配和管理

这一部分其实单独属于一块内容，后面会单独讲

设计模式（单例模式或者其它）

这一部分其实单独属于一块内容，后面会单独讲

类转换成标准类型(operator int())

类可以使用operator转换成一些类型，在编辑器认为转化可以通过编译时会进行转换，当然我们也可以使用static_cast显式转化

struct A {public:A(int a_) { a = a_; }int a;operator int() {return a;}operator float() {return a;}
}
void Test() {Aa(10);int b=10+static_cast<int>(a);int c=static_cast<float>(a)+100;
}

需要注意的是，这个operator函数并不需要返回值，默认返回值类型就是你写的要转换的类型
这里operator不光可以转为内置类型int/float，还可以转换成自己写的类等等

类通过单参数的构造函数自动转化/explicit

c++可以通过operator将类转化成一些类型，同样也支持反向转化，编译器可以自动根据单参数输入的构造函数，将对应的参数的自动执行构造函数构造对象
💡：这里说的单参数，只指可以输入是一个参数的函数，比如一个函数有三个三数，但是后面两个带了默认参数，也满足单参数；又或者只有一个参数，并且这个参数是默认参数，也属于单参数

struct A {public:A(int a_) { a = a_;}int a;A operator+(const A& obj) {return A(a+obj.a);}
};

比如我要执行： A a(10); A b=a+10; 这里重载了+运算符，c++会自动将后面的10调用构造函数，转换成一个类

如果是A b=10+a就不行
这里的+运算符属于内置的int，在这里就不会默认转换
如果要运行这句话，就要用前面的operator int()
operator int() {return a;
}
运行的顺序就是先把a转换成int，然后10+整数，然后将加之后的结果转换成A类类型赋值给b

如果我们同时写了单参数的构造函数和operator 类型()，就有可能出现冲突，就比如上面的例子：


struct A {public:A(int a_) { a = a_;}int a;A operator+(const A& obj) {return A(a+obj.a);}operator int() {return a;}
}void Test() {A a(10);A b=a+10;A c=10+a;
}

这里的A b=a+10;就会有问题，因为冲突了

因为既可以把10调用构造函数转换成类然后执行operator +
也可以把a转换成int，然后加了后再调用构造函数转换成类

这时候我们就可以使用explicit显式的禁止允许单参数的构造函数的默认转换，这样那个构造函数就只允许我们显式调用，而不允许转换了。在示例中也就是不允许10转换成类的类型了

让类表现出指针形式（重载`*`和`->`）

我们可以重载*和->让类表现出类似于指针的形式，使用示例比如说智能指针和容器的迭代器

struct A {public:int& operator*() const {return *p;}int* operator->() const {return &(this->operator*());// return p;}int* p;
};

在这里，*用来表现解引用，->用来表现指针的成员内容，一般来说->在函数返回值表现形式后还会有一个潜在的->（设计如此）

让类表现出函数形式（重载括号运算符）

这个其实非常常用，比如在ceres库中用于传递代价函数，平时也把这种函数叫做仿函数（模仿函数？）

struct A {public:template <typename T>T operator()(const T& a,const T& b) {return a>b?a:b;}
};
void Test() {A a;std::cout << a(10,20);
}

函数模板/类模板/模板模板参数

对于模板来说，关键字class和typename是一样的，为啥有两个？历史原因，不重要了
函数模板：

template <typename T>
void Foo(T t) {}

类模板：

template <typename T>
struct Foo {Foo(T t) {}
}

模板模板参数：

template <typename T>
struct Foo {T foo;
};template <typename T,template <typename> class my_class>
struct A {my_class<T> class_a;
};template <typename T1,typename T2>
struct Goo {T1 goo1;T1 goo2;
};
template <typename T1,typename T2,template <typename,typename> class my_class>
struct B {my_class<T1,T2> class_b;
};void Test() {A<int,Foo> a;B<int,float,Goo> b;
}

其中：template <typename> class my_class是一个示例，表示输入的是带有一个模板参数的类

template表示这是一个模板
typename的个数表示对应类的模板个数，需要和传入的模板类对应
class 也是个关键词，和typename一样，换成typename也是可以的
my_class是这个模板名

在上面的示例中，分别给了一个参数和两个参数的模板类传参示例

模板特化和偏特化

其实特化也就是指定模板的某一个或者任意个参数。
所以特化也就分成全特化和偏特化，全特化就是所有模板参数都指定的特化，偏特化就是只指定部分的特化

有一条规则是函数模板只允许全特化，不允许偏特化，类模板允许偏特化

比如在c++标准库中判断一个参数是否为整数的源码：

// Integer types
template <typename _Tp>
struct __is_integer {enum { __value = 0 };
};
template <>
struct __is_integer<bool> {enum { __value = 1 };
};
template <>
struct __is_integer<char> {enum { __value = 1 };
};
template <>
struct __is_integer<signed char> {enum { __value = 1 };
};
template <>
struct __is_integer<unsigned char> {enum { __value = 1 };
};
...
后面有其它整数类型包括了int和long,都是和前面一样的
...

在这里列出所有整数类型，只要是整数就会进入到特化的版本，这样只需要根据__value的值就可以判断了
上面这种形式就是全特化

再给个函数模板全特化的例子：

template <typename T1,typename T2>
void Foo(T1 a,T2 b) {std::cout << "Test1" << std::endl;
}template<>
void Foo<int,float>(int a,float b) {std::cout << "Test2" << std::endl;
}void Test() {Foo<int,int>(10,20);Foo<int,float>(10,20);Foo(10,20);Foo(10,20.0f);
}

下面演示下类模板的偏特化和全特化

template <typename T1,typename T2>
struct A {A(T1 a,T2 b) {std::cout << "A" << std::endl;}
};template <typename T>
struct A<int,T> {A(int a,T b) {std::cout << "A<int,T>" << std::endl;}
};template <typename T>
struct A<float,T> {A(int a,T b) {std::cout << "A<float,T>" << std::endl;}
};template <>
struct A<int,int> {A(int a,int b) {std::cout << "A<int,int>" << std::endl;}
};template <>
struct A<int,float> {A(int a,float b) {std::cout << "A<int,float>" << std::endl;}
};void Test() {A("10","20");A(10,"20");A(10.0f,"20");A(10,20);A(10,20.0f);
}