精华内容
下载资源
问答
  • vector容器和数组

    2009-08-27 08:10:00
    vector容器和数组的区别,vector是c++特有的用来存储某一类型对象的容器,数组也是存储的也是同一类型的对象,但是数据是比较低级的,是语言内置的,所以程序需要以更高速度运行时就尽量使用数组。除此以外,由于...

    vector容器和数组的区别,vectorc++特有的用来存储某一类型对象的容器,数组也是存储的也是同一类型的对象,但是数据是比较低级的,是语言内置的,所以程序需要以更高速度运行时就尽量使用数组。除此以外,由于vector容器不像数组一样在声明定义的时候就固定了存储的空间大小,vector会显得比较自由,能随时添加新的对象。Vector的用法可以查阅vs的帮助文档,在文档里几乎每一个函数的的用法都配有一个简单易明的demo让你更好理解vector,让你了解到vector的方便和强大。在《C++ Primer》中也推荐除了在使用vector应用程序速度达不到要求时,在编写程序的时候都尽量用vector来代替数组。

    数组于数组之间不同直接通过数组标识符进行赋值,例如:

           int a[]={1,2,4};

           int b[3];

           b = a;        //error

    转载于:https://www.cnblogs.com/IamEasy_Man/archive/2009/08/27/1554782.html

    展开全文
  • C++ Vector容器数组

    2019-10-06 18:05:51
    ▶ Vector表示对象的集合,属于模板类 ,因为其容纳着其他对象,所以又被称为"容器"; 注:对于数据的集合,如果不知道数据个数,使用vector优于数组;... vector容器本身具有的方法v1.begin(...

    Vector表示对象的集合,属于模板类 ,因为其容纳着其他对象,所以又被称为"容器";

    :对于数据的集合,如果不知道数据个数,使用vector优于数组;

    1> 数组不允许拷贝和赋值(vector支持)

    2> 数组的维度必须是常量表达式(vector支持变长)

    3> 数组不支持迭代器(vector支持)

    4> vector容器本身具有的方法v1.begin()/v1.end(),但C++11中引入了begin()和end()函数用于数组



    #include<iostream>
    #include<vector>
    using namespace std;
     
    void func1(){
    	/*
    	Vector的初始化
    	1. Vector尾部添加数据 push_back()
    	2. Vector尾部删除/弹出数据 pop_back()
    	3. Vector求元素个数 size() 
    	*/
    	vector<int> v1;
    	vector<string> v2(10,"*"); 
    	vector<string> v3 = {"AAA","BBB","CCC"};
    	vector<string> v4{"AAA","BBB","CCC"};
    	vector<string> v5;
    	
    	for(int i=0;i<10;i++){
    		v1.push_back(i+1);
    	}
    	v1.pop_back();
    	//v1[9] = 99;
    	cout << v1.size() << endl;
    	for(auto c:v1){
    		cout << c << endl;
    	}
    }
    
    
    void func_6(){
    	/*
    	测试向量中数据的插入 insert()
    	测试向量中数据的删除 erase()
    	测试向量中数据的清空 clear()
    	*/
    	vector<int> a1 = {1,2,5,8,4,3,0};
    	a1.insert(a1.begin()+0,999);    //在下标为0的位置前面添加数据999
    	a1.erase(a1.begin()+1);    //删除索引为1的元素
        //a1.clear(); 
    	for(auto i:a1){
    		cout << i << " ";
    	}
    	cout << endl;
    	cout << "Length:" << a1.size() << endl; 
    }
    
    
     
    void func_2(){
    	/*
    	1. 尝试输出begin()和end()
    	2. 判断Vector是否为空 
    	*/
    	vector<int> v1{1,2,3};
    	vector<string> v5{"abcdEGGf"};
    	
    	auto a0 = v1.begin();
    	auto a1 = v1.end();
    	cout << *a0 << endl;
    	cout << *a1 << endl;
    	
    	if(v5.begin()!=v5.end()){
    		auto str0 = v5.begin();
    		cout << *str0 << endl;
    	}
    	else{
    		cout << "Blank!" << endl;
    	}
    }
     
     
    void func_3(){
    	/*
    	String类型也支持begin()与end方法 
    	*/
    	string a="hello";
    	cout << *a.begin() << *a.end() << endl;
    }
     
     
    void func_4(){
    	/*
    	使用迭代器循环遍历 
    	*/
    	string s("hello,world!");
    	if(s.begin()!=s.end()){
    		auto it = s.begin();
    		*it = toupper(*it);
    	}
    	cout << s << endl;
    	
    	///判断字符是否为空格 isspace(char c) 
    	// 不是空格返回 0,是空格返回非0值 ! 
    	cout << isspace('a') <<endl;
    	cout << isspace('\t') <<endl;
    	cout << isspace('	') <<endl;
    	cout << isspace(' ') <<endl;
    	cout << isspace('\n') <<endl;
    	
    	for(auto it=s.begin();it!=s.end() && !isspace(*it);it++){
    		*it = toupper(*it);
    	}
    	cout << s << endl;
    	
    } 
     
     
    void func_5(char find){
    	/*
    	二分搜索 (begin()+end())
    	*/
    	string text = "abcdefg";
    	auto begin = text.begin(),end = text.end();
    	auto mid = begin+(end-begin)/2;
    	while(mid!=end){
    		if(*mid > find){
    			end = mid;
    		}
    		else if(*mid < find){
    			begin = mid+1;
    		}
    		else{
    			cout << "Find it! Index:";
    			cout << mid-text.begin() << endl;
    			return;
    		}
    		mid = begin+(end-begin)/2;
    	}
    	if(mid==end){
    		cout << "Can't find it!" << endl;
    		return ;
    	}
    } 
    
    
    int main(){
    	//...
    	//func_5('c');
    	func_4();
    	return 0;
    } 


    ▶ 数组与Vector:

    :数组是类似于vector的一种容器数据结构,但是相较于vector损失了部分灵活性;

    1> 数组也可以使用begin()和end(),但是此处的方法和vector中的不同,需要额外通过std引用,而且数组需要作为参数;

    2> 使用数组给vector赋值时:vector<int> v1(begin(a1),end(a1)); 需要使用到begin()和end();

    int main(){
    	
    	int a[5] = {1,2,5,6,7};
    	cout << sizeof(a[0]) << endl;
    	cout << begin(a) << endl;
    	cout << end(a) << endl;
    	cout << *begin(a) << endl;
    	cout << *end(a) << endl;
    	
    	vector<int> data(begin(a),end(a));
    	for(auto i : data){
    		cout << i << endl;
    	}
    	return 0;
    } 

     


    展开全文
  • (打赏完成私信我)9.2 vector容器数组的最佳替代者在STL尚未诞生的年代,如果要想在程序中保存管理大量的同类型数据,则只能采用数组这种“粗鲁”的方式。例如,我们要保存公司中所有的员工对象,需要这样的数组...

    想要抢先看后面的章节?打赏本文10元,即可获得带插图全本下载地址!

    (打赏完成私信我)

    9.2 vector容器是数组的最佳替代者

    在STL尚未诞生的年代,如果要想在程序中保存和管理大量的同类型数据,则只能采用数组这种“粗鲁”的方式。例如,我们要保存公司中所有的员工对象,需要这样的数组:

    // 定义数组的容量const int MAX_COUNT = 100000;

    // 定义保存Employee对象的数组Employee arrEmp[MAX_COUNT];

    这样的方式是可以解决问题,但是却显得非常“粗鲁”: 如果定义的最大容量大于实际的需要,会造成内存空间的浪费;而如果定义的最大容量小于实际的需要,又无法满足程序的需要,更不利于程序的扩展。同时,对数组元素的访问也非常“粗鲁”,数组无法对索引值进行检查,很容易造成数组的访问越界等严重的内存访问错误;无法在一个数组中动态地插入或者删除一个数据;无法通过传值的方式在函数之间传递一个数组等。

    随着STL的出现,其中的vector容器同样可以用于保存和管理大量同类型数据,但无论是在内存管理上还是在对数据元素的访问上,都要优于数组:vector容器动态增减的容量大小替代了数组的固定容量,可以适应各种不同的需要;通过vector容器提供的功能函数操作数据元素替代了数组通过“[]”对数据元素的直接操作,不仅更加安全,同时还提供了更丰富的操作。因此vector容器也成为了数组的最佳替代者,是我们最为常用的STL容器。同时,其使用方法具有一定的典型性,学会了使用vector容器,依葫芦画瓢,基本上也就学会了使用STL中的其他容器。

    9.2.1 创建并初始化vector对象

    在本质上,vector容器是一个类模板vector,因此要想使用vector容器,首先需要根据我们想要保存数据的类型实例化得到一个特定类型的模板类,然后创建相应的vector容器对象,最后就可以利用它提供的功能函数,对容器进行添加、删除、插入等常见操作,完成对数据的管理。例如,我们的程序中拥有大量的Employee对象,需要一个vector容器来对其进行管理:

    #include // 引入vector类模板所在的头文件using namespace std; // 使用vector所在的名字空间std

    // …// 因为要保存Employee对象,先使用Employee类型实例化vector类模板,// 然后创建实例对象vecEmpvector vecEmp;

    这样,我们就得到了一个空的可以保存Employee类型数据的vector容器。除了空容器之外,如果想得到一个已经保存有默认数据的vector容器,则可以在创建容器对象的时候,利用其构造函数指定默认数据及默认数据的个数。当容器对象创建完成时,这些默认数据也就已经保存在容器中了。例如:

    Employee emp; // 默认数据// 创建4个emp对象的副本保存到容器中vector vecEmp(4, emp);

    // 使用Employee类的默认构造函数创建4个对象保存到容器中vector vecDefEmp(4);

    在创建一个vector容器的时候,除了可以指定其中元素的个数以及默认的元素之外,vector容器还提供了一个可以接受初始化列表(initializer list)为参数的初始化列表构造函数,这也就意味着,我们可以利用初始化列表,在创建容器对象的同时将任意多个相应类型的数据添加到容器中,以此来完成vector容器的初始化工作。例如:

    // 创建一个保存学生成绩的vector容器// 在创建的同时利用初始化列表添加初始数据vector vecScores = { 87, 72, 63, 93 };

    虽然vector容器的内存是随着元素个数的增加而动态增加的,但如果已经预先知道vector容器可能的最大容量,则可以使用reserve()函数申请足够的内存,为vector容器预留足够多的元素位置,减少在元素添加过程中内存的动态申请过程。例如:

    // 大约有1000位员工,所以为vector容器预留1000个元素位置vecEmp.reserve( 1000 );

    vector容器的“备胎”——array容器

    作为数组的最佳替代者,vector容器有着无数的优势,但是在某些特殊情况下,这些优势却反而变成了劣势。比如,要保存一组固定个数相同类型的数据,例如一年12个月的平均气温、一周7天的PM 2.5数值等。在这种情况下,如果仍旧使用vector容器来存放这些数据,vector容器的动态内存往往会申请比实际保存数据所需的更多的空间,这样会浪费宝贵的内存资源;vector容器提供了push_back()函数可以动态地向容器中添加数据,如果无意中调用了push_back()函数,就会破坏这组数据的固定个数。既要利用容器的各种优势,又要避免vector容器在保存这类数据时的各种劣势,STL提供了vector容器的备胎——array容器。

    array是一个支持随机访问且大小固定的容器。跟vector容器为元素预留空间不同,array容器并不预留多余空间,只为元素分配必需的空间,因此它克服了vector容器在保存固定个数数据浪费内存资源的劣势;同时,跟普通数组不同的是,它保存了自己的size信息,同时提供了必要的操作函数,可以方便地安全地对数据进行操作,这又使得它弥补了普通数组的劣势。正是array容器的这些特点,使得它特别适合在嵌入式系统和有类似限制(性能敏感、安全关键、内存紧张)的系统中使用。

    跟vector容器相似,array容器同样是一个类模板,只不过它需要两个特化参数,第一个参数表示这个容器可以保存的数据类型,第二个参数表示这个容器可以保存的数据个数。例如:

    // 引入定义array容器的头文件#include using namespace std;

    // 定义一个只能保存12个double类型数据元素的array容器array

    arrMonths;

    // 像使用普通数组一样,使用下标对容器中的数据元素进行赋值,将数据保存到容器中arrMonths[0] = 15.4;

    arrMonths[1] = 17.6;

    // ...arrMonths[11] =19.7;

    同样,我们也可以使用迭代器访问array容器中的数据:

    // 输出array容器中的所有数据for(auto it =

    arrMonths.begin();

    it

    != arrMonths.end(); ++it )

    {

    // 使用迭代器访问array容器中的数据 cout<

    }

    概括来讲,array容器除了无法动态地改变它的大小之外,在操作上,array容器与vector容器并无太大区别。所以,如果有一组固定个数相同类型的数据需要保存,array容器是比vector容器更好的选择。

    9.2.2 对vector容器的操作

    对于数组,我们都是通过指针或者它的下标来对其中的元素进行访问,这样的操作方式虽然简便,却也非常容易造成数组访问越界的错误。vector容器作为数组的最佳替代者,当然不会采用这么“粗鲁”的方式来操作容器中的元素。取而代之的是,它提供了很多操作函数,使用这些函数,可以灵活而安全地完成对vector容器的各种操作。vector容器提供的常用操作函数如表9-1所示。

    表9-1 vector容器的常用操作函数(以操作vector容器v为例)

    函 数 说 明v.empty() 判断容器v是否为空。如果v为空,则返回true;否则返回false

    v.size()返回容器v中已保存元素的个数

    v.push_back(val)在容器v的末尾增加一个值为val的元素

    v.pop_back()返回容器v的最后一个元素

    v.insert(pos,val)在容器v的pos位置插入一个值为val的元素

    v.earse(pos)删除容器v中pos位置上的元素

    v.clear()删除容器v中的所有元素

    v.at( pos )返回容器v中pos位置上的元素

    v1 = v2将v2赋值给v1,也就是把容器v2中的元素全部复制到容器v2中

    v1 == v2判断容器v1和容器v2是否相等,也就是两个容器中的元素是否相等,如果v1与v2相等,则返回true

    在表9-1所述的这些操作函数中,最常用的应该是push_back()函数了,我们通常使用它来将数据保存到vector容器中。当使用push_back()函数向vector容器中添加数据时,它会接受一个跟vector容器模板参数数据类型相同的数据,然后将其复制为一个新元素并添加到vector容器的末尾,也就是将数据“推送(push)”到vector容器的“后面(back)”。例如:

    // 创建一个空的可以保存整型数的vector容器vector vecSalary;

    int nSalary; // 接受用户输入// 循环读取用户输入while(cin>>nSalary)

    {

    // 利用push_back()函数将用户输入的数据保存到vector容器对象vecSalary中 vecSalary.push_back( nSalary );

    }

    // 在容器的开始位置插入一个数据auto it = vecSalary.begin(); // 获得指向开始位置的迭代器vecSalary.insert(it,2200); // 在容器的开始位置插入数据// 输出当前容器中的元素个数cout<

    在这段代码中,因为需要保存用户输入的int类型的工资数据,所以首先以int作为vector类模板的类型参数,定义了一个空的能够保存int类型数据的vector容器vecSalary;然后通过循环从标准输入读取用户输入的数据,每循环一次就添加一个新数据元素到vecSalary容器的末尾位置,当循环结束时,vecSalary容器就包含了所有输入的数据。

    9.2.3 访问vector容器中的数据

    如果我们已经使用push_back()函数将数据保存到了容器中,那么接下来当然是希望能够访问容器中的数据,对其进行相应的处理。本质上,vector容器就是一个数组,跟访问数组中的元素相似,我们同样可以使用“[ ]”符号,以元素在容器中的次序作为下标来访问vector容器中的数据。例如:

    // 将vecSalary容器中的第一个数据元素赋值为3000vecSalary[0] = 3000;

    但是,为了保证访问元素的安全性,vector容器更多的是使用迭代器或者at()函数来访问容器中的数据元素。例如:

    // 定义索引值变量,用于访问容器中的数据

    vector::size_type nIndex = 0;

    // 循环遍历vector容器

    for( auto it = vecSalary.begin();

    it !=vecSalary.end(); ++it, ++nIndex )

    {

    // 通过迭代器读取容器中的数据

    cout<

    // 通过at()函数修改容器中元素的值

    vecSalary.at( nIndex ) += 1000; // 涨工资啦!每个人加1000元!

    cout<

    }

    这里,我们分别通过迭代器和at()函数对vector容器中的数据进行了读/写操作。虽然两者在效果上是相同的,但是在条件允许的情况下,为了保持代码的一致性,应优先通过迭代器对容器中的元素进行访问。

    从这里也可以看到,vector容器的使用如此简单,同时又比数组更加便利和安全,当我们在程序中需要保存相同类型的某个数据序列时,vector容器是数组的最佳替代者。

    展开全文
  • vector容器常用操作 初识vector vector构造函数 vector常用赋值操作 vector大小操作 vector数据存取操作 vector插入删除操作 用swap,收缩内存空间 reserve预留空间 vector容器常用操作 array是静态...

    vector容器常用操作

    array是静态空间,vector是动态空间

    vector<int>::iterator it1;      //it1的型别其实就是int*
    vector<Teacher>::iterator it2;  //it2的型别其实就是Teacher*

    初识vector

    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<vector>
    using namespace std;
    
    int main() {
    
        vector<int> v;
        for (int i = 0; i < 10;i++) {
            v.push_back(i);
            cout <<"capacity:"<< v.capacity() << endl;
        }
    
        int* start = &v[0];
        int* end = &v[v.size() - 1];
    
        for (; start <= end; start++) {
            cout << *start << "  ";
        }
    
        system("pause");
        return EXIT_SUCCESS;
    }
    输出结果:
    capacity:1
    capacity:2
    capacity:3
    capacity:4
    capacity:6
    capacity:6
    capacity:9
    capacity:9
    capacity:9
    capacity:13
    0  1  2  3  4  5  6  7  8  9  请按任意键继续. . .

    所谓动态增加大小,并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间),而是一块更大的内存空间,然后将原数据拷贝新空间,并释放原空间。因此,对vector的任何操作,一旦引起空间的重新配置,指向原vector的所有迭代器就都失效了。

    vector构造函数

    vector<T> v; //采用模板实现类实现,默认构造函数
    vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
    vector(n, elem);//构造函数将n个elem拷贝给本身。
    vector(const vector &vec);//拷贝构造函数。
    
    //例子 使用第二个构造函数 我们可以...
    int arr[] = {2,3,4,1,9};
    vector<int> v1(arr, arr + sizeof(arr) / sizeof(int)); 

    vector常用赋值操作

    assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
    assign(n, elem);//将n个elem拷贝赋值给本身。
    vector& operator=(const vector  &vec);//重载等号操作符
    swap(vec);// 将vec与本身的元素互换。

    vector大小操作

    size();//返回容器中元素的个数
    empty();//判断容器是否为空
    resize(int num);//重新指定容器的长度为num,若容器变长,则以默认值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。
    resize(int num, elem);//重新指定容器的长度为num,若容器变长,则以elem值填充新位置。如果容器变短,则末尾超出容器长>度的元素被删除。
    capacity();//容器的容量
    reserve(int len);//容器预留len个元素长度,预留位置不初始化,元素不可访问。

    vector数据存取操作

    at(int idx); //返回索引idx所指的数据,如果idx越界,抛出out_of_range异常。
    operator[];//返回索引idx所指的数据,越界时,运行直接报错
    front();//返回容器中第一个数据元素
    back();//返回容器中最后一个数据元素

    vector插入和删除操作

    insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
    push_back(ele); //尾部插入元素ele
    pop_back();//删除最后一个元素
    erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
    erase(const_iterator pos);//删除迭代器指向的元素
    clear();//删除容器中所有元素

    用swap,收缩内存空间

    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<vector>
    #include<algorithm>
    using namespace std;
    int main() 
    {
    
        vector<int> v;
        for (int i = 0; i < 100000;i++) {
            v.push_back(i);
        }
    
        cout << "capacity:" << v.capacity() << endl;
        cout << "size:" << v.size() << endl;
    
        //此时 通过resize改变容器大小
        v.resize(10);
    
        cout << "capacity:" << v.capacity() << endl;
        cout << "size:" << v.size() << endl;
    
        //容量没有改变
        vector<int>(v).swap(v);
    
        cout << "capacity:" << v.capacity() << endl;
        cout << "size:" << v.size() << endl;
    
    
        system("pause");
        return EXIT_SUCCESS;
    }
    输出结果:
    capacity:138255
    size:100000
    capacity:138255
    size:10
    capacity:10
    size:10
    请按任意键继续. . .

    reserve预留空间

    说明,提前预留空间,内存只分配一次

    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<vector>
    usingnamespace std;
    
    int main()
    {
        vector<int> v;
        //预先开辟空间
        v.reserve(100000);
        int* pStart =NULL;
        int count =0;
        for(int i =0; i <100000;i ++
        {
            v.push_back(i);
            if(pStart !=&v[0])
            {
                pStart =&v[0];
                count++;
            }
        }
        cout <<"count:"<< count << endl;
        system("pause");
        return EXIT_SUCCESS;
    }
    输出结果:count:1
    展开全文
  • 容器和数组的区别

    千次阅读 2013-08-07 16:04:57
    容器和数组的区别: 创建方式: 创建数组时必须指定其大小; 而容器不必指定,可动态改变其大小。 存储方式: 数组在内存空间上是连续存储的; 而容器中顺序容器vector和deque是连续存储的(deque与vector 不同的是...
  • vector:动态数组

    2019-09-28 06:22:18
    vector之所以被认为是一个容器,是因为它能够像容器一样存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加压缩数据。 头文件:#include<vector> 参数:vector<int&g...
  • vector包含在c++标准模版库中,能够存放任意类型的动态数组,类似于一个容器,能够增加数据减少数据 使用方法如下: #include <iostream> #include <vector> struct Vertex{ int x,y,z; Vertex...
  • 数组是存放类型相同的对象的容器数组的大小确定不变,不能随意向数组中增加元素。 1、定义初始化内置数组 (1)数组的大小不变,(a[d],d为数组的维度),数组的维度必须是一个常量表...
  • 一.理论分析 1.1堆栈的区别 栈区(stack)— 由编译器自动分配释放,存放函数的参数值,局部...全局区(静态区)(static) — 全局变量静态变量的存储是放在一起的,初始化的全局变量静态变量在一块区域,...
  • 2、vector 是STL中的容器类 包含多种通用算法 长度可变,使用灵活,但效率稍低 vector是使用 new delete 来管理内存的(堆中分配内存) 3、array 数组模板 ,在C++11中才支持 通用格式:array<类型名, ...
  • 网上对vector和array的评价吐槽,也是喜忧参半,各有不同啊。在面临选择的时候,我们到底用哪一种呢,我们可能都犹豫过?下面对该问题进行理论分析实际测试验证。 2.理论分析 数组是底层数据类型,存放在栈中,...
  • 见注释: 1 #include <iostream> 2 #include <vector> 3 4 using namespace std; 5 6 int main() 7 { 8 vector<... //定义一个整型的容器,它的类型是vector<int> 9 vector<in...
  • 大多数技术计算语言非常重视其数组实现,但需要付出使用其它容器的代价。Julia 用同样的方式来处理数组。就像其它用 Julia 写的代码一样,Julia 的数组库几乎完全是用 Julia 自身实现的,它的性能源自编译器。...
  • 在没有了解vector之前,动态数组一般都是又new创建的。在了解vector后发现vector竟是那样方便好用,但方便的同时却是以牺牲执行效率为代价的。网上对vector和array的评价吐槽,也是喜忧参半,各有不同啊。在面临...
  • 使用STL的vector实现动态数组,示例功能如下: 函数名 功能 push_back(x) 在向量末尾添加元素 pop_back(x) 删除向量最后一个元素 begin() 返回指向向量开头的迭代器 end() 返回指向...
  • 分割等子集)时,我发现我模仿官方答案写的程序运行速度比官方答案耗时多几倍,于是就开始了一行一行的比对,最后发现原来是vector<int>和vector<bool>的区别。 对于只需要区分true或false的情况,...
  • 历届试题 大臣的旅费: 1遇到的问题 大家都能想到的是用: 枚举+dfs。就能很轻松的解决,这样可以直接拿到75%分!! 但是时间复杂度会超过。...开始想用 容器定义一个二维数组vector < vector > mapp;
  • C++自身实现了一个array容器,但是STL里的动态数组Vector(直译为向量)使用更方便,这里还是讨论下VectorVector是内存连续的,空间按需增长的结构。 Vector和List是刚好相反的,Vector在随机存储的操作上非常...
  • C++ list vector 数组 的区别

    千次阅读 2015-03-23 10:38:59
    首先c++标准库中,容器vector和list都可以用来存放一组类型相同的数据,支持动态增长。数组虽然也是用来存放一组想动类型的数组,但是它不支持动态增长; list和vector的区别: (1) vector是顺序表,表示的是一...
  • 2、vector的头文件命名空间 #include //注意没有.h using namespace std; 3、vector的定义 vector是一个类模板,可以定义任何类型 例: vector arr_int; //定义了一个内部元素是int的动态数组 vector arr_char; /...
  • 就我熟悉的C语言C++来说,就有着一定的差异。 对于C语言,数组变量保存在一个专门开辟出来的栈当中,因此,如果是小范围的越界调用,并不会造成灾难性的后果,比如以下程序。 #include <iostream> #...
  • 作为一个C语言程序猿来说,数组是非常重要的,也是必不可少的一种数据组织存储方式。在C++中却很少使用数组。从根本说主要有以下几个方面:数据存储方式: (1)数组的内存地址是连续的,也就是说如果你要申请的内存...
  • C++中输出数组数据分两种情况:字符型数组和非字符型数组 字符型数组 cout << 数组名——字符串 //以字符的形式初始化 char str[10] = { '1','2' };//12 //以字符串的形式初始化 char str_array[10] = {"jiang...
  •  vector是一个顺序容器,可以存放各种类型的对象,简单地说,vector是一个能够存放任意类型的动态数组,能够增加压缩数据。  vector是动态空间,随着元素的增加内部机制可以自行扩充空间,而array则是固定...
  • 数组和向量都可以用来存储元素列表,向量可以用来替换数组,且比数组更灵活(类vector包含很多成员函数)。但是,如果列表大小固定,则使用数组会更加高效。 关于数组和向量的不同相似之处如下表所示: 操作 数组 ...
  • vector动态数组

    千次阅读 2019-03-29 18:47:45
    实际上就是动态数组vector是同一种类型的对象的集合,每个对象都有一个对应的整数索引值。string对象一样,标准库负责管理存储元素的相关内存。我们把vector称为容器,是因为它可以包含其他对象。一个容器中的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,398
精华内容 1,759
关键字:

vector容器和数组