C++随心记

🕗 发布于 2024-10-03 13:43 c++ 开发语言

C++随心记

C++中的 CONST

C++中的const是表示不可修改

int main()
{
    /* 对于变量而言 */

    // 不可修改的常量
    const int A = 10;
    // 不可修改的指针指向
    const int* pointer_0 = nullptr;
    int const* poniter_1 = nullptr;
    // 不可修改指针指向的内容
    int* const poniter_2 = nullptr;
}

const也可修饰函数

class Entity
{
private:
    int* pointer;
    int x;
public:
    /* 对于函数而言 */

    // 修饰函数，使得其权限仅为读取，不可写入
    int GetX() const
    {
        // x++; 此语句是非法的，函数被const修饰后不准更改函数外的变量
        return x;
    }
    // 如果返回的为指针也可以用于修饰指针
        // 指向内容不可变
    int* const GetPoniter()
    {
        return pointer;
    }
        // 指向不可变
    const int* GetPointer()
    {
        return pointer;
    }
    // 一次性写最多的合法const
    const int* const GetPointer() const
    {
        return pointer;
    }

};

C++中的mutable

和上文的const一样，都是关键字，但mutable与const相反。mutable意味着可更改的。

class Entity
{
private:
    mutable int x;
    int y;
public:
    Entity()
        : x(10), y(20)
    {}

    void ChangeXAndRead() const
    {
        x++;
        std::cout << "The value of X,Y is " << x << ',' << y << std::endl;
        // 这里的输出结果为11，20
        // 当试图修改y的值的时候，因为y的值为非mutable修饰，所以会报错
    }
};

C++中的成员初始化列表

在面向对象的语言中，多数程序员喜欢在构造器内初始化成员。在C++语法中，存在专门初始化成员的功能，此功能的优点是：避免了在定义成员时被构造，当我们定义一个变量时，如果这个变量为某个类的实例，那么在定义时会调用其构造器，当我们赋值时回再次调用构造器，这造成了性能的浪费。

class Entity
{
public:
    std::string x;  // 此时调用了string的构造器

    Entity()
    {
        x = "Hello";    // 此时调用了"Hello"的构造器，并把地址给了x
    }
};

// 下面是一个比较直观的例子
class Example
{
public:
    Exapmle()
    {
        std::cout << "Example created!" << std::endl; 
    }

    Example(int x)
    {
        std::cout << "Example created with x! x=" << x << std::endl; 
    }
};

class Entity
{
public:
    Example example;
    // 这里会输出Example created!
    Entity()
    {
        example = Example(8);
        // 这里会输出Example created with x! x=8
    }
};

这样就输出了两次，代表着调用了两次构造器。为了节省性能，我们可以使用成员初始化列表，语法如下

class Entity
{
private:
    std::string m_Name;
    int m_DebugCount;
public:
    Entity(const std::string& Name)
        :m_Name(Name), m_DebugCount(0)
    {}
};

上面写了一个有参构造器，参变量为常量引用的Name。重点是下面是成员初始化列表，用冒号隔开，冒号后为要初始化的成员，初始化的内容为后面的括号的内容。需要注意的是，成员初始化列表需要和成员变量的定义顺序相同，这一规则非严格规定，但不遵守此规则可能会导致部分成员变量无法初始化！每个成员变量之间用逗号隔开

delete的小注意

对于new出来的对象，要记得delete。要delete一块数组，要用delete[]

int main()
{
    int* a = new int[10];
    delete[] a; // To delete array a
    return 0;
}

如果不使用delete[]的话，你删的只是指针所指的第一个元素而已。

C++的隐式类型转换

C++中的类型转换是自动的，甚至可以转换到类的构造器中，以下为实例。

class Entity
{
private:
    int m_Age;
    std::string m_Name;
public:
    Entity(const std::string& name)
        :m_Age(-1), m_Name(name)
    {
        std::cout << "Entity constructor with name has called!" << std::endl;
    }

    Entity(int age)
        :m_Age(age), m_Name("Unknown")
    {
        std::cout << "Entity constructor with age has called!" << std::endl;
    }
};

int main()
{
    Entity e1 = 12; // 隐式类型转换
    Entity e2 = std::string("Chreno");
    return 0;
}

explicit关键字

由于隐式转换是默认的，开发者不希望自己的构造函数被隐式转换就可以添加关键字explicit来强制构造器拒绝隐式转换。例如

class Entity
{
private:
    int m_Age;
    std::string m_Name;
public:
    Entity(const std::string& name)
        :m_Age(-1), m_Name(name)
    {
        std::cout << "Entity constructor with name has called!" << std::endl;
    }

    explicit Entity(int age)
        :m_Age(age), m_Name("Unknown")
    {
        std::cout << "Entity constructor with age has called!" << std::endl;
    }
};

int main()
{
    // Entity e1 = 12; // 此行由于构造器被explicit修饰故报错
    Entity e2 = std::string("Chreno");
    return 0;
}

C++中的运算符重载

浅谈一下重载问题，其实运算符最简单的四则运算无非就是加减乘除。我们在重载时只要跟编译器说明了这个函数就是在重载就好了，我们会用到operator标识一下我们重载的是运算符

struct Vector2
{
    float x, y;

    Vector2(float x, float y)
        :x(x), y(y) {}

    // 运算符重载
    Vector2 operator+(const Vector2& other) const
    {
        return Vector2(x + other.x, y + other.y);
    }
    Vector2 operator-(const Vector2& other) const
    {
        return Vector2(x - other.x, y - other.y);
    }
    Vector2 operator*(const Vector2& other) const
    {
        return Vector2(x * other.x, y * other.y);
    }
    Vector2 operator/(const Vector2& other) const
    {
        return Vector2(x / other.x, y / other.y);
    }

    Vector2 Add(const Vector2& other) const
    {
        return Vector2(x + other.x, y + other.y);
    }
    Vector2 Multiply(const Vector2& other) const
    {
        return Vector2(x * other.x, y * other.y);
    }

    void printSelf()
    {
        std::cout << "Value of x:" << x << ",Value of y:" << y << std::endl;
    }
};


int main()
{
    Vector2 position(4.0f, 4.0f);
    Vector2 speed(0.5f, 1.5f);
    Vector2 powerup(1.1f, 1.1f);

    Vector2 result = position.Add(speed.Multiply(powerup));
    Vector2 res = position + speed * powerup;

    result.printSelf();
    res.printSelf();
    // result equals res
    return 0;
}

再补充一点，我们可以重载ostream的<<运算符来达到输出内容的目的

#include <iostream>

class Entity
{
public:
    int x, y;

    Entity(int x, int y)
        :x(x), y(y)
    {}

};

// 2、此时我们就需要重载一下运算符
std::ostream& operator<<(std::ostream& stream, const Entity& other)
{
    stream << other.x << ',' << other.y << std::endl;
    return stream;
}

int main()
{
    Entity e(1, 2);
    // std::cout << e << std::endl; // 1、这里肯定不会输出其内容，而且也会报错

    // 3、然后我们再来使用这个运算符
    std::cout << e << std::endl;
    return 0;
}

C++智能指针

智能指针就是用std::unique_ptr<>来裹住一个对象，相对于原始指针，智能指针加了一层壳。将这个对象的栈和堆内存绑定，在跳出作用域时自动调用delete方法，语法见下

#include <iostream>
#include <memory>

class Entity
{
public:
    int x, y;

    Entity(int x, int y)
        :x(x), y(y)
    {
        std::cout << "Entity created!" << std::endl;
    }
    ~Entity()
    {
        std::cout << "Entity destory by itself" << std::endl;
    }

};

int main()
{
    {
        std::unique_ptr<Entity> entity = std::make_unique<Entity>();    // 就一次内存分配，更效率
        std::unique_ptr<Entity> e(new Entity(1, 2));    // 先Entity()构造分配一次内存，再给unique_ptr分内存
    }
    
    std::cout << "Program is going done~" << std::endl;
    return 0;
}

但是unique_ptr不能共享指针给别人，从原理上来说，这个对象被释放以后手握这个对象的指针也都会嗝屁，实际上需要同步。从源码上来看，=号这个运算符被重载了。
下面看一下shared_ptr，一个可以共享的智能指针

#include <iostream>
#include <memory>

class Entity
{
public:
    int x, y;

    Entity(int x, int y)
        :x(x), y(y)
    {
        std::cout << "Entity created!" << std::endl;
    }
    ~Entity()
    {
        std::cout << "Entity destory by itself" << std::endl;
    }

    void print()
    {
        std::cout << "The value of x:" << x << ",y:" << y << std::endl;
    }
};

int main()
{
    std::shared_ptr<Entity> e;

    {
        std::shared_ptr<Entity> shared_entity = std::make_shared<Entity>(); // 性能缘由同上
        std::shared_ptr<Entity> shared_entity_new(new Entity(1, 2));

        e = shared_entity;
    }

    e->print();

    std::cout << "Program is going done~" << std::endl;
    return 0;
}

shared_ptr底层实现类似计数器，不分享的时候相当于在unique_ptr和计数器=0，分享一次就会计数器++。当计数器为0后，再结束生命周期就会delete这个对象本体（在堆上），否则只是释放了指针本身的内存（在栈上）。给weak_ptr分享不会增加计数器。

C++计算偏移量

计算偏移量在计算机图形学里比较多见，先写一下具体过程

#include <iostream>

struct Vector3
{
    float x, y, z;
};

int main()
{
    int offset = (int)&((Vector3*)nullptr)->y;
    
    std::cout << offset << std::endl;

    std::cin.get();
    return 0;
}

代码中offset就是偏移量。首先将0或者nullptr强制转化为结构体或类的指针，再去通过->调用指针就会根据偏移量偏移到目标的起始位置(这就是我们需要的值)，之后取这个位置的地址(因为使用0或者nullptr作为起始地址所以不用再考虑起始地址)用&取地址(内存编号为偏移量)，再通过(int)强制转换成整数就得到了偏移量

C++中优化std vector三个简单方法

我们先来写一段代码实验一下

#include <iostream>
#include <vector>

struct Vertex
{
    float x, y, z;

    Vertex(float x, float y, float z)
        : x(x), y(y), z(z)
    {
    }

    // copy constructor
    Vertex(const Vertex& vertex)
        : x(vertex.x), y(vertex.y), z(vertex.z)
    {
        std::cout << "Copied!" << std::endl;
    }
};

int main()
{
    std::vector<Vertex> vertices;
    vertices.push_back({ 1, 2, 3 }); //1号语句
    vertices.push_back({ 4, 5, 6 }); //2号语句
    vertices.push_back({ 7, 8, 9 }); //3号语句
    return 0;
}

这段代码中我们规定：Vertex结构体，每当被复制后就向控制台输出
经过实际运行后，这段代码一共输出了 6 行Copied，说明在添加到vector时Vertex被复制了六次。以下是流程：执行到1号语句时vertices的承载力为0，产生新的vertices并将旧的vertices复制到新的vertices中此时输出1次Copied，到二号语句，承载力不够，接着出现新的容器，旧的vertices中已经有的Vertex和新的Vertex都会被复制到新的容器中，此时复制了两次，即输出两次Copied,以此类推三号语句输出了三次Copied，最后即输出了1+2+3次即6次Copied
这段过程看似在计算机强大算力前不复杂，但是当push_back次数多了以后复制次数就会爆炸式增长

解决方案一

先告诉vector给留多少空间，避免了多次复制

#include <iostream>
#include <vector>

struct Vertex
{
    float x, y, z;

    Vertex(float x, float y, float z)
        : x(x), y(y), z(z)
    {
    }

    // copy constructor
    Vertex(const Vertex& vertex)
        : x(vertex.x), y(vertex.y), z(vertex.z)
    {
        std::cout << "Copied!" << std::endl;
    }
};

int main()
{
    std::vector<Vertex> vertices;
    vertices.reserve(3);    // 预留空间
    vertices.push_back(Vertex(1, 2, 3));
    vertices.push_back(Vertex(4, 5, 6));
    vertices.push_back(Vertex(7, 8, 9));
    return 0;
}

在这里通过reserve告诉vector给我留3个单位的空间，运行完毕后仅输出了 3 次Copied，即没有新的容器创建

解决方案二

通过调用类或者结构体的构造器，函数括号内为构造器对应参数

#include <iostream>
#include <vector>

struct Vertex
{
    float x, y, z;

    Vertex(float x, float y, float z)
        : x(x), y(y), z(z)
    {
    }

    // copy constructor
    Vertex(const Vertex& vertex)
        : x(vertex.x), y(vertex.y), z(vertex.z)
    {
        std::cout << "Copied!" << std::endl;
    }
};

int main()
{
    std::vector<Vertex> vertices;
    vertices.emplace_back(1, 2, 3);
    vertices.emplace_back(4, 5, 6);
    vertices.emplace_back(7, 8, 9);
    return 0;
}

此方法效率和法一相同，实现机制不同

解决方案三(二 + 一)

预留好空间后再使用emplace不会产生任何复制(预留空间>=实际需求空间)

#include <iostream>
#include <vector>

struct Vertex
{
    float x, y, z;

    Vertex(float x, float y, float z)
        : x(x), y(y), z(z)
    {
    }

    // copy constructor
    Vertex(const Vertex& vertex)
        : x(vertex.x), y(vertex.y), z(vertex.z)
    {
        std::cout << "Copied!" << std::endl;
    }
};

int main()
{
    std::vector<Vertex> vertices;
    vertices.reserve(3);
    vertices.emplace_back(1, 2, 3);
    vertices.emplace_back(4, 5, 6);
    vertices.emplace_back(7, 8, 9);
    return 0;
}

此示例Vertex类没有发生复制

原文地址：https://blog.csdn.net/Coniary/article/details/142661873

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：B+树和跳表
下一篇：【Nacos 架构 & 原理】服务发现模块之Nacos注册中心服务数据模型

npm下载淘宝镜像的方式和用法
第一种下载cnpmnpm install --global cnpm下载的包直接通过淘宝镜像下载，也同样可以使用npm第二种如果你不想下载cnpm,也可以直接添加下载地址npm config set
阅读更多2024-10-04
springboot+大数据+数据挖掘+基于数据挖掘技术的线上招聘信息分析系统【内含源码+文档+部署教程
基于数据挖掘技术的线上招聘信息分析系统旨在通过应用先进的数据分析方法，为求职者和招聘者提供更加高效、精准的招聘服务。总体而言，该系统通过数据挖掘技术的应用，为招聘市场带来了更加智能化和个性化的服务体验
阅读更多2024-10-04
基于深度学习的点云处理模型PointNet++学习记录
根据其论文中给出的介绍，Point++是用于点云分割与分类的深度学习模型，由下图可知，该模型主要分为三部分，分别是点空间特征提取、分割模型以及分类模块。其中，由一系列点集抽象层（）组成，而每一个。：S
阅读更多2024-10-04
01---java面试八股文——springboot---10题
Springboot的十道面试题
阅读更多2024-10-04
数据结构（链表的操作算法）
编写一个程序exp2_2.cpp,采用单链表表示集合(假设同一个集合中不存在重复素)，将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。(2)依次采用尾插法插入a、b、c、d、e元素
阅读更多2024-10-04
【MAUI】CollectionView之垂直网格
App主页或者导航页面中动态按钮的垂直网格布局在 XAML 中，CollectionView 可以通过将其 ItemsLayout 属性设置为 VerticalGrid，在垂直网格中显示其项：
阅读更多2024-10-04
LangGPT结构化提示词编写实践
你是一个高级数学家，请你在对比数字大小之前，特别是浮点数字，请多步思考对比找出正确答案。
阅读更多2024-10-04
24.2.29蓝桥杯|单位换算--8道题
本篇或者本系列文章使用蓝桥云课平台，借助CSDN梳理思路，给自己做一个电子笔记。
阅读更多2024-10-04
【Linux私房菜（九）之进程间通信】
进程间通信简称IPC（Interprocess communication），进程间通信就是在不同进程之间传播或交换信息。管道是Unix中最古老的进程间通信的形式，我们把从一个进程连接到另一个进程的数
阅读更多2024-10-04
【Linux庖丁解牛】—Linux基本指令(中)！
由于ﬁnd具有强大的功能，所以它的选项也很多，其中大部分选项都值得我们花时间来了解一下。当我们使用cat指令想要获取一个文件当中的内容时，如果我们不指定文件，则默认到键盘文件当中获取（读取）内容，如
阅读更多2024-10-04

C++随心记

C++随心记

C++中的 CONST

C++中的mutable

C++中的成员初始化列表

delete的小注意

C++的隐式类型转换

explicit关键字

C++中的运算符重载

C++智能指针

C++计算偏移量

C++中优化std vector三个简单方法

解决方案 一

解决方案 二

解决方案 三(二 + 一)

相关文章

解决方案一

解决方案二

解决方案三(二 + 一)