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

news2024/11/23 12:30:47

前言

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2062129.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Ansys Zemax｜如何自定义优化操作数

Ansys Zemax｜如何自定义优化操作数

虽然Zemax OpticStudio有300多个内建优化操作数&#xff0c;但是还是会有一些特殊情况是这300多个操作数无法涵盖的。这就要求使用者根据要求计算出某些特定的数值&#xff0c;将这些数值返回到某个操作数&#xff0c;再对此操作数进行优化。 Zemax OpticStudio支持用户编程&a…
阅读更多...
【SpringCloud】（一文通）多机部署, 负载均衡-LoadBalance

【SpringCloud】（一文通）多机部署, 负载均衡-LoadBalance

目 录 一. 负载均衡介绍1.2 什么是负载均衡1.3 负载均衡的⼀些实现 二. Spring Cloud LoadBalancer2.1 快速上手2.1.1 使用 Spring Cloud LoadBalancer 实现负载均衡2.1.2 启动多个product-service实例 2.2 负载均衡策略2.3 LoadBalancer 原理 三. 服务部署(Linux)3.2 服务构建…
阅读更多...
（24）(24.4) MultiWii/DJI/HDZero OSD (version 4.2 and later)（一）

（24）(24.4) MultiWii/DJI/HDZero OSD (version 4.2 and later)（一）

文章目录 前言 1 基于遥测的OSD 前言 ArduPilot 使用基于MSP&#xff08;MultiWii 串行协议&#xff09;的协议支持多种类型的屏幕显示&#xff08;OSD&#xff09;&#xff1a; 基于 MSP 遥测的操作系统&#xff0c;如大疆 FPV 护目镜 V1/V2、大疆护目镜 RE、FatShark Byte…
阅读更多...
QML----QML+VTK+CMake示例

QML----QML+VTK+CMake示例

为了创建一个使用QML和VTK的示例项目，并使用CMake进行构建，将遵循以下步骤： 创建C++类以集成VTK和QML：这个类将负责设置VTK渲染数据，并与QML进行交互。设置CMake配置：配置CMake以找到并链接Qt和VTK库。创建QML界面：设计QML界面以显示VTK渲染的内容。编写主函数：初始化应…
阅读更多...
C语言实现通讯录-动态版本与文件版本

C语言实现通讯录-动态版本与文件版本

C语言实现通讯录-动态版本与文件版本 1.前言2.动态版本2.1联系人信息之前的&#xff1a;改版: 2.2初始化之前的&#xff1a;改版&#xff1a; 2.3自动扩容 3.文件版本3.1自动保存函数实现&#xff1a;效果&#xff1a; 3.2打开时加载信息函数实现&#xff1a;效果&#xff1a; …
阅读更多...
day37-https实战

day37-https实战

1.知识点补充: 四层代理转发数据库 目的: 通过10.0.0.4 使用ssh远程连接到web01 ssh--->10.0.0.4:2222 ---------->172.16.1.7:22 xshell-->创建会话-->10.0.0.4 端口 2222 Linux系统 ssh 10.0.0.4 -p2222作业: 目的: 实现连接10.0.0.4的5555端口转发到后端数据库…
阅读更多...
【hot100篇-python刷题记录】【只出现一次的数字】

【hot100篇-python刷题记录】【只出现一次的数字】

R5-技巧篇 思路&#xff1a;使用哈希记录次数即可 class Solution:def singleNumber(self, nums: List[int]) -> int:dictdefaultdict(int)for num in nums:dict[num]1for num in nums:if dict[num]1:return num
阅读更多...
【hot100篇-python刷题记录】【爬楼梯】

【hot100篇-python刷题记录】【爬楼梯】

R5-真正的动态规划 动态规划核心&#xff1a; 第i步是怎么来的&#xff08;即动态规划公式&#xff09; 走到第i步阶梯的总方法数sum(走到第i-1步阶梯的总方法数&#xff0c;走到第i-2步阶梯的总方法数) class Solution:def climbStairs(self, n: int) -> int:if n<2:r…
阅读更多...
云原生系列 - Nginx(高级篇)

云原生系列 - Nginx(高级篇)

前言 学习视频&#xff1a;尚硅谷Nginx教程&#xff08;亿级流量nginx架构设计&#xff09;本内容仅用于个人学习笔记&#xff0c;如有侵扰&#xff0c;联系删学习文档&#xff1a; 云原生系列 - Nginx(基础篇)云原生系列 - Nginx(高级篇) 一、扩容 通过扩容提升整体吞吐量…
阅读更多...
OpenCV resize 的各插值方式的区别与用途

OpenCV resize 的各插值方式的区别与用途

一、resize 函数中 interpolation 参数的区别和用途 cv2.resize 函数中的 interpolation 参数用于指定图像缩放时使用的插值方法。不同的插值方法会影响缩放后图像的质量和处理速度。以下是cv2.INTER_AREA、cv2.INTER_CUBIC、cv2.INTER_NEAREST、cv2.INTER_LINEAR 和 cv2.INTE…
阅读更多...
有关应用层面试题有关库的思维导体

有关应用层面试题有关库的思维导体

面试题目&#xff1a; TCP通信中3次握手和四次挥手&#xff1f; 答&#xff1a; 第一次握手&#xff1a;客户端发送SYN包&#xff08;SYN1, seq0&#xff09;给服务器&#xff0c;并进入SYN_SENT状态&#xff0c;等待服务器返回确认包。第二次握手&#xff1a;服务器接收到S…
阅读更多...
什么是Redis大key问题？如何解决？

什么是Redis大key问题？如何解决？

目录 Key多大算大呢&#xff1f; 识别big key 处理big key Big Key是Redis中存储了大量的数据的Key&#xff0c;不要误以为big key只是表示Key的值很大&#xff0c;他还包括这个Key对应的value占用空间很多的情况&#xff0c;通常在String、list、hash、set、zset等类型中出…
阅读更多...
三、Socket多路复用介绍

三、Socket多路复用介绍

一、Socket连接方式 二、多路复用 三、Socket连接包含的内容
阅读更多...
搭建TestBench，收藏这几条基本框架就够了

搭建TestBench，收藏这几条基本框架就够了

Verilog功能模块HDL设计完成后&#xff0c;并不代表设计工作的结束&#xff0c;还需要对设计进行进一步的仿真验证。掌握验证的方法&#xff0c;即如何调试自己的程序非常重要。在RTL逻辑设计中&#xff0c;要学会根据硬件逻辑来写测试程序即写Testbench。Verilog测试平台是一个…
阅读更多...
MATLAB中qr函数用法

MATLAB中qr函数用法

目录 语法 说明 示例 Q-Less QR 分解 矩阵的完整 QR 分解 置换 QR 分解 用精简 QR 因子求解线性系统 求解稀疏线性系统 求解矩形稀疏线性系统 提示 qr函数的功能是对矩阵进行QR 分解。 语法 R qr(A) [Q,R] qr(A) [Q,R,P] qr(A) [___] qr(A,"econ") […
阅读更多...
sklearn转换器和估计器

sklearn转换器和估计器

转换器 实例化一个转换器类 调用fit_transform() 转换器调用有以下几种形式&#xff1a; fit_transform fit transform估计器&#xff08;sklearn机器学习算法的实现&#xff09; 在sklearn中&#xff0c;估计器是一个重要的角色&#xff0c;是一类实现了算法的API 1、用于…
阅读更多...
深入理解 C# 中的 dynamic 类型详解与示例

深入理解 C# 中的 dynamic 类型详解与示例

文章目录 1. 什么是 dynamic 类型&#xff1f;2. dynamic 的工作原理3. dynamic 类型的使用4. 使用 dynamic 的场景5. dynamic 的优缺点6. dynamic 类型的注意事项7. 总结 在 C# 编程中&#xff0c;dynamic 类型是一个非常特殊的类型&#xff0c;它在编译时并不会进行类型检查&…
阅读更多...
TCP协议中的建立连接机制

TCP协议中的建立连接机制

目录 客户端与服务器间的三次握手 1、关于SYN_RCVD状态 2、关于系统调用listen的第二个参数 3、为什么服务端操作系统内核中的全连接队列不能太长&#xff1f; 4、服务端操作系统内核中可以没有全连接队列&#xff1f; 客户端与服务器间的三次握手 要想成功创建连接需要客…
阅读更多...
【Docker深入浅出】Docker镜像

【Docker深入浅出】Docker镜像

文章目录 一. Docker镜像简介二. Docker镜像详解1. 镜像和容器的关系2. 镜像通常比较小3. 拉取镜像4. 镜像命名4.1. 镜像仓库服务4.2. 官方和非官方镜像仓库4.3. 镜像的命名和标签 5. 为镜像打多个标签6. 过滤镜像内容6.1. 虚空镜像6.2. 删除虚空镜像6.3. 过滤器与格式化输出 7…
阅读更多...
【C++题解】1004 - 编程求1*2*3*...*n

【C++题解】1004 - 编程求1*2*3*...*n

欢迎关注本专栏《C从零基础到信奥赛入门级&#xff08;CSP-J&#xff09;》 问题&#xff1a;1004 - 编程求1 * 2 * 3 * … * n 类型&#xff1a;简单循环 题目描述&#xff1a; 编程求 123⋯n 。 输入&#xff1a; 输入一行&#xff0c;只有一个整数 n(1≤n≤10)&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023