函数

1. 函数的嵌套调用

• 头文件 func.h

#include//头文件放的是函数声明和常量

int printstar(int i);//函数声明
void print_message();
1
2
3
4

• 源文件 func.c

#include"func.h"

//printstar函数定义,函数定义就是函数实现
int printstar(int i)//i即为形式参数
{
    printf("******************\n");
    printf("printstar %d\n", i);
    return i + 3;//前面是有int
}

//print_message函数定义
void print_message()//可以调用printstar
{
    printf("how do you do\n");
    printstar(3);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 源文件main.c

#include"func.h"

int main()
{
    int a = 10;
    a = printstar(a);//函数调用，a是一个实参
    print_message();//调用print_message
    printstar(a);
    return 0;
}
1
2
3
4
5
6
7
8
9
10

结果

2. 全局变量

#include

int i = 10;//全局变量 （最好不要使用）,在函数外定义的变量是全局变量，i位于数据区
void print(int a)
{
    printf("print i = %d\n", i);
}

int main()
{
    printf("main i=%d\n", i);
    i = 5;//这里的i位于数据区
    //int i = 5;//当这里加了int后，就是在main定义了一个名为i的局部变量，此时i位于栈空间
    print(i);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 递归调用

#include

//递归:函数自己调用自己
int f(int n)
{
    if (n == 1)
    {
        return 1;//一定要写结束条件
    }
    return n * f(n - 1);//第一步是写好公式
}

int main()
{
    int n = 5;
    int result = f(n);
    printf("result = %d\n", result);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4. Day10 作业

#define _CRT_SECURE_NO_WARNINGS
#include

void change(int* p)//相当于p=&i,*&i相当于i
{
    *p = *p / 2;
}

int main()
{
    int i;
    scanf("%d", &i);
    change(&i);
    printf("%d\n", i);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5. Day11 作业

#define _CRT_SECURE_NO_WARNINGS
#include

int main()
{
    char* p;//p是一个指针，指向的空间有malloc(n)个字节
    int n;
    char c;
    scanf("%d", &n);
    p = malloc(n);
    scanf("%c", &c);//注意在scan和gets中间使用
    gets(p);//c用来消除\n,如果不通过上面的scanf消除\n,gets不会卡住
    //gets读取到\n就自动结束
    puts(p);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6. Day12 作业

#define _CRT_SECURE_NO_WARNINGS
#include

int step(int n)
{
    if (n == 1 || n == 2)//递归结束条件
    {
        return n;
    }
    return step(n - 1) + step(n - 2);//递归公式
}

int main()
{
    int n;//存储台阶
    scanf("%d", &n);
    printf("%d",step(n));
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

结构体

1. 结构体(难点)

• scanf(“%d%s %c%d%f%s”, &sarr[i].num, sarr[i].name, &sarr[i].sex, &sarr[i].age, &sarr[i].score, &sarr[i].addr)：%s和%c之间有空格,sarr[i].name整个是字符数组，不需要加取地址符&

#define _CRT_SECURE_NO_WARNINGS
#include
#include

//结构体所占空间是68个字节，因为存在对齐，对齐目的是提高CPU效率
struct student
{
    int num;
    char name[20];//字符串%s
    char sex;//字符%c
    int age;
    float score;
    char addr[30];
};//结构体类型声明，注意最后一定要加分号

int main()
{
    struct student s = { 1001,"lele",'m',20,98.5,"Shenzhen" };
    struct student sarr[3];
    int i;
    printf("%d %s %c %d %5.2f %s\n", s.num, s.name, s.sex, s.age, s.score, s.addr);
    for (i = 0; i < 3; i++)//%s和%c之间有空格,sarr[i].name整个是字符数组，不需要加取地址符&
    {
        scanf("%d%s %c%d%f%s", &sarr[i].num, sarr[i].name, &sarr[i].sex, &sarr[i].age, &sarr[i].score, &sarr[i].addr);
    }
    for (i = 0; i < 3; i++)
    {
        printf("%d %s %c %d %f %s\n", sarr[i].num, sarr[i].name, sarr[i].sex, sarr[i].age, sarr[i].score, sarr[i].addr);
    }
    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

2. 结构体指针(难点)

#define _CRT_SECURE_NO_WARNINGS
#include
#include

struct student
{
	int num;
	char name[20];
	char sex;
};

int main()
{
	struct student s = { 1001,"wangle",'M' };
	struct student* p;
	p = &s;
	printf("%d %s %c\n",(*p).num,(*p).name,(*p).sex );//.的优先级大于*
	printf("%d %s %c\n", p->num, p->name, p->sex);//指针成员选择
	//结构体数组初始化
	struct student sarr[3] = { 1001,"leili",'M',1005,"zhangsan",'M',1007,"lili",'F' };
	int num;
	p = sarr;//sarr本身存的就是结构体指针类型
	printf("-----------------------\n");
	num = p->num++;//num=p->num;p->num++
	printf("num = %d,p->num = %d\n", num, p->num);//1001,1002
	num = p++->num;//num=p->num;p++指向下一个结构体
	printf("num = %d,p->num = %d\n", num, p->num);//1002,1005
	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

3. typedef的使用(难点)

#define _CRT_SECURE_NO_WARNINGS
#include
#include

//结构体指针,typedef作用就是起别名
//给结构体类型起别名，叫stu,结构体指针类型的别名，叫pstu
typedef struct student
{
    int num;
    char name[20];
    char sex;
}stu, * pstu; //pstu等价于struct student*,即结构体指针

//为什么要对int起别名，为了代码即注释

typedef int INTEGER;
int main()
{
    stu s = { 1001,"wangle",'M' };
    pstu p;//stu* p也可以表示结构体指针
    INTEGER i = 10;
    p = &s;
    printf("i = %d,p->num = %d\n", i, p->num);
    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

4. C++引用(难点)

#define _CRT_SECURE_NO_WARNINGS
#include
#include//标准头文件

//把&写到形参的位置是C++语法，称为引用,此时操作b和在主函数里使用a是等价的
void modify_num(int& b)//里面对b的操作就是实际中对a的操作
{
    ++b;
}

void modify_pointer(int*& p1)//C++引用,p是指针类型，在子函数内操作p和在主函数操作p的手法一致
{
    p1 = (int*)malloc(20);//进行强制类型转换,申请空间
    p1[0] = 5;
}

int main()
{
    int a = 10;
    modify_num(a);
    printf("a = %d\n", a);
    int* p = NULL;
    modify_pointer(p);
    printf("p[0] = %d\n", p[0]);
    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