1. 首页
  2. 文章中心
  3. C++

C++的list和vector的三种循环遍历方式list的三种循环遍历方式vector的三种循环遍历方式

104 阅读 0 评论
我是靠谱客的博主 老实苗条，最近开发中收集的这篇文章主要介绍C++的list和vector的三种循环遍历方式list的三种循环遍历方式vector的三种循环遍历方式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

list的三种循环遍历方式

// int的类型

#include <iostream>
#include <list>

//using namespace std;

int main() {

//=================================================================
    std::list<int> ls;

    ls.push_back(120);
    ls.push_back(110);
    ls.push_front(130);	// list有push_front,vector没有push_front
    ls.push_front(140);
    ls.push_front(150);
    ls.push_back(100);


    for (int i = 0; i < ls.size(); ++i) {
//        std::cout << ls[i] << std::endl;	// list不可以这么用,vector可以这么用
    }

    
    for (int ele:ls) {
        std::cout << "基于范围的for循环：" << ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;
    
    
    std::list<int>::iterator ele;
    for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    ls.pop_back();
    ls.pop_front();	// list有pop_front,vector没有pop_front
    
    ls.emplace_back(200);
    ls.emplace_front(300);
    
    return 0;
}

// float的类型

#include <iostream>
#include <list>

//using namespace std;

int main() {

//=================================================================
    std::list<float> ls;

    ls.push_back(120.123);
    ls.push_back(110.123);
    ls.push_front(130.123);	// list有push_front,vector没有push_front
    ls.push_front(140.123);
    ls.push_front(150.123);
    ls.push_back(100.123);


    for (int i = 0; i < ls.size(); ++i) {   // TODO 这里i不要用float
//        std::cout << ls[i] << std::endl;	// list不可以这么用,vector可以这么用
    }


    for (float ele:ls) {
        std::cout << "基于范围的for循环：" << ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;


    std::list<float>::iterator ele;
    for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    ls.pop_back();
    ls.pop_front();	// list有pop_front,vector没有pop_front

    ls.emplace_back(200.123);
    ls.emplace_front(300.123);
    
    return 0;
}

// string的类型

#include <iostream>
#include <list>

//using namespace std;

int main() {

//=================================================================
    std::list<std::string> ls;

    ls.push_back("CCC");
    ls.push_back("BBB");
    ls.push_front("DDD");	// list有push_front,vector没有push_front
    ls.push_front("EEE");
    ls.push_front("FFF");
    ls.push_back("AAA");


//    for (std::string i = 0; i < ls.size(); ++i) {
        std::cout << ls[i] << std::endl;	// 不能这么用
//    }

    
    for (std::string ele:ls) {
        std::cout << "基于范围的for循环：" << ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;
    
    
    std::list<std::string>::iterator ele;
    for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    ls.pop_back();
    ls.pop_front();	// list有pop_front,vector没有pop_front

    ls.emplace_back("XXX");
    ls.emplace_front("YYY");
    
    return 0;
}

// class的类型

#include <iostream>
#include <list>

//using namespace std;

class A {
public:
    std::string name = "";
    int age = 0;

    A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
        std::cout << "执行了构造函数 " << name << std::endl;
    }

    ~A() {
        std::cout << "执行了析构函数 " << name << std::endl;
    }
};


int main() {

//=================================================================
    A a1("张一", 10);
    A a2("张二", 20);
    A a3("张三", 30);
    A a4("张四", 40);

    std::list<A> ls;

    ls.push_front(a3);    // 这里也会执行构造函数创建对象
    ls.push_back(a2);
    ls.push_back(a1);
    ls.push_front(a4);	// list有push_front,vector没有push_front


//    for (A i = 0; i < ls.size(); ++i) {
        std::cout << ls[i] << std::endl;	// 不能这么用
//    }

    
    for (A ele:ls) {
        std::cout << "基于范围的for循环：" << ele.name << ele.age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

    
    std::list<A>::iterator ele;
    for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << (*ele).name << (*ele).age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    ls.pop_back();
    ls.pop_front();	// list有pop_front,vector没有pop_front

    ls.emplace_back(A("张五", 50));
    ls.emplace_front(A("张六", 60));
    
    return 0;
}

// class的类型(指针)

#include <iostream>
#include <list>

//using namespace std;

class A {
public:
    std::string name = "";
    int age = 0;

    A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
        std::cout << "执行了构造函数 " << name << std::endl;
    }

    ~A() {
        std::cout << "执行了析构函数 " << name << std::endl;
    }
};


int main() {

//=================================================================
    A a1("张一", 10);
    A a2("张二", 20);
    A a3("张三", 30);
    A a4("张四", 40);

    std::list<A*> ls;		// 这里用了指针

    ls.push_front(&a3);    // 这里不会执行构造函数创建对象
    ls.push_back(&a2);
    ls.push_back(&a1);
    ls.push_front(&a4);		// list有push_front,vector没有push_front


//    for (A* i = 0; i < ls.size(); ++i) {
        std::cout << ls[i] << std::endl;	// 不能这么用
//    }


    for (A* ele:ls) {
        std::cout << "基于范围的for循环：" << ele->name << ele->age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;


    std::list<A*>::iterator ele;
    for (ele = ls.begin(); ele != ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << (*ele)->name << (*ele)->age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    ls.pop_back();
    ls.pop_front();	// list有pop_front,vector没有pop_front
    
    A a5("张五", 50);
    A a6("张六", 60);
    ls.emplace_back(&a5);
    ls.emplace_front(&a6);
    
    return 0;
}

vector的三种循环遍历方式

// int的类型

#include <iostream>
#include <vector>

//using namespace std;

int main() {

//=================================================================
    std::vector<int> v;

    v.push_back(120);
    v.push_back(110);
//    v.push_front(130);	// list有push_front,vector没有push_front
//    v.push_front(140);
//    v.push_front(150);
    v.push_back(100);


    for (int i = 0; i < v.size(); ++i) {
        std::cout << v[i] << std::endl;	// list不可以这么用,vector可以这么用
    }


    for (int ele:v) {
        std::cout << "基于范围的for循环：" << ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;


    std::vector<int>::iterator ele;
    for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    v.pop_back();
//    v.pop_front();	// list有pop_front,vector没有push_front
    
    v.emplace_back(200);
//    v.emplace_front(300);	// list有emplace_front,vector没有emplace_front
    
    return 0;
}

// float的类型

#include <iostream>
#include <vector>

//using namespace std;

int main() {

//=================================================================
    std::vector<float> v;

    v.push_back(120.123);
    v.push_back(110.123);
//    v.push_front(130.123);	// list有push_front,vector没有push_front
//    v.push_front(140.123);
//    v.push_front(150.123);
    v.push_back(100.123);


    for (int i = 0; i < v.size(); ++i) {   // TODO 这里i不要用float
        std::cout << v[i] << std::endl;	// list不可以这么用,vector可以这么用
    }


    for (float ele:v) {
        std::cout << "基于范围的for循环：" << ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;


    std::vector<float>::iterator ele;
    for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    v.pop_back();
//    v.pop_front();	// list有pop_front,vector没有push_front
        
    v.emplace_back(200.123);
//    v.emplace_front(300.123);	// list有emplace_front,vector没有emplace_front
    
    return 0;
}

// string的类型

#include <iostream>
#include <vector>

//using namespace std;

int main() {

//=================================================================
    std::vector<std::string> v;

    v.push_back("CCC");
    v.push_back("BBB");
//    v.push_front("DDD");	// list有push_front,vector没有push_front
//    v.push_front("EEE");
//    v.push_front("FFF");
    v.push_back("AAA");


//    for (std::string i = 0; i < v.size(); ++i) {
        std::cout << ls[i] << std::endl;	// 不能这么用
//    }


    for (std::string ele:v) {
        std::cout << "基于范围的for循环：" << ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;


    std::vector<std::string>::iterator ele;
    for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    v.pop_back();
//    v.pop_front();	// list有pop_front,vector没有push_front
        
    v.emplace_back("XXX");
//    v.emplace_front("YYY");	// list有emplace_front,vector没有emplace_front
    
    return 0;
}

// class的类型

#include <iostream>
#include <vector>

//using namespace std;

class A {
public:
    std::string name = "";
    int age = 0;

    A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
        std::cout << "执行了构造函数 " << name << std::endl;
    }

    ~A() {
        std::cout << "执行了析构函数 " << name << std::endl;
    }
};


int main() {

//=================================================================
    A a1("张一", 10);
    A a2("张二", 20);
    A a3("张三", 30);
    A a4("张四", 40);

    std::vector<A> v;

//    v.push_front(a3);	// list有push_front,vector没有push_front
    v.push_back(a2);       // 这里也会执行构造函数创建对象
    v.push_back(a1);
//    v.push_front(a4);


//    for (A i = 0; i < v.size(); ++i) {
        std::cout << ls[i] << std::endl;	// 不能这么用
//    }


    for (A ele:v) {
        std::cout << "基于范围的for循环：" << ele.name << ele.age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;


    std::vector<A>::iterator ele;
    for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << (*ele).name << (*ele).age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    v.pop_back();
//    v.pop_front();	// list有pop_front,vector没有push_front
        
    v.emplace_back(A("张五", 50));
//    v.emplace_front(A("张六", 60));	// list有emplace_front,vector没有emplace_front

    return 0;
}

// class的类型(指针)

#include <iostream>
#include <vector>

//using namespace std;

class A {
public:
    std::string name = "";
    int age = 0;

    A(std::string name_temp, int age_temp) : name(name_temp), age(age_temp) {
        std::cout << "执行了构造函数 " << name << std::endl;
    }

    ~A() {
        std::cout << "执行了析构函数 " << name << std::endl;
    }
};


int main() {

//=================================================================
    A a1("张一", 10);
    A a2("张二", 20);
    A a3("张三", 30);
    A a4("张四", 40);

    std::vector<A*> v;		// 这里用了指针

//    v.push_front(&a3);	// list有push_front,vector没有push_front
    v.push_back(&a2);       // 这里不会执行构造函数创建对象
    v.push_back(&a1);
//    v.push_front(&a4);


//    for (A* i = 0; i < v.size(); ++i) {
        std::cout << ls[i] << std::endl;	// 不能这么用
//    }


    for (A* ele:v) {
        std::cout << "基于范围的for循环：" << ele->name << ele->age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;


    std::vector<A*>::iterator ele;
    for (ele = v.begin(); ele < v.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << (*ele)->name << (*ele)->age << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================
    v.pop_back();
//    v.pop_front();	// list有pop_front,vector没有push_front
    
    A a5("张五", 50);
    A a6("张六", 60);
    v.emplace_back(&a5);
//    v.emplace_front(&a6);	// list有emplace_front,vector没有emplace_front
    
    return 0;
}

最后

以上就是老实苗条为你收集整理的C++的list和vector的三种循环遍历方式list的三种循环遍历方式vector的三种循环遍历方式的全部内容，希望文章能够帮你解决C++的list和vector的三种循环遍历方式list的三种循环遍历方式vector的三种循环遍历方式所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(69)

相关文章

vector 循环输入数据
vector 循环输入数据
（vector&C++）（四、遍历与访问）
（vector&C++）（四、遍历与访问）
c++中如何用vector与cin实现字符串的循环读取
c++中如何用vector与cin实现字符串的循环读取
C++ STL vector for_each循环输出
C++ STL vector for_each循环输出
C++的list和vector的三种循环遍历方式list的三种循环遍历方式vector的三种循环遍历方式
C++的list和vector的三种循环遍历方式list的三种循环遍历方式vector的三种循环遍历方式
vector 用法
vector 用法
5.31C++：vector、基于范围的for循环配合auto、传递引用；vector对象名不能当做数组的头指针使用1 vector类模板：容纳任何类型的容器2 基于范围的for循环配合auto3 传递普通变量的引用、传递数组的引用
5.31C++：vector、基于范围的for循环配合auto、传递引用；vector对象名不能当做数组的头指针使用1 vector类模板：容纳任何类型的容器2 基于范围的for循环配合auto3 传递普通变量的引用、传递数组的引用
实战c++中的vector系列--vector的遍历(stl算法、vector迭代器(不要在循环中判断不等于end())、operator[])
实战c++中的vector系列--vector的遍历(stl算法、vector迭代器(不要在循环中判断不等于end())、operator[])

评论列表共有 0 条评论

立即
投稿
返回
顶部