目录

• 一维数组的创建与初始化
• 程序一：
• 程序二：
• 程序三
• 程序四（二维数组 - 二维数组 的 列 绝对不能 省略 ）
• 二维数组在内存中的存储
• 程序一
• 数组作为函数参数，怎么作？
• 实例：冒泡排序
• 数组名：

一维数组的创建与初始化

数组是一种相同类型元素的集合

程序一：

#includestdio.h>
    
#includestring.h>

int main()
{
    
创建一个数组
int arr1[10];
//  [常量]
初始化 int arr[10]={
1,2,3}
    ;
    不完全初始化，剩下的元素默认初始化0.
char arr2[5];

初始化 char arr[5]={
'a','b'}
    ;
    ,不完全初始化，剩下元素默认初始化0.
初始化 char arr[5]="ab" 这是可行的，因为隐藏一个'\0'，后面的0使我们自己给的（这个字符串都给给它的==），不是系统默认



int n = 5;
    
char ch[n];
 这样创建数组是错误，因为n还是变量，值是被赋值了，并不会改变它的属性
char arr3[5] = {
 'a', 98/*b的ASCII码等于98*/ }
    ;
//可行
上式等价于下式
char arr3[5] = {
'a','b'}
    




char arr4[] = "abcd";
    //加上后面隐藏的'\0',大小为5
当我们并没有指定大小的时候，它会根据后面的数据，自己给定大小

    char  arr5[] = "abcdef";
    
    printf("%d\n",sizeof(arr5));
    // 7 sizeof晕倒'\0'，把它算进去，在停止计算
    printf("%d\n", strlen(arr5));
//6 strlen是遇到'\0'（不包含）,就停止计算
    
    char arr6[] = {
 'a', 'b','c','\0' }
    ;
    
    printf("%d\n",strlen(arr6));
    //如果没有'\0'结束标志符，它会一直算个数，直到遇到'\0',输出的是一个随机数
    printf("%d\n", sizeof(arr6));
    //没有'\0'它就少算一个就是3
    return 0;

}
    

程序二：

#includestdio.h>
    
#includestring.h>

int main()
{
    
    char arr[] = "abcdef";
    //元素下标是从0开始
    pritnf("%c\n",arr[0]);
     //arr[0] == a，表示首元素a，输出结果为a

    如果要依次打印字符串所有元素用循环更简单，字符串的 '\0' 是隐藏的，一般是不用打印的
    int i = 0;
    
    int len = strlen(arr);
    // 计算元素个数
    for (i = 0;
     i  len;
 i++)
    {
    
        printf("%c ",arr[i]);
// a b c d e f
    }
    

    return 0;

}
    

程序三

#includestdio.h>

int main()
{

    int arr[] = {
1,2,3,4,5,6,7,8,9,10}
    ;
    
    int sz = sizeof(arr) / sizeof(arr[0]);
    
    // sizeof(数组名)计算的整个数组的字节大小，我们只要再求一个元素的大小就可以了，因为 数组是一群相同类型数据的集合，所以我
    // 假设 int a[10]； 数组 a 有 10个 int（4byte） 类型的元素，整个数组的大小就是 4*10 == 40 byte， 数组大小除以数组元素大小，不就是数组元素个数嘛。（40/4 == 10）
    
    int i = 0;
    
    for (i = 0;
     i  sz;
 i++)
    {
    
        printf("%d ",arr[i]);
    
        printf("&
    arr[%d]=%p\n",i,&
    arr[i]);
// 打印 数组对应下标元素的地址
    }
    
    
    return 0;

}
    

程序四（二维数组 - 二维数组 的 列 绝对不能 省略 ）

#includestdio.h>

int main()
{
    
    ///int arr[3][4];
//存储一个三行四列的数据 3是行(3个一维数组)，4是列
int arr1[3][4] = {
1,2,3,4,5}
    ;

假设 数据 是这样存的，在内存是连续存储的12345000.....
1234 
5000 
0000

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

 1 2 3 0                      
 4 5 0 0
 0 0 0 0
一行的数据 是根据元素加个后面的{
 }
，方便你们去区分，再根据列数确定 一行有多少个元素

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

 1 2 3 0
 4 5 0 0
二维数组不管行还是列，下标都是从0开始，而且 二维数组的 行 是可以省略的，它会根据 元素 和 列的值，来确定行数

    int arr4[3][4] = {
 {
 1, 2, 3 }
, {
 4, 5 }
 }
    ;
    
    int i = 0;
    
    for (i = 0;
     i  3;
 i++)
    {
    
        int j = 0;
    
        for (j = 0;
     j  4;
 j++)
        {
    
            printf("%d ",arr4[i][j]);
1 2 3 0 
                                     4 5 0 0
                                     0 0 0 0
        }
    
        printf("\n");

    }
    
    return 0;

}

二维数组在内存中的存储

在内存中实际存储情况，第一行完了，第二行紧跟在第一行，第三行紧跟在第二行，int a[2][2]={ 1,2,3,4} , 在内存中存储情况为 1 2 3 4 （小端）
因为 数组的首元素地址是最小的，后面元素，地址依次增大（大约增大 一个元素的类型的字节大小）

程序一

#includestdio.h>

int main()
{

    int arr[3][4] = {
 {
 1, 2, 3 }
, {
 4, 5 }
 }
    ;
    
    int i = 0;
    
    for (i = 0;
     i  3;
 i++)
    {
    
        int j = 0;
    
        for (j = 0;
     j  4;
 j++)
        {
    
            printf("arr[%d][%d]=%p\n", i, j, &
    arr[i][j]);

            arr[0][3]和arr[1][0]地址相差4，二维数组与一维数组一样，都连续存储
        }

    }
    
    return 0;

}
    

数组作为函数参数，怎么作？

实例：冒泡排序

#includestdio.h>

void bubble_sort(int arr[],int sz)
{
    
    
    确定冒号排序的趟数
    int i = 0;
    
    for (i = 0;
     i  sz - 1;
 i++)// 排序要排 元素总个数-1，最后一个元素不用排
    {
    
        int flag = 1;
    //假设这一趟的数据已经有序
       
        int j = 0;
    
        for (j = 0;
     j  sz-1-i;
 j++)//  每一趟冒号排序的过程
        {
    
            if (arr[j] >
 arr[j + 1])
            {
    
                int tmp = arr[j];
    
                arr[j] = arr[j + 1];
    
                arr[j + 1] = tmp;
    
                flag = 0;
//本趟排序的数据不完全有序
            }

        }

        if (1 == flag)
        {
    
            break;

        }

    }

}

int main()
{

    int arr[] = {
 0, 8, 7, 6, 5, 4, 3, 2, 1, 9 }
    ;
    
    int i = 0;
    
    int sz = sizeof(arr) / sizeof(arr[0]);
    
    bubble_sort(arr,sz);
    
    对数组arr进行传参，传递的是数组arr首元素的地址
    for (i = 0;
     i  sz;
 i++)
    {
    
        printf("%d ",arr[i]);
//0,1,2,3,4,5,6,7,8,9
    }
    
    return 0;

}
    

数组名：

#includestdio.h>

int main()
{

	int arr[] = {
 1, 2, 3, 4, 5, 6, 7 }
    ;
    //数组随着下标的增长，地址是由低到高变化点

	printf("%p\n",arr);
    
	数组名就是数组首元素地址，是一样的。见附图1
	printf("%p\n",&
    arr[0]);
    


	但有两个意外

	1.sizeof(数组名) - 数组名表示整个数组 ，计算的是整个数组的大小，单位为字节（byte）
	int sz = sizeof(arr);
     
	printf("%d\n",sz);
    // 4(元素大小)* 7（元素个数）== 28，效果见附图 2


	2.&
    (数组名)，数组名代表整个数组，&
    数组名，取的是整个数组的地址
	printf("%p\n", &
    arr);
    //表示数组的起始地址，是整个数组的地址
	上下两者的值一样，但 意义完全不同，效果图 见附图 3
	printf("%p\n", arr);
    //首元素的地址

    //进一步论证  &
    arr 和 arr的意义完全不同，不同在哪里
    printf("%p\n", &
    arr+1);
    //地址增加28字节，一个元素4byte，7个元素28字节，意味着 &
    arr + 1 跳过一整个数组的元素，指向最后一个元素后面的地址
    printf("%p\n", arr+1);
    //地址增加4字节，意味着 arr +1，跳过一个元素，改地址 arr+1，指向第二个元素
    效果见附图 4
    return 0;

}
    

关于数组名，有兴趣的，可以看看我这篇文章指针和数组试题解析（重置版）

附图1；

附图2：

附图3：

附图4：

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！