前言
上一章节我们讲解了 关于C++静态和指针与引用的部分
我们先来回顾一下相关的内容：
指针说白了就是地址，
int a;
int * ptr = &a
这里的整形指针 就是存放的整数变量的地址
静态 static
有两种层面：
第一种层面就是在其他的文件里，如果加入了static修饰
那么被修饰的在link的时候就会被跳过
第二种就是在类内写的静态
当类内的变量被写为静态的时候，该变量不属于此类了，属于静态类，所以就不能去访问。
类内的方法的静态后，不可以访问非静态的变量，因为被静修饰后的方法已经不属于此类，因此不能访问类内的变量
详情请看我的上一篇文章
Secure Coding in C and C ++ (三）关于语法与指针的感悟
今天就来说第三种静态 ：
1.local static
这里的localstatic保证变量的生存周期只在某个函数内部
例如：
结果显然是1 ，因为每次调用后，都重新运行了这个函数，相当于每次都将i改为了1；
但是如果给 i 加上static修饰后，就变得不一样了
这里所用到的就是生命周期的作用，
由于int被static修饰，导致其在函数空间内一直存在，只要调用这个函数，这个i就不会被重置。
其作用还体现在如下的例子中：
#include<iostream>
class Singleton{
private :
static Singleton* s_Instance;
public:
static Singleton& Get(){ return *s_Instance;}
};
在这个类中，我们使用的是两个static修饰过的
所以如果我们想去使用单例类，必须得额外声明：
Singleton* Singleton::s_Instance = nullptr;
随后才能在main中调用：
我们使用local static 使其变的更加简洁
public:
static Singleton& Get()
{
static Singleton instance;
return instance;
}
};
如果不加以static修饰，该变量会在栈上被创建，随着函数结束，此变量会被销毁。
说白了这里的类内的变量如果是静态，只能通过类名：：变量的形式进行修改
必须要类内定义，类外初始化。
2.枚举ENUM
枚举说白了我感觉就是一个集合：
如下：
#include<iostream>
using namespace std;
enum Example
{
A,B,C
};
int a=1;
int b=2;
int c=3;
int main()
{
Example value=B;
cout<<value<<endl;
}
这里使用关键词：enum来初始化枚举。
随后使用{}来填充里面的内容，
当然，默认是从0开始，这里的a是0 b是1 c是2.。。以此递增
也可以给其指定类型：
enum Example:unsigned char
还记得之前的文章里的log类吗？
那个地方我们就可以用这个来优化：
#include<iostream>
using namespace std;
class Log{
public:
enum Level{
Error=0,
Warning,
Info
};
private:
int m_LogLevel ;
public :
void SetLevel(Level Level)
{
m_LogLevel = Level;
}
void LogError(const char * message)
{
if(m_LogLevel >= Error)
{
cout<<"[Error]"<<message<<endl;
}
}
void LogWarning(const char * message)
{
if(m_LogLevel >= Warning)
{
cout<<"[Warning]"<<message<<endl;
}
}
void LogInfo(const char * message)
{
if(m_LogLevel >= Info)
{
cout<<"[Info]"<<message<<endl;
}
}
};
int main()
{
Log log;
log.SetLevel(Log::Error);
log.LogError("123");
}
这里当我们去调用内部量的时候可以看到我们的调用方式是：
Log::Error注意一下
3.构造函数
构造函数的作用就是初始化类内的变量：
如
#include<iostream>
class Entity{
public:
int x,y;
void Print()
{
std::cout<<x<< ","<<y<<std::endl;
}
};
int main()
{
Entity e;
e.Print();
}
其结果为：
是因为我们只是创造了变量x和y并没有为其初始化赋值，所以被随机了
我们可以在其内部使用构造函数：
构造函数的用法就是函数名与其类名一致：
#include<iostream>
class Entity{
public:
int x,y;
void Print()
{
std::cout<<x<< ","<<y<<std::endl;
}
Entity(){
x=2;
y=3;
};
};
int main()
{
Entity e;
e.Print();
}
当然也可以在构造函数中为其传入一些参数：
Entity(float a,float b)
{
x=a;
y=b;
}
所以我们可以通过控制构造函数来对类进行一个初始化。
如果存在一个类，其作用只有一个静态的方法，在开发过程中我们不想让其他人去调用这个类，只想让其的方法被调用，我们可以将类的构造函数改为private就可以了：
#include<iostream>
class Log{
private:
Log();
public:
static void Print();
}
int main()
{ Log::Print();
Log l;
}
Calling a private constructor of class ‘Log’
这个时候就不可以使用类了，只能通过Log::Print去调用方法，当然我们也可以去删掉构造函数：
Log() = delete;即可
4.析构函数
与构造函数不同，构造函数是在初始化的时候作用的，析构函数是在销毁变量的时候使用的。
让我们回到之前写的Entity类：
class Entity{
public:
float X,Y;
Entity(float x,float y)
{
X=x;
Y=y;
}
Entity();
void Print()
{
std::cout<<X<<","<<Y<<std::endl;
}
};
析构函数的构造只是需要在类名前加入波浪线～即可
~Entity(){
std::cout<<"Destoryed Suceesuflly"<<std::endl;
}
在程序结束后，会打印出来
5.继承
继承就跟字面意思一样，是一个类继承了另一个类。
如之前创造的Entity 类中
class Entity{
public:
float X,Y;
Entity()
{
X=1.22f;
Y=2.44f;
std::cout<<"Created Compeleted!"<<std::endl;
};
void Print()
{
std::cout<<X<<","<<Y<<std::endl;
}
~Entity(){
std::cout<<"Destoryed Suceesuflly"<<std::endl;
}
};
这里加入一个新的类：
Player：
使用： 进行继承：
class Player : public Entity{
const char * Name;
void Print2()
{
Print();
}
};
继承后，Player将获得Entity里的方法同时还可以用自己的新的方法。
这里的Player其实也属于Enttity类 ，但是自己也是一个类 这属于多态 以后会详细讲
在这里：我们的Entity里有两个浮点数变量
来看一下他的大小
std::cout<<sizeof(Entity)<<std::endl;
运行结果为8
是因为浮点数站了4字节，两个浮点数就是8字节
来看一下 Player的大小：
std::cout<<sizeof(Player)<<std::endl;
结果是16 比父类Entity大一些
（至于为什么是16这里就不详细说了，得考虑到对齐的问题）
6.虚函数
虚函数的作用就是在父类里的方法可以被重写
例如：
#include<iostream>
class Entity{
public :
std::string GetName(){
return "Entity";
}
};
class Player : Entity{
private:
std::string m_Name;
public:
Player(const std::string& name): m_Name(name){}
std::string GetName(){ return m_Name;}
};
int main(){
}
这里创建了两个类，其中的第一个类是Entity ，里面有一个GetName的方法 用来返回一个Enttiy字符串
后来的Player是Entity的子类，其中也有一个GetName，这里的Getname是返回的Player中的private的name
int main(){
Entity * e = new Entity();
std::cout<<e->GetName()<<std::endl;
Player * p = new Player("KKK");
std::cout<<p->GetName()<<std::endl;
}
我们在main函数中做如此引用，运行结果肯定是一个Entity 一个KKK
这是毋庸置疑的。
我们使用一个新的Entity类，指向P，
Entity * entity = p;
这里的entity是player类的，
当我们使用里面的方法
entity->GetName();
会返回Entity；
当我们写一个函数：
void PrintEntity(Entity * entity){
std::cout<<entity->GetName()<<std::endl;
}
随后我们使用两个不同的类去调用的时候：
二者的结果都是Entity；
这是为什么呢？
明明我在Player的构造函数里写了一个m_Name的变量，为什么用Player调用GetName的时候还是父类的Entity的结果呢？
是因为没有使用虚构函数，也就是没有将父类的GetName（）重写，这就导致了这种情况的发生。
改变父类的Entity函数
virtual std::string GetName(){
return "Entity";
}
后结果为：
这样与预期的就一致了。
C++引入了虚表，会查询这个表去查找对应复写的方法所对应的类，然后将其替换，这点以后会详细点说。
当然，我们也可以在子类中将需要修改的方法加入override （前提是父类的函数是虚函数）否则会出现：
虚函数的引入毫无疑问的提高了开销：
不只需要v表的开销，在实例内也要浪费一个指针。并且在每次访问v表的时候，也要花时间去遍历查看对应的正确函数。
管他呢，自己用着爽就行。（不搞嵌入式 差cpu就没事）
7.纯虚函数（接口)
接口的存在就是为了某些父类强行让子类自己实现没有实现的方法（父母的愿望没有实现让孩子去实现）
是这样写的：
virtual std::string GetName() = 0;
在父类Entity中 ，使这个函数为0即可。
在子函数中，必须要实现完这个纯虚函数之后才能实例化。
这里取消掉了子类中的GetName()后，就报错咯
这里再来套娃：
#include<iostream>
class Printable{
public :
virtual std::string GetClassName() =0 ;
};
class Entity :public Printable{
public :
virtual std::string GetName() {return "Entity";}
std::string GetClassName(){
return "Entity";
}
};
class Player : public Entity {
private:
std::string m_Name;
public:
Player(const std::string& name): m_Name(name){}
std::string GetName() override{ return m_Name;}
std::string GetClassName() override{
return "KKK";
}
};
class A:public Printable{
std::string GetClassName() override{
return "A";
}
};
void Print(Printable* obj)
{
std::cout<<obj->GetClassName()<<std::endl;
}
void PrintEntity(Entity * entity){
std::cout<<entity->GetName()<<std::endl;
}
int main(){
Entity * e = new Entity();
Print(e);
Player * p = new Player("KKK");
Print(p);
Print(new A());
}
值得注意的是，我们在创造对象并且使用对象的方法的时候：
如这里的Print（）里面传入了一个指针，这个指针指向了对象的地址，并且使用./ -> 方法去调用其方法。这是经常用到的。
ok ，这盘文章就到这里吧
复盘一下今天学的内容简直就是面向对象的精华部分。
下一篇文章将继续讲解 可见性、字符串 、数组 等关键内容。
下期间～ 不出意外应该是后天更新了（2024.8.23）
8.22会更新汇编的内容。