c++知识点汇总--数组

数组：

数组声明：typename arrayname[size] = {value1,value2,..};元素个数必须是一个大于0的整型常量，数据类型可以是任意有效的C++数据类型。其中size可以省略，则数组大小和初始化变量个数相同，如int arr[] = {1,2,3};初始化可以省略，如int arr[3];

数组访问：arrayname[num];实现修改，查看;

//声明
int a[4];
int b[3] = {1,2,3};
int i;
std::cin>>i;
int c[i];//会报警告

//赋值
int a[4] = {1,2,3};//a[4] = 0
int b[2];
b[0]=1;
b[1] =2;
int c[100];
for(int i = 0; i < 100; i++)
    c[i] = i+i; 

数组特点：必须是在一块连续的内存空间;数组中的每个元素类型相同。

创建数组的其他方法？
—使用new ，delete 关键字，即

//申请
int *arr = new int[3];
int *arr1 = new int[4]{2,1,3,0};
//释放
delete [] arr;

二维数组：
—typename arrayname[size][size]={{},{},...}; 如

int a[3][4] = {
        {0, 1, 2, 3},   /*  初始化索引号为 0 的行 */
        {4, 5, 6, 7},   /*  初始化索引号为 1 的行 */
        {8, 9, 10, 11}, /*  初始化索引号为 2 的行 */
};

等价与 int a[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}; 即嵌套的括号是可选的。

—使用new关键字创建二维数组：

    //申请
    int** a = new int*[rows];
    for(int i=0;i<rows;i++)
        a[i] = new int[columns];
    //释放
    for(int i=0;i<rows;i++)
        delete []a[i];
    delete []a;

数组与指针：数组名是一个指向数组中第一元素的常量指针(int const *p;),即数组第一个元素的地址;

int const *p;
int arr[9];
p=arr;

数组的另一种访问方式:
------使用地址访问：*(arr+3) 等价与arr[3]

如何将数组传递给函数？
—常用方式是将数组和数组大小分别传递，即

void func(int *arr, int size);//数组传递是地址传递，但传递得只是数组的首地址;
//若不传递数组大小，则在函数内部sizeof(arr) 只是一个指针的大小;

如何将数组传递出函数？

int * func();//注意事项：不能返回局部变量的地址;非要返回局部变量，可以将局部变量声明成static
{
	static int arr[10];
	...
	return arr;
}

注意事项：
—在数组声明时，只能使用常量值，不能使用变量值，即

int arr[4];
int num=4;
int array[num]; //会报错

—若非要使用变量值，则可以将其声明为const

const int num = 10;
int array[num];

vector容器:—支持动态扩展
1.构造函数:

vector<T> v;//vector<int> v
vector(v.begin(),v.end());  //将区间[)的元素拷贝给本身
vector(n,elem);//将n个elem拷贝给本身
vector(const vector<T> & vec);

//对应实例
vector<int> v1;//vector<int> v1(10);
vector<int> v2(v1.begin(),v1.end());
vector<int> v3(5,1);
vector<int> v4(v3);
int b[7]={1,2,3,4,5,9,8};
vector<int> a(b,b+7); //从数组中获得初值

2.赋值操作:

vector& operator=(const vector &vec);
assign(beg,end);//[)
assign(n,elem);//将n个elem拷贝赋值;

//对应实例
vector<int> v1(10,1);
vector<int> v2 = v1;
v2.assign(v1.begin(),v1.begin()+2);
vector<int> v3;
v3.assign(3,2);

3.vector容量和大小:

//对应实例
empty(); //判断容器是否为空?
capacity();//容量
size(); //返回容器中的个数;
resize(int num);//重新制定容器长度为num。若容器长度变长,则以默认值填充新位置,若变短,删除超出元素。
resize(int num,elem); //.........//若变长,则以elem填充,......

//对应实例
vector<int> v1(15,2);
bool b = v1.empty();
int cap = v1.capacity();
int size = v1.size();
v1.resize(10);
v1.resize(30,5);

4.插入和删除操作:

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

//对应实例
vector<int> v1(1,2);
v1.push_back(3);
v1.pop_back();
v1.insert(v1.begin(),1);
v1.insert(v1.end(),5,3);
v1.erase(v1.end()-1);
v1.erase(v1.begin()+3,v1.begin()+4); 

5.数据的读取操作:

at(int idx); //返回索引idx所指的数据
operator[];//返回索引idx所指向的数据
front();//返回容器第一个数据元素
back();//返回容器最后一个数据元素

//对应实例
vector<int> v1(10,4);
int a = v1.at(4);
int b = v1[4];
int front = v1.front();
int back = v1.back();

6.互换容器:

swap(vector<T> &vec); //将容器vec与本身元素互换;
//实际用途--收缩内存:vector<int>(v).swap(v)//匿名对象

//对应实例
vector<int> v1(3,1);
vector<int> v2(10,2);
v2.swap(v1);

7.预留空间:减少vector在动态扩展容量时的扩展次数

reserve(int len);//容器预留len个元素长度,预留位置不初始化,元素不可访问。在调用默认构造函数后,就使用。
//将容器的容量（capacity）扩充至len，也就是说现在测试capacity();的时候返回值是len.这种操作只有在需要给a添加大量数据的时候才显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能）

//对应实例
vector<int> v1(3,1);
v1.reserve(20);

8.几种重要的算法 —适用于STL
----使用时需要包含头文件：#include<algorithm>

vector<int> a;
vector<int> b(5,2);
a.push_back(3);
...
a.push_back(6);

sort(a.begin(),a.end());//对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
reverse(a.begin(),a.end());//对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
copy(a.begin(),a.end(),b.begin()+1);//把a中的从a.begin()（包括它）到a.end()（不包括它）的元素复制到b中，从b.begin()+1的位置（包括它）开始复制，覆盖掉原有元素
find(a.begin(),a.end(),10); //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置