一维数组

一维数组定义&形式

是一组数据类型相同的变量，可以存放一组数据
数组名[下标]

数组第0个元素的地址等价于数组首个元素的地址

数组第n个元素的地址：地址首个元素的地址+n

C++编译器将数组名[下标] 解释为 *数组首个地址+下标数组首个地址+下标
地址[下标] 解释为 *地址+下标地址+下标
数组第0个元素的地址等价于数组首个元素的地址

数组表示法&指针表示法

1.数组表示法

形式为数组名[下标] 地址形式为类型类型&数组名[下标]

int a[5]={0,4,5,8,2};
for ( int i=0 ; i < 5 ; i++ ){
    std::cout << "a[i]=" << a[i] <<  "地址为" <<  (long long)&a[i] << std::endl;  //使用long long类型是方便计算
}
//运行结果(相差4是因为int类型为4个字节)
a[i]=0地址为880790205704
a[i]=4地址为880790205708
a[i]=5地址为880790205712
a[i]=8地址为880790205716
a[i]=2地址为880790205720

2.指针表示法

使用指针来表示数组地址,定义形式为 *指针名 = 数组地址例如a或者a[下标]例如a或者a[下标]

取值形式为 *指针名+下标指针名+下标

地址形式为指针名+下标

int a[5]={0,4,5,8,2};
int *p = a; //让指针指向数组首个元素的地址 
for ( int i=0 ; i < 5 ; i++ ){
    std::cout << "p=" << *(p+i) <<  "地址为" <<  (long long)(p+i) << std::endl;  //使用long long类型是方便计算
}
//运行结果(相差4是因为int类型为4个字节)
p=0地址为666805205224
p=4地址为666805205228
p=5地址为666805205232
p=8地址为666805205236
p=2地址为666805205240

⚛联系

C++编译器将数组名[下标] 解释为 *数组首个地址+下标数组首个地址+下标
地址[下标] 解释为 *地址+下标地址+下标

int a[5]={0,4,5,8,2};
std::cout << a[2] << std::endl;     // a[2]  ——>  *( a的首个元素地址 + 2 )
//输出结果为5
std::cout << &a[2] << std::endl;  
//输出结果为a[2]的地址
std::cout << (&a[2])[2] << std::endl;  // (&a[2])[2]——> *( a[2]的地址 + 2 )
//输出结果为2

//简化(指针表示法)
int *p = &a[2]
std::cout << *p << std::endl;
std::cout << p << std::endl;   
std::cout << p[2] << std::endl;  //  p[2] ——> (&a[2])[2] ——>  *( a[2]的地址 + 2 )

一维数组用于函数的参数

形式: void func int∗arr,intlenint∗arr,intlen; void func intarr[],intlenintarr[],intlen;

当且仅当用于函数头或函数原型中,int arr[]和int *arr 才都意味着arr为一个int指针（在操作系统中，int指针为8字节）

⚠长度intlenintlen必须传入，除非数组中有最后一个元素的标志

int a[5]={0,4,5,8,2};
void func(int *arr){
    //std::cout << sizeof(arr) <<std::endl;                输出结果为8 (arr在函数参数中为int 指针,在操作系统中，int指针为8字节)
    //std::cout << sizeof(arr) /sizeof(int)<<std::endl;        输出结果为8/4=2
    for(int i=0 ; i<sizeof(arr) /sizeof(int); i++ ){
    std::cout << a[i] <<std::endl;
    }
}
void func(int *arr,int len){
    for(int i=0 ; i < len; i++ ){
    std::cout << a[i] <<std::endl;
    }
}
int main(){
    int a[5]={0,4,5,8,2};
    void func(a);       //输出结果为 0  4
    void func(a,5);    //输出结果为 0  4  5  8  2
}

动态创建一维数组

栈内存很小，当有大量的数据需要存储时，应在堆上存储

语法

创建: 数据类型 *指针 = new 数据类型[数组长度]

释放: delete [] 指针

‼重点

1⃣动态创建的数组无数组名，不能用sizeof运算符sizeof(指针sizeof(指针==8)

2⃣可以用数组表示法(arr[i])和指针表示法(*arr+iarr+i)来使用动态创建的数组

3⃣释放动态分配的只能用delete [] 数组名,不能只用delete 数组名

4⃣不要用delete释放不是动态分配的内存例如栈上内存、C语言malloc动态分配的内存例如栈上内存、C语言malloc动态分配的内存

5⃣不要用delete[]释放同一内存2次(第一次正常释放，第二次相当于释放野指针)

6⃣对空指针用delete[]是安全的释放内存后，指针应置为nullptr，防止误操作释放内存后，指针应置为nullptr，防止误操作

7⃣如果内存不足，调用new 会发生异常，导致程序中止，如果在new关键词后面加std::nothrowstd::nothrow,则返回nullptr，不会产生异常

int *p = new(std::nothrow) int [1000000001];
if(p==nullptr)
    std::cout << "分配内存失败" << std::endl;
else
    std::cout << "分配内存成功" << std::endl;
//运行结果
分配内存失败        //程序正常退出，保证了程序的健壮性

8⃣用delete[]释放数组时，不需要指定数组大小，因为系统会自动跟踪已分配的数组内存

数组排序qsort函数

qsort函数用于各种数据类型的数组进行排序

函数的原型为 void qsortvoid∗base,sizetnmemb,sizetsize,int(∗comparvoid∗base,sizetnmemb,sizetsize,int(∗comparconstvoid∗,constvoid∗constvoid∗,constvoid∗)

回调函数决定排序的顺序

int compar constvoid∗p1,constvoid∗p2constvoid∗p1,constvoid∗p2

如果函数的返回值<0，那么p1所指向元素会被排在p2所指向元素的前面。
如果函数的返回值==0，那么p1所指向元素与p2所指向元素的位置不确定。
如果函数的返回值>0，那么p1所指向元素会被排在p2所指向元素的后面。

❗其他细节

1⃣size_t是C标准库中定义的，在64位操作系统中为8字节的无符号整型unsignedlonglongunsignedlonglong , typedef unsigned long long size_t

2⃣形参的地址用void是为了支持所有类型，在回调函数中应具体化

//升序为例
int compasc (const void *p1, const void *p2){
    if (*((int *)p1) < *((int *)p2) )    return -1;        // (int*)p1 将p1转为int指针类型
    if (*((int *)p1) == *((int *)p2) )    return 0;        // *((int *)p1) 取p1中的值
    if (*((int *)p1) > *((int *)p2) )    return 1;
}
//简化
int compasc (const void *p1, const void *p2){
    return *((int *)p1) - *((int *)p2)
}

3⃣排序的需求除了升序和降序，还有很多不可预知的情况，只能用回调函数。

💡举例

#include <iostream>
//升序回调函数
int compasc(const void* p1, const void* p2) {
    return *((int*)p1) - *((int*)p2);
}
//升序回调函数
int compdesc(const void* p1, const void* p2) {
    return *((int*)p2) - *((int*)p1);
}
int main() {
    int arr[] = { 12,5,18,2,12,19,0,14,18,25,21 };
    //升序输出
    qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), compasc);
    for (int i = 0; i < sizeof(arr) / sizeof(int); i++) {
        std::cout << "arr[" << i << "]=" << arr[i] << std::endl;
    }
    std::cout << std::endl;
    //降序输出
    qsort(arr, sizeof(arr) / sizeof(int), sizeof(int), compdesc);
    for (int i = 0; i < sizeof(arr) / sizeof(int); i++) {
        std::cout << "arr[" << i << "]=" << arr[i] << std::endl;
    }
    return 0;
}

⚠注意事项

1⃣当直接打印char类型a的地址时，std::cout会把&a当做字符串来输出，导致乱码

解决办法：使用强制转换void∗void∗明确告诉编译器&a为地址

char a;
std::cout << "a的地址为" << &a << std::endl;
//输出结果为
a的地址为烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫?蠆?
//改进方法
std::cout << "a的地址为" << (void*)&a << std::endl;
//添加(void*)明确告诉编译器&a为地址

2⃣由于数组申请内存用来存放某一类型的数据，可以通过强制类型转换来存放其他类型的数据

char a[20]; //申请20字节的内存用来存放char类型数据
int *p = (int*)a; //通过强制类型转换将上面申请的内存改存放int类型数据
for (int i = 0 ; i < 5 ; i++){
    *p = 100 + i; //赋值
}
!!!
for (int i = 0 ; i < 6 ; i++){  //报错，原因：20个字节的内存，1个int占4字节，最多能赋值5个整数
    *p = 100 + i; //赋值
}

3⃣在栈上申请内存时，注意栈溢出

大多数Linux发行版的GCC编译器，栈上内存为8M，即223 字节 = 8388608字节
Windows的Visual C++编译器，栈上内存为1M，即220 字节 = 1048576字节

在Windows栈上分配int类型的数组理论上最多有220 字节/4字节=262144个元素,但是栈上还会存储局部变量、函数参数、函数调用的上下文，所以实际上应少于262144个元素

int a[262144];
a[262143]=1;
//栈溢出

本文由自僱落葉竟痴迷原创，采用 CC BY-NC-SA 4.0 许可协议，转载请注明出处。