一、sizeof运算
对静态数组名进行sizeof运算时,结果是整个数组占用空间的大小,因此可以用sizeof(数组名)/sizeof(*数组名)来获取数组的长度。
int a[5]; 则sizeof(a)=20,sizeof(*a)=4.因为整个数组共占20字节,首个元素(int型)占4字节。
int *a=new int[4];则sizeof(a)=sizeof(*a)=4,因为地址位数为4字节,int型也占4字节。
二、作为函数参数
静态数组作为函数参数时,在函数内对数组名进行sizeof运算,结果为4,因为此时数组名代表的指针即一个地址,占用4个字节的内存(因为在传递数组名的参数时,编译器对数组的长度不做检查,具体可参考前面一篇c++对数组的引用实例分析)。对动态数组的函数名,无论何时进行sizeof运算,得到的结果都是4。
void size(int a[])
{
cout << sizeof(a) << endl;
}
int main()
{
int *a = new int[10];
int b[10] = {1,2,3,4,5};
size(a);
size(b);
return 0;
}
运行结果:
new.cpp: In function 'void size(int*)':
new.cpp:7:21: warning: 'sizeof' on array function parameter 'a' will return size of 'int*' [-Wsizeof-array-argument]
7 | cout << sizeof(a) << endl;
| ^
new.cpp:5:15: note: declared here
5 | void size(int a[])
| ~~~~^~~
4
4
三、空间位置
new还需要你delete,是在堆分配空间,效率较低;而[]直接在栈上分配,会自动释放,效率高,但是栈空间有限。
四、通过函数返回一个数组的问题
函数声明的静态数组不可能通过函数返回,因为生存期的问题,函数调用完其内部变量占用的内存就被释放了。如果想通过函数返回一个数组,可以在函数中用new动态创建该数组,然后返回其首地址。
其原因可以这样理解,因为[]静态数组是在栈中申请的,而函数中的局部变量也是在栈中的,而new动态数组是在堆中的分配的,所以函数返回后,栈中的东西被自动释放,而堆中的东西如果没有delete不会自动释放。
例子如下:
int *test(int *b) //b可以是静态数组的数组名,也可以是动态数组的首地址
{
for(int i=0;i<5;i++) //输出传入的数组各元素
cout<<*(b+i)<<" ";
cout<<endl;
int *c=new int[5]; //动态创建一个数组
//如果将绿色部分换为int c[5];则主函数中调用test无法得到c数组
for(i=0;i<5;i++) //新数组的各项值等于传入的数组各项值加5
*(c+i)=*(b+i)+5;
return c; //返回新创建的动态数组的首地址
}
int main()
{
int *b=new int[5]; //创建动态数组b
for(int i=0;i<5;i++)//赋值
*(b+i)=i;
//绿色部分也可以换为int b[5]={0,1,2,3,4};即也可以是静态数组
int *c=test(b); //将b作为参数,调用test函数,返回值赋给c
for(i=0;i<5;i++) //输出test返回的数组的各项
cout<<*(c+i)<<" ";
cout<<endl;
return 0;
}
五、数组越界
C和C++均不会对数组进行越界检查:
int b[10] = {1,2,3,4,5};
int *c;
c=(int *)malloc(10);
cout << c[-100] << endl;
cout << b[-100] << endl;
运行结果:
0
4784200
可这不对啊!那我平时遇到的段错误是怎么回事啊?原来只要数组越界访问的还是本进程的地址,编译器就不会报错,甚至有可能访问到的还是本数组内的地址,如N[2][6] 与数组N[4][3] 访问到的是相同的地址,因为这些数组元素在内存中就是连续排放的,[ ]只是提供了一种索引的方式。
1) 堆中的数组越界
因为堆是我们自己分配的,如果越界,那么会把堆中其他空间的数据给写掉,或读取了其他空间的数据,这样就会导致其他变量的数据变得不对,如果是一个指针的话,那么有可能会引起crash
2) 栈中的数组越界
因为栈是向下增长的,在进入一个函数之前,会先把参数和下一步要执行的指令地址(通过call实现)压栈,在函数的入口会把ebp压栈,并把esp赋值给ebp,在函数返回的时候,将ebp值赋给esp,pop先前栈内的上级函数栈的基地址给ebp,恢复原栈基址,然后把调用函数之前的压入栈的指令地址pop出来(通过ret实现)。
栈是由高往低增长的,而数组的存储是由低位往高位存的,如果越界的话,会把当前函数的ebp和下一跳的指令地址覆盖掉,如果覆盖了当前函数的ebp,那么在恢复的时候esp就不能指向正确的地方,从而导致未可知的情况,如果下一跳的地址也被覆盖掉,那么肯定会导致crash。
回顾上面的例子,idx为负时,程序似乎还能输出个什么东西,但把pos改为一个较大的正数时就会出现问题,不同开发环境可能会出现不同情况,可以自行测试。
另外gcc支持零长数组char data[]或char data[0],其实现与不检查越界有关:
struct Header
{
int data_type;
char data[];
};
struct data_A_struct
{
int a;
int b
int content;
int c;
};
struct data_B_struct
{
int content;
int b;
int c;
};
void parse_data(char * data)
{
int content;
char * data_ptr;
data_ptr=(struct Header *)data->data;
switch((struct Header*)data->data_type)
{
case DATA_A_TYPE:
content=(struct data_A_struct *)data_ptr->content;
break;
case Data_B_TYPE:
content=(struct data_B_struct *)data_ptr->content;
break;
}
}