C++随心记

server/2024/10/19 15:30:39/

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;}// 一次性写最多的合法constconst 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 areturn 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 resreturn 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 constructorVertex(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 constructorVertex(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 constructorVertex(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 constructorVertex(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类没有发生复制


http://www.ppmy.cn/server/126479.html

相关文章

JavaScript中的字符串处理方法详解

JavaScript中的字符串处理方法详解

文章目录 一、字符串的基本概念二、字符串的创建1. 字面量创建2. 使用String构造函数 三、字符串的基本操作1. 获取字符串长度2. 访问字符串中的字符使用charAt()方法使用方括号表示法&#xff08;ES5及以上&#xff09; 3. 字符串的拼接使用加号&#xff08;&#xff09;运算符…
阅读更多...
【优选算法】（第十五篇）

【优选算法】（第十五篇）

目录 和为k的⼦数组&#xff08;medium&#xff09; 题目解析 讲解算法原理 编写代码 和可被K整除的⼦数组&#xff08;medium&#xff09; 题目解析 讲解算法原理 编写代码 和为k的⼦数组&#xff08;medium&#xff09; 题目解析 1.题目链接&#xff1a;. - 力扣&am…
阅读更多...
MFC有三个选项：MFC ActiveX控件、MFC应用程序、MFC DLL，如何选择？

MFC有三个选项：MFC ActiveX控件、MFC应用程序、MFC DLL，如何选择？

深耕AI&#xff1a;互联网行业 算法研发工程师 ​ 目录 MFC ActiveX 控件 控件的类型 标准控件 自定义控件 ActiveX控件 MFC ActiveX控件 标准/自定义控件 MFC ActiveX控件分类 3种MFC如何选择&#xff1f; MFC ActiveX控件 MFC 应用程序 MFC DLL 总结 举例说明…
阅读更多...
Python 入门--基础语法

Python 入门--基础语法

目录 1. 注释 2. 字面量 3. 变量 4. 数据类型 5. 字符串扩展 (1). 字符串的三种定义方式 (2). 字符串拼接 (3). 字符串格式化1 (4). 格式化精度控制 (5). 字符串格式化2 (6). 表达式的格式化 6. 数据类型转换 7. 标识符 8. 运算符 9. 数据输入(input语句) 1. …
阅读更多...
前端——Ajax和jQuery

前端——Ajax和jQuery

一、Ajax Ajax即“Asynchronous Javascript And XML”&#xff08;异步 JavaScript 和 XML&#xff09;&#xff0c; 通过 JS 异步的向服务器发送请 求并接收响应数据。 同步访问&#xff1a;当客户端向服务器发送请求时&#xff0c;服务器在处理的过程中&#xff0c;浏览器…
阅读更多...
C嘎嘎入门篇：类和对象（2）

C嘎嘎入门篇：类和对象（2）

前言&#xff1a; 上一篇小编讲了类和对象&#xff08;1&#xff09;&#xff0c;当然&#xff0c;在看这篇文章之前&#xff0c;读者朋友们一定要掌握好前面的基础内容&#xff0c;因为这篇和前面息息相关&#xff0c;废话不多说&#xff0c;下面小编就加快步伐&#xff0c;开…
阅读更多...
顺序表的实现

顺序表的实现

1.顺序表功能的.h文件 #define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include <stdio.h> #include <stdlib.h> #include <string.h> typedef int typedata; typedef struct Seqlist{ typedata* node; int size; int capacity; }seqlist; v…
阅读更多...
《Spring Boot应用进阶：打造优雅的错误处理机制与全局异常拦截器》

《Spring Boot应用进阶：打造优雅的错误处理机制与全局异常拦截器》

文章目录 自定义异常类AppException封装业务有关的枚举类AppExceptionCodeMsg全局异常拦截器Handler响应类模板Resp案例展示 || Demo项目结构pom依赖DemoController实际执行结果 Demo案例Git地址 | Gitee 本文主要介绍自己在工作中在处理抛出异常类和封装响应类处理的模板总结。…
阅读更多...
最新文章

Copyright @ 2022~2023