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

    2019-10-19 13:12:31
    定义数组的固定性 关于定义数组,我们都知道,当我们定义完一个数组,该数组的成员数就已经固定了 例如,定义一个成员数为n的整型数组 则这个n应该表示的是常量,而不是变量 int nums[n];...容器的可变性 ...

    定义数组的固定性

    关于定义数组,我们都知道,当我们定义完一个数组,该数组的成员数就已经固定了,即数组是静态分配内存的,一旦分配完内存大小,便不可改变。
    例如,定义一个成员数为n的整型数组
    则这个n应该表示的是常量,而不是变量

    int nums[n];//在写出该语句后,nums数组的成员数就已经不可变了
    

    更形象一些,假设我们需要自定义数组的成员数,我们可能会这么做。

    #include <iostream>
    using namespace std;
    int main(void)
    {
    	int n = 0;//定义成员数变量并初始化
    	cout << "请输入需要定义的数组成员数:" << endl;
    	cin >> n;
    	int nums[n];//定义整型数组,且成员数为n
    	return 0;
    }
    

    但尝试进行编译时,会发现编译器提示在int nums[n];语句的所在行报错了,原因便是之前说明的,定义数组成员数接收的参数必须是常量。

    容器的可变性

    而容器则可以改变这一切,它分配内存的方式是动态分配的。它相比于常规数组,明显的优点是能实现自定义数组的操作。
    例如,用它的方式可以实现上述的代码。需要注意的是,使用它需要用到vector头文件,所以加上就好了。

    #include <iostream>
    #include <vector>
    using namespace std;
    int main(void)
    {
    	int n = 0;//定义成员数变量并初始化
    	cout << "请输入需要定义的数组成员数:" << endl;
    	cin >> n;
    	vector<int>nums(n, 0);//使用vector容器一个整型数组数为n的整型变量,且默认初始化数组的每个元素为0
    	for (int i = 0; i < n; i++)//输出结果
    	{
    		cout << nums[i] << endl;//从这可以看出,它也可以像数组一样操作
    	}
    	return 0;
    }
    

    自定义数组成员数的实用性:这样做有什么好处呢?

    以我自己的例子,在暑假的时候,不知道如何自定义数组成员数大小,但为了实现扫雷游戏的难度设置(即布置地图的格子与雷的个数,布置地图需要用到数组操作),而数组成员数的设置又不能接受变量,只能每个自定义函数都需要重复写几遍,这样的话就异常繁琐且稍有不慎就会出差错。而学习了容器之后,可以实现自定义数组成员数就完全可以避免这样繁琐的操作了。

    容器与数组相比,它的缺点又是什么

    当然,容器也有它的缺点,即它的效率比数组要低,所以,如果没有动态分配内存的必要,用常规数组的方式操作依然是不二之选。

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

    2019-10-06 18:05:51
    ▶ Vector表示对象的集合,属于模板类 ,因为其容纳着其他对象,所以又被称为"容器"; 注:对于数据的集合,如果不知道数据个数,使用vector优于数组; 1> 数组不允许拷贝和赋值(vector支持) 2> 数组的...

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

     


    展开全文
  • Java 容器与数组

    千次阅读 2014-08-31 14:35:55
    数组和其它容器区别主要有三个:效率,类型,和存放基本类型的能力.JAVA中的数组是一种效率最高的存储和随机访问对象引用序列的方式.它就是一个简单的线性序列,所以访问是非常快.但它也损失了其他的特性.当创建一个...
    容器是用来保存多个对象的东西.严格来说是保存对象的引用.因为对象实际的数据是放在另外的地方的.放在容器中的只是指向那块内存区域的一个标识. 
    
    JAVA中内置了数组.数组和其它容器的区别主要有三个:效率,类型,和存放基本类型的能力.JAVA中的数组是一种效率最高的存储和随机访问对象引用序列的方式.它就是一个简单的线性序列,所以访问是非常快.但它也损失了其他的特性.当创建一个数组时,它的长度就被固定了.通常是创建一个固定大小的数组,在空间不足时,再创建一个大的数组,然后把旧数组中的所有引用移到新数组中.这种机制被JAVA中的另一个容器:ArrayList采用.所以,ArrayList的效率要比数组低.JAVA中还有一些其他的容器:List,Set(每个对象只保存一份),Map(允许将一个对象和另一对象关联存储).它们都是针对Object来处理的.而Object是JAVA中所有类的基类,所以说这些容器可以存放所有JAVA类.注意:基本类型如:boolean char byte short long float double void..不继承Object,所以这些容器不能存放这些.如果要存进去必须用JAVA为这些类提供的 包装类 它们对应的包装类是:  Boolean    Character    Byte    Short    Integer    Long    Float    Double    Void

    因为基本类型是不继承自Object的,所以强制转换也是不可能的.必须用包装类进行强制转换.比如说将一个String强制转换成int型,必须:Integer.praseInt("3");必须用包装类来.自动装箱与自动拆箱原理

    经包装类包装后的基本类型就可以随便往容器里放了.

    JAVA容器的缺点:
    1)将对象保存到容器的时候它的类型信息就丢失了.因为容器是针对Object的.所以可以将不同类型的对象放入同一个容器中.而数组则不同,一个数组里只能存同一类型的对象.
    2)在从容器中取出对象使用时必须进行类型转换.
    当然,上面的问题可以通过泛型来解决.

    容器的选择:
    容器实际上只有三种:Map , List, Set;但每种接口都有不同的实现版本.它们的区别可以归纳为由什么在背后支持它们.也就是说,你使用的接口是由什么样的数据结构实现的.
    List的选择:
    比如:ArrayList和LinkedList都实现了List接口.因此无论选择哪一个,基本操作都一样.但ArrayList是由数组提供底层支持.而LinkedList是由双向链表实现的.所以,如果要经常向List里插入或删除数据,LinkedList会比较好.否则应该用速度更快的ArrayList.
    Set的选择
    HashSet总是比TreeSet 性能要好.而后者存在的理由就是它可以维持元素的排序状态.所以,如果需要一个排好序的Set时,才应该用TreeSet
    Map选择:
    同上,尽量选择HashMap,只要需要排好序的确Map时才用Treemap;

    展开全文
  • 数组是存放类型相同的对象的容器数组的大小确定不变,不能随意向数组中增加元素。 1、定义和初始化内置数组 (1)数组的大小不变,(a[d],d为数组的维度),数组的维度必须是一个常量表...

    目录

    一、数组

    二、向量vector

    三、数组与vector的对比

    array和vector,数组三者区别和联系

    共同点

     不同点


     

    本文基于邓俊辉编著《数据结构(C++语言版)(第3版)》、《C++ Primer(第5版)》以及网上的相关博文而写,博主水平有限,若有不妥处,欢迎指出。

     

    一、数组

    C++中数组是一种内置的数据类型。

    数组是存放类型相同的对象的容器,数组的大小确定不变,不能随意向数组中增加元素。

    1、定义和初始化内置数组

    (1)数组的大小不变,(a[d],d为数组的维度),数组的维度必须是一个常量表达式。定义数组的时,必须指定数组的类型和大小。

    (2)初始化时,允许不指明数组的维度,不指明维度,则编译器根据数组初始值的大小推测出维度;若指定维度,则初始值的个数要小于等于维度,当小于时,不足的部分为0(其实还是等于维度)。

    int a[]={1,2,3};    //数组a的大小为3;
    int a[5]={1,2,3};    //等价于{1,2,3,0,0},大小为5
    int a[5]={1,2,3,4,5,6};    //错误,初始值过多
     

     还有一种特殊的情况:字符数组。当用字符串字面值去初始化数组时,要注意字符串字面值的后面还有一个空字符。也就是说,数组的大小要等于字面值的大小加1。

    特别注意:不允许拷贝和赋值------不能将数组的内容拷贝给其他数组作为初始值,也不能用数组为其他数组赋值。

    int a[]={1,2,3};    
    int a2[]=a;            //错误
    a2=a;                //错误

     2、访问数组元素

    数组的索引是从0开始,如:包含10个元素的数组a,其索引是从0到9而非1到10,若是a[10]则下标越界。

    另外,使用数组下标时,其类型是size_t,在头文件cstddef中。

    二、向量vector

    C++中vector为类模板。

    vector是类型相同的对象的容器,vector的大小可以变化,可以向数组中增加元素。

    1、定义和初始化vector对象

    初始化的方式比较多,有如下几种:

     

    1 vector<T> v1;                    //v1为空,执行默认初始化
    2 vector<T> v2(v1);                //v2中包含v1所有元素的副本
    3 vector<T> v2=v1;                //等价于v2(v1)
    4 vector<T> v3(n,val);            //v3中包含n个重复元素,每个元素的值都是val
    5 vector<T> v4(n);                //v4包含n个重复执行了值初始化的对象
    6 vector<T> v5{a,b,c...};         //包含初始化元素个数,每个元素被对应的赋予相应的值
    7 vector<T> v5={a,b,c...};        //等价v5{a,b,c...}

     

     注意事项:

    (1)vector<T> v1,只用默认初始化时,不能通过下标进行添加元素。也就是说,当你将v1初始化为空时,假如你想向v1中添加10个元素,不能通过v1[2]=3;等形式添加,因为,别人为空,压根不知道v1[2]是什么东东。

    (2)注意vector<T> v4(n)和vector<T> v4{n}的区别。前者说的是,v4中有n个相同的元素,至于值为多少要看相应对象的初始化值;而后者,则是说v4中只有一个元素,其值为n。

    (3)不能使用包含着多个值的括号去初始化vector对象。注意和或括号的区别。

    1 vector<int> intV(1,2,3);        //错误 

     2、向vector对象中添加对象

    利用vector的成员函数push_back向其中添加对象:

    vector<int> v;
    for(int i = 0; i != 100; ++i)
    {
        v.push_back(i);
        
    }

     注意:

    若是循环体内包含向vector对象添加元素的语句,则不能使用范围for循环。因为范围for语句不应改变其所遍历序列的额大小。原因如下:

     

     1 vector<int> v={1,2,3,4,5,6,7,8,9};
     2 for(auto &r: v)
     3 {
     4     r*=2;
     5 }
     6 
     7 等价于
     8 for(auto beg=v.begin(),end=v.end();beg !=end;++beg)
     9 {
    10     auto &r=*beg;
    11     r*=2;
    12 }

     

     即在范围for语句中,预存了end()的值,一旦在序列中添加(删除)元素,end函数的值就可能变的无效了。

    3、vector的扩容、插入和删除

    (1)扩容

    vector的底层数据结构时数组。

    当vector中的可用空间耗尽时,就要动态第扩大内部数组的容量。直接在原有物理空间的基础上追加空间?这不现实。数组特定的地址方式要求,物理空间必须地址连续,而我们无法保证其尾部总是预留了足够空间可供拓展。一种方法是,申请一个容量更大的数组,并将原数组中的成员都搬迁至新空间,再在其后方进行插入操作。新数组的地址由OS分配,与原数据区没有直接的关系。新数组的容量总是取作原数组的两倍

    (2)插入和删除

    插入给定值的过程是,先找到要插入的位置,然后将这个位置(包括这个位置)的元素向后整体移动一位,然后将该位置的元素复制为给定值。删除过程则是将该位置以后的所有元素整体前移一位。

    (2)vector的size和capacity

    size指vector容器当前拥有的元素个数,capacity指容器在必须分配新存储空间之前可以存储的元素总数,capacity总是大于或等于size的。

    三、数组与vector的对比

    1、内存中的位置

    C++中数组为内置的数据类型,存放在中,其内存的分配和释放完全由系统自动完成;vector,存放在自由存储区(堆)中,由STL库中程序负责内存的分配和释放,使用方便。

    2、大小能否变化

    数组的大小在初始化后就固定不变,而vector可以通过push_back或pop等操作进行变化。

    3、初始化

    数组不能将数组的内容拷贝给其他数组作为初始值,也不能用数组为其他数组赋值;而向量可以。

    4、执行效率

    数组>vector向量。主要原因是vector的扩容过程要消耗大量的时间。

    Ref:

     http://www.cnblogs.com/chhuach2005/p/3627011.html

    array和vector,数组三者区别和联系

     

    共同点

    (1.)都和数组相似,都可以使用标准数组的表示方法来访问每个元素(array和vector都对下标运算符[ ]进行了重载)
    (2.)三者的存储都是连续的,可以进行随机访问

     
    不同点

    (0.)数组是不安全的,array和vector是比较安全的(有效的避免越界等问题)
    (1.)array对象和数组存储在相同的内存区域(栈)中,vector对象存储在自由存储区(堆)
    (2.)array可以将一个对象赋值给另一个array对象,但是数组不行
    (3.)vector属于变长的容器,即可以根据数据的插入和删除重新构造容器容量;但是array和数组属于定长容器
    (4.)vector和array提供了更好的数据访问机制,即可以使用front()和back()以及at()(at()可以避免a[-1]访问越界的问题)访问方式,使得访问更加安全。而数组只能通过下标访问,在写程序中很容易出现越界的错误
    (5.)vector和array提供了更好的遍历机制,即有正向迭代器和反向迭代器
    (6.)vector和array提供了size()和Empty(),而数组只能通过sizeof()/strlen()以及遍历计数来获取大小和是否为空
    (7.)vector和array提供了两个容器对象的内容交换,即swap()的机制,而数组对于交换只能通过遍历的方式逐个交换元素
    (8.)array提供了初始化所有成员的方法fill()
    (9.)由于vector的动态内存变化的机制,在插入和删除时,需要考虑迭代的是否有效问题
    (10.)vector和array在声明变量后,在声明周期完成后,会自动地释放其所占用的内存。对于数组如果用new[ ]/malloc申请的空间,必须用对应的delete[ ]和free来释放内存
     

    希望通过我的总结大家能够对这三者有一个很深刻的认识,再合适的地方选择合适的结构。

    本文是参考《C++primer》和《C和指针》
     
    原文链接:https://blog.csdn.net/alidada_blog/article/details/83029438

    用法
     

    std::array<int,5> arr;
    std::array<int,5> a = {10, 20, 30, 40, 50};
    

     

    展开全文
  • 1、数组 数组的几种声明方式 var arr1 [5]int//直接定义长度 arr2 := [3]int{1,3,5}//定义长度加初始化数组 arr3:=[...]int{2,4,6,8,10}//未定义长度,直接赋值,[...]为固定格式,无.为切片 var grid [4][5]int//...
  • 容器数组区别

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

    千次阅读 2016-08-24 16:28:53
    数组与容器区别:1. 数组可以存储基本数据类型,也可以存储引用数据类型,集合只能存储引用数据类型。 2. 数组是固定长度的,集合的长度是可变的。3. 数组存储的元素必须是同一个数据类型;集合存储的对象可以是...
  • Go容器数组(array)

    2020-09-08 17:50:53
    这类复杂类型一般情况下具有各种形式的存储和处理数据的功能,将它们称为“容器”。 1 数组概念 数组是一段固定长度的连续内存空间,由若干相同数据类型的元素组成的序列。 在Go语言中,数组的大小在声明时就固定...
  • 数组与容器对比

    2019-12-23 20:03:09
    容器能否完全替代数组? 针对数组类型,很多语言都提供了容器类,比如 Java 中的 ArrayList、C++ STL 中的 vector。...那它与数组相比,到底有哪些优势呢? 我个人觉得,ArrayList 最大的优势就是可以将...
  • 容器中顺序容器vector和deque是连续存储的(dequevector 不同的是它支持高效地在其首部插入和删除元素),但list是链式存储的。 访问效率: 访问数组元素时可根据数组下标直接访问相应位置的元素;而容器...
  • 但很多时候,我们并不知道未来将会发生什么,所以我们创造了容器,它是不固定的,可变的,可以根据元素的增加而增加,每次增加原数组的1.5倍。为什么是1.5倍呢,因为2倍太大了,1倍太小,所以为了保证效率,择中选...
  • 数组和其他容器区别

    千次阅读 2016-07-15 15:50:14
    数组和其他容器区别  (2012-06-27 16:47:15) 转载▼ 标签:  哈希   对象   数组   元素   杂谈 分类: java—web 数组和其它容器区别主要有三方面...
  • 1、vector:是动态数组 定义vector对象的时候先不用指定数组的大小,有数据的化就往数组里面插入就可以了。vector内部自己管理存储空间。 2、vector的头文件和命名空间 #include //注意没有.h using namespace std; ...
  • Java基础——持有对象(数组与容器)~数组当你使用Java编程时,应用“优选容器而不是数组”。只有在已证明容器性能成为问题(并且切换到数组对性能有所帮助)时,你才应该将程序重构为使用数组。初始化:int[] a = {...
  • 容器转成数组:List.toArray() 数组转换成容器:Arrays.asList[]
  • 二维数组与容器

    2020-01-14 22:18:16
    一、二维数组 数组中嵌套数组数组中还有数组) 1、声明 数据类型[][] 数组名; 数据类型[] 数组名[]; 数据类型 数组名[][]; int[][] arr6; int[] arr4[]; int arr5[][]; 2、初始化 动态...
  • 认识Java容器——数组

    2020-11-24 21:24:20
    1.数组就是容器,同一种数据类型的集合; 2.数组是有长度的容器; 3.这个容器的长度当我们用变量控制时,数组就变成了一个动态数组; 4.数组为存入其中的数据进行自动编号,编号从0开始; 5.组成数组的元素可以是...
  • 在LeetCode算法题中,我发现了不同类型的vector容器访问速度有显著差异,于是进一步想探索vector容器与传统C风格数组之间的的访问速度差异。 我编写了一个简单的测试用例,在VS2017环境下测试,代码如下: #...
  • 2:这个容器中有包含数组和集合 2.1: Arrays 2.1.1:Arrays是最高效的,但是它的容量是固定的无法动态改变的,看见这个Arrays就让人想起了一个和它非常相似的一个list集合中的ArrayList 2.1.2:ArrayList是一个容量...
  • c++数组容器类型的两种方式https://blog.csdn.net/zvall/article/details/78652077 string nums[] = { "one","two","three" }; vector<string> svec(begin(nums), end(nums)); // 第一种 int arr[] = {...
  • Java容器(数据结构)—数组详解及运用 一.数组的定义: 数组是一种用于存放 **相同对象 **, 连续存放 , 大小不可改变的 一种容器. ##二. 数组的应用场景(优点) 1.需要的对象数量固定,或在某个范围 2.不需要改变容器...
  • vector容器与迭代器,数组与指针

    千次阅读 2013-07-16 11:16:56
    vector容器与数组非常相似,他们都存放一组具有相同类型数据的元素,其元素是以连续的方式存放——每一个元素紧挨着前一个元素存储。他们的元素没有独立的名字,所以对元素进行访问时都需要一种相应迭代器来历遍元素...
  • 本文讨论了vector高维数组与一维数组的处理速度。 ////////////////////////////////////////////// // // File: vector_text.cpp // Author: Onlyone // Date: 2017.10.5 //  // Description: // runing time...
  • 数组容器之间的转换

    千次阅读 2017-07-20 18:06:49
    数组转化为集合: List list = Arrays.asList(1, 2, 3); 集合转化为数组Collection.toArray(): Object[] objects = list.toArray(); Integer[] integers = list.toArray(new Integer[0]); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 348,975
精华内容 139,590
关键字:

容器与数组的区别