5-C++的list列表、deque队列、迭代器、继承、权限

最新推荐文章于 2024-07-22 09:46:58 发布
最新推荐文章于 2024-07-22 09:46:58 发布
阅读量367 收藏
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Summer_taotao/article/details/130122613
版权
本文详细介绍了C++中的list和deque容器的使用，包括插入、删除和迭代器操作。同时，文章讲解了迭代器在遍历容器时的重要性，并展示了如何利用迭代器进行元素访问和修改。此外，文章还涉及了C++中的继承概念，包括构造函数的透传和委托，以及成员访问权限的控制。
摘要由CSDN通过智能技术生成

目录

1.list列表

 list列表应用：选猴王

2.deque队列

 键---值   

3.迭代器

4.继承

4.1继承中的构造函数

透传函数

委托构造

5.权限

1.list列表

list是双向的列表，高效的插入和删除，但是读取效率稍低。不支持下标操作，用迭代器来操作

#include <iostream>
#include <list> //写明头文件
using namespace std;

int main(){
    list<string> lis; //创建空list列表
    //尾部增加
    lis.push_back("AA");
    lis.push_back("BB");
    lis.push_back("CC");
    lis.push_back("DD"); //AA BB CC DD

    //尾部删除
    lis.pop_back(); //AA BB CC

    //头部增删
    lis.push_front("tom"); //tom AA BB CC
    lis.pop_front(); //AA BB CC


    //lis.erase(lis.begin()+2); //vector的方法不可用
    //list列表迭代器不支持随机访问 list迭代器访问最后一个和前一个是可以的
    lis.erase(++lis.begin()); //AA CC

    lis.push_back("EE");
    lis.push_back("FF");   //AA CC EE FF

    //插入
    list<string>::iterator it=lis.begin();
    advance(it,2);  //再往后移动2位
    cout<<*it<<endl;  //EE
    lis.insert(it,"hello");  //AA CC hello EE FF
    
    //删除最后的元素
    lis.erase(--lis.end()); //AA CC hello EE
    //lis.erase(lis.end());  直接这样可能会全删除

    for(string s:lis){
        cout<<s<<" ";
    }cout<<endl;

}

#include <iostream>
#include <list> //写明头文件
using namespace std;
int main()
{
    list<string> lis;
    lis.push_back("AA");
    lis.push_back("BB");
    lis.push_back("CC");
    lis.push_back("DD"); //AA BB CC DD
    
    list<string>::iterator it=lis.begin();
    advance(it,1);
    cout<<*it<<endl; //BB
    
    //删除
    it=lis.erase(it); 
    //删除之后会返回删除元素后面的位置的迭代器。但是需要迭代器变量重写来接收    
    cout<<"删除之后："<<*it<<endl;

    //lis.erase(it);  再cout<<*it<<endl;  出来的是乱码
    //it=lis.erase(it); 再cout<<*it<<endl;  出来的是下一个字符串  
    //比如AA BB CC DD  it是BB，it=lis.erase(it);  再cout<<*it<<endl;  出来的是CC
    //结果是AA CC DD
    
    
    for(string s:lis)
    {
    cout<<s<<" ";
    }

}

 list列表应用：选猴王

有n只猴围城一圈，从1开始报数，数到m的就离开。直到最后一只猴，这只猴就是猴王

#include <iostream>
#include <list> //写明头文件
using namespace std;
int main()
{
    int n,m;
    cin>>n>>m; //n 总数  查到m删除
    list<int> monkeys;
    for(int i=1;i<=n;i++)   //5
    {
        monkeys.push_back(i);
    }
    list<int>::iterator it=monkeys.begin();
    //当个数=1的时候停止  所以>1的时候循环
    while(monkeys.size()>1){
        for(int i=1;i<m;i++){   //m=3
            it++;
            //如果加到end（）时证明已经到末尾了，转成开头的元素继续报数
            if(it==monkeys.end()){
                it=monkeys.begin();
                }
            }
        it=monkeys.erase(it);
        //删除之后如果到了end（）位置 ，应转到开头元素位置
        if(it==monkeys.end()){
            it=monkeys.begin();
        }
        cout<<"准备删除的元素是："<<*it<<endl;
        
        for(int j:monkeys)
        {
            cout<<j<<" ";
        }
        cout<<endl;
    
}
cout<<"猴王编号："<<monkeys.front()<<endl;
}

2.deque队列

API兼顾vector和list，性能在两者之间 ，和前面通用；

关联容器

元素之间位置并没有严格物理上的顺序关系，不能指明元素的位置。但内部会自动的排序；

常见的关联容器：map（键值对） mulitmap（多重键值对）

#include <iostream>
#include <map>
using namespace std;
int main(){
    map<string,int>mp;
    cout<<mp.empty()<<endl;  //1空 0非空  判断是不是空的
    mp["age"]=20;  //键是age 值是20
    //如果map中没有键，mp["age"]=20；相当于新增

    cout<<mp["age"]<<endl;  //20
    mp["age"]=30;
    cout<<mp["age"]<<endl;  //30    //相当于更新操作
    //map中的键是不允许重复的

    if(mp.find("age")==mp.end()){
        cout<<"没找到，不存在！"<<endl;
    }else{
        cout<<"找到，已经存在！"<<endl;
    }
    //插入操作 pair是个有键值对的模板
    pair<string,int> pair1;
    pair1.first="hello"; //键
    pair1.second=70;    //值

    mp.insert(pair1);
    mp.insert( pair<string,int> ("world",80));

    cout<<mp["hello"]<<endl;  //70


}

 键---值   

#include <iostream>
#include <map>

using namespace std;

int main(){
    map<string,int> mp;
    cout<<mp.empty()<<endl;
    mp["age"]=20;
    cout<<mp["age"]<<endl;
    if(mp.find("age")==mp.end()){
        cout<<"no"<<endl;
    }else{
        cout<<"yes"<<endl;
    }

    pair<string,int> pair1;
    pair1.first="height";
    pair1.second=150;
    mp.insert(pair1);
    cout<<mp["height"]<<endl;
    mp.insert(pair<string,int>("weight",1000));
    //mp.insert(pair<string,int>("height",1000));  //height键已存在 键相同 不允许插入成功
    cout<<mp["weight"]<<endl;
}

3.迭代器

------>[遍历]

迭代器是个特殊的指针。通用的形式访问各种容器；iteratro 可读可写 const iterator 可读

通常使用迭代的方式遍历容器，效率比较高

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

using namespace std;

int main(){

    map<string,int> mp;
    mp.insert(pair<string,int>("weight",1000));
    mp.insert(pair<string,int>("height",1900));
    mp.insert(pair<string,int>("age",20));

    map<string,int>::iterator it;

    for(it=mp.begin(); it!=mp.end() ; it++){
        cout<<it->first<<" "<<it->second<<endl;
    }

    cout<<"----------------------------"<<endl;

    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);

    vector<int>::const_iterator it2;

    for(it2=v.begin();it2!=v.end();it2++){
        cout<<*it2<<" ";
        //++*it2;  //只读迭代器 只允许读取
    }cout<<endl;

    cout<<"----------------------------"<<endl;

    list<string> lis;
    lis.push_back("Tom");
    lis.push_back("Jerry");
    lis.push_back("link&co");
    lis.push_back("BMW");

    list<string>::iterator it3;

    for(it3=lis.begin();it3!=lis.end();it3++){
        cout<<*it3<<endl;
    }cout<<endl;
}

4.继承

（面向对象三大特征：封装 继承 多态）

定义：从已有的类的继承上，创建新的类，会拥有已有类的属性和方法，通常会再此继承上添加新的属性和方法，完成扩充

已存在的类 成为基类 或者 父类

新的类 成为派生类 或者 子类

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

using namespace std;
class Father{
public:
    string name = "wang";
    void work(){
        cout<<"share"<<endl;
    }
    void show(){
        cout<<"name: "<<name<<endl;
    }
};
class Son:public Father{

};

int main(){

    Son s;
    s.show();
    s.work();
}

 派生类可自己再定义一些属性

如果子类中给出了父类同名的函数，会把父类的同名函数隐藏起来

#include <iostream>
using namespace std;
class Father{
public:
    string first_name="王";
    void work(){
        cout<<"我是一名理发师"<<endl;
    }
    void show(){
        cout<<"姓氏："<<first_name<<endl;
    }
};
class Son:public Father{
public:
    int age=20;
    void work(){
      cout<<"我是一名老师"<<endl;
    }
    void play_game(){
        cout<<"玩游戏"<<endl;
    }
};

int main(){
    Son s;
    s.work(); 
    s.play_game(); 
    cout<<s.first_name<<" "<<s.age<<endl;
}

调用父类隐藏的函数需要 父类：：函数名 的方式访问

#include <iostream>
#include <map> //写明头文件
#include <vector>
#include <list>
using namespace std;
class Father{
public:
string first_name="王";
void work(){
cout<<"我是一名理发师"<<endl;
}
void show(){
cout<<"姓氏："<<first_name<<endl;
}
};
class Son:public Father{
public:
    int age=20;
void work(){
    cout<<"我是一名老师"<<endl;
}
void show(){
    Father::show();
    cout<<"年龄:"<<age<<endl;
}


};
int main()
{
    Son s;
    s.work(); //隐藏了父类的同名函数，子类直接调用只会打印子类中的函数
    s.Father::work(); //父类：：
    s.show();
}

继承的注意事项：

父类的构造函数不会继承下来

子类一定要最直接或间接调用父类的构造函数，来完成父类继承过来数据的初始化，如果子类不写明如何调用父类的构造函数，这时会调用父类无参的构造函数。如果父类没有无参的构造函数，这是会报错

如下：会报错的！

#include <iostream>
using namespace std;
class Father{
private:
    string first_name;
public:
    Father(string s)
    {
        first_name=s;
    }
    void show(){
        cout<<"姓氏："<<first_name<<endl;
    }
};
class Son:public Father{

};
int main()
{
    Son s;
}


E:\qtfile\helloworld\main.cpp:21: error: use of deleted function 'Son::Son()'
     Son s;
         ^

4.1继承中的构造函数

透传函数

直接调用父类的构造函数，称为透传构造

#include <iostream>
using namespace std;
class Father{
private:
    string first_name;
    int age;
public:
    Father(string s){
        first_name=s;
    }
    Father(string first_name,int age){
        this->first_name=first_name;
        this->age=age;
    }
    void getFirstname(){
        cout<<"姓氏："<<first_name<<endl;
    }
    void show(){
        cout<<"姓氏："<<first_name<<"年龄："<<age<<endl;
    }
};
class Son:public Father{
private:
    int height;   //子类新增的
public:
    Son(string name,int age):Father(name,age){}
    Son(string name, int age,int height):Father(name,age){
        this->height=height; //子类新增的属性，自己完成初始化
    }
    void son_show(){
        Father::show();
        cout<<"身高："<<height<<endl;
    }

};
int main(){
    Son s("小红",20);
    s.show();

    Son s2("小米",20,167);
    s2.son_show();

}

委托构造

间接的调用父类的构造函数，子类的构造函数调用子类另一个构造函数，另一个构造函数调用了父类的构造函数，相当于间接调用父类的构造函数

 

#include <iostream>
using namespace std;
class Father{
private:
    string first_name;
    int age;
public:
    Father(string s){
        first_name=s;
    }
    Father(string first_name,int age){
        this->first_name=first_name;
        this->age=age;
    }
    void getFirstname(){
        cout<<"姓氏："<<first_name<<endl;
    }
    void show(){
        cout<<"姓氏："<<first_name<<"年龄："<<age<<endl;
    }
};
class Son:public Father{
private:
    int height;   //子类新增的
public:
    Son(string name):Son(name,18){}
    Son(string name,int age):Father(name,age){}
    Son(string name, int age,int height):Father(name,age){
        this->height=height; //子类新增的属性，自己完成初始化
    }
    void son_show(){
        Father::show();
        cout<<"身高："<<height<<endl;
    }

};
int main(){
    //Son s("小名",20);
    //s.show();

    //Son s2("小米",20,167);
    //s2.son_show();

    Son s3("张飞");
    s3.show();      //姓氏：张飞 年龄：18

}

练习：

封装Person 类

name,age,sex

给出show方法要输出上面三条信息

封装Employee 职员 继承自Person

salary, work_id

给出show方法要输出除了Person类中基本的情况之外 再输出salary, work_id

封装Manager 管理者 继承自Employee

position 职位

给出show方法要输出除了Employee类中基本的情况之外 再输出position

我的方法：

#include <iostream>

using namespace std;
class Person{
private:
    string name;
    string sex;
public:
    Person(string n,string s):name(n),sex(s){}
    void show(){
        cout<<"姓名："<<name<<endl;
        cout<<"性别："<<sex<<endl;
    }
};
class Employee:public Person{
private:
    double salary;
    int work_id;
public:
    Employee(string name,string sex,double salary,int work_id):Person(name,sex){
        this->salary=salary;
        this->work_id=work_id;
    }
    void Eshow(){
        Person::show();
        cout<<"薪水："<<salary<<endl;
        cout<<"工号："<<work_id<<endl;
    }
};

class Manager:public Employee{
private:
    string position;
public:
    Manager(string name,string sex,double salary,int work_id,string position):Employee(name,sex,salary,work_id){
        this->position=position;
    }
    void Mshow(){
        Employee::Eshow();
        cout<<"职位："<<position<<endl;
    }
};

int main(){
    Person p1("jerry","男");
    p1.show();
    cout<<"************************"<<endl;
    Employee p2("tom","男",3000.4,22121);
    p2.Eshow();
    cout<<"************************"<<endl;
    Manager p3("lisa","女",6000.5,21233,"HR");
    p3.Mshow();
}

运行结果：

5.权限

public           在本类中可以访问    在子类中可以访问        全局中可以使用          //父亲

protected     在本类中可以访问    在子类中可以访问         全局中不可以使用      //儿子

private         在本类中可以访问    在子类中不可以访问      全局中不可以使用      //外人

 

#include <iostream>

using namespace std;

class Father{
public:
    string first_name="王";
protected:
    string car="link&co";
private:
    string password="123456#";
public:
    void show(){
        cout<<first_name<<endl;
        cout<<car<<endl;
        cout<<password<<endl;
    }
};

class Son:public Father{
public:
    void s_show(){
        cout<<first_name<<endl;
        cout<<car<<endl;
        //cout<<password<<endl;  父类私有的 子类中不可以访问
    }
};

int main(){
   Father f;
   f.show();
   cout<<"*************"<<endl;
   Son s;
   s.s_show();
   cout<<"*************"<<endl;
   //全局相当于外人
   cout<<f.first_name<<endl;
   //cout<<car<<endl;      //保护权限数据在全局中不能访问
   //cout<<password<<endl; //私有内容在全局中不能访问


}

 

Summer_taotao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ vector、List、deque资料整理
cxz932652580的博客
09-10 354
顺序容器 vector介绍 vector是C++STL库中表示数组大小可以改变的序列容器，使用连续的存储位置来存储元素，这意味着也可以使用只想元素的常规指针上的偏移量来访问元素（eg：a[i])，与数组不同的是，vector的大小可以动态变化，存储用容器来自动处理。 vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的. 在内部，vector使用动态分配的数组来存储它们的元素。这个数组可
【C++】STL之适配器---用deque实现栈和队列
m0_63198468的博客
09-22 2503
本介绍了什么是适配器，deque，并且使用queue去实现了stack和queue，重点介绍了他们函数接口的使用，以及后面的stack和queue模拟实现。
c++中deque和list的基础知识
枯树无花
04-07 239
https://blog.csdn.net/t46414704152abc/article/details/79322896
C++ STL deque与list容器对比
最新发布
weixin_49329296的博客
07-22 456
本文对这，`std::list` 和 `std::deque` 两种容器进行全面分析，探讨它们的内存分布、底层原理、性能特点、适用场景以及常见使用方法，并对比迭代器在不同操作中的失效情况。
C++学习——Deque（双向队列）和List
m0_37876745的博客
06-28 783
双向队列是一种优化的，可以对序列两端进行添加和删除的序列容器，在随机访问上效率也比较高，存储的方式采用的是多个连续的存储块，两端添加和删除的开销很小 双向队列和List的对比特点： Deque的特点： (1)随机访问方便，即支持[ ]操作符和vector.at()，但性能没有vector好； (2)可以在内部进行插入和删除操作，但性能不及list； (3)可以在两端进行push、pop； (4)相对于verctor占用更...
c++ deque容器和list容器
Raindrips的博客
03-06 929
deque&list 文章目录deque&list序列式容器deque容器属性Deque特点函数相关list容器属性list特点insert emplace 的区别容器的使用vector deque list 之间的区别容器之间的转换迭代器拷贝vector&deque&list之间的转换总结 deque 和 list 都是属于序列式容器 与vector有许多相似的功...
C++ list 与 deque 比较
GIS探索之路
02-20 1578
题目描述：dota2-senate #include <string> #include <list> using namespace std; class Solution { public: string predictPartyVictory(string senate) { int cnt = 0; list<int> R; list&lt...
C++--双端队列deque
Iiverson2000的博客
09-16 530
双端队列这个结构 ，总是作为stack和queue容器适配器的默认模板参数类型，它的功能很丰富，头删头插，尾插尾删，随机存取等等，看起来就是vector和list的合体。为什么这么说呢？ 优点 缺点 vector 1.随机访问 2.尾插 头、中部插入删除 list 任意位置插入删除 随机访问 那么在功能上，我们可以清楚的看到 deque = vector+list 真的是这样么？ 结论： 1.deque不能替代vector和list 2.deque采用operator [ ]
deque 迭代器失效的问题详解
monkey_D_feilong的博客
07-04 5475
今天在看STL源码的时候，无意写了如下的代码，发现程序崩溃了： deque::iterator iter=d.begin(); d.insert(iter,5); d.insert(iter,6); //崩溃，迭代器失效了 之前一直没有留意这个问题，后来结合源码和查找资料，得到如下的结论： 插入操作： 1、在队前或队后插入元素时（push_back(),pus
初识C++之模拟实现stack、queue和反向迭代器
Masquerena114514的博客
03-12 533
讲解了stl库中的stack和queue的模拟实现、适配器模式、双端队列及反向迭代器的实现和仿函数的概念
C++STL容器 ---- 顺序容器之deque、list
Disremembrance的博客
04-17 787
顺序容器2---deque：双端队列 1、Deque(doubled-ended queue)是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。 底层数据结构：动态开辟的二维数组，和vector的底层数据结构不同，deque的第二维是按固定大小开辟的，内存扩容时，扩容第一维的数组空间，每次按原空间2倍方式进行扩容，然后把第二维...
【C++】教你学会 顺序容器(vector、deque、list)的使用
m0_56051805的博客
04-25 1920
【C++】教你学会 顺序容器(vector、deque、list)的使用
C++ deque,list
qq_37667464的博客
01-21 226
链表特性： 1.l.reverse() //逆序 2.链表不支持迭代器的随机访问 it++;可以 it+1;不行 3.可以直接删除值，删掉所有特定值的元素 l.remove(2)； #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;string&gt; #include &lt;deque&gt; #inc...
剑指offer06——c++中栈，队列，列表使用
qq_35754359的博客
08-30 94
c++中栈，队列，列表使用 栈的使用 定义头文件 #include<stack> 初始定义 stack<int> s; 相关操作 s.empty()//如果栈为空返回true，否则返回false s.size()//返回栈中元素的个数 s.pop()//删除栈顶元素但不返回其值 s.top()//返回栈顶的元素，但不删除该元素 s.push(X)//在栈顶压入新元素 ，参数X为要压入的元 队列的使用 定义头文件 #include<queue> 初始
C++学习路线之C++基础（十一）——deque容器，stack容器，queue容器和list容器
enentohaha的博客
04-25 113
维护每段缓冲区中的内容，缓冲区中存放真实数据，中控器维护每个缓冲区的地址，使得deque使用时像是一片连续内存空间。入队：push，出队：pop，队头 ：front（），队尾：back（）；优点：可以对任意位置进行快速插入或者删除元素，（不需要移动元素，直接修改指针域）缺点：容器遍历速度没有数组快，占用空间大（存储指针需要额外空间），不支持随机访问。链表迭代器是一个双向迭代器，不支持随机访问。排序规则：按年龄升序，年龄相同，身高降序。front（）和back（）和迭代器访问。的容器，有两个出口。
【C++】deque和list以及它们和vector的区别
GoingJack博客
07-16 220
deque:双端队列容器 底层数据结构：动态开辟的二维数组，一维数组从2开始，以2倍的方式进行扩容，每次扩容后，原来第二维的数组，从 新的第一维数组的下标oldsize/2开始存放，上下都预留相同的空行，方便支持deque的首尾元素添加 deque<int> deq; 增加： deq.push_back(20); 从末尾添加元素 O(1) deq.push_front(2...
C++（十二）：栈、队列、list、set、map
黄孝果的博客
09-22 377
#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <queue> using namespace std; void printDeque(deque<int>& q) { size_t i = 0; for (; i < q.size(); i++) { cout...
C++三种容器：list、vector和deque的区别
好习惯成就伟大
08-10 1168
在写C++程序的时候会发现STL是一个不错的东西，减少了代码量，使代码的复用率大大提高，减轻了程序猿的负担。还有一个就是容器，你会发现要是自己写一个链表、队列，或者是数组的时候，既要花时间还要操心怎么去维护，里面的指针啊，内存够不够用啊，长度问题，有没有可能溢出啊等等一系列的问题等着我们去解决，还是比较头疼的。所以容器的出现解决了这一个问题，它将这些数据结构都封装成了一个类，只需要加上头文件，我们就可以轻松的应用，不用那么复杂，就连指针也被封装成了迭代器，用起来更方便，更人性化，方便了我们的编程，对于程序员
C++ list容器和deque容器的基本操作
xbj319wz的博客
04-16 284
功能：双端数组，可以对头端进行插入和删除操作deque与vector区别：*vector对于头部的插入删除效率低，数据量越大，效率越低。*deque相对而言，对头部的插入删除速度比vector快*vector访问元素时的速度会比deque快，这和两者内部实现有关。函数原型：//默认构造形式//构造函数将(beg,end)区间中的元素拷贝给本身//构造函数将n个elem拷贝给本身//拷贝构造函数​it!= d.end();​。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值