C语言的数组

一.一维数组

数组是一组相同类型元素的集合。
数组的创建方式：

type_t  arr_name  [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

数组创建的实例：

//代码1
int arr1[10];
//代码2
int count = 10;
int arr2[count];//C99开始可以这样实使用
//代码3
char arr3[10];
float arr4[1];
double arr5[20];

1.数组是使用下标来访问的，下标是从0开始。
2. 数组的大小可以通过计算得到。 

int arr[10];
int sz = sizeof(arr)/sizeof(arr[0]);

 仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。
由此可以得出结论：数组在内存中是连续存放的。

二.二维数组

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

由以上列子可知，数组名即是数组首元素的地址 

以上代码可说明，因为数组在内存中连续存放，所以用指针的写法和用数组打印出来的结果一样。

以上代码也可以说明二维数组是连续存储的。 

数组越界：

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果输入有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。

如以下代码所示：

 正确的写法应该是：

二维数组的行和列也可能存在越界。

结论： 数组名是数组首元素的地址（有两个例外）

1.sizeof（数组名），这里的数组名表示整个数组，sizeof（数组名）计算的是整个数组的大小。

2.&数组名，这里的数组名表示整个数组，取出的是数组的地址

数组作为函数参数：

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序

首先什么是冒泡排序？

核心思想：两两相邻的元素进行比较 

一趟冒泡排序可以搞定一个数字，让它来到最终应该出现的位置上。

 

源代码：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

//int arr[5];//全局变量不初始化存放的都是0
//int main()
//{
//    int arr1[20] = { 1,2,3 };//不完全初始化，剩余的默认初始化为0
//    int arr2[] = { 1,2,3 };//只存放三个元素
//    char arr3[] = "abc";//数组存放了abc\0这四个字节
//    char arr4[] = { 'a','b','c' };//只存放abc三个元素
//    char arr5[] = { 'a',98,'c' };//98是b的ASCLL码值
//    int arr6[5];//局部变量不初始化存放的都是随机值
//    return 0;
//}

//int main()
//{
//    int arr[10] = { 0 };
//    int i = 0;
//    for (i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i)
//    {
//        printf("&arr[%d] = %p\n", i, &arr[i]);
//    }
//    return 0;
//}

数组创建
//int main()
//{
//    int arr[3][4];//三行四列的表格
//    char arr[3][5];
//    double arr[2][4];
//    return 0;
//}

//int main()
//{
//    //数组初始化
//    int arr[3][4] = { 1,2,3,4 };//一行一行放满再会到下一行
//    int arr[3][4] = { {1,2},{4,5} ,{6,7} };//第一行放的是12000，第二行是34000，第三行是67000
//    int arr[][4] = { {2,3},{4,5} };//二维数组初始化时可以省略行，不可省略列
//
//    char ch[4][6] = { 'a','b' };//第一行依次放的是a，b
//    char ch[4][6] = { {'a'},{'b'} };//第一行和第二行分别放a和b
//    char ch[4][6] = { "abc","def","qwe" };//三行分别为abc\0，def\0，qwe\0
//    return 0;
//}

//
//int main()
//{
//    int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,0} };
//    int i = 0;
//
//    for (i = 0; i < 3; i++)
//    {
//        int j = 0;
//        for (j = 0; j < 5; j++)
//        {
//            printf("&arr[%d][%d]%p\n ",i,j, &arr[i][j]);
//        }
//        printf("\n");
//    }
//    return 0;
//}

//
//int main()
//{
//    int arr[5] = { 1,2,3,4,5 };
//    printf("%p\n", arr);
//    printf("%p\n", &arr[0]);
//    return 0;
//}

//int main()
//{
//    int arr[5] = { 1,2,3,4,5 };
//    int *p = arr;
//    int i = 0;
//    for (i = 0; i < 5; i++)
//    {
//        printf("%d ", *p);
//        p++;
//    }
//    printf("\n");
//    for (i = 0; i < 5; i++)
//    {
//        printf("%d ", arr[i]);
//    }
//
//    return 0;
//}

//
//int main()
//{
//    int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,0} };
//    int*p = &arr[0][0];
//    int i = 0;
//    for (i = 0; i < 15; i++)
//    {
//        printf("%d ", *p);
//        p++;
//    }
//        return 0;
//}

//int main()
//{
//    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
//    int i = 0;
//    for (i = 0; i < 10; i++)
//    {
//        printf("%d ", arr[i]);
//    }
//    return 0;
//}

//int main()
//{
//    int arr[10] = { 1,2,3,4,5 };
//    printf("%p\n", arr);
//    printf("%p\n", &arr[0]);
//    printf("%d\n", *arr);
//    //输出结果
//    return 0;
//}

//int main()
//{
//    int arr[10] = { 1,2,3,4,5 };
//    printf("%p\n", arr);//数组首元素的地址
//    printf("%p\n", &arr[0]);//数组首元素的地址
//    printf("%p\n", &arr);//数组的地址
//    printf("-----------------\n");
//    printf("%p\n", arr+1);
//    printf("%p\n", &arr[0]+1);
//    printf("%p\n", &arr+1);//指向数组的指针会跳一整个数组
//
//    return 0;
//}

冒泡排序
//void Sort(int arr[],int sz)//数组传参实际上传过去的是数组首元素的地址
//{
//    int i = 0;
//    //冒泡排序的趟数是元素个数减一
//    for (i = 0; i < sz - 1; i++)
//    {
//        int j = 0;
//        for (j = 0; j <sz-1-i; j++)//j<sz-1-i这一步需要好好思考
//        {
//            if (arr[j] > arr[j + 1])
//            {
//                //交换
//                int tmp = arr[j];
//                arr[j] = arr[j + 1];
//                arr[j + 1] = tmp;
//            }
//        }
//    }
//}
//int main()
//{
//    int arr[] = { 1,4,2,3,8,7,5,6,9,0 };
//    //数组传参
//    //排序
//    int sz = sizeof(arr) / sizeof(arr[0]);//数组名单独放在sizeof内部时，如：sizeof(arr),这里的arr表示的是整个数组，而不是首元素地址
//    Sort(arr,sz);//数组名在传递给函数的时候，会降级变成首元素的地址
//    for (int i = 0; i < sz; i++)
//    {
//        printf("%d ", arr[i]);
//    }
//    return 0;
//}