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

list的三种循环遍历方式

// int的类型

#include <iostream>
#include <list>

//using namespace std;

int main() {

//=================================================================
    // int的类型
    std::list<int> ls;

    ls.push_back(120);
    ls.push_back(110);
    ls.push_front(130);
    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;

//=================================================================

    return 0;
}

// float的类型

#include <iostream>
#include <list>

//using namespace std;

int main() {

//=================================================================
    // int的类型
    std::list<float> ls;

    ls.push_back(120.123);
    ls.push_back(110.123);
    ls.push_front(130.123);
    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;

//=================================================================

    return 0;
}

// string的类型

#include <iostream>
#include <list>

//using namespace std;

int main() {

//=================================================================
    // int的类型
    std::list<std::string> ls;

    ls.push_back("CCC");
    ls.push_back("BBB");
    ls.push_front("DDD");
    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;

//=================================================================

    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() {

//=================================================================
    // class的类型
    A a1("张三", 30);
    A a2("张四", 40);
    A a3("张五", 50);
    A a4("张六", 60);

    std::list<A> ls;

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


//    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;

//=================================================================

    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() {

//=================================================================
    // class的类型(指针)
    A a1("张三", 30);
    A a2("张四", 40);
    A a3("张五", 50);
    A a4("张六", 60);

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

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


//    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;

//=================================================================

    return 0;
}

vector的三种循环遍历方式

// int的类型

#include <iostream>
#include <vector>

//using namespace std;

int main() {

//=================================================================
    // int的类型
    std::vector<int> ls;

    ls.push_back(120);
    ls.push_back(110);
//    ls.push_front(130);	// 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::vector<int>::iterator ele;
    for (ele = ls.begin(); ele < ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================

    return 0;
}

// float的类型

#include <iostream>
#include <vector>

//using namespace std;

int main() {

//=================================================================
    // int的类型
    std::vector<float> ls;

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

//=================================================================

    return 0;
}

// string的类型

#include <iostream>
#include <vector>

//using namespace std;

int main() {

//=================================================================
    // int的类型
    std::vector<std::string> ls;

    ls.push_back("CCC");
    ls.push_back("BBB");
//    ls.push_front("DDD");	    // 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::vector<std::string>::iterator ele;
    for (ele = ls.begin(); ele < ls.end(); ++ele) {// list不可以用<,vector可以用!=和<
        std::cout << "基于容器的for循环：" << *ele << std::endl;
    }
    std::cout << "-----------------------------" << std::endl;

//=================================================================

    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() {

//=================================================================
    // class的类型
    A a1("张三", 30);
    A a2("张四", 40);
    A a3("张五", 50);
    A a4("张六", 60);

    std::vector<A> ls;

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


//    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::vector<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;

//=================================================================

    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() {

//=================================================================
    // class的类型(指针)
    A a1("张三", 30);
    A a2("张四", 40);
    A a3("张五", 50);
    A a4("张六", 60);

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

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


//    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::vector<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;

//=================================================================

    return 0;
}