Cherno C++ 学习(二)
学习来源https://www.youtube.com/user/TheChernoProject/playlists
C++的static关键字
static分可以修饰两种变量或成员函数，一种是在类（或结构体）外，另一种在类（或结构体）内。
在类外的static
对于在类（或结构体）外的函数或变量，我们将其称为全局函数或全局变量，对于普通的全局变量，整个项目内的cpp文件都可以对其进行访问，Static关键字可以修改全局变量的作用域，与类里的私有成员变量类似，加了static的变量如同该cpp文件的私有全局变量
如果对于一个全局变量，我们只想让他成为该CPP内的全局变量，而不想让整个项目都能访问它的值，那么我们可以使用static关键字：
static int a =5; // 只在当前文件范围内使用
顺便提一句，因为cpp定义的全局变量所有文件里都能访问，所以如果同时有两个CPP有相同的定义，是会报错的:
//A.cpp
int global_a;
//B.cpp
int global_a;
会报错：
这个时候可以用extern关键字来解决，表示其中一个全局变量是从外面引进来的：
//A.cpp
int global_a;
//B.cpp
extern int global_a; //正确
值得一提的是，对于static变量，即使用extern关键词去声明，也是不能获取的，如下的代码示例，如果我们光这样声明，不在B.cpp里去调用global_a的值，是不会报错的。
//A.cpp
extern int global_a;
void main()
{
}
//B.cpp
static int global_a;
比如我们把B.cpp再加一个函数：
```css
//A.cpp
extern int global_a;
void main()
{
}
//B.cpp
static int global_a;
void Func()
{
int v = global_a;
}
会发现运行后报错了，因为Link阶段检查到了改变量是无法获取的：
在类内的static
在类内的static变量或函数，表示该变量或该函数是整个类共有的，相当于类里的单例，即使没有创建任何对象，这些变量和成员函数也随着类存在。
举个例子
class A
{
public:
int a;
static int b;//声明b
}
int A::b;//定义b
int main()
{
cout << A::a; //错误
cout << A::b; //正确
A instance;
cout << instance.a; //正确
cout << instance.b; //正确，这种语法是允许的，实际上相当于cout << A::a
}
值得注意的是，类的static函数无法直接使用非静态成员变量和成员函数，因为他们是属于类的成员的，举个例子
class A
{
public:
int a;
static int b;//声明b
static void Log()
{
cout << b << endl;//正确
cout << a << endl;//错误，编译不过
}
}
int A::b;//定义b
如果要访问非静态成员或函数，需要传入类的对象：
static void Log(A& instance)
{
cout << b << endl;//正确
cout << instance.a << endl;//正确
}
局部作用域内的static变量
static关键字能够修改局部作用域内的成员的lifetime(生命期)，使其跟程序的生命期一样长
举个例子：
//A.cpp
int a = 0;//全局变量
void plusA()
{
a++;
cout << a <<endl;
}
//B.cpp
void plusA()
{
static int a = 0;//只会在第一次进入此函数的时候执行
a++;
cout << a <<endl;
}
上述两段代码，如果同时执行n次，最后的结果都是一样的，唯一不同的就是，我们能在A.cpp的任何地方读取a的值，因为a是全局变量，但是在B.cpp里面，我们只能在plusA中读取a的值，也就是说a变量的作用域没变，还是仅限于plusA函数，但是其生命期现在跟整个程序几乎一样长。也就是说，全局成员加上static就变成了该文件的私有成员，class内的成员加上static就变成了全类的共有成员，作用域（比如函数体内，{} 大括号里的范围）内的成员加上static就变成了永不消失的成员
有的人会说这玩意儿没卵用，但是这里可以举个例子，通过local static member使代码更简洁：
//对于单例模式，如果不用local static member
//也是一种通用的写法
class Singleton
{
private:
static Singleton instance;
Singleton(){} //构造函数私有化
public:
static Singleton& Get(){return instance;}
Singleton (const Singleton&) = delete;//禁止通过"="进行Singleton的复制
}
Singleton Singleton::instance = null;//初始化单例
如果通过local static member可以简化代码
class Singleton
{
private:
Singleton(){} //构造函数私有化
public:
static Singleton& Get()
{
static Singleton instance;//只会在第一次使用Get时进行创建
return instance;
}
Singleton (const Singleton&) = delete;//禁止通过"="进行Singleton的复制
}
C++的构造函数
1. C++的默认构造函数相当于没有参数的函数体为空的函数，而且只有一个，同样如此的还有默认析构函数和默认复制构造函数，别记错了
ClassName()
{
}
2. 禁止C++自动为类生成默认构造函数的方法有两个：
- 构造函数私有化
Class Student
{
private:
Student(){}
};
- 直接声明禁止构造函数
Class Student
{
public:
Student() = delete;
};
3. sizeof派生类时，除了派生类本身的变量大小，还要加上从基类继承过来的变量的大小。
4. C++类的protected访问级别介于private和public之间，不可以用类成员加.后缀的形式访问，但是公有继承的派生类可以直接使用protected成员
5. C++中类的构造函数应该被声明为explict，否则会产生隐式转换，如下所示：
class Student
{
public:
Student(int a){num = a;}
private:
int num;
}
int main()
{
//如果构造函数不加explict，那么我们可以这么创建一个对象
Student s = 5;//这样也能创建对象，如果写错代码，很容易出现这样的错误
}
所以应该在构造函数前面加上关键字explicit
Smart Pointers
智能指针本质上只是一个包含了原始指针的Wrapper，功能就一个：
自动释放指针，无需使用delete，甚至也不需要使用new
Smart pointer is a wrapper class over a pointer with operator like * and -> overloaded. The objects of smart pointer class look like pointer, but can do many things that a normal pointer can’t like automatic destruction (yes, we don’t have to explicitly use delete), reference counting and more.
代码本质上大概是这个样子:
using namespace std;
class SmartPtr
{
int *ptr; // Actual pointer
public:
// Constructor: Refer https://www.geeksforgeeks.org/g-fact-93/
// for use of explicit keyword
explicit SmartPtr(int *p = NULL) { ptr = p; }
// Destructor
~SmartPtr() { delete(ptr); }
// Overloading dereferencing operator
int &operator *() { return *ptr; }
};
int main()
{
SmartPtr ptr(new int());
*ptr = 20;
cout << *ptr;
// We don't need to call delete ptr: when the object
// ptr goes out of scope, destructor for it is automatically
// called and destructor does delete ptr.
return 0;
}
智能指针会在退出局部范围时释放,比如:
void main()
{
{
smartPoint p = ....//创建智能指针
}//会在这里释放
}
C++ 11提供了以下几种Smart Pointers, 使用智能指针需要#include<memory>
std::unique_ptr
a smart pointer that owns a dynamically allocated resource;(不可复制, 一个资源只可以使用一个pointer)
如下所示, unique_ptr的复制构造函数和 = 运算符重载都被禁用了, 所以unique_ptr不能当作函数的参数进行传参
具体有两种写法:
std::unique_ptr<ClassName>ptrName(new ClassName());
std::unique_ptr<ClassName>ptrName = std::make_unique<ClassName>();//这种更好
std::shared_ptr
a smart pointer that owns a shared dynamically allocated resource. Several std::shared_ptrs may own the same resource and an internal counter keeps track of them;
shared_ptr允许同一个对象出现多个指针指向它, shared_ptr会记录这个指针的数量, 称为refference count, 每复制一个指向该对象的指针, 引用计数会加1, 每一个指针退出其scope函数范围进行释放时,会减1, 当引用计数为0时,会释放所有的指针, delete掉该对象
举个例子:
void main()
{
{
//Entity是一个类名, 该类的析构函数执行时会打印消息
std::shared_ptr<Entity>ptr1;
{
std::shared_ptr<Entity>ptr2 = std::make_shared<Entity>();//引用计数加一
ptr1 = ptr2;//引用计数加一
}//引用计数减一
}//引用计数减一, 执行析构函数, 打印消息
}
std::weak_ptr
like a std::shared_ptr, but it doesn’t increment the counter.
与shared_ptr类似, 但是不会改变引用计数, 还是上面的例子:
void main()
{
{
//Entity是一个类名, 该类的析构函数执行时会打印消息
std::weak_ptr<Entity>ptr1;
{
std::shared_ptr<Entity>()ptr2 = std::make_shared<Entity>();//引用计数加一
ptr1 = ptr2;//引用计数不变
}//引用计数减一, 执行析构函数, 打印消息
}
}
Templates
C++的template关键字, 可以方便我们写代码:
如下例子是一个log系统, 无论输入什么类型的变量, 都可以打印出来:
template<typename T>
void log(T v)
{
std::cout << v << std::endl;
}
void main()
{
log(5);
log<int>(5);//其实log(5)本质上是这么写
log(5.6f);
log("Hello");
}
可以看出来, T是代表了所有的类型, 那么上述功能具体是怎么实现的呢?
template功能是由编译器实现的:
举个例子, 编译器在编译阶段实际干了以下工作:
编译到语句log(5) -> 前往log函数 -> 获取参数的类型为int ->根据模板定义, 复制出一个函数出来, 来替换log(5)这条语句:
void main()
{
std::cout << 5 << std::endl;
}
也就是说, template这个指令, 是告诉编译器, 按照输入的参数的类型, 给我创建出相应的函数, 再进行执行的这个过程, 如果不调用模板函数, 那么编译器会直接无视这个函数, 如下所示:
template<typename T>
void log(T v)
{
std::cout << v < std::endl;//可以看到这里有语法错误
}
void main()
{
return 0;//编译器编译成功
}
拓展函数的参数类型, 是template关键字的用法, 实际上该用法远不止上面的那么简单, 再举一个例子, 如果我们要写下面的一个类:
class C
{
int array[num];//这里会报错, 因为num不是常数
}
上面的写法会不通过, 因为必须是一个常量, 通过template, 我们可以这么写:
template<int N>
class C
{
private:
int array[N];//这里能编译
public:
int getSize() const { return N };
}
void main()
{
C<5>obj;//<>里的5就是传入模板类的N的值
}
为什么这个能编译呢, 这就涉及到了上面讲的原理了, 实际上编译器会创建一个类, 编译的是以下文件:
class C
{
private:
int array[5];
public:
int getSize() const { return 5 };
}
void main()
{
C c;
}
我们可以再举一个拓展的例子:
template<typename T, int N>
class C
{
private:
T array[N];//这里能编译
public:
int getSize() const { return N };
}
void main()
{
//下面这一句就很像我们用到的STL容器了, 实际上他们也底层都是用模板封装的
C<int, 5>obj1;
C<string, 6>obj2;
}
关于template的一点提醒
很多游戏公司明令禁止使用template, 因为程序臃肿之后，template拓展得很复杂， 代码可能会很难看懂.
不过template用于制作log系统、material系统这些东西，可能还是挺方便的
