Secure Coding in C and C ++ (四）局部静态构造函数虚函数

二进制菜鸟K1rito

于 2024-08-21 23:23:19 发布

阅读量521

点赞数 12

分类专栏：安全编程C++ 文章标签： c语言数据结构开发语言程序人生

本文链接：https://blog.csdn.net/baidu_33751906/article/details/141396070

版权

安全编程C++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

`前言`

上一章节我们讲解了关于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会更新汇编的内容。