naoemb
0%

03c_06day

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

===========================
2022-7-21
===========================

一.温故知新	
    指针
        malloc
    指针的含义 : 指针就是用来存储地址
    NULL
    指针的定义 : 数据类型	指针名	;
                 char *		pc		;
                 char *		pi		;
                 float *	pf		;

指针

    通过sizeof测试
    指针的命名规则和变量的命名规则一致
    int i = 0;
    int *p;

    p = &i;
    *p
    指针运算符
    数据类型	指针名	=	地址	;
    int *		p		=	NULL	;
    int *p;	->	int
    char *p;	->	char
    指针可以做加减法运算
        p+1;	p+=1;	p++;	++p;
    特殊指针
        空类型指针(万能指针)
        空指针
        野指针

    容易混淆的声明
        const	指针
        指针常量
        常量指针
        数组	函数
        指针数组
        数组指针
        指针函数
        函数指针
        函数指针数组

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

int add(int a, int b);//函数的声明

int add(int a, int b)//函数的实现
{
	return a + b;
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;
	int sum = 0;

	scanf("%d-%d", &a, &b);

	sum = add(a, b);//函数的调用

	printf("sum = %d\n", sum);

	return 0;
}


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>

int max(int , int );//函数的声明

int max(int x, int y)//函数的实现
{
	//x > y ? return x : return y;
	return x > y ? x : y;
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;
	int sum = 0;

	scanf("%d-%d", &a, &b);

	sum = max(a, b);//函数的调用

	printf("sum = %d\n", sum);

	return 0;
}


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>

int isleapyear(int );//函数的声明

int isleapyear(int abc)//函数的实现
{
	return (!(abc%4)&&(abc%100)) || (!(abc%400));
}

int main(int argc, char *argv[])
{
	int year = 0;
	int sum = 0;

	scanf("%d", &year);

	sum = isleapyear(year);//函数的调用
	//如果sum = 1代表是闰年 如果sum = 0代表是平年
	
	sum == 1 ? printf("%d年是闰年!\n", year) : printf("%d年是平年!\n", year);

	return 0;
}


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
#include <stdio.h>
#include <stdlib.h>

void func(int ,int);

void func(int a, int b)
{
	int min = 0, max = 0;
	int i = 0, j = 0;

	min = a < b ? a : b;
	max = a > b ? a : b;

	for(i = min; i <= max; i++)
	{
		for(j = 2; j < i; j++)
		{
			if(i % j == 0)
				break;
		}
		if(i == j)
			printf("%d\t", i);
	}
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);

	func(a, b);//函数的调用
	//func()的功能是寻找最小值 - 最大值之间的素数

	return 0;
}


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
#include <stdio.h>
#include <stdlib.h>

void swap(int ,int);

void swap(int a, int b)
{
	int tmp = 0;

	printf("swap.交换之前a = %d b = %d\n", a, b);
	printf("swap.交换之前a = %p b = %p\n", &a, &b);
	tmp = a;
	a = b;
	b = tmp;
	printf("swap.交换之后a = %d b = %d\n", a, b);
	printf("swap.交换之后a = %p b = %p\n", &a, &b);
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);
	
	printf("main.交换之前a = %d b = %d\n", a, b);
	printf("main.交换之前a = %p b = %p\n", &a, &b);
	
	swap(a, b);//通过swap()交换变量a b的值
	
	printf("main.交换之后a = %d b = %d\n", a, b);
	printf("main.交换之后a = %p b = %p\n", &a, &b);

	return 0;
}

交换变量值

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
#include <stdio.h>
#include <stdlib.h>

void swap(int *, int*);

void swap(int *a, int *b)
{
	int tmp = 0;

	tmp = *a;
	*a = *b;
	*b = tmp;
}

int main(int argc, char *argv[])
{
	int a = 0, b = 0;

	scanf("%d-%d", &a, &b);
	
	printf("main.交换之前a = %d b = %d\n", a, b);
	
	swap(&a, &b);//通过swap()交换变量a b的值
	
	printf("main.交换之后a = %d b = %d\n", a, b);

	return 0;
}

程序员写C语言程序会经历几个阶段
第一阶段	只写一个.c文件,在.c文件中只写一个main函数
            把所有的功能都放到main函数中
第二阶段	只写一个.c文件,在.c文件中除了有main函数以外
            还会有其他的功能函数的封装
第三阶段	在一个项目工程中存在多个.c或者.h文件
            main.c		存放main函数以及功能函数的调用
            func.c		存放功能函数的实现
            func.h		存放功能函数的声明以及各种定义
            makefile	是一个脚本文件(存放的是编译规则)
第四阶段	把func.c制作成库文件
            动态库和静态库

函数
当写一个C语言程序时,首先需要写的一个函数就是main函数
1.函数的含义
    函数就是一个功能,当调用函数时,会使用这个功能
    printf()	->	打印输出
    scanf()		->	录入
    rand()		->	用来产生随机数
    srand()		->	随机种子
    time()		->	获取时间的描述
    getpid()	->	获取进程ID号
    sleep()		->	秒级延时
    usleep()	->	微秒级延时
    system()	->	调用shell命令
    函数的出现是为了减少代码量,减少代码的冗余
    例子 : printf函数的代码量有100行左右
    如何把一部分的代码封装成一个函数,其实是由程序员决定的
    通过是根据每个函数执行一个特定的功能来进行划分的
2.函数组成部分
    一般来说函数是由三个部分组成的
    1)函数的声明(函数的定义)
        其实就是告诉编译器,函数的名称,函数的返回值
            以及函数的参数
函数的返回值类型 函数名(参数列表);//该处参数指的是形式参数
函数的返回值类型 函数名	(参数列表);
char *			 strcpy (char *dest, const char *src);
void *			 malloc (size_t size);
int				 rand	(void);
void			 srand	(unsigned int seed);
注意 : 
        1>函数名的命名规则和变量的命名规则一致
        2>在写函数的声明时,可以不指定形式参数的名字,
            但是必须要有形式参数的数据类型
    2)函数的实现
        其实就是把函数所代表的功能通过代码进行实现
函数的返回值类型 函数名(参数列表)//该处参数指的是形式参数
{
    功能实现的代码
}
    注意 : 
        1>在写函数的实现时,必须要指定形式参数的名字
    3)函数的调用
        其实就是在代码中使用函数实现的功能
函数名(参数);//该处参数指的是实际参数
形式参数和实际参数是两个不同的内容,可以同名
其实是形式参数来接收实际参数的值的
3.函数的传参
    值传递	: 是把实际参数的值传递给形式参数
            在这种情况下修改形式参数的值不会影响实际参数
        总结: 如果只是想要访问实际参数的值,
                不想修改实际参数的值,那么就使用值传递
        add(); max(); isleapyear(); printf();

    地址传递: 是把实际参数的地址传递给形式参数(指针)
            如果通过形式参数修改指向空间的数据
            会改变实际参数的值
        总结: 如果想要通过形式参数修改实际参数的值
            那么就用地址传递
        swap(); scanf();

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
#include <stdio.h>
#include <stdlib.h>

void print(int);
void change(int *);

void print(int a)
{
	printf("a = %d\n", a);
}

void change(int *a)
{
	scanf("%d", a);
}

int main(int argc, char *argv[])
{
	int a = 9527;

	print(a);//通过print函数打印变量a的值

	change(&a);//通过change函数改变a的值
	
	print(a);//通过print函数打印变量a的值

	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[])
{
	int i = 9527;
	int *p = &i;

	printf("i = %d &i = %p\n", i, &i);
	printf("*p = %d p = %p\n", *p, p);

	return 0;
}


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

int main(int argc, char *argv[])
{
	printf("sizeof(char **) = %ld\n",sizeof(char **));
	printf("sizeof(short **) = %ld\n",sizeof(short **));
	printf("sizeof(int **) = %ld\n",sizeof(int **));
	printf("sizeof(long **) = %ld\n",sizeof(long **));
	printf("sizeof(float **) = %ld\n",sizeof(float **));
	printf("sizeof(double **) = %ld\n",sizeof(double **));

	return 0;
}

/*
===========================
作业:
1.把今天讲过的内容完完整整的复习一遍
2.最少把<猜数游戏>和<口算卡>改为多函数的版本
===========================
二级指针
1.二级指针的含义
只要是指针,那就是用来存储地址的
一级指针是用来保存变量的地址的
    (可以使用一级指针操控变量)
二级指针是用来保存一级指针的地址的
    (可以使用二级指针操控一级指针)
2.二级指针的定义
    int			i		;
    数据类型	指针名	;
    int *		p		;
    int **		pp		;
3.通过sizeof测试占用存储空间的大小
    无论何种类型的二级指针在我当前的机器环境中,
    占用空间大小都是8个字节
4.二级指针的命名规则和变量的命名规则一致
5.使用二级指针

1
2
3
4
5
6
7
8
9
10
名	i		p		pp

值	100		0x1000	0x2000
	i		p		pp
	*p		*pp
	**pp
址	0x1000	0x2000	0x3000
	&i		&p		&pp
	p		pp
	*pp

*/

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>

int main(int argc, char *argv[])
{
	int i = 100;
	int *p = &i;
	int **pp = &p;

	printf("i = %d\n", i);
	printf("*p = %d\n", *p);
	printf("**pp = %d\n", **pp);
	printf("====================\n");
	printf("&i = %p\n", &i);
	printf("p = %p\n", p);
	printf("*pp = %p\n", *pp);
	printf("====================\n");
	printf("&p = %p\n", &p);
	printf("pp = %p\n", pp);
	printf("====================\n");
	printf("&pp = %p\n", &pp);

	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>

int main(int argc, char *argv[])
{
	int i = 100;
	int *p = &i;
	int **pp = &p;
	
	printf("&p = %p\n", &p);
	printf("pp = %p\n", pp);
	
	pp++;

	printf("&p = %p\n", &p);
	printf("pp = %p\n", pp);

	return 0;
}


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>

void change(int **, int *);

void change(int **p, int *b)
{
	*p = b;
}

int main(int argc, char *argv[])
{
	int a = 100, b = 200;
	int *p = &a;

	printf("*p = %d p = %p\n", *p, p);
	
	//change(p, &b);
	change(&p, &b);//通过change函数把指针p指向b变量
	
	printf("*p = %d p = %p\n", *p, p);

	return 0;
}

随机函数
    rand();			//功能:就是用来产生随机数的
    rand() % 1000; 	//[0 ~ 999]
    rand() % 100 - 50;//[-50 ~ 49]
    
    srand();		//功能:可以保证每一次产生的随机数可变
        srand函数在调用时需要有可变的因子
        time(NULL);	//时间种子
        getpid();	//进程种子

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <unistd.h>

void func(void);

void func(void)
{
	int T = 0;//存储随机出的数字
	int guess = 0;//存储玩家猜的数字
	int num = 1;

	srand(getpid());//随机种子
	
	T = rand() % 10;

	for(num = 1; ; num++)
	{
		scanf("%d", &guess);
		if(T > guess)
			printf("[%d]	Small!\n", num);
		else if(T < guess)
			printf("[%d]	Big!\n", num);
		else
		{
			printf("[%d]	Bingo!\n", num);
			break;
		}
	}
}

int main(int argc, char *argv[])
{
	func();

	return 0;
}