C++程序设计-大模型思维与实践课件 第08章 一维数组与向量-进阶内容

第八章一维数组与向量C++程序设计——大模型思维与实践28.2.1数组的初始化（1）局部变量数组如果没有给出初始化列表，它的元素将不会自动初始化，而是包含随机值。intmain(){intlocalArray[5];//局部数组，未初始化for(inti=0;i<5;i++)cout<<localArray[i]<<"";//可能输出随机值}（2）全局变量数组如果没有给出初始化列表，它的所有元素将自动初始化为0。intglobalArray[5];//全局数组，自动初始化为0intmain(){

for(inti=0;i<5;i++)

cout<<globalArray[i]<<"";//输出0}默认初始化38.2.1数组的初始化（1）为数组的全部元素赋初值如果明确指定了数组的长度，初始化列表中的元素数量应该小于等于数组的长度。inta[5]={0,2,4,6,8};//明确指定长度，并初始化所有元素

列出所有元素的值时，数组的长度可以省略inta[]={0,2,4,6,8};

//省略长度，编译器自动计算长度为5以上初始化等价于逐个为数组元素赋值： a[0]=0;a[1]=2;a[2]=4;a[3]=6;a[4]=8;显式初始化在定义数组时，可以包括用于初始化数组元素的值。48.2.1数组的初始化（2）为数组的部分元素赋初值对于未被显式初始化的元素，C++标准规定它们将被自动初始化为0。inta[10]={1,3,5,7,9};//只初始化前五个元素，剩下的a[5]到a[9]将被自动初始化为0（3）数组全部元素初始化为0显式地列出足够多的0来匹配数组的长度inta[10]={0,0,0,0,0,0,0,0,0,0};//显式初始化所有元素为0inta[]={0,0,0,0,0,0,0,0,0,0};//显式初始化所有元素为0在花括号中只写一个0，并显式指定长度，编译器会处理其余元素的初始化。例如：inta[10]={0};//只需一个0，编译器自动将剩余元素初始化为058.2.1数组的初始化（4）避免以下常见的错误①

数组名不能被赋值：数组名代表数组的首地址，是一个常量指针inta[10],b[10];

a={1,3,5,7,9};//错误：初始化操作只能在定义数组时进行b

=a;//错误：数组名不能被赋值。如期望将a的内容复制到b，需使用循环对元素逐一操作②使用下标进行初始化：inta[10];

a[10]={1,3,5,7,9};//错误：a[10]表示a数组的第10个元素，只能赋值为一个整数。并且，访问a[10]发生了下标越界的错误③初值个数超出数组长度：初始化数组时，提供的初值个数不能超出数组声明的长度。intc[3]={1,2,3,4};//错误：初值个数超出数组长度68.2.2下标越界数组下标的越界是一个常见但危险的问题intintarray[10];，数组的下标从0到9。访问超出这个范围的元素，比如intarray[10]，这会导致未定义行为：程序继续执行但结果不正确引发程序崩溃（如段错误或访问违规）例如：以下代码从键盘输入数据到数组：intmain(){inti,a[10];for(i=1;i<=10;i++)cin>>a[i];return0;}7基于范围的for循环如果想要在循环中修改数组的元素，可以使用引用来声明循环变量：intmain(){

intarr[]={1,2,3,4,5};

for(int&elem:arr)

//elem是引用类型，因此修改elem将导致修改数组元素

elem*=2;//将每个元素的值翻倍

//再次遍历数组以打印修改后的值

for(intelem:arr)

//elem是值类型，用于从数组中复制元素值到elem变量中

cout<<elem<<"";

return0;}8有一个包含6个元素的数组arr，从任意位置开始，输出数组的所有元素。循环数组intmain(){

intarr[]={0,1,2,3,4,5};

intn=6;//数组的长度

intstart=3;//从数组的第3个元素开始

for(inti=0;i<n;++i){

intindex=(start+i)%n;//计算循环下标

cout<<arr[index]<<"";

}

return0;}start=3,输出将是345012逻辑上将数组首尾相连，数组的最后一个元素与第0个元素相邻。使用(start+i)%n计算每次迭代的下标值，确保索引循环回到数组开始。98.3.1指针指向数组任意元素示例：以下代码中指针指向数组首地址intmain(){

inta[5]={10,20,30,40,50};

int*p=a;//p指向数组a的首地址

//使用指针访问数组的第2个元素

cout<<"p[2]="<<p[2]<<endl;//输出:p[2]=30

//直接使用数组名访问相同的元素

cout<<"a[2]="<<a[2]<<endl;//输出:a[2]=30

return0;}当指针p指向数组a的首地址时，即p=a;，此时p[i]与a[i]访问的是同一个元素。这是因为数组名a在表达式中会被转换为指向其首元素的指针。10示例：以下代码中指针指向数组中的任意元素8.3.1指针指向数组任意元素intmain(){

inta[5]={10,20,30,40,50};

int*p=&a[2];//p指向数组a的第2个元素

//使用指针访问当前指向的元素

cout<<"p[0]="<<p[0]<<endl;//输出:p[0]=30

//使用指针访问下一个元素

cout<<"p[1]="<<p[1]<<endl;//输出:p[1]=40

//使用指针访问前一个元素

cout<<"p[-1]="<<p[-1]<<endl;//输出:p[-1]=20

return0;}如果指针p指向了数组a的第i个元素，即p=&a[i];，那么：·

p[0]等价于*(p+0)，即*p，也就是a[i]。·

p[1]等价于*(p+1)，也就是a[i+1]。·

p[-1]等价于*(p-1)，也就是a[i-1]。数组名：数组名代表数组的起始地址，但它本身是一个数组类型。例如，对于声明intarr[10];，arr是一个具有10个整数的数组类型。指针：指针是一个变量，其值是内存中的地址。指针有自己的类型，例如，int*p;声明了一个指向整数的指针。0102类型区别11指针和数组名都可以用来访问数组中的元素数组名代表数组的首地址，也是一个指针8.3.2数组名与指针的区别12以下代码输出数组和指针所占内存的大小，可以了解到它们属于不同的类型：8.3.2数组名与指针的区别intmain(){

inta[10]={1,2,3,4,5,6};

int*p=a;

//计算并输出数组的内存大小

cout<<"数组:"<<sizeof(a)<<"字节"<<endl;

//计算并输出指针的内存大小

cout<<"指针:"<<sizeof(p)<<"字节"<<endl;

return0;}程序运行的输出结果为：数组:40字节指针:8字节对于数组a，sizeof(a)将返回整个数组所占内存空间的大小，即数组中所有元素所占内存大小总和。对于指针p，sizeof(p)将返回指针变量本身所占内存空间的大小，而不是它指向的内容的内存空间大小。指针变量的内存大小通常是4字节（在32位系统上）或8字节（在64位系统上）。138.3.2数组名与指针的区别数组名：数组名是一个常量，不能被赋值。数组名总是指向由其声明的数组的第0个元素，不可修改。a++;错误a=b;//试图将b数组赋值给a，错误指针：指针是一个变量，可以被赋值。指针可以改变，指向内存中的任何位置。p++;正确p=b;正确，使得p指向b数组。0102可变性区别已有变量声明inta[10],b[10],*p;14当需要在函数之间传递数组时，C++的做法是传递数组的首地址，而不是复制整个数组的内容。形式参数可以采用数组形式或指针形式。（1）使用数组形式的形参形参看起来像是一个数组，实际上接收的是数组的首地址。（2）使用指针形式的形式参数形参是一个指向数组元素类型的指针。更加明确地表明了函数接收的是一个指针。8.4.1数组的指针作函数形参voidprintArray(intarr[],intsize){for(inti=0;i<size;i++){cout<<arr[i]<<"";}cout<<endl;}voidprintArray(int*arr,intsize){for(inti=0;i<size;i++){cout<<*(arr+i)<<"";}cout<<endl;}intarr[]，实际上是一个指针，若在函数内部输出sizeof(arr)，可以看到输出的值是8（在部分电脑上是4），而不是数组所占的字节数。15（3）函数调用以下代码调用前面定义的printArray函数输出数组的元素值，由于定义的两个printArray函数功能完全相同，可以相互替换，读者在运行下面代码时，可以使用上述的任意一个函数定义。intmain(){

inta[10];

for(inti=0;i<10;i++)a[i]=i;

printArray(a,10);//输出全部元素

printArray(a,5);//输出前5个元素

printArray(a+5,5);//输出后5个元素

return0;}实参为a+5和5时，循环将会打印a[5]到a[9]的元素，即数组的后5个元素。voidprintArray(intarr[],intsize){for(inti=0;i<size;i++){cout<<arr[i]<<"";}cout<<endl;}指向数组的第5个元素，即数组的后半部分的起始位置。8.4.1数组的指针作函数形参一维数组的指针168.5.1一维数组编程实践voidreverse1(intarr[],intsize){intstart=0;intend=size-1;while(start<end){//交换元素inttemp=arr[start];arr[start]=arr[end];arr[end]=temp;//移动下标start++;end--;}}intmain(){inta[10];for(inti=0;i<10;i++)a[i]=i;reverse1(a,10);for(inti=0;i<10;i++){ cout<<a[i]<<"";}cout<<endl;return

0;}【例1】：数组逆置。编写一个函数，该函数的功能是将一个一维数组中的元素顺序逆置。用户将在main函数中输入数组的元素。一维数组的指针178.5.1一维数组编程实践【例2】：筛选法求素数。intmain(){const

intN=100;boolisPrime[N+1];//isPrime[i]为true表示i是素数//初始化，0和1不是素数，其余先假设都是素数isPrime[0]=false;isPrime[1]=false;//赋值为false，表示将该数挖掉for(inti=2;i<=N;i++) isPrime[i]=true;//筛选法一直进行到sqrt(N)，将i的倍数挖掉for(inti=2;i*i<=N;i++){if(isPrime[i]){//只有i为素数，才需要将它的倍数挖掉//把i的倍数全部标记为非素数，即挖掉for(intj=i*2;j<=N;j+=i) isPrime[j]=false;}具体做法如下：先将1挖掉(因为1不是素数)。把2的倍数挖掉。把3的倍数挖掉。把5、7、11（因为4、6、8、9、10已被挖掉）……的倍数挖掉。

一维数组的指针188.5.1一维数组编程实践}cout<<"1~100的素数有："

<<endl;for(inti=2;i<=N;i++){if(isPrime[i]) cout<<i<<"";}cout<<endl;return

0;}程序运行结果为：1~100的素数有：2357111317192329313741434753596167717379838997一维数组的指针198.5.1一维数组编程实践【例3】：选择排序。编写一个函数，使用选择排序算法对一个一维数组中的元素从小到大排序。具体做法如下：初始化：设定未排序部分的起始位置。寻找最小值：在未排序部分中找到最小值的索引。交换位置：将找到的最小值与未排序部分的第一个元素交换位置。重复步骤2和3，直到所有元素都已排序。voidselectionSort(intarr[],intn){//每次循环选择一个最小的元素，放到第i个位置for(inti=0;i<n-1;i++){//查找最小元素的索引intminIndex=i;for(intj=i+1;j<n;j++){if(arr[j]<arr[minIndex]){ minIndex=j;}}//如果最小元素不是当前位置，进行交换if(minIndex!=i){inttemp=arr[i];arr[i]=arr[minIndex];arr[minIndex]=temp;}}}一维数组的指针208.5.1一维数组编程实践intmain(){intarr[]={64,25,12,22,11};intn=5;selectionSort(arr,n);cout<<"排序后的数组:";for(inti=0;i<n;i++){ cout<<arr[i]<<"";}cout<<endl;return

0;}

一维数组的指针218.5.1一维数组编程实践【例4】：使用指针编程对数组逆置。编写一个函数，该函数的功能是将一个一维数组中的元素顺序逆置。用户将在main函数中输入数组的元素。voidreverse2(intarr[],intsize)

{int*startPtr=arr;int*endPtr=arr+size-1;while(startPtr<endPtr){//交换元素inttemp=*startPtr;*startPtr=*endPtr;*endPtr=temp;//移动指针startPtr++;endPtr--;}}初始化两个指针变量：一个指向数组的首元素（startPtr），另一个指向数组的末元素（endPtr）。交换元素：使用循环，只要startPtr小于endPtr，就交换startPtr和endPtr指向的元素。移动指针：每次交换后，将startPtr向前移动一位（指向下一个元素），将endPtr向后移动一位（指向前一个元素）。重复以上的交换元素和移动指针操作，直到startPtr大于或等于endPtr，完成数组的逆置。一维数组的指针228.5.1一维数组编程实践intmain(){inta[10];for(inti=0;i<10;i++)a[i]=i; reverse2(a,10);for(inti=0;i<10;i++){ cout<<a[i]<<"";}cout<<endl;return

0;}

一维数组的指针238.5.1一维数组编程实践【例5】：编写一个函数，该函数接收一个一维数组和一个指向数组中某个元素的指针作为参数。函数的任务是从数组中删除指针所指向的元素。用户将在main函数中输入数组的元素。intdeleteElement(intarr[],intsize,int*ptr){//确保指针在数组范围内if(ptr>=arr&&ptr<arr+size){//使用指针遍历数组，从要删除的元素开始for(int*current=ptr;current<arr+size-1;current++)//向前移动

*current=*(current+1);size--;//调整数组大小}returnsize;}​指针范围检查

通过

ptr>=arr&&ptr<arr+size

判断指针

ptr

是否在数组范围内，若不在则不执行删除操作。​删除元素

使用指针

current

从待删除位置开始遍历，通过

*current=*(current+1)

将后续元素前移，覆盖待删除元素。​调整数组大小

删除完成后，将数组大小

size

减1（size--），并返回更新后的

size

值。一维数组的指针248.5.1一维数组编程实践intmain(){inta[10],arrSize=10;for(inti=0;i<10;i++)a[i]=i;intdeleteIndex=5;//假设我们要删除索引为5的元素arrSize=deleteElement(a,10,&a[deleteIndex]);//调用函数//arrSize=deleteElement(a,10,a+deleteIndex);//也可如此调用函数for(inti=0;i<arrSize;i++)//注意，arrSize已经减小了1 cout<<a[i]<<"";cout<<endl;return

0;}一维数组的指针258.5.1一维数组编程实践【例6】：使用指针编程，向一个有序数组中插入一个num，要求数组仍然保持有序。intmain(){intarr[10]={1,3,5,7,9};//初始有序数组intn=5;//当前数组大小intnum;//要插入的元素int*p;//指向数组元素的指针cin>>num;for(p=arr+n;(*(p-1)>num)&&(p>arr);p--) *p=*(p-1);*p=num;n++;for(inti=0;i<n;i++) cout<<arr[i]<<"";return

0;}一维数组的指针268.5.1一维数组编程实践【例7】：使用动态分配数组重写例8-1，从键盘输入一个整数n（n的范围为2到80），计算并输出Fibonacci数列的第n个值。Fibonacci数列定义为：第0项为0，第1项为1，之后每一项都是前两项之和。intmain(){intn;cout<<"请输入一个整数n（n的范围为2到80）:";cin>>n;long

long*fib;fib=new

long

long[n+1];//动态分配一个大小为n+1的数组fib[0]=0;fib[1]=1;for(inti=2;i<=n;++i)fib[i]=fib[i-1]+fib[i-2];cout<<"第"

<<n<<"个值是："

<<fib[n]<<endl;delete[]fib;return

0;}27有一个包含6个元素的数组arr，从任意位置开始，输出数组的所有元素。intmain(){

intarr[]={0,1,2,3,4,5};

intn=6;//数组的长度

intstart=3;//从数组的第3个元素开始

for(inti=0;i<n;++i){

intindex=(start+i)%n;//计算循环下标

cout<<arr[index]<<"";

}

return0;}start=3,输出将是345012逻辑上将数组首尾相连，数组的最后一个元素与第0个元素相邻。使用(start+i)%n计算每次迭代的下标值，确保索引循环回到数组开始。8.5.1一维数组编程实践一维数组的指针288.5.1一维数组编程实践【例8】：猴子选大王。n只猴子围成一圈，从1到n编号。从第1只开始报数（从1报到m），报到m的猴子退出圈，下一只猴子重新从1开始报数。如此循环，直到圈内只剩一只猴子，即为大王。intmain(){intn,m;//n:猴子总数,m:报数上限cout<<"请输入猴子总数：";cin>>n;cout<<"请输入报数上限：";cin>>m;//创建并初始化猴子数组（0表示未淘汰，1表示淘汰）int*monkey=new

int[n];for(inti=0;i<n;++i)monkey[i]=0;intremain=n;//剩余猴子数量intcurrent=0;//当前猴子位置intcount=0;//当前报数29//当剩余猴子数大于1时继续游戏while(remain>1){//只在未淘汰的猴子处报数if(monkey[current]==0){count++;//报数增加//当报数达到上限m时淘汰当前猴子if(count==m){monkey[current]=1;//标记为淘汰remain--;//剩余猴子减1count=0;//重置报数}}//移动到下一个位置（循环数组）current=(current+1)%n;}//找出最后剩下的猴子（大王）for(inti=0;i<n;i++){if(monkey[i]==0){cout<<"猴子大王是第"

<<i+1<<"号猴子"

<<endl;break;}}delete[]monkey;return

0;}8.5.1一维数组编程实践308.9.1实践探究

背景:学生在学习C++时，需要理解二分查找算法的原理和实现。特色:你是一位经验丰富的计算机科学教师，专注于算法和数据结构的教学。技能:你具备深入的算法知识，能够清晰地解释复杂的算法概念。流程:1.介绍算法的基本概念和适用场景。2.详细解释算法的工作原理和逻辑流程。3.提供C++代码示例，演示如何实现。4.讨论实现时的注意事项和常见错误。【提问】：

318.9.1实践探究【回复】：

二分查找算法（BinarySearch）是一种高效的查找算法，适用于在有序数组或列表中查找特定元素。二分查找的基本思想是通过不断将查找范围减半，从而快速缩小目标元素的可能位置。适用场景：数据必须是有序的（升序或降序）以及需要频繁查找元素的位置。二分查找的工作原理如下：初始化：设定查找范围的起始点left和终止点right。计算中间点：计算中间点mid，公式为mid=left+(right-left)/2。比较中间点的值：如果中间点的值等于目标值，查找成功，返回中间点位置。如果中间点的值小于目标值，说明目标值在右半部分，更新left=mid+1。如果中间点的值大于目标值，说明目标值在左半部分，更新right=mid-1。重复步骤2和3，直到找到目标值或查找范围为空（即left>right）。328.9.1实践探究以下是一个完整的C++代码示例，演示如何实现二分查找算法：#include<iostream>#include<vector>usingnamespacestd;intbinarySearch(constvector<int>&arr,inttarget){intlow=0,high=arr.size()-1;while(low<=high){intmid=low+(high-low)/2;if(arr[mid]==target){returnmid;//查找成功}elseif(arr[mid]>target){high=mid-1;}else{low=mid+1;}}

return-1;//查找失败}intmain(){vector<int>arr={2,4,6,8,10,12,14};inttarget=10;intresult=binarySearch(arr,target);if(result!=-1){cout<<"Foundatindex:"<<result<<endl;}else{cout<<"Notfound"<<endl;}return0;}338.9.1实践探究实现时的注意事项：数组必须有序：二分查找只能在有序数组中使用。如果数组无序，必须先进行排序。避免溢出：计算中间点时，使用mid=left+(right-left)/2而不是mid=(left+right)/2，以避免left和right较大时的整数溢出。边界条件：确保在更新left和right时正确处理边界条件，避免无限循环。常见错误：数组未排序：在无序数组上使用二分查找会导致错误结果。溢出问题：直接使用(left+right)/2可能导致溢出，尤其是在处理大数组时。边界处理错误：在更新left和right时，容易出现边界处理错误，导致查找失败或无限循环。348.10.1大模型探究

背景:学生在学习C++时，需要理解一维数组的相关算法。特色:你是一位经验丰富的计算机科学教师，专注于算法和数据结构的教学。技能:你具备深入的算法知识，能够清晰地解释复杂的算法概念。任务：现在要求编写一个C++程序，将两个国家的企业专利申请数量排行榜合并成一张混合榜单，按照专利数降序排列。其中，两个国家的专利申请数量分别存储在一个一维数组中，按照降序排列，合并后，成为一个一维数组，仍然降序排列。要求:1.从计算思维的角度，详细阐述解题思路。要求详细到能根据描述将每一句话转换成流程图的一个框，并需要分析为什么要进行该处理。可以采取逐步细化的方式自顶向下逐步阐述。2.提供C++代码示例，演示如何实现算法。3.讨论实现时的注意事项和常见错误。【提问】：

358.10.1大模型探究为了解决这个问题，可以使用双指针法（注意，此处的指针是一个通俗叫法，其实是下标）。具体步骤如下：1.初始化：创建两个指针，分别指向两个数组的开始位置。同时，创建一个新的数组，用于存储合并后的结果。2.比较和合并：比较两个指针所指向的元素，将较大的元素添加到结果数组中，并将对应的指针向后移动一位。这是因为我们需要保持结果数组的有序性，所以我们每次都选择较大的元素添加到结果数组中。当任一指针超出其数组范围时，循环结束。3.处理剩余元素：如果一个数组被完全遍历，但另一个数组还有剩余元素，那么将剩余元素添加到结果数组中。4.返回结果：返回合并后的结果数组。【回复】：

368.10.1大模型探究【回复】：

下面是根据上述思路编写的C++代码示例：vector<int>mergeArrays(constvector<int>&arr1,constvector<int>&arr2){

vector<int>merged(arr1.size()+arr2.size());//创建新数组，用于存储合并后的结果

inti=0,j=0,k=0;//当两个数组都有剩余元素时，比较两个数组的当前元素，将较大元素添加到结果数组中

while(i<arr1.size()&&j<arr2.size()){

if(arr1[i]>arr2[j]){

merged[k++]=arr1[i++];

}else{

merged[k++]=arr2[j++];

}

}378.10.1大模型探究//如果第一个数组还有剩余元素，将它们添加到结果数组中

while(i<arr1.size()){

merged[k++]=arr1[i++];

}//如果第二个数组还有剩余元素，将它们添加到结果数组中

while(j<arr2.size()){

merged[k++]=arr2[j++];

}

returnmerged;//返回合并后的结果数组}intmain(){

vector<int>arr1={6494,1988,1799,1766,1738,1631};

vector<int>arr2={3410,1350,901,853,761,638};

vector<int>merged=mergeArrays(arr1,arr2);

for(inti:merged){

cout<<i<<"";

}}388.10.1大模型探究注意事项：1.在合并过程中，我们需要确保不会访问数组的越界元素。因此，我们在移动指针时，需要检查指针是否已经超过了数组的末尾。2.在创建结果数组时，我们需要确保其大小足以容纳两个输入数组的所有元素。因此，我们将结果数组的大小设置为两个输入数组的大小之和。3.我们假设输入数组已经按降序排列。如果实际情况不是这样，需要在合并之前先对数组进行排序。398.11.1大模型探究

教材上写到：C++编程时在函数内部“直接返回一个数组的局部变量将导致错误，因为数组的局部变量存储在栈上，函数返回时该内存会被释放，这样在主调函数里访问返回的数组将导致未定义行为”。这句话该如何理解，请举例说明。【探究1】：

408.11.1大模型探究【回复1】：作者实践时，得到回复如下：这句话的意思是，在C++中，如果你在一个函数内部创建了一个数组（作为局部变量），然后尝试直接返回这个数组，这将是不安全的。原因在于局部变量（包括数组）是存储在函数的栈帧上的，当函数执行完毕并返回时，其栈帧上的所有局部变量都会被销毁，内存被释放。因此，尽管你可能得到了这个数组的地址，但是这个地址指向的内存区域已经不再保留那个数组的内容了，访问它将是危险的，因为这是未定义行为（可能导致程序崩溃，数据损坏等问题）。考虑以下错误的示例：int*createArray(){intarr[5]={1,2,3,4,5};returnarr;//错误：返回局部数组的地址}intmain(){int*myArray=createArray();//myArray现在指向一个已经被释放的内存区域//下面的访问是未定义行为cout<<myArray[0]<<endl;//可能导致运行时错误}418.11.1大模型探究在这个例子中，createArray函数创建了一个局部数组arr，然后尝试返回这个数组。但是，由于arr是局部变量，当createArray函数返回时，arr所占用的内存就被释放了。因此，尽管main函数中的myArray指针试图访问这个数组，但是它实际上指向的是一个已经被释放的内存区域，这种操作是非常危险的。如果你需要从函数返回一个数组，你可以考虑以下几种安全的做法：使用动态分配的数组：可以使用new关键字在堆上分配数组，这样的数组不会在函数返回时被自动销毁。但是，记得最终需要使用delete[]来释放内存，避免内存泄漏。int*createArray(){int*arr=newint[5]{1,2,3,4,5};returnarr;//安全：返回在堆上分配的数组}使用标准库容器：如vector，这是更现代、更安全的做法，因为vector会自动管理内存。vector<int