Linux第一课：c语言 学习记录day05

四、数组

1、概念

        具有一定顺序的若干变量的合集

2、定义格式

        存储类型 数据类型 数组名[元素个数]

int arr[5]；

        数组名：代表数组首元素的地址，arr是地址常量，不能为左值，不能被赋值

        访问元素：数组名[下标]；下标从0开始

                访问第一个元素：arr[0]；

                访问第n个元素：arr[n-1]；

        注意：数组越界问题

3、特点

        1）内存连续

        2）数据类型相同

4、注意

        1）数组的数据类型就是元素的数据类型

        2）数组名要符合标识符的命名规则

        3）在同一个函数中，数据名不要与变量名相同

        4）下标从0开始，到n-1结束

5、分类

        一维数组、二维数组

1、一维数组

        只有一个下标数组

1、格式

        存储类型 数据类型 数组名[元素个数]；

2、元素访问

        数组名[下标]，下标从0开始

3、数据名

        数组的首地址

4、初始化

1)全部初始化：

#include<stdio.h>
int main()
{
    int arr[3]={1, 2, 3};

    printf("%d\n", arr[0]);
    printf("%d\n", arr[1]);
    printf("%d\n", arr[2]);

    return 0;
}

2）部分初始化：

#include<stdio.h>
int main()
{
	int arr[3]={1};
	
	printf("%d\n", arr[0]);
	printf("%d\n", arr[1]);
	printf("%d\n", arr[2]);
	
	return 0;
}

        部分初始化中，未初始化的元素为0

3）未初始化：

#include<stdio.h>
int main()
{
	int arr[3];
	printf("%d\n", arr[0]);
	printf("%d\n", arr[1]);
	printf("%d\n", arr[2]);
	return 0;
}

随机值：需要单个元素赋值，以下是单个元素赋值

#include<stdio.h>
int main()
{
	int arr[3];
	arr[0]=1;
	arr[1]=2;
	arr[2]=3;
	printf("%d\n", arr[0]);
	printf("%d\n", arr[1]);
	printf("%d\n", arr[2]);
	return 0;
}

5、定义空数组

1）全部初始化：

int arr[3]={0,0,0};

2）部分初始化：

int arr[3]={0};

int arr[3]={};

6、引用

1、先定义后引用

2、每次只能引用一个数组元素 arr[i]，如果想引用所有元素可以循环遍历

#include<stdio.h>
int main()
{
	int arr[3]={1,2,3};
	for(int i=0;i<3;i++)
	{
		printf("%d\n",arr[i]);
	}
	return 0;
}

3、引用时防止数组越界，虽然有时候编译器不会报错

4、打印数组元素地址用%p格式

#include<stdio.h>
int main()
{
	int arr[3]={1,2,3};
	for(int i=0;i<3;i++)
	{
		//printf("%d\n",arr[i]);
        printf("%p\n", &arr[i]);
	}
	return 0;
}

7、内存分配

        顺序分配，一一对应

1	a[0]
2	a[1]
3	a[2]
4	a[3]

8、数组遍历

        把循环变量作为数组下标，用for循环遍历

#include<stdio.h>
int main()
{
	int arr[3];
	int i;
	for(i=0;i<3;i++)
		scanf("%d", &arr[i]);
	printf("-------------\n");
	for(i=0;i<3;i++)
		printf("%d\n", arr[i]);
	return 0;
}

9、数组的大小

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

int a[5]        //4*5=20

double b[2]        //8*2=16

char c[32]        //1*32=32

        函数：szieof（数组名）

int arr[5]={};

printf("%d\n",sizeof(arr));

        计算元素的个数

直接观察

sizeof（数组名）/sizeof（数据类型）；

练习：计算斐波那契数列前15项并逆向输出

        1 1 2 3 5 8 13 21 ……

#include<stdio.h>
int main()
{
	int arr[15]={1,1};
	int i,j;
	for(i=2;i<15;i++)
	{
		arr[i]=arr[i-1]+arr[i-2];
	}
	for(j=14;j>=0;j--)
	{
		printf("%-4d", arr[j]);
	}
	printf("\n");
	return 0;
}

2、清零函数

1、bzero

#include <strings.h>

void bzero(void *s, size_t n)；

功能：将内存空间设置为0

参数：s：要清空的空间首地址

        n：字节大小

返回值：无

示例：

2、memset

#include <string.h>

void *memset(void *s, int c, size_t n);

功能：将内存空间设置为0

参数：s：要清空空间的首地址

        c：要设置的值，设置为0

        n：字节大小

返回值：要清空空间的首地址

示例：

3、字符数组

        字符数组存放字符串

1、概念

        元素的数据类型为字符型数据

2、形式

// 元素个数没写的时候，会以后面实际的元素数量去开辟空间

char str[] ={'a', 'b', 'c'};        // 逐个字符的赋值 sizeof(str) = 3

char c[];        // 大小为0，随便输入一个元素就会越界

char str[] = {"abc"};        // 用字符串赋值  sizeof(str) = 4

char ch[] = "hello";        // 用字符串赋值 sizeof(ch) = 6

printf("%c\n", ch[0]);

char c[32] = "hello"        // 用字符串赋值 sizeof(c) = 32

注意：字符串赋值常常会省略数组长度，需要注意数组越界问题

3、字符数组的输入输出

输入

        char s[32] = {};

1）scanf输入字符串

#include <stdio.h>
int main()
{
    char s[32] = {};
    scanf("%s", s);
    for (int i = 0; i < 10; i++)
    {
        printf("%d\n", s[i]);
    }
    printf("%s\n",s);
    return 0;
}

输入的字符串不能含有空格，因为scanf输入字符串遇到空格或回车都会认为字符串输入结束，空格或回车后面的内容就不会放到数组里面

如果需要输入空格，就按照以下格式输入：

scanf("%[^\n]",s);        // 直到输入回车结束

2）循环输入字符

#include<stdio.h>
int main()
{
    char arr[32] = {};
    int i;
    for (i = 0; i < 32; i++)
    {
        scanf("%c", &arr[i]);
    }
    return 0;
}

3）gets

char *gets(char *s);

功能：从终端输入字符串

参数：s：目标字符数组的首地址

返回值：目标字符数组的首地址

gets(s);        //gets在输入时不关心数组越界问题，使用时会报警告

#include<stdio.h>
int main()
{
    char s[32] = {};
    gets(s);
    printf("%s\n",s);
    return 0;
}

输出

1、printf输出字符串

printf("%s\n",s);

2、循环输出单个字符

for( i = 0; i < 32; i++)

        printf("%c",arr[i]);

3、puts

int puts(const char *s);

功能：向终端输出字符串

参数：s：要输出字符串的首地址

返回值：输出字符的个数

#include<stdio.h>
int main()
{
    char s[32] = {};
    gets(s);
    puts(s);
    return 0;
}

例题：判断对错

char s[10] = {};

s[10] = "hello"；        //错误，数组越界

s = "hello";        // 错误， s是地址常量，不能为左值

strcpy(s, "string");         //对

计算字符串实际长度

1、for循环遍历数组，指导\0为止

        int n = 0

        for (n = 0; s[n] != '\0'; n++);

#include<stdio.h>
int main()
{
    char s[32] = "hello world";
    int n = 0;
    for (n = 0; s[n] != '\0'; n++)
    printf("%d\n",n);
    return 0;
}

2、strlen

        #include <string.h>

        size_t strlen(const char *s);

功能：计算字符串的实际长度（不包括\0）

参数：s：要计算的字符串的首地址

返回值：字符串的实际长度

示例：

sizeof和strlen的区别

// 本质上

1、sizeof是关键字，strlen是函数

// 从功能上

2、sizeof 是计算数据所占空间大小，strlen计算字符串的实际长度

3、在没有写元素个数的情况下，sizeof的计算包括\0；计算字符串长度时，sizeof比strlen大1；