Linux C语言 06-数组

Linux C语言数组

本节关键字：Linux、C语言、一维数组、二维数组
相关C库函数：printf、sizeof

数组的特点

• 开辟的空间地址连续；
• 可以存放大量类型相同的数据；
• 数组名就是数组的首地址，也是数组第一个元素的地址；

类型表达式

数据类型 数组名[数组长度];
例：int num[10];

类型含义

int num[10];
num的类型为 int [10]，称为整型数组，每个元素的类型为 int，用于存放n个整型数，并且地址连续；

数组元素个数

数组元素个数 = sizeof(数组名) / sizeof(数组名[0]);

数组类型大小

数组类型大小 = 数组类型 * 元素个数

取数组元素

数组名[下标]
下标的范围：0 ~ 元素个数-1
下标的含义：距离数组首地址（数组的第一个元素）相差几个元素

一维数组初始化

#include <stdio.h>

int num5[7];

int main(int argc, char *argv[])
{
	//  定义时全部初始化
	printf("1. 定义时全部初始化\n");
	int num1[7] = {1, 2, 3, 4, 5, 6, 7};
	int count = sizeof(num1) / sizeof(num1[0]);
	for (int i=0; i<count; i++)
		printf("num1[%d] = %d, address = %p\n", i, num1[i], num1+i);	

	// 定义时部分初始化，从第一位开始依次赋值，没有初始化的元素默认为 0
	printf("2. 定义时部分初始化，没有初始化的元素默认为0\n");
	int num2[7] = {1, 2, 3};
	count = sizeof(num2) / sizeof(num2[0]);
	for (int i=0; i<count; i++)
		printf("num2[%d] = %d, address = %p\n", i, num2[i], num2+i);	

	// 定义时省略数组长度
	printf("3. 定义时省略数组长度\n");
	int num3[] = {1, 2, 3, 4, 5, 6, 7};
	count = sizeof(num3) / sizeof(num3[0]);
	for (int i=0; i<count; i++)
		printf("num3[%d] = %d, address = %p\n", i, num3[i], num3+i);
		
	// 不初始化，定义成拒不数组时默认值为随机值，定义为全局数组时默认值为0
	printf("4. 定义时不初始化,局部变量为随机值\n");
	int num4[7];
	count = sizeof(num4) / sizeof(num4[0]);
	for (int i=0; i<count; i++)
		printf("num4[%d] = %d, address = %p\n", i, num4[i], num4+i);

	printf("5. 定义时不初始化,全局变量为默认值为0\n");
	count = sizeof(num5) / sizeof(num5[0]);
	for (int i=0; i<count; i++)
		printf("num4[%d] = %d, address = %p\n", i, num5[i], num5+i);
		
	return 0;
}
/* 执行结果： 
1. 定义时全部初始化
num1[0] = 1, address = 0x7fff5dbdbb40
num1[1] = 2, address = 0x7fff5dbdbb44
num1[2] = 3, address = 0x7fff5dbdbb48
num1[3] = 4, address = 0x7fff5dbdbb4c
num1[4] = 5, address = 0x7fff5dbdbb50
num1[5] = 6, address = 0x7fff5dbdbb54
num1[6] = 7, address = 0x7fff5dbdbb58
2. 定义时部分初始化，没有初始化的元素默认为0
num2[0] = 1, address = 0x7fff5dbdbb20
num2[1] = 2, address = 0x7fff5dbdbb24
num2[2] = 3, address = 0x7fff5dbdbb28
num2[3] = 0, address = 0x7fff5dbdbb2c
num2[4] = 0, address = 0x7fff5dbdbb30
num2[5] = 0, address = 0x7fff5dbdbb34
num2[6] = 0, address = 0x7fff5dbdbb38
3. 定义时省略数组长度
num3[0] = 1, address = 0x7fff5dbdbb00
num3[1] = 2, address = 0x7fff5dbdbb04
num3[2] = 3, address = 0x7fff5dbdbb08
num3[3] = 4, address = 0x7fff5dbdbb0c
num3[4] = 5, address = 0x7fff5dbdbb10
num3[5] = 6, address = 0x7fff5dbdbb14
num3[6] = 7, address = 0x7fff5dbdbb18
4. 定义时不初始化,局部变量为随机值
num4[0] = 1572715384, address = 0x7fff5dbdbae0
num4[1] = 32767, address = 0x7fff5dbdbae4
num4[2] = 0, address = 0x7fff5dbdbae8
num4[3] = 1, address = 0x7fff5dbdbaec
num4[4] = 0, address = 0x7fff5dbdbaf0
num4[5] = 0, address = 0x7fff5dbdbaf4
num4[6] = 4195102, address = 0x7fff5dbdbaf8
5. 定义时不初始化,全局变量为默认值为0
num5[0] = 0, address = 0x600c90
num5[1] = 0, address = 0x600c94
num5[2] = 0, address = 0x600c98
num5[3] = 0, address = 0x600c9c
num5[4] = 0, address = 0x600ca0
num5[5] = 0, address = 0x600ca4
num5[6] = 0, address = 0x600ca8
*/

二维数组

二维数组也可以看作是一维数组，只不过每个元素都是一维数组，示例：
int arr[3][4];
说明：arr是一个二维数组，每个元素都是一个长度为4的一位数组。

// 二维数组示例
#include <stdio.h>

int arr1[3][4];

int main()
{
	int arr2[3][4] = {
		{1, 1, 1, 1},
		{2, 2},	// 思考一下？ 剩余未初始化的元素 值是多少呢？会是随机值吗？
		{3},
		{4}
	};
	int i, j, count1, count2;
	count1 = sizeof(arr1) / sizeof(arr1[0]);
	count2 = sizeof(arr2) / sizeof(arr2[0]);
	for (i=0; i<count1; i++)
		for (j=0; j<4; j++)
			printf("arr1[%d][%d]=%d\n", i, j, arr1[i][j]);
	
	for (i=0; i<count2; i++)
		for (j=0; j<4; j++)
			printf("arr2[%d][%d]=%d\n", i, j, arr2[i][j]);
	return 0;
}
/* 执行结果
arr1[0][0]=0
arr1[0][1]=0
arr1[0][2]=0
arr1[0][3]=0
arr1[1][0]=0
arr1[1][1]=0
arr1[1][2]=0
arr1[1][3]=0
arr1[2][0]=0
arr1[2][1]=0
arr1[2][2]=0
arr1[2][3]=0
arr2[0][0]=1
arr2[0][1]=1
arr2[0][2]=1
arr2[0][3]=1
arr2[1][0]=2
arr2[1][1]=2
arr2[1][2]=0
arr2[1][3]=0
arr2[2][0]=3
arr2[2][1]=0
arr2[2][2]=0
arr2[2][3]=0

*/

补充：
在实际操作过程中，需要注意数组的越界问题，数组越界会导致程序异常崩溃，避免数组越界的方法是正确计算数组的元素个数，计算方法为： sizeof(数组名) / sizeof(数组名[]);

变长数组

以一维整型数组为例，自行封装一个可变数组，该部分补充内容为了契合分类分项，暂时放在这里，后期需要的话再做调整。

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


typedef struct 
{
    int *value;
    int size;
//    int value[0]; // 这种方式定义该结构体,只占用4字节,value不占用内存,每个结构体中只能有一个变长变量,并且必须在结构体成员的最后一位
} array_t;

int  array_create(array_t *arr, int size);
void array_delete(array_t *arr);
int  array_size(const array_t *arr);
int  array_at(const array_t *arr, int index);
void array_set(array_t *arr, int index, int value);
int  array_expansion(array_t *arr, int size);

int main(void)
{
    int i, size, rc;
    array_t ary;
    
    rc = array_create(&ary, 5);
    if (rc == 0)
        return 1;
    
    size = array_size(&ary);
    printf("=================== ary size: %d\n", size);
    
    for (i=0; i<size; i++)
        array_set(&ary, i, i);

    for (i=0; i<size; i++)
        printf("ary[%d]=%d\n", i, array_at(&ary, i));
    
    array_set(&ary, size*2, size*2);
    
    size = array_size(&ary);
    printf("=================== ary size: %d\n", size);
    for (i=0; i<size; i++)
        printf("ary[%d]=%d\n", i, array_at(&ary, i));
    
    array_delete(&ary);
    
    return 0;
}

int array_create(array_t *arr, int size)
{   
    arr->value = (int*)malloc(sizeof(int) * size);
    if (!arr->value)
    {
        arr->size = 0;
        return 0;
    }
    else
    {
        arr->size = size;
        memset(arr->value, 0, sizeof(int)*size);
    }
    
    return size;
}

void array_delete(array_t *arr)
{
    if (arr->value)
        free(arr->value);
    
    arr->value = NULL;
    arr->size = 0;
}

int array_size(const array_t *arr)
{    
    return arr->size;
}

int array_at(const array_t *arr, int index)
{
    return arr->value[index];
}

void array_set(array_t *arr, int index, int value)
{
    if (index < arr->size)
    {
        arr->value[index] = value;
    }
    else 
    {
        int rc, resize;
        resize = index + 1;
        rc = array_expansion(arr, resize);
        if (rc != resize)
            return;
        array_set(arr, index, value);
    }
}

int array_expansion(array_t *arr, int size)
{
    int *p = NULL;
    int resize;
    
    resize = sizeof(int) * size;
    p = (int *)realloc(arr->value, resize);
    if (!p)
        return 0;
    
    // 注意观察并理解这一步的含义 可以屏蔽memeset进行观察
    memset(arr->value + arr->size, 0, sizeof(sizeof(int) * (size - arr->size)));
    arr->size = size;
    return size;
}

/** 运行结果：
=================== ary size: 5
ary[0]=0
ary[1]=1
ary[2]=2
ary[3]=3
ary[4]=4
=================== ary size: 11
ary[0]=0
ary[1]=1
ary[2]=2
ary[3]=3
ary[4]=4
ary[5]=0
ary[6]=0
ary[7]=0
ary[8]=0
ary[9]=0
ary[10]=10
*/