naoemb
0%

03c_09day

发表于 更新于
本文字数： 7.2k 阅读时长 ≈ 7 分钟

============================
2022-7-26
============================

一.温故知新

    多维数组
        二维数组
            可以存储多个相同类型的数据
            可以抽象成有行有列的形式
            数据类型 数组名[行数][列数];
            int arr[2][3];
            一共有6个成员
            arr[0][0] arr[0][1] arr[0][2]
            arr[1][0] arr[1][1] arr[1][2]
int arr[3][5] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
现在想要找出数值为7的成员
            数组名 + 下标	arr[1][1]
            数组名 + 偏移量	*(*(arr + 1) + 1)
            通过sizeof运算符计算
            int arr[3][5];
            sizeof(arr[0][0]) = 4 = 一个成员的大小
            sizeof(arr[0]) = 20 = 一行的大小
            sizeof(arr) = 60 = 整个数组的大小
            sizeof(arr)/sizeof(arr[0][0]) = 15 = 成员个数
            sizeof(arr)/sizeof(arr[0]) = 3 = 行数
            sizeof(arr[0])/sizeof(arr[0][0]) = 5 = 列数
            通过打印每个成员的地址发现
            二维数组的成员也是占用了连续的存储空间
            二维数组的数组名相当于是数组首行的地址
            (一维数组的数组名相当于是数组首成员的地址)
字符数组和字符指针
    在C语言中没有字符串类型
    在C语言中需要使用字符数组来存储字符串数据
    字符数组
1.字符数组的含义
    是用来存储一组字符数据的
2.字符数组的定义
    数据类型	数组名	[成员个数]	;
    char		arr		[10]		;
3.字符数组的初始化
    数据类型	数组名	[成员个数] = {数值,数值};
    char arr[10] = {0};//给数组的10个成员都初始化成0
    char arr[5] = {1,2,3,4,5};
    char arr[5] = {'1','2','3','4','5'};
    char arr[5] = {'\0'};
    char arr[5] = {'0'};
    char arr[10] = "easthome";
    arr[0] = 'e' arr[1] = 'a' ... arr[7] = 'e' 
    arr[8] = '\0'
    char arr[10] = {"easthome"};

注意 : 
    当通过scanf("%c")的方式给字符数组录入字符数据时
    需要注意回车('\n'),因为回车会被当作换行符保存到
    字符数组中
    当通过scanf("%s")的方式给字符数组录入字符数据时
    需要注意空格,因为空格会被当作字符串的截断标志
    当通过scanf("%s")的方式给字符数组录入字符数据时
    需要注意数组越界的问题

字符指针

1.字符指针的含义
    字符指针也是指针,是用来保存地址的
2.字符数组和字符指针
    char arr[10] = "easthome";
    char *p = "easthome";
    字符数组在初始化的时候,是把"easthome"字符串中的字符
    一个一个的保存到字符数组的成员中
    字符指针在初始化的时候,指针p是保存了"easthome"
    这个字符串常量的首地址
    C语言会把内存分为5大区域
    栈区
    堆区
    常量区(read only)
    全局区
    代码区	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	for(i = 0; i < size; i++)
	{
		scanf("%c", &arr[i]);
	}

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

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	for(i = 0; i < size; i++)
	{
		scanf("%c", &arr[i]);
	}

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

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	scanf("%s", arr);

	for(i = 0; i < size; i++)
	{
		printf("arr[%d] = %c-%d\n", i, arr[i], arr[i]);
	}

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = {0};//初始化10个成员的字符数组
	int i = 0;
	int size = sizeof(arr) / sizeof(*arr);

	scanf("%s", arr);

	printf("arr = %s\n", arr);
	/*
		%d->int
		%f->double
		%c->int
		%s->char *
	*/

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = "easthome";
	char brr[10] = {"easthome"};

	printf("arr = %s\n", arr);
	printf("brr = %s\n", brr);

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = "easthome";
	char *p = "easthome";

	printf("arr = %s\n", arr);
	printf("p = %s\n", p);

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char arr[10] = "easthome";//可以,数组成员保存每个字符
	char *p = "easthome";//可以,指针保存字符串常量的首地址
	printf("arr = %s\n", arr);//可以打印
	printf("p = %s\n", p);//可以打印
	p++;//可以,指针保存的是字符串常量首地址
	printf("p = %s\n", p);//自增之后保存下一个成员的地址
	arr++;//不可以,数组名不能做自增或者赋值运算
	printf("arr = %s\n", arr);
	//arr[0] = 'E';//可以,实际上是修改了数组首成员的数据
	//printf("arr = %s\n", arr);
	//p[0] = 'E';//不可以,指针保存的是常量区地址(readonly)
	//printf("p = %s\n", p);

	return 0;
}

常量区

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
	char src[10] = "easthome";
	char dest[10] = {0};

	printf("strcpy = %s\n", strcpy(dest, src));

	//printf("dest = %s\n", dest);
	
	//strcpy(dest, src);
	
	//printf("dest = %s\n", dest);

	return 0;
}

/*
调用strcpy函数时,第一个参数必须是一个字符数组,
    第二个参数可以是字符数组\字符指针\字符串常量
调用strcat函数时,第一个参数必须是一个字符数组,
    第二个参数可以是字符数组\字符指针\字符串常量
*/


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
	//char src[10] = "easthome";
	char *src = "embsky!";
	char dest[32] = "embsky";
	int ret = 0;

	//ret = strcmp(src, dest);
	ret = strcmp("embsky", "easthome");
	printf("ret = %d\n", ret);
	//printf("strlen = %ld\n", strlen("Hello World!"));
	//printf("strlen = %ld\n", strlen(dest));
	//printf("strlen = %ld\n", strlen(src));
	//printf("dest = %s\n", dest);
	//strcpy(dest, "embsky");
	//strcat(dest, src);
	//printf("dest = %s\n", dest);

	return 0;
}


/*
重新实现strcpy strcat strcmp strlen
    字符串的结束标志是'\0'

1
2
3
4
5
6
7
strncpy strncat strncmp

char dest[5] = "abc";
char *src = "Hello World!";

strcpy(dest, src);
strncpy(dest, src, 5);


*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <stdio.h>
#include <stdlib.h>

char *mystrcpy(char *dest, const char *src);
char *mystrcat(char *dest, const char *src);
int mystrcmp(const char *s1, const char *s2);
size_t mystrlen(const char *s);

char *mystrcpy(char *dest, const char *src)
{
	int i = 0;
	
	for(i = 0; src[i] != '\0'; i++)//可以把有效的字符遍历
		dest[i] = src[i];
	dest[i] = src[i];//为了拷贝'\0'

	return dest;
}

char *mystrcat(char *dest, const char *src)
{
	int i = 0, j = 0;

	for(i = 0; dest[i] != '\0'; i++)//用来找字符串的'\0'
		;
	for(j = 0; src[j] != '\0'; i++,j++)
		dest[i] = src[j];
	dest[i] = src[j];//这次赋值是为了拷贝'\0'

	return dest;
}

int mystrcmp(const char *s1, const char *s2)
{
	int i = 0;

	for(i = 0; s1[i] == s2[i] && s1[i] != '\0'; i++)
		;
	/////如果程序可以执行到此处
	return s1[i] - s2[i];
}

size_t mystrlen(const char *s)
{
	int i = 0;

	for(i = 0; s[i] != '\0'; i++)
		;
	return i;
}

int main(int argc, char *argv[])
{
	char *src = "Hello";
	char dest[32] = "World";

	printf("mystrcpy = %s\n", mystrcpy(dest, src));
	printf("mystrcat = %s\n", mystrcat(dest, src));
	printf("mystrcmp = %d\n", mystrcmp(dest, src));
	printf("mystrlen = %ld\n", mystrlen(dest));
	//printf("dest = %s\n", dest);
	//mystrcpy(dest, src);
	//printf("dest = %s\n", dest);

	return 0;
}



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
	char *p = "root:x:0:0:root:/root:/bin/bash";
	//需要大家把/etc/passwd文件读出的内容进行解析
	int i = 0;

	for(i = 0; p[i] != '\0'; i++)
	{
		if(p[i] != ':')
			printf("%c", p[i]);
		else
			printf("\n");
	}


	return 0;
}