C++（学习）2024.9.24

news2024/11/15 8:24:32

目录

容器

1.标准模板库STL

2.概念

3.顺序容器

（1）array数组

（2）vector向量

（3）list列表

（4）deque 队列

4.关联容器

5.迭代器

面向对象核心

继承

概念

构造函数

1.派生类与基类构造函数的关系

2.解决方案

（1）补充基类的无参构造函数

（2）手动在派生类中调用基类构造函数

1.透传构造

容器

1.标准模板库STL

标准模板库（Standard Template Library，STL）是惠普实验室开发的一系列软件的统称。虽说它主要出现到了C++中，但是在被引入C++之前该技术就已经存在了很长时间。
STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。

2.概念

容器是用来存储数据的集合，数据元素可以是任何类型（因为是使用模板实现）。
容器类的使用，都要引入对应的头文件。

3.顺序容器

顺序容器中每个元素都有固定的位置并呈线性排布，除非使用删除或者插入的操作改变元素的位置。

（1）array数组

array是C++11新增的容器类型，与传统数组相比更加的安全、易于使用。array数组是定长的。没有办法方便的进行伸缩。

#include <iostream>
#include <array>
using namespace std;

int main()
{
    // 创建一个长度为5的int数组
    array<int,5> arr = {1,2,3}; // 后面两位补零
    cout << arr[0] << endl; // 1
    cout << arr[4] << endl; // 0
    cout << arr.at(2) << endl;  // 3
    arr[3] = 200;
    arr[4] = 300;
    for(int i = 0; i < arr.size(); i++)
    {
        cout << arr.at(i) << " ";
    }
    cout << endl;

    // for each
    for(int i : arr)
    {
        cout << i << endl;
    }
    return 0;
}

（2）vector向量

        vector内部是由数组实现的，比较适合进行随机的存取操作，而不擅长插入删除操作。不是定长的。

#include <iostream>
#include <vector>
using namespace std;

int main()
{
    vector<int> vec(5);     // 创建一个长度为5的int向量
    cout<<vec.size()<<endl;     // 5

    // 增
    // 向后追加单元素
    vec.push_back(111);
    cout<<vec.size()<<endl;     // 6

    vec.insert(vec.begin()+1,666);// begin()可以返回指向第一个元素的迭代器指针，+1是在第二个位置上插入333

    //改
    vec.at(0)=777;
    vec[2]=555;
    vec.at(3)=444;
    vec.at(4)=333;
    vec.at(5)=222;
    for(int i:vec)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    // 删除
    // 删除最后一个元素
    vec.pop_back();
    for(int i:vec)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    vec.erase(vec.begin()+1);//删除第二个元素
    vec.erase(vec.end()-2);//删除倒数第二个元素
    for(int i:vec)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    //查
    cout<<"vec[0]="<<vec.at(0)<<endl;
    cout<<"vec[1]="<<vec[1]<<endl;

    for(size_t i=0;i<vec.size();i++)
    {
        cout<<vec.at(i)<<" ";
    }
    cout<<endl;

    //判断是否为空，0:非空   1:空
    cout<<vec.empty()<<endl;
    vec.clear();
    cout<<vec.empty()<<endl;
    return 0;
}

（3）list列表

        list内部是由双向链表实现，内存空间不连续，不支持下标。优点：可以高效的删除和插入操作，但是不适合随机的存取。

#include <iostream>
#include <list>
using namespace std;

int main()
{
    //    list<string>  lis1;
    //    list<string>  lis2={"hello","world"};


    // 创建一个长度为5的列表，每个元素都是hello
    list<string> lis(5,"hello");
    for(string i:lis)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    // 增
    lis.push_back("world");// 向后追加单元素
    lis.push_front("heiheihei");// 向前追加单元素

    lis.insert(++lis.begin(),"111");// 在第二个位置上插入"111"
    for(string i:lis)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    //删除
    lis.pop_back();// 删除最后一个元素
    lis.pop_front();  // 删除第一个元素
    for(string i:lis)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    list<string>::iterator iter=lis.begin();// 保存迭代器指针
    advance(iter,1); // 移动迭代器指针到固定位置
    lis.insert(iter,"222");
    for(string i:lis)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    // 删除最后一个元素
    //    iter=lis.end();
    //    iter--;
    //    lis.erase(iter);
    iter=lis.begin();
    advance(iter,1);
    lis.erase(iter);
    for(string i:lis)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    // 返回第一个元素的引用
    cout << lis.front() << endl;
    // 返回最后一个元素的引用
    cout << lis.back() << endl;

    //改
    iter=lis.end();
    advance(iter,2);
    *iter="200";
    for(string i:lis)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    //查
    cout<<"iter="<<*iter<<endl;

    // 不能使用普通循环遍历，因为不支持下标
    // 清空
    lis.clear();
    cout << lis.size() << endl; // 0
    return 0;
}

（4）deque 队列

        deque几乎支持所有vector的API，性能位于vector与list两者之间，是最擅长两端存取的顺序容器。

#include <iostream>
#include <deque>
using namespace std;

int main()
{
    deque<int> deq(5);     // 创建一个长度为5的int队列
    cout<<deq.size()<<endl;     // 5

    // 增
    // 向后追加单元素
    deq.push_back(111);
    cout<<deq.size()<<endl;     // 6

    deq.insert(deq.begin()+1,666);// begin()可以返回指向第一个元素的迭代器指针，+1是在第二个位置上插入333

    //改
    deq.at(0)=777;
    deq[2]=555;
    deq.at(3)=444;
    deq.at(4)=333;
    deq.at(5)=222;
    for(int i:deq)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    // 删除
    // 删除最后一个元素
    deq.pop_back();
    for(int i:deq)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    deq.erase(deq.begin()+1);//删除第二个元素
    deq.erase(deq.end()-2);//删除倒数第二个元素
    for(int i:deq)
    {
        cout<<i<<" ";
    }
    cout<<endl;

    //查
    cout<<"deq[0]="<<deq.at(0)<<endl;
    cout<<"deq[1]="<<deq[1]<<endl;

    for(size_t i=0;i<deq.size();i++)
    {
        cout<<deq.at(i)<<" ";
    }
    cout<<endl;

    //判断是否为空，0:非空   1:空
    cout<<deq.empty()<<endl;
    deq.clear();
    cout<<deq.empty()<<endl;
    return 0;
}

4.关联容器

关联容器的各个元素之间没有严格顺序，虽然内部具有排序特点，但是在使用时没有任何顺序相关接口。最常见的关联容器就是map-键值对映射。

         对于map而言，键具有唯一性，通常使用字符串类型，值可以是任何类型。通过键可以找到对应的值。

#include <iostream>
#include <map>
using namespace std;

int main()
{
    //列表初始化
    map<string,int> ma1={{"身高",185},{"年龄",22}};//有两个元素
    cout<<ma1.size()<<endl;     //2
    
    //创建一个元素数据为0的键值对对象
    map<string,int> ma;
    cout<<ma.size()<<endl;      //0
    
    //增
    ma["身高"]=180;
    ma.insert(pair<string,int>("体重",120 ));
    
    //查
    cout<<ma["身高"]<<endl;       //180
    cout<<ma["体重"]<<endl;       //120
    
    //改
    ma["身高"]=175;
    cout<<ma["身高"]<<endl;       //175
    
    //删
    int re=ma.erase("身高");
    cout<<"身高删除 "<<re<<endl;        //身高删除 1
    
    cout << ma.size() << endl;      //1
    
    re = ma.erase("学号");
    cout << re << endl;     //0
    
    if(ma.find("身高")==ma.end())
    {
        cout<<"没有找到身高元素"<<endl;
    }
    else
    {
        cout<<ma["身高"]<<endl;
    }
    
    ma.clear();
    cout<<ma.size()<<endl;      //0
    
    return 0;
}

5.迭代器

迭代器是一个特殊的指针，主要用于容器的元素读写以及遍历。
如果迭代器不进行修改操作，仅以使用只读迭代器，const_iterator，反之则使用iterator。

#include <iostream>
#include <map>
#include <array>
#include <vector>
#include <list>
#include <deque>

using namespace std;

int main()
{
    string s="abcd";
    cout<<"迭代器遍历string"<<endl;
    for(string::const_iterator iter=s.begin();iter!=s.end();iter++)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    cout << "--------------" <<endl;

    array<int,5> arr={1,2,3,4,5};
    cout<<"迭代器遍历array"<<endl;
    for(array<int,5>::const_iterator iter=arr.begin();iter!=arr.end();iter++)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    cout << "--------------" <<endl;

    vector<string> vec(6,"hello");
    cout<<"迭代器遍历vector"<<endl;
    for(vector<string>::const_iterator iter = vec.begin();iter != vec.end();iter++)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    cout << "--------------" <<endl;

    list<string>lis(6,"world");
    cout<<" 迭代器遍历list"<<endl;
    for(list<string>::const_iterator iter = lis.begin();iter != lis.end();iter++)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    cout << "--------------" <<endl;

    deque<string> de(6,"haha");
    cout<<"迭代器遍历deque"<<endl;
    for(deque<string>::iterator iter = de.begin(); iter != de.end(); ++iter)
    {
        cout<<*iter<<" ";
    }
    cout<<endl;
    cout << "--------------" <<endl;

    map<string,int>ma;
    ma["年龄"] = 22;
    ma["身高"] = 175;
    ma["体重"] = 60;
    cout<<"迭代器遍历map"<<endl;
    for(map<string,int>::const_iterator iter = ma.begin();iter != ma.end();iter++)
    {                       // first 是键，second 是值
        cout << iter->first << " " << iter->second << endl;
    }
    return 0;
}

面向对象核心

继承

概念

继承就是面向对象的三大特性之一，体现了代码复用的思想。
继承就是在一个已存在的类的基础上，建立一个新的类，并拥有其特性。
1.已存在的类被称为“基类”或者“父类”
2.新建立的类被称为“派生类”或者“子类”

#include <iostream>
using namespace std;

// 基类
class Father
{
private:
    string name = "张";
public:
    void set_name(string name)
    {
        this->name = name;
    }
    string get_name()
    {
        return name;
    }
    void work()
    {
        cout << "我的工作是厨师，我负责炒菜" << endl;
    }
};

// 派生类
class Son:public Father
{
};

int main()
{
    Son son;
    cout << son.get_name() << endl;
    son.work();
    return 0;
}

上面的代码，Son类的功能几乎与Father类重叠，在实际的使用过程中，派生类会做出一些与基类的差异化。
●修改继承来的基类内容
属性：

1、公有属性可以直接更改。更改后基类中的属性也会改变，因为改的是同一份变量        

2、私有属性，需要使用基类公有函数进行更改。
行为：函数隐藏，通过派生类实现一个同名同参数的函数，来隐藏基类的函数。
●新增派生类的内容

#include <iostream>
using namespace std;

// 基类
class Father
{
private:
    string name = "张";
public:
    void set_name(string name)
    {
        this->name = name;
    }
    string get_name()
    {
        return name;
    }
    void work()
    {
        cout << "我的工作是厨师，我负责炒菜" << endl;
    }
};

// 派生类
class Son:public Father
{
public:
    void init()
    {
        set_name("王");
    }

    void work()
    {
        cout << "我的工作是司机" << endl;
    }

    void game()
    {
        cout << "开挖掘机" << endl;
    }
};


int main()
{
    Son son;
    son.init();

    cout << son.get_name() << endl;
    son.work(); 
    son.game();

    son.Father::work();
    return 0;
}

基类和派生类都是相对的，一个类可能存在又是基类又是派生类的情况，取决于那两个类进行比较。

构造函数

1.派生类与基类构造函数的关系

构造函数与析构函数不能被继承。

#include <iostream>
using namespace std;

// 基类
class Father
{
private:
    string name;
public:
    Father(string name):name(name){}    // 有参构造函数
    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
};

int main()
{
//    Son s;    // 找不到基类的无参构造函数
//    Son s("张"); // 找不派生类的有参构造函数
    return 0;
}
2.解决方案
（1）补充基类的无参构造函数
#include <iostream>
using namespace std;

// 基类
class Father
{
private:
    string name;
public:
    // 无参构造函数
    Father():name("张"){}

    // 有参构造函数
    Father(string name):name(name){}

    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
};

int main()
{
    Son s;    
    cout << s.get_name() << endl;
    return 0;
}
（2）手动在派生类中调用基类构造函数
1.透传构造

在派生类的构造函数中，调用基类的构造函数，实际上编译器自动添加的派生类构造函数，调用基类无参构造函数时，就是采用的这种方式。

#include <iostream>
using namespace std;

// 基类
class Father
{
private:
    string name;
public:
    // 有参构造函数
    Father(string name):name(name){}
    string get_name()
    {
        return name;
    }
};

// 派生类
class Son:public Father
{
public:
    // 编译器会自动添加构造函数，透传调用基类无参构造函数(透传构造)
    // Son():Father(){}
    // 手动添加构造函数，透传构造
    Son():Father("王"){}
    // 有参构造函数，调用基类有参构造函数
    Son(string fn):Father(fn){}
};

int main()
{
    Son s;
    cout << s.get_name() << endl;
    Son s1("张");
    cout << s1.get_name() << endl;
    return 0;
}

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

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

相关文章

软件需求规格说明书编制模板参考（Doc原件）

软件需求规格说明书编制模板参考（Doc原件）

1 范围 1.1 系统概述 1.2 文档概述 1.3 术语及缩略语 2 引用文档 3 需求 3.1 要求的状态和方式 3.2 系统能力需求 3.3 系统外部接口需求 3.3.1 管理接口 3.3.2 业务接口 3.4 系统内部接口需求 3.5 系统内部数据需求 3.6 适应性需求 3.7 安全性需求 3.8 保密性需…
阅读更多...
项目实战总结-Kafka实战应用核心要点

项目实战总结-Kafka实战应用核心要点

Kafka实战应用核心要点 一、前言二、Kafka避免重复消费2.1 消费者组机制2.2 幂等生产者2.3 事务性生产者/消费者2.4 手动提交偏移量2.5 外部存储管理偏移量2.6 去重逻辑2.7 幂等消息处理逻辑2.8 小结 三、Kafka持久化策略3.1 持久化文件3.2 segment 分段策略3.3 数据文件刷盘策…
阅读更多...
Leetcode面试经典150题-39.组合总和

Leetcode面试经典150题-39.组合总和

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target &#xff0c;找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 &#xff0c;并以列表形式返回。你可以按 任意顺序 返回这些组合。 candidates 中的 同一个 数字可以 无限制重复被选取 。如…
阅读更多...
加固与脱壳01 - 环境搭建

加固与脱壳01 - 环境搭建

虚拟机 VMWare 多平台可用&#xff0c;而且可以直接激活&#xff0c;需要先注册一个账号 https://support.broadcom.com/group/ecx/productdownloads?subfamilyVMwareWorkstationPro KALI 类Ubuntu系统&#xff0c;官方提供了 vmware 版本&#xff0c;直接下载就可以使用。…
阅读更多...
【Python机器学习】NLP信息提取——提取人物/事物关系

【Python机器学习】NLP信息提取——提取人物/事物关系

目录 词性标注 实体名称标准化 实体关系标准化和提取 单词模式 文本分割 断句 断句的方式 使用正则表达式进行断句 词性标注 词性&#xff08;POS&#xff09;标注可以使用语言模型来完成&#xff0c;这个语言模型包含词及其所有可能词性组成的字典。然后&#xff0c;该…
阅读更多...
三子棋小游戏

三子棋小游戏

使用C语言编写代码&#xff0c;实现一个简单小游戏---三子棋 这里创建1个game.h文件&#xff0c;用来声明函数、宏的文件&#xff0c;一个game.c文件用来实现函数game&#xff08;&#xff09;&#xff0c;一个play.h文件用来作为该游戏的源文件。 具体代码如下&#xff1a; …
阅读更多...
利用大型语言模型轻松打造浪漫时刻

利用大型语言模型轻松打造浪漫时刻

当情人节年年如约而至&#xff0c;每每都需费尽心思为对方营造一场令人难忘的仪式&#xff0c;却因缺乏创意与思路而倍感困扰。今天&#xff0c;我决定让大型语言模型为我们提供一些灵感和建议&#xff0c;让我们能够轻松实现这一目标。让我们开始行动吧&#xff01;此前&#…
阅读更多...
问卷是否要做信效度分析，5类信度与4类效度常用指标及评价标准

问卷是否要做信效度分析，5类信度与4类效度常用指标及评价标准

论文问卷进行分析时&#xff0c;大家是否有这样的疑惑—— 我收集的问卷是否需要进行信效度分析呢&#xff1f; 下面一文给大家梳理问卷信效度分析的相关内容&#xff0c;包括什么样的题目需要进行信效度分析、5类信度分析与4类效度分析常用指标及评价标准。 一、问卷是否需…
阅读更多...
JW01二氧化碳传感器（串行通信 STM32）

JW01二氧化碳传感器（串行通信 STM32）

目录 一、介绍 二、传感器原理 1.工作原理介绍 2.串口数据流格式 三、程序设计 main.c文件 usart3.h文件 usart3.c文件 四、实验效果 五、资料获取 项目分享 一、介绍 JW01-CO2检测模块是一种用于检测空气中二氧化碳浓度的传感器模块。它可以广泛应用于室内空气质量…
阅读更多...
java算法OJ（1）位运算

java算法OJ（1）位运算

目录 1.前言 2.正文 2.1位运算符号 2.1俩数相除 2.1.1题目 2.1.2示例 2.1.3题解 2.2二进制求和 2.2.1题目 2.2.2示例 2.2.3题解 2.3只出现一次的数字 2.3.1题目 2.3.2示例 2.3.3题解 2.4只出现一次的数字&#xff08;进阶版&#xff09; 2.4.1题目 2.4.2示例…
阅读更多...
glb数据格式

glb数据格式

glb数据格式 glb 文件格式只包含一个glb 文件&#xff0c;文件按照二进制存储&#xff0c;占空间小 浏览 浏览glb工具的很多&#xff0c;ccs&#xff0c;3D查看器等都可以&#xff0c;不安装软件的话用下面网页加载就可以&#xff0c;免费 glTF Viewer (donmccurdy.com) glb…
阅读更多...
uniapp小程序中通过uni.setClipboardData实现复制功能无效的原因和解决方案

uniapp小程序中通过uni.setClipboardData实现复制功能无效的原因和解决方案

// 复制下载链接const shareFile (filePath) > {const pdfUrl 复制内容uni.showModal({title: 下载提示,content: 请复制链接到浏览器中下载,confirmColor: #eb2444,confirmText: 复制链接,success(res) {if (res.confirm) {uni.setClipboardData({data: pdfUrl, // url地…
阅读更多...
C++: unordered系列关联式容器

C++: unordered系列关联式容器

目录 1. unordered系列关联式容器1.1 unordered_map1.2 unordered_set 2. 哈希概念3. 哈希冲突4. 闭散列5. 开散列 博客主页: 酷酷学 感谢关注!!! 正文开始 1. unordered系列关联式容器 在C98中&#xff0c;STL提供了底层为红黑树结构的一系列关联式容器&#xff0c;在查询时…
阅读更多...
【笔记】自动驾驶预测与决策规划_Part4_时空联合规划

【笔记】自动驾驶预测与决策规划_Part4_时空联合规划

文章目录 0. 前言1. 时空联合规划的基本概念1.1 时空分离方法1.2 时空联合方法 2.基于搜索的时空联合规划 &#xff08;Hybrid A* &#xff09;2.1 基于Hybrid A* 的时空联合规划建模2.2 构建三维时空联合地图2.3 基于Hybrid A*的时空节点扩展2.4 Hybrid A* &#xff1a;时空节…
阅读更多...
多线程——“死锁”

多线程——“死锁”

目录 前言 一、一个线程&#xff0c;一把锁 1.问题介绍 2.可重入锁 二、两个线程&#xff0c;两把锁 1.问题介绍 2.解决方式 三、N个线程&#xff0c;M把锁 1.哲学家就餐问题 2.解决方式 结尾 前言 “死锁”是多线程代码中一类常见的问题&#xff0c;加锁是能解决线…
阅读更多...
plt的简单使用

plt的简单使用

目录 介绍示例 介绍 plt 是 Python 中 Matplotlib 库的一个常用别名&#xff0c;它表示 pyplot&#xff0c;这是一个用于创建图形和图形的可视化表示的工具。下面是一些 plt 函数的详解和示例&#xff0c;以帮助大家理解和使用。 示例 示例1&#xff1a; import matplotlib…
阅读更多...
AV1 Bitstream Decoding Process Specification--[9]：语法结构语义-5

AV1 Bitstream Decoding Process Specification--[9]：语法结构语义-5

原文地址&#xff1a;https://aomediacodec.github.io/av1-spec/av1-spec.pdf 没有梯子的下载地址&#xff1a;AV1 Bitstream & Decoding Process Specification摘要&#xff1a;这份文档定义了开放媒体联盟&#xff08;Alliance for Open Media&#xff09;AV1视频编解码…
阅读更多...
loadrunner个人笔记

loadrunner个人笔记

创建场景配置&#xff1a; 两个同时 去四&#xff1a;日志、时间、模拟、其他自动事务 加一&#xff1a;首选项 1、写脚本&#xff0c;沟通官方、文件打印扫描 MFI-sw.support.gsd.imsc.sda.globalopentext.com support.casemicrofocus.com 支持资源 | Micro Focus | OpenT…
阅读更多...
【毕业论文+源码】基于ASP的课程指导平台的开发

【毕业论文+源码】基于ASP的课程指导平台的开发

引 言 随着全球信息化技术的兴起&#xff0c;特别是Internet的日益普及&#xff0c;解决了信息Internet上传递的问题&#xff0c;建立了一个组织得很好的信息结构框架&#xff0c;使得Internet用户能够在Internet上的任何一个终端&#xff0c;以一种简单、统一的方式来访问超…
阅读更多...
Leetcode Hot 100刷题记录 -Day18（反转链表）

Leetcode Hot 100刷题记录 -Day18（反转链表）

反转链表&#xff1a; 问题描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023