C语言初阶之数组

前言

本文主要介绍C语言中的数组，很高兴和大家一起学习。

一、一维数组的创建和初始化

1.数组的创建

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

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

数组创建的实例：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int arr1[10];
	//创建一个数组，整型存放10个
    char arr2[10];
    int n=10
    char arr3[n];
	//错误！！[ ] 内必须是常量或常量表达式，不能使用变量
    return 0;
}

注：数组创建，[ ]中要给一个常量才可以，不能使用变量。

2.数组的初始化

数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值。

int main()
{
int arr1[10] = {1, 2, 3};
//不完全初始化，剩下的元素默认初始化为0
//[ ]里的数字可以不写,会根据初始化内容自动判定数组长度
//[ ]写数字的话，{ }内不能超过数组长度

char arr2[5] = {"a","b"};
char arr3[5] = "ab";
//打印结果相同，但是后者还包括了" \0 "

char *p = "abc";
//这里不展开讲'指向数组的指针'的相关概念
return 0;
}

大家可以使用sizeof看一下arr2和arr3各自的长度，是不一样的。

这里补充一些知识：sizeof与strlen没有什么关联：

1. strlen是求字符串长度的，它只能针对字符串求长度，还因为它是库函数，使用的话需要头文件。

2. sizeof是操作符，可以计算变量、数组、类型的大小，单位是字节

3.一维数组的使用

关于数组的使用，我们之前已经见过了一个操作符：[ ]，下标引用操作符，它其实就是数组访问的操作符。

例：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char arr[10] = "abcdef";
    int i = 0;
    for ( i = 0; i < 10; i++ )
	//不能写成i<11 ，不可以越界访问
    {
        printf("%c   ",arr[i]);
    }
    //数组是使用下标来访问的，下标从0开始
    return 0;
}

4.一维数组在内存中的存储

#include <stdio.h>
#include <stdlib.h>

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

	return 0;
}

运行结果：

数组在内存中是由低到高并且是连续存放的。

二、二维数组的创建和初始化

1.数组的创建

int arr[3][4] ;
char arr[2][4] ;
double arr[3][2] ;

2.数组的初始化

//第一个[ ]是行 ; 第二个[ ]是列
int arr[3][4] = { 1, 2, 3, 4, 5};
//因为数组是4列，1234在一行，5被放到了第二行
int arr[3][4] = {{1,2},{4,5}};
int arr[][3] = {{1,2},{4,5}}；
//当一行中有元素没有初始化的时候，默认为0
int arr[1][4] = {{1,2},{4,5}}；//错误示例：超出了数组范围
int arr[3][] = {{1,2},{4,5}}；//错误示例：行可以省略，但列不能省略掉

3.二维数组的使用

二维数组的使用也是通过下标的方式

#include <stdio.h>
#include <stdlib.h>

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

	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}

	return 0;
}

4.二维数组在内存中的存储

我们在这里打印二维数组的每个元素，来观察它是如何存储的

#include <stdio.h>
#include <stdlib.h>

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

运行结果：

从这里我们可以看出，二维数组的元素也是连续存放的。

补充:

举个栗子： int arr [3] [4];
我们可以用arr[0]、arr[1]、arr[2]的方式访问数组
arr[0]就是arr[0][j]
arr[1]就是arr[1][j]
arr[2]就是arr[2][j]

三、数组作为函数参数

在我们在写代码的时候，往往会将数组作为参数传给函数。

例：冒泡排序函数将一个整形数组排序

补充：冒泡排序（此例子为升序）:两两相邻的元素进行比较
10,9,8,7,6,5,4,3,2,1
9,10,8,7,6,5,4,3,2,1
9,8,10,7,6,5,4,3,2,1
9,8,7,10,6,5,4,3,2,1
...
9,8,7,6,5,4,3,2,1,10
这是一趟冒泡排序,然后以此类推，再从开始两两数字相比较
10个元素，所以要进行9趟冒泡排序
最后的结果就是1,2,3,4,5,6,7,8,9,10

#include <stdio.h>
#include <stdlib.h>

void bubble_sort(int arr[],int sz)
{
    //确定冒泡排序躺数
    int i = 0;
    for (i=0; i < sz - 1 ; i++)
    {
        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(flag == 1)
             {
               break;
             }
    }
}

int main()
{
    int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    //对arr进行排序,排成升序
    //arr是数组，我们对数组arr传参，实际上传递过去的是数组arr的首元素的地址
    bubble_sort(arr,sz);//冒泡排序函数
    for(i = 0;i<sz;i++)
    {
        printf("%d",arr[i]);
    }
    return 0;
}

注意：
1.数组作为函数参数时，不会把整个数组传递过去，实际上只是把数组的首元素的地址传递过去了。

2.数组名就是数组首元素的地址（有两个除外）
1）sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。
2）&数组名，取出的是数组的地址，&数组名表示的是整个数组

结尾

以梦为马，不负韶华。

标签：10,arr,初阶,int,C语言,数组,sizeof,include
来源： https://www.cnblogs.com/yjlin/p/16101513.html