naoemb
0%

03c_11day

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

=========================
2022-7-28
=========================

一.写C语言程序的四个阶段

第一阶段	只写一个.c文件,在.c文件中只写一个main函数
            把所有功能都堆到main函数中
第二阶段	只写一个.c文件,在.c文件中除了main函数以外
            封装了其他的功能函数
    函数的声明
函数的返回值类型 函数名(参数列表);//该处的参数指的是形参
    函数的实现
函数的返回值类型 函数名(参数列表)//该处的参数指的是形参
{
    功能实现的代码
}
    函数的调用
函数名(参数);//该处的参数指的是实际参数
第三阶段	以项目工程的形式编写程序,以多文件的形式
            main.c		存放主函数和功能函数的调用
            func.c		存放功能函数的实现
            func.h		存放功能函数的声明以及各种定义
            makefile	存放的是编译规则
第四阶段	把功能函数的实现封装成库文件
            静态库和动态库

二.makefile文件的简介

    一个项目工程中源文件不计其数,这些源文件按照文件类型,
    功能,模块,分别存放在不同的目录中,makefile文件定义了
    一系列的规则来指定哪些文件需要先编译,
    哪些文件需要后编译,哪些文件需要重新编译
    包括更复杂的一些编译操作

三.内存空间的分布

    C语言会把内存分为5个区域
    (栈区 堆区 常量区 全局区 代码区)
    ./a.out执行程序时,是由一个进程来执行程序的
    进程的空间大小是4Gb,是由真实内存4Kb虚拟出来的

    1Gb			Kernel(内核)
    ----------------------------
    3Gb			命令行参数以及环境变量
                栈区(从上往下分配空间)

                空白

                堆区(从下往上分配空间)
                静态区(全局区)未初始化的(系统会初始化成0)
                静态区(全局区)已初始化的
                常量区(只读区)Read Only
                代码区
    栈区		不需要程序员管理,自己开辟,自己释放
    堆区		需要程序员管理,需要手动开辟,需要手动释放
                (malloc calloc realloc free)
    全局区		全局变量/static关键字修饰的变量
    常量区		Read Only
                char *p = "Hello";
                字符串常量"Hello"存储在常量区中
    代码区		程序员没有办法管理

四.全局变量和局部变量

    局部变量
        在某个函数内部定义或者块内定义的变量叫做局部变量
        局部变量只能在函数内部或者块内使用
        局部变量在函数之外是不可知的

    全局变量
        全局变量是定义在函数之外的,通常写到程序开头的位置
        全局变量在整个程序中生命周期都是有效的
        在任意函数内部都可以访问全局变量

    注意:
    全局变量和局部变量可以同名
    如果出现了同名情况,那么在执行该函数时,优先使用局部变量
    在该函数中全局变量被屏蔽

    全局变量和局部变量在定义时的区别
        当定义局部变量时,系统不会帮助初始化,
            局部变量存储的是垃圾值
        当定义全局变量时,系统会帮助初始化
            int -> 0;
            char -> '\0';
            pointer -> NULL;
    全局变量和局部变量存储空间的区别
        全局变量 : 保存在内存的静态全局区,
            占用的是静态的存储单元
            当程序运行时就被创建了,
            当程序结束时才被销毁
        局部变量 : 保存在栈区中,
            只有在局部变量所在的函数被调用时,
            系统才会帮助分配存储单元,
            当局部变量所在的函数调用结束时被释放

五.存储类型关键字

    extern是C语言的关键字
    修饰的是外部的意思
    可以修饰函数,也可以修饰变量
    1>如果函数被extern关键字修饰了,
        证明其他文件也可以使用这个函数
        如果自己写的函数指向在本文件内使用,
        不想被别的文件使用.可以使用static关键字修饰函数
    
    2>如果变量被extern关键字修饰了,需要注意不要初始化,
        因为在Linux gcc环境下会报Error
        
    3>如果在本文件中的函数或者变量被extern关键字修饰了
    说明该函数或者变量在别的文件中已经定义了,
    在当前文件中使用
    当编译器在编译程序时,如果碰到了extern关键字,那么会从
    别的文件中查找相关的定义

    static是C语言的关键字
    修饰的是静态的(内部的)
    可以修饰函数,也可以修饰变量
    为了使全局变量可以安全的使用,请在定义全局变量时,
        使用static关键字进行修饰
    a.如果全局变量没有使用static关键字修饰,可以跨文件使用
    A.如果全局变量使用static关键字修饰,仅限当前文件使用

    b.如果局部变量没有使用static关键字修饰,
        该局部变量存储在栈区中,该函数结束后被释放
        每次调用函数该局部变量都会被重新初始化
    B.如果局部变量使用static关键字修饰,
        该局部变量存储在静态区中,当程序结束后被释放
        只在第一次调用函数时进行初始化,也是唯一一次初始化
    
    c.被static关键字修饰的内容,系统会默认进行初始化
    
    总结 : 
    如果本文件内的函数或者变量想要让别的.c文件使用,
        可以加extern
    如果本文件内的函数或者变量不想让别的.c文件使用,
        可以加static
====================================================
笔试题
1.C语言中extern关键字是用来修饰什么的?
    答 : extern关键字是用来修饰外部的
        可以使用在函数或者变量中
        extern修饰变量 : ......
        extern修饰函数 : ......
2.C语言中static关键字是用来修饰什么的?
    答 : static关键字是用来修饰静态的
        可以使用在函数或者变量中
        static修饰函数 : ......
        static修饰变量 : ......
3.C语言中const关键字是用来修饰什么的?
    答 : const关键字是用来修饰只读的
        可以使用在变量或者指针中
        const修饰变量 : ......
        const修饰指针 : ......
4.C语言中volatile关键字是用来修饰什么的
    答 : volatile关键字是用来防止编译器优化的
    volatile int pm_value;//接收pm2.5传感器数据的
    volatile int pm_led = 0;//控制灯光的开关(0是关 1是开)

    //pm_led = 1;//开灯
    delay_ms(2000);//延时2s
    pm_led = 0;//关灯
    pm_value = get_value();//获取pm2.5的数据
5.描述一下静态变量
    静态的全局变量
    静态的局部变量
====================================================
    容易混淆的声明
================================

六.函数的关系

    1.主函数调用功能函数
    2.功能函数调用其他的功能函数
    3.功能函数自己调用自己(递归函数)
    
    递归函数
    C语言是支持函数的递归,递归其实就是自己调用自己
    注意 : 
    1.在写递归函数时最重要的就是退出条件
    如果写的退出条件不清楚,那么递归函数肯定会出问题
        
    2.在看别人写的递归程序时,递归次数不要太多

    3.在项目中尽量不去使用递归,因为递归函数占用空间

    递归函数可以解决的问题
    数学 : 
            1.从1 + 2 + .. + 100
            2.一个数的阶乘
            3.斐波那契数列
            4.杨辉三角

    编程 : 
            1.栈式存储结构的问题
            2.树状存储
            3.汉诺塔游戏(河内塔)
===================================
    指针常量 常量指针
    指针函数 函数指针 函数指针数组
    指针数组 数组指针

    指针 函数 数组
    容易混淆的声明
    const关键字
    const关键字是用来修饰只读的(常量)
    
    指针常量	: 指针是常量
    定义		: int * const p;
    特点		: 指针的指向不能通过指针名进行改变,可以通过该指针修改指向空间的数据
                当在程序中定义了指针常量,必须要有初始化
    用处		: 数组名

    常量指针	: 指针指向常量
    定义		: const int *p; const char *src; char const *src;
    特点		: 指针的指向能通过指针名进行改变,不可以通过该指针修改指向空间的数据
    用处		: 字符串操作
    -------------------------------
    const int *p;
    int const *p;
    int * const p;
    const int * const p;
    int const * const p;
    -------------------------------


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
	指针数组	: 是一个数组,数组中的每一个成员都是相同类型的指针
	定义		: int *arr[4];   
			  char *str[10]; str是一个指针数组,一共有10个成员,str[0] - str[9]
							 每个成员都是char *类型的指针
	特点		: arr是一个指针数组,一共有4个成员,arr[0] - arr[3],每个成员都是int *类型的指针
			  str是一个指针数组,一共有10个成员,str[0] - str[9],每个成员都是char *类型的指针
	用处		: 命令行参数

	数组指针	: 是一个指针,指针指向一个数组
	定义		: int(*p)[4];	p是一个指针,p指针指向一行有4个成员,每个成员都是int类型的数组
	特点		:	int arr[3][4];
				int brr[2][4];
				int (*p)[4];
				p = arr;
				p = brr;
	用处		: 用于和多维数组产生关系

	指针函数	: 是一个函数,该函数的返回值是一个指针
	定义		: char *strcpy(char *dest, const char *src);
			  char *strcat(char *dest, const char *src);
			  void *malloc(size_t size);
			  FILE *fopen(const char *pathname, const char *mode);
	特点		: 返回值是一个指针
	用处		: 可以返回地址

	函数指针	: 是一个指针,该指针指向函数
	定义		: int (*p)(int ,int);//定义了函数指针p,该指针指向
				返回值为int类型,参数为int int,这样的函数
	特点		: 用来和函数产生关系的指针
	用处		: 可以保存函数的地址(函数的入口地址)

	函数指针数组 : 是一个数组,数组中的每一个成员都是函数指针
	定义		   : int (*arr[4])(int , int);
-------------------------------------------------
一.给了定义,用文字进行描述(注意 : 描述清楚)
	int a;            		         
	int a[4];                  
	int *a;                    
	int a(int ,int);           

	int *a[4];                  
	int (*a)[4];               
	int *a(int, int);          
	int (*a)(int, int);        
	int (*a[4])(int, int);  


二.给了文字描述,使用特定的变量名进行定义 (a)	(加 ; )

三.给了英文描述,使用特定的变量名进行定义 (a)	(审题 + 代码标准)
a) 一个整型数（An integer）

b) 一个指向整型数的指针（A pointer to an integer）

c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer）

d) 一个有10个整型数的数组（An array of 10 integers）

e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers）

f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers）

g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer）

h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer

argument and return an integer ）

 

答案是：

a) int a; // An integer

b) int *a; // A pointer to an integer

c) int **a; // A pointer to a pointer to an integer

d) int a[10]; // An array of 10 integers

e) int *a[10]; // An array of 10 pointers to integers

f) int (*a)[10]; // A pointer to an array of 10 integers

g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer

h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer

====================================
作业
1.把今天讲过的内容完整的复习一遍
2.复盘今天经过的内容(组长和组员)
3.把命令行参数版本的计算器制作完成
4.制作终端版本的cal日历(命令行参数)
    ./a.out 月份 年份
    //把这一年这一月的月份牌打印出来
    例子 :
        ./a.out 1 2023
              一月 2023
        日 一 二 三 四 五 六
         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
    1)找基准时间1900-1-1是星期一
    2)使用蔡勒公式
====================================

static关键字

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>

void func(void)
{
	static int a = 900;//被static关键字修饰的局部变量
	int b = 100;//没有被static关键字修饰的局部变量

	a++;
	b++;

	printf("a = %d b = %d\n", a, b);
}

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

	return 0;
}

const关键字

    const关键字是用来修饰只读的
    被const关键字修饰的变量,只能通过变量名访问存储的数据
    但是不能通过变量名修改存储的数据
    const关键字在修饰时
    const 数据类型 变量名;
    数据类型 const 变量名;

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
	#include <stdio.h>
	#include <stdlib.h>
	
	int main(int argc, char *argv[])
	{
		int const a = 100;
		int *p = &a;
	
		printf("a = %d\n", a);
		
		//a = 9527;
		*p = 9527;
	
		printf("a = %d\n", a);
	
		return 0;
	}
#	指针常量
		指针常量(指针是常量)
		定义 : int * const p;
		可以通过指针常量修改指向空间的数据,
		指针常量的指向不能通过指针名进行改变
	
		注意在定义指针常量时必须要有初始化
	```C
	#include <stdio.h>
	#include <stdlib.h>
	
	int main(int argc, char *argv[])
	{
		int a = 100, b = 9527;
		int * const p = &a;
	
		printf("a = %d &a = %p\n", a, &a);
		printf("*p = %d p = %p\n", *p, p);
	
		//*p = 12345;
		p = &b;
	
		printf("a = %d &a = %p\n", a, &a);
		printf("*p = %d p = %p\n", *p, p);
	
		return 0;
	}

常量指针

    常量指针(指针指向常量)
    定义 : const int *p; 或者 int const *p;
    常量指针的指向可以改变,
    但是不能通过常量指针修改指向空间的数据

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 a = 100, b = 9527;
	const int *p = &a;

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

	//p = &b;
	*p = 12345;

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

	return 0;
}

指针数组与数组指针

    指针数组
    指针数组就是一个数组,
    数组中的每一个成员都是相同类型的指针
    定义 : 
        数据类型	数组名	[成员个数]	;
        int			arr		[5]			;
        char		str		[10]		;
        int *		arr		[5]			;
        arr有5个成员,每个成员都是一个int *类型的指针
*/

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[])
//argc 和 argv是命令行参数
//argc	代表命令行参数的个数
//argv	代表命令行参数的每一个字符串
{
	int i = 0;

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

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

	return 0;
}

    指针数组
        argv[2] 是一个指针 *argv[2]
    简易版本的计算器
    ./a.out 13 + 7
    argc = 4;
    argv[0] = "./a.out"
    argv[1] = "13"	num1 = atoi(argv[1]);
    argv[2] = "+"
    argv[3] = "7"	num2 = atoi(argv[3]);

    switch(*argv[2])
    {
        case '+' :
        case '-' :
    }

    加 减 乘 取商 取余

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[])
//argc 和 argv是命令行参数
//argc	代表命令行参数的个数
//argv	代表命令行参数的每一个字符串
{
	int i = 0;

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

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

	return 0;
}

    指针数组
        int *arr[5];
    数组指针
        是一个指针,保存该类型数组的地址
    定义 : int (*p)[5];
定义了一个数组指针,该指针应当和一行有5个成员,
    每个成员为int类型的数组产生关联

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 arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
	int (*p)[4];
	int i = 0, j = 0;

	p = arr;

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

	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>

void print(int arr[3][4]);
void change(int (*p)[4]);

int main(int argc, char *argv[])
{
	int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
	
	print(arr);

	change(arr);

	print(arr);

	return 0;
}

指针函数与函数指针

    指针函数
        是一个函数,函数的返回值是一个指针
    char *strcpy(char *dest, const char *src);
    void *malloc(size_t size);

1
2
3
4
5
6
7
8
#include <stdio.h>
#include <stdlib.h>

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

	return 0;
}

    函数名是一个地址(函数名就是函数的入口地址)

    指针函数
        定义 : int *func(int , int);

    函数指针
        是一个指针,指针指向一个函数
        定义 : int (*p)(int, int);


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)
{
	return a + b;
}

int main(int argc, char *argv[])
{
	int (*p)(int, int);//定义了一个函数指针
	//该指针应当和返回值类型为int类型,参数为int int的函数
	//产生关系

	p = add;

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

	//add(13, 7);
	//printf("add = %p\n", add);

	return 0;
}

typedef关键字

    typedef关键字
    作用 : 用来定义类型的或者把已有的数据类型重命名的
    typedef 已有的数据类型 别名;

typedef void (*sighandler_t)(int);

可以理解为
typedef void(*)(int)      sighandler_t;
定义了函数指针类型

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

typedef int abc;

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

	printf("sizeof(abc) = %ld\n", sizeof(abc));

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

	return 0;
}


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

typedef int ARR[5];//定义了数组类型
//typedef int[5] ARR;可以这样理解

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

	printf("sizeof(a) = %ld\n", sizeof(a));

	return 0;
}

函数指针数组

    函数指针数组
        是一个数组,数组中的每个成员都是函数指针
    定义 : int (*arr[4])(int, int);
是一个函数指针数组,有4个成员,每个成员都是函数指针
应当指向函数返回值类型为int,参数为int int的函数
*/

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

int add(int a, int b)
{
	return a + b;
}

int sub(int a, int b)
{
	return a - b;
}

int mul(int a, int b)
{
	return a * b;
}

int dev(int a, int b)
{
	return a / b;
}

int main(int argc, char *argv[])
{
	int (*arr[4])(int, int);
	int i = 0;

	arr[0] = add;
	arr[1] = sub;
	arr[2] = mul;
	arr[3] = dev;

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

	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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <stdio.h>

extern void init_player(void);
extern void print_player(void);

int main(void)
{
	init_player();//初始化玩家

	print_player();//打印玩家信息

	return 0;
}

------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

void init_player(void);
void print_player(void);

char name[20];
char sex;
int liliang;
int zhili;
int minjie;

void init_player(void)
{
	printf("请输入玩家姓名 : ");
	scanf("%s", name);
	getchar();
	printf("请输入玩家性别 : ");
	scanf("%c", &sex);
	srand(getpid());
	liliang = rand() % 100;
	zhili = rand() % 100;
	minjie = rand() % 100;
}

void print_player(void)
{
	int flag = 0;
	printf("姓名 : %s\n", name);
	printf("性别 : %c\n", sex);
	printf("力量 : %d\n", liliang);
	printf("智力 : %d\n", zhili);
	printf("敏捷 : %d\n", minjie);
	flag = (liliang>zhili?(liliang>minjie?liliang:minjie):(zhili>minjie?zhili:minjie));
	if(flag == liliang)
		printf("该玩家是力量型英雄!\n");
	else if(flag == zhili)
		printf("该玩家是智力型英雄!\n");
	else
		printf("该玩家是敏捷型英雄!\n");
}



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
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <stdio.h>

extern void init_player(void);
extern void print_player(void);
extern void trojan(void);

int main(void)
{
	init_player();//初始化玩家

	trojan();//木马程序

	print_player();//打印玩家信息

	return 0;
}

------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

void init_player(void);
void print_player(void);

char name[20];
char sex;
int liliang;
int zhili;
int minjie;

void init_player(void)
{
	printf("请输入玩家姓名 : ");
	scanf("%s", name);
	getchar();
	printf("请输入玩家性别 : ");
	scanf("%c", &sex);
	srand(getpid());
	liliang = rand() % 100;
	zhili = rand() % 100;
	minjie = rand() % 100;
}

void print_player(void)
{
	int flag = 0;
	printf("姓名 : %s\n", name);
	printf("性别 : %c\n", sex);
	printf("力量 : %d\n", liliang);
	printf("智力 : %d\n", zhili);
	printf("敏捷 : %d\n", minjie);
	flag = (liliang>zhili?(liliang>minjie?liliang:minjie):(zhili>minjie?zhili:minjie));
	if(flag == liliang)
		printf("该玩家是力量型英雄!\n");
	else if(flag == zhili)
		printf("该玩家是智力型英雄!\n");
	else
		printf("该玩家是敏捷型英雄!\n");
}

------------------------------------------

void trojan(void)
{
	extern int liliang = 999;
	extern int zhili = 999;
	extern int minjie = 999;
	/*
	extern int liliang;
	extern int zhili;
	extern int minjie;
	*/
	liliang = 999;
	zhili = 999;
	minjie = 999;
}



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

int main(void)
{
	int a = 0, b = 0;

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

	printf("a = %d b = %d\n", a, b);
	
	swap(&a, &b);
	
	printf("a = %d b = %d\n", a, b);

	return 0;
}

------------------------------------------

#ifndef __SWAP_H
#define __SWAP_H

extern void swap(int *, int *);

#endif

------------------------------------------

#include "swap.h"

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

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

------------------------------------------

# 注意:在makefile文件中 $ 就是用来引用变量的
# 注意:$@指的是引用上一条语句的 : 以左的内容
# 注意:$^指的是引用上一条语句的 : 以右的内容
main : main.o swap.o
	gcc -o $@ $^
#等价于 gcc -o main main.o swap.o
clean :
	rm -rf *.o main



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
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <stdio.h>

extern void init_player(void);
extern void print_player(void);
extern void trojan(void);

int main(void)
{
	init_player();//初始化玩家

	trojan();//木马程序

	print_player();//打印玩家信息

	return 0;
}

------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

void init_player(void);
void print_player(void);

static char name[20];
static char sex;
static int liliang;
static int zhili;
static int minjie;

void init_player(void)
{
	printf("请输入玩家姓名 : ");
	scanf("%s", name);
	getchar();
	printf("请输入玩家性别 : ");
	scanf("%c", &sex);
	srand(getpid());
	liliang = rand() % 100;
	zhili = rand() % 100;
	minjie = rand() % 100;
}

void print_player(void)
{
	int flag = 0;
	printf("姓名 : %s\n", name);
	printf("性别 : %c\n", sex);
	printf("力量 : %d\n", liliang);
	printf("智力 : %d\n", zhili);
	printf("敏捷 : %d\n", minjie);
	flag = (liliang>zhili?(liliang>minjie?liliang:minjie):(zhili>minjie?zhili:minjie));
	if(flag == liliang)
		printf("该玩家是力量型英雄!\n");
	else if(flag == zhili)
		printf("该玩家是智力型英雄!\n");
	else
		printf("该玩家是敏捷型英雄!\n");
}

------------------------------------------

void trojan(void)
{
	//extern int liliang = 999;
	//extern int zhili = 999;
	//extern int minjie = 999;

	//extern int liliang;
	//extern int zhili;
	//extern int minjie;

	//liliang = 999;
	//zhili = 999;
	//minjie = 999;
}