数组

定义一个数组并把他初始化为0,是个好习惯

int a[10]={0}; //java不需要这样,java会自动的

一维数组指针和二维数组指针

二维数组指针是比如 int * [4],因为二维数组名指向一维数组
一维数组是char *类似这种

数组名是个常量指针

//这样不可以
arr = NULL;

在这2种情况下,数组名不是指向首元素的sizeof和**&arr**取地址

void printArray(int *arr, int len) {
    for (int i = 0; i < len; i++) {
        printf("%d\n", arr[i]);
        //也可以这样
        printf("%d\n", *(arr + i));
    }
}

数组指针类型和数组首元素指针类型

定义一个指向数组的指针

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    &arr;

    //我们先定义数组类型,再定义数组指针
    typedef int(ARRAY_TYPE)[5];
    ARRAY_TYPE myarray;     //等于 int myarray[5]

    for (int i = 0; i < 5; i++) {
        myarray[i] = i * i;
    }

    ARRAY_TYPE *p = &myarray;   //不能是指向首元素了,这边是数组指针了

    //打印元素, 数组指针取地址等于数组名,数组名等于首地址
    int ele = *(*p + 3);
    printf("%d\n", ele);

    getchar();
    return 0;
}

int arr[5] = {1, 2, 3, 4, 5};
//定义数组指针类型
typedef int(*ARRAY_POINT)[5];
ARRAY_POINT pArr = &arr;

int main() {

    int arr[] = {1, 2, 3, 4, 5, 6};

    typedef int (*ARRAY_POINT)[6];
    ARRAY_POINT pArr = &arr;
    printf("%d \n", *((*pArr) + 1));

    getchar();

    return 0;
}

输出

3

一维数组定义

数组就是在内存中连续相同类型的变量空间

int a[10];  //定义了10个int,第一个变量名是a[0],最后一个是a[9],没有a[10]这个变量

这10个变量在内存中的位置是连续的
定义一个数组的时候,[]里面要用常量
但使用数组的时候里面可以是常量可以是变量
数组在内存的存储方式
同一个数组的所有成员都是相同的数据类型,同时所有的成员在内存中的地址是连续的,数组名是一个地址的常量,代表数组中首元素的地址

int a[10];
a[0]=1;
a[3]=5;
printf("%p,%p\n",a,&a[0]);

2个地址是一样的
但是a[0] +1 代表下个元素,而a+1代表移动过整个数组
数组元素+1 (sizeof(数据类型))
数组名+1 (sizeof(数组名))

遍历数组

int a[]={4,5,6,7,8,9,12,34};
int i;
for (i = 0; i < sizeof(a)/sizeof(a[0]); ++i)
{
    printf("a[%d] = %d\n",i,a[i] );
}

二维数组

格式:
数据类型 数组名 [行个数] [列个数]

int a2[2][10];     //a2是一个二维数组,这个二维数组中包含2个一维数组,a2[0],a2[1],这2个数组是连续的

二维数组的数组名代表首元素的地址的常量

int a2[2][10];
printf("%p,%p,%p\n", a2,a2[0],&a2[0][0]);
//值是一样的

二维数组的初始化

二维数组的遍历

int main(int argc, char const *argv[])
{
    int a3[][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}};
    for (int i = 0; i < sizeof(a3)/sizeof(a3[0]); ++i)
    {
        for (int j = 0; j < sizeof(a3[0])/sizeof(a3[0][0]); ++j)
        {
            printf("a3[%d][%d] = %d\t", i,j,a3[i][j]);
        }
        printf("\n");
    }
    return 0;
}

二维数组名

int main() {
    int arr[3][5] = {
            {1, 2, 3, 4, 5},
            {6, 7, 8, 9, 10},
            {11, 12, 13, 14, 15}
    };
    //二维数组的数组名和一维数组一样
    int a = *(*(arr + 1) + 2);
    printf("%d\n", a);  //8
    getchar();
    return 0;
}

int arr[3][3] = {
            {1, 2, 3},
            {6, 7, 8},
            {11, 12, 13}
    };
arr是 int(*)[3] 类型的

char *arr3[] = {"aaa", "bbb", "ccc"};
arr3是char **类型的

char数组

字符串就是子符数组以’\0’结尾

char a[10];
a[0]='a';
a[1]='b';
a[2]='c';
a[3]='\0';
printf("%s\n",a );

char a[10]="hello";
a[3]=0;
//对于字符串来讲是hel,因为0结尾,0就是\0的ascii码
但是对于数组来说成员数量没有发生变化

一个char数组中可以有多个0,字符串只能一个
scanf录制到char数组

int main()
{
    char arr[100];
    //scanf默认遇到空格会结束,这样的意思是遇到\n才结束
    scanf("%[^\n]", arr);
    printf("%s\n", arr);
    system("pause");
    return EXIT_SUCCESS;
}

查看数组内存结构

int main()
{
    //数组内存结构
    int scores[5] = { 99 ,10, 11, 15, 9};
    printf("%p\n", &scores[0]);
    system("pause");
    return  EXIT_SUCCESS;
}

在system那设置断点
然后调试,会出现个内存地址,复制那地址,不要结束调试
然后在调试->窗口->内存->选择一个
把你刚才出现的内存地址复制到那

int是四个字节,上面结果是16进制,涉及到内存大小端对齐,看的时候是从后到前
我们打开计算器

可以看到63的十六进制是99