函数基础总结:只能说多文件使用被搞哭啦

目录

一.函数概念

1.函数又叫子程序

2. 函数的好

3.函数分类

二.库函数的了解

1.认识库函数

2. 学习网站

3..如何自己学习库函数

总结1:

三.自定义函数(重点)

1.函数的语法形式

2 函数的举例

总结2

四.形参和实参

1.申明是实参和形参

补充:心得

2.实参和形参的关系

五.return语句

1.特点和注意事项 5

总结3

(1)函数的返回类型

(2)函数参数

六.数组作为函数参数

1.数组函数特点

2.直接上题学习数组

补充心得

总结4:数组传参的⼏个重点知识

七.嵌套调用和链式访问

1.嵌套调用

(1)练习

2.链式访问

(1)练习

八.函数的声明和定义

1.单个文件 ,用函数怎么写?

总结5

2.多个文件

总结6

九.static和extern

1.static 和 extern 都是C语⾔中的关键字。

2.作用域

总结7

3.生命周期

补充心得

总结8

十.使用方法

1.static修饰局部变量

(1) 分析:

总结9:stctic修饰局部变量

2.stctic修饰全局变量,要用到多个文件

总结10:static修饰全局变量

3.static修饰函数

总结11:static修饰函数



一.函数概念

1.函数又叫子程序

*C语言的程序其实是由无数个小的函数组合而成的;比如说:贪吃蛇由500行代码组成,这500行代码都是拆分成一个一个函数存在的,因为功能比较复杂,拆分一个一个功能。

(1) 一小段代码,不会特别长。

(2) 完成某项特定的任务。

所以一个大的计算任务可以分解成若干个较小的函数(对应较小的任务)完成。同时一个函数如果能完成某项特定任务的话,这个函数也是可以复用的,提升了开发软件效率.

2. 函数的好除

(1) 可以拆分任务
(2) 可以复用,提升开发效率//写好了一个函数可以复用它,它可以用,你也可以用。

3.函数分类

1.库函数是现成的,可以直接使用。
2.自定义函数是根据需要,自己创造的函数。

二.库函数的了解

1.认识库函数

(1) C语言规定了语法规则
(2) C语言本身不提供库函数
(3) 但是C语言规定了,一些库函数的各种信息;比如:
scanf - 名字 ,参数 ,返回类型,函数的功能...C语言自己不去实现,让C语言编译器的厂商根据规定来实现这些函数
printf - 
......

微软 - MSVC - 微软的团队就实现对应的库函数。
苹果 - clang - 苹果的团队就实现对应的库函数。

2. 学习网站

*库函数相关头⽂件:https ://zh.cppreference.com/w/c/header
库函数的学习和查看⼯具很多,⽐如:
C / C++官⽅的链接:https ://zh.cppreference.com/w/c/header
cplusplus.com:https ://legacy.cplusplus.com/reference/clibrary/

3..如何自己学习库函数

在网站对应下面格式看文档
(1)函数原型
(2)函数的功能介绍
(3)参数和返回类型说明
(4)代码列举
(5)代码输出
(6)相关知识链接/功能差不多一样的库函数

总结1:

1.库函数的实现细节可能有差异,但是程序员使用的时候,基本无感。

2.如果有些功能库函数是能够完成的,自己就不要尝试实现类似的功能,你写的功能可能有bug,而且程序执行的效率可能没库函数这么好。

3.库函数是在标准库中对应的头⽂件中声明的,所以库函数的使⽤,务必包含对应的头⽂件,不包含是可能会出现⼀些问题的。

4.库函数的学习不用着急一次性全部学会,慢慢学。

三.自定义函数(重点)

⾃定义函数其实更加重要,根据需求创建,也能给程序员写代码更多的创造性。库函数并不能完成所有任务,库函数把所有问题解决了还要程序员干什么。

1.函数的语法形式

//其实⾃定义函数和库函数是⼀样的,形式如下:
1ret_type fun_name(形式参数)
2{
3  //大括号里面的是函数体,描述的是函数完成任务的过程
4}
//这只是格式

 ret_type 是函数返回类型
• fun_name 是函数名
• 括号中放的是形式参数
•{}括起来的是函数体

2 函数的举例

举个例⼦:
写⼀个加法函数,完成2个整型变量的加法操作。完成2个整形的相加,要传进来2个整形类型值。

int Add(int x, int y)//我们自己创建的函数的叫函数定义
//x接收a,y接收b,a,b都是int类型也要用2个int类型接收
{
	int z = 0;
	z = x + y;
//	return x + y;这种写法直return直接把算出的结果返回。
	return z;把z的结果返回到sum里面去,返回z的类型是int类型,函数Add也要用int类型
}

int main()
{
	int a = 0;
	int b = 0;
	int sum = 0;//sum变量存的Add这个函数返回的结果
	scanf("%d %d", &a, &b);

	//求和这个功能分装成个函数
    int sam = Add(a, b);//这里是函数调用,调用或使用这个函数
	//Add这个函数想让2个数相加必须得传参。调用的时候传2个参数

	printf("%d\n", sum);
	return 0;
}
int Add(int x, int y)//我们自己创建的函数的叫函数定义
//x接收a,y接收b,a,b都是int类型也要用2个int类型接收
{
	
	return x + y;这种写法直return直接把算出的结果返回。
	
}

这种写法也能返回最终的值

总结2

1.函数名是自定义的,根据实际情况起名字。
2.参数的个数也算根据实际情况来确定,可以有0个参数,也可以有多个参数。
3.函数的返回值,函数可以返回值,也可以不返回,要根据实际情况来写。
4.函数不返回值的时候,返回类型写void

四.形参和实参

1.申明是实参和形参

在函数使用过程中,把函数的参数分为,实参和形参。
int Add(int x, int y) 形式参数,简称:形参
*如果只是定义了 Add 函数,⽽不去调⽤的话, Add 函数的参数 x和 y 只是形式上存在的,
不会向内存申请空间,不会真实存在的,所以叫形式参数。形式参数只有在函数被调⽤的过程中为了存放实参传递过来的值,才向内存申请空间,
//这个过程就是形式的实例化。
 


int Add(int x, int y)//形式参数,简称:形参

	                     //一整个函数叫 函数定义
	return  x + y;
	
}

int main()
{
	int a = 0;
	int b = 0;
	int sum = 0;
	scanf("%d %d", &a, &b);
	int sam = Add(a, b);//函数调用,a和b真实传给函数的参数,他们叫实际参数,简称:实参。
	                    //理解为函数调用时,传递给函数的参数就是实参
	printf("%d\n", sum);
	return 0;
}
补充:心得

要使用必须调用,不一定要先定义,因为可以在.h头文件定义,然后再在其它源文件.c,实现你定义的功能,我们使用调用一下就ok了。

2.实参和形参的关系

4.3实参和形参的关系
补充:
X86 表示32位环境 - 编译生成的32位的程序//这个更好观看内存地址
X64 表示64位环境 - 编译生成的64位的程序

形参和实参各⾃是独⽴的内存空间
当我们创建变量a的时候会向内存申请一块空间,放入值;当我们函数调用的时候,也会创建接x接收a传来的真实参数,这个过程叫实例化;
实参和形参不是同一块空间的,内存地址不一样,

(1) 当实参传给形参的时候,形参是实参的一份临时拷贝。
(2) 对于形参的修改,是不会改边实参的。

五.return语句

1.特点和注意事项 5

在函数的设计中,函数中经常会出现return语句,这⾥讲⼀下return语句使⽤的注意事项。

(1) return后边可以是⼀个数值,也可以是⼀个表达式,如果是表达式则先执⾏表达式,再返回表达式的结果。

int fufu(int a)
{
	if (a % 2 == 1)
	{
		return 1;//return 可以返回数值或表达式
	}
	else
	{
		return 0;
	}
}
int main()
{
	int a = 0;
	scanf("%d", &a);
	 int b  = fufu(a);
	 if (b == 1)
		 printf("奇数");
	 else
		 printf("偶数");
	return 0;
}

(2) return后边也可以什么都没有,直接写 return; 这种写法适合函数返回类型是void的情况

//写一个函数打印1-n的数字;这个代码写的时候思考全面要是输入-1咋办,代码不知道做什么了就蒙蔽了
void Add(int n)
{
	if (n < 1)
	{
		return;//只返回不带会任何值;函数提前返回,提前结束
		//这里不能用break,break是打破循环的,不能打破函数
	}
	int i = 0;
	for (i = 1; i <= n; i++)
	{
		printf("%d ", i);
	}
}
  
int main()//main函数用来表示代码没问题才返回0
{
	int m = 0;
	scanf("%d", &m);
	Add(m);
	return 0;
}

(3)return返回的值和函数返回类型不⼀致,系统会⾃动将返回的值隐式转换为函数的返回类型。

(3)
//函数前面是什么类型就返回什么类型
int fufu(int c)//函数这里是int类型,会把return返回的值强行转换成int类型。
{
	return c;//要是这里c = 3.5 函数fufu是int类型;会把小数去掉返回3
}

int main()
{
	int c = 0;
	scanf("%d", &c);

	//创建一个op变量,接收函数fufu返回来的值。
	int op = fufu(c);//函数调用
	printf("%d", c);
	return 0;
}

4 // return语句执⾏后,函数就彻底返回,后边的代码不再执⾏

(4)如果函数中存在if等分⽀的语句,则要保证每种情况下都有return返回,否则会出现编译错误。

(4)
int rest()
{
	int n = 0;
	scanf("%d", &n);
	if (n % 2 == 1)
	{
		return 1; //如果if为真就返回1;但是得考虑为假返回几。
	}
	else
		return 0;
}

int main()
{
	int a = rest();
	printf("%d\n", a);
	return 0;
}

总结3

(1)函数的返回类型

1.函数的返回类型可以是char,int,short,double……这些内置类型,也可以是自定义类型组,结构体,枚举,联合体。
2.函数的返回类型也可以是void ,void的意思就是函数不需要返回值,也不返回值。
3.函数需不需要返回值,是根据实际的情况设计的;不是别人告诉你要或不要。你希望有返回类型,那就设计。

(2)函数参数

1.函数的参数可以有0个,也可以有多个,这个根据实际需要来确定
2.参数的类型只要合法的类型,char,int,flaot,double……内置类型,也可以是自定义类型
3.函数的参数如果是0个,也就是不需要参数的时候,//函数的参数类型可以写成void,void在这里表示函数没有参数,也不需

1.举例:函数参数(3)

void test(void)//这里写void意思是明确告诉编译器我不许要参数,只要函数调用传参就报警告
{
	printf("hehe\n");
}

int main()
{
	test();//函数调用
	test(1);//函数调用
	test(100);//函数调用
	test(100,200);//函数调用
	//test函数没有形参接收,但是实参依然可以传参,只不过没有变量接收它,你调用的时候可以传参
	//但c语言这样写法不太合理,明明没有参数你还能给我传参,结果还对了,避免这种方式形参里面写void
	return 0;
}

2种情况
1.函数调用了4次所以打印hehe
2.形参里面是void,函数调用里面有参数会报警告

2.举例:函数的返回类型如果什么都不写,默认函数的返回类型是int

void test(void)//2.函数类型写void明确函数不需要返回,拿int a 接收返回值就报警高了
{
	printf("hehe\n");
}

int main()
{
	int a = test();
	printf("%d", a);//1.打印5,是随机打印的 
	return 0;
}

2种情况
1.函数需要返回类型,你没写默认函数返回int类型,接收它返回来的值,打印是5,明明打印的字符,为啥是5,因为随机的。
2.给函数类型类型写void,明确告诉编译器不需要返回类型,你创建变量去接收就会报警告。

 

六.数组作为函数参数

1.数组函数特点

(1) 实参和形参的名字可以相同
(2) 数组传参写的是数组名
//数组去掉名字,是这个数组的类型比如 int [], float [].
(3) 形参写的也是数组形式,并且在形参书写的时候可以省略元素个数//(指的一维数组)
(4) 数组传参后, 形参的数组和实参数组是同一块空间,改变形参的数组就是在修改实参数组(为什呢?)

2.直接上题学习数组

想把数组传给函数,就把数组作为函数参数
题目:写一个函数将一个和整形的内容,全部设置为 - 1,再写一个函数打印数组的内容。
(1) 通过题目知道自己要创建2个函数
(2) set_arr()用于将数组元素设置为-1
(3) print_arr()打印数组所有内容

void print_arr(int arr1[], int sz1)//设置这个函数的值,不用返回
{
	int a = 0;
	for (a = 0; a < sz1; a++)
	{
		printf("%d ", arr1[a]);
	}
	printf("\n");
	
}

void set_arr(int arr2[], int sz1)//设置这个函数的值,不用返回
{
	int a = 0;
	for (a = 0; a < sz1; a++)
	{
		arr2[a] = -1;
	}
}

int main()
{
	int arr1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int sz1 = sizeof(arr1) / sizeof(arr1[0]);//传给形参的元素个数

	print_arr(arr1, sz1);//改之前,打印一次,改之后打印一次;这就是函数复用
	set_arr(arr1, sz1);//数组传参写的是数组名,不是arr[10]这是数组第11个元素
	print_arr(arr1, sz1); //打印数组所有内容
	return 0;
}
补充心得

区分
arr[10]这是指大小
arr[10]函数调用里面这样写是指下标数组第11个元素
 

总结4:数组传参的⼏个重点知识

• 函数的形式参数要和函数的实参个数匹配
• 函数的实参是数组,形参也是可以写成数组形式的
• 形参如果是⼀维数组,数组⼤⼩可以省略不写,写了也是摆设
• 形参如果是⼆维数组,⾏可以省略,但是列不能省略
• 数组传参,形参是不会创建新的数组的//实参传给形参的数组,是同一个数组,地址没发生变化,不会创建新的数组;这里注意和其它内置类型传参的区别
• 形参操作的数组和实参的数组是同⼀个数组//函数改变形参的数组其实是改变实参的数组
根据上述的信息,我们就可以实现这两个函数:
 

七.嵌套调用和链式访问

1.嵌套调用

嵌套调⽤就是函数之间的互相调⽤,每个函数就⾏⼀个乐⾼零件,正是因为多个乐⾼的零件互相⽆缝
的配合才能搭建出精美的乐⾼玩具,也正是因为函数之间有效的互相调⽤,最后写出来了相对⼤型的程序

(1)练习

假设 : 我们计算某年某月有多少天?如果要函数实现,可以以设计2个函数//计算某2020年2月有多少天
 
 闰年的判断
 1.能被4整除,并且不能被100整除
 2.或能被400整除

 int is_leap_year(int x)
{
	 if (x % 4 == 0 && x % 100 != 0 || x % 400 == 0)
		 return 1;//如果为真返回1
	 else
	     return 0;//如果为假返回0
 }

int get_days_of_month(int x, int y)//接收类型是整形,所以函数是整形,要返回一个值
{
	int days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };//创建一个每个月天数的数组
	//              0   1   2   3   4   5   6   7   8   9  10  11
	//2.因为下标是0开始的,要用下标对应月,所以下标-1
	int day = days[y - 1];

	//因为2月是特殊的要判断是不是闰年 - 29天

	//3.在这个函数里面再嵌套一个函数,也相当于再创建一个函数去判断是不是闰年
	if(is_leap_year(x) && y == 2)//判断这个函数是不是真
	{
		day++;
	}
	return day;

}

int main()
{
	int year = 0;//年的变量
	int month = 0;//月的变量
	scanf("%d %d", &year, &month);//输入2020 2
	//1.自定义一个函数,计算某年某月有多少天,用个变量接收
	int d = get_days_of_month(year, month);
	printf("%d", d);

	return 0;
}

2.链式访问

将一个函数的返回值作为另外一个函数的参数,像链条一样将函数串起来就是函数的链式访问。

(1)练习

int main()
{
	printf("%d", printf("%d", printf("%d", 43)));//4321
	printf("%d ", printf("%d ", printf("%d ", 43)));//43 3 2
	return 0;
}

1.printf返回值是字符总个数,就是在屏幕上打印的几个字符
2.如果%d用空格隔开也会打印一个空白字符个数

*3.可以这样写把一个函数的返回值作为另外一个函数的参数,但不要列的太长了

八.函数的声明和定义

*这个玩意非常重要。

1.单个文件 ,用函数怎么写?

这里假如写个判断闰年的函数

函数声明 - 告诉编译器函数的名字,参数,返回类型
int is_leap_year(int x);只要在使用之前声明,函数声明只要告诉,函数名,参数,返回类型是什么加分号。
 

错误示范,应该要把函数定义写在主函数上面

int main()
{
	int year = 0;
	scanf("%d", &year);
	int c = is_leap_year(year);//函数调用
	if (c == 0)
	{
		printf("是闰年\n");
	}
	else
		printf("不是闰年\n");
	return 0;
}

//函数定义
int is_leap_year(int x);
{
	if (x % 4 == 0 && x % 100 != 0 || x % 400 == 0)
		return 1;//如果为真返回1
	else
		return 0;//如果为假返回0
}

总结5

//1.因为编译器编译代码的时候,会对代码进行扫描,扫码从第一行往后扫码的~
//2.它从前面扫码发现了函数定义,它认识了,然后他会往后扫描,看见这个地方要函数调用,它就知道这里要调用刚刚扫码的函数。
//3.如果你把函数定义放在后面,它扫描到这个地方要函数调用,它就会报警告,函数未定义,但是强行执行也可以
//4c语言中要求函数,先声明后使用
//5.只要在使用之前声明,函数声明只要告诉,函数名,参数,返回类型是什么加分号,也可以把函数定义放在后面。
//6.函数定义放在前面也没需要声明,函数定义 - 是一种特殊的声明,因为函数定义这玩意太比函数声明nb太多了,不仅仅告诉你有函数,怎么实现都告诉你。本身就是声明 定义。
//7.函数定义放在main函数后面使用,要先在前面声明。

2.多个文件

⼀般在企业中我们写代码时候,代码可能⽐较多,不会将所有的代码都放在⼀个⽂件中;我们往往会根据程序的功能,将代码拆分放在多个⽂件中。
⼀般情况下,函数的声明、类型的声明放在头⽂件(.h)中,函数的实现是放在源⽂件(.c)⽂件中。

总结6

1.这种才是企业是代码的方式。
2.把函数定义,实现的功能写在一个创建的源文件,把函数的声明,写在一个创建的头文件。
3.我门要使用这个函数功能的时候包含一下头文件,自己创建的头文件使用双引号,也相当于函数声明。

分模块写代码的好处:
1.逻辑清晰。
2.方便协助,假如10个程序员写代码,一个文件不够。
3.方便隐藏代码。一个模块有拆分.c和.h文件,是为了代码隐藏。只给你看.h文件不给你看.c文件你就不知道这个函数功能如何实现,只能使用。

可以把实现功能的.c源文件设置成静态库,我们使用的时候 导入静态库

九.static和extern

1.static 和 extern 都是C语⾔中的关键字。

static 是 静态的 的意思,可以⽤来:
1.修饰局部变量
2.修饰全局变量
3.修饰函数

extern 是⽤来声明外部符号的。

2.作用域

一个变量在哪里使用,哪里就是作用域,能够使用的区域,就是作用域。

int c = 100;//全局变量,想在哪里使用就在哪里使用,创建的函数都行。
void test()
{
	printf("c = %d", c);
}

int main()
{
	int a = 0;
	int  b = 20;//局部变量
	for (a = 0; a <= 10; a++)
	{
		int i = 10;//这个i的作用域就是创建这个大括号的局部范围,局部变量
		printf("i = %d", i);//只能在这里面使用

		printf("b = %d", b);//因为b这个变量在main函数里面的大括号,它包含了里面的大括号,可以在其它大括号  使用
	}
	printf("i = %d", i);//当把创建里面的变量拿出来用不行
	return 0;
}

1.局部变量的作用域是变量所在的范围
2.全局变量的作用域是整个工程(项目)

总结7

1.main函数创建的变量也是局部变量。
2.main函数创建的变量只是范围更大了一些,能在main函数创建大括号里面通用,不能拿出来用。
3.在大括号里面创建的变量是局部变量,在大括号外面创建的变量是全局变量。

3.生命周期

指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的一个时间段,中间这个时间段,就是生命周期。

分析:局部变量生命周期是什么?

int maain
{
	{
		int a = 10;   //-- 进作用域(进大括号) 创建,生命周期开始
		int b = a + 1;
		printf("%d\n", b); --结果是11
	}    	          //-- 出作用域(出大括号) 结束销毁,生命周期结束
		printf("%d\n", b); --强行一起运行,编译器会报错,未声明的标识符
	return 0;
}

这就是局部变量的生命周期:进入作用域变量创建,生命周期开始,出作用域结束。
 

分析:全局变量生命周期是什么?

int c = 20;
void test()
{
	printf("c = %d\n", c);//20,test函数能用
}
int c = 20;//如果把int c 放在这里使用,程序依次扫描程序会报错,说这里未声明
int main()
{
	test();
	printf("c = %d\n", c);//20,主函数能用
	return 0;
}

补充心得

1.只要程序还在运行这个全局变量都可以用,但是要合理的位置。
2.全局变量的生命周期是:是整个程序的生命周期。

总结8

1.不管使用全局变量和局部变量都要在合理的位置使用。
2.编译器依次扫描程序,有地方要声明的一定要先声明。

十.使用方法

1.static修饰局部变量

(1)
int a = 1;//这里加个全局全局变量,出函数之后不会销毁,2 3 4 5 6.
void test(void)  进入这个函数
{
	int a = 1;//创建一个变量 a;大括号里面的是局部变量,进函数创建,出函数销毁
	a++;     //a++之后就变2
	printf("%d \n", a);//打印  2 2 2 2 2
	//打印完之后,出函数就销毁了,循环5次,每次都这样。
}

分析循环5次,每次函数调用//看tset函数分析

int main()
{
	ing i = 0;
	for (i = 0; i < 5; i++)
	{
		test();
	}
	return 0;
}
(2)
void test(void) 
{
	static int a = 1;//static修饰局部变量
	a++;     
	printf("%d ", a);//2 3 4 5 6
}

int main()
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		test();
	}
	return 0;
}

1.当调用这个这个函数,进入函数的时候就创建变量,出函数之后不销毁了, 不会每次进函数就创建变量

(1) 分析:

内存分为3个核心区域

1.栈区:放 局部变量,形式参数,临时变量//栈区变量的特点:都是临时的,进入作用域创建,出作用域创建
2.堆区: 动态内存分配 malloc函数,calloc函数,realloc函数,free函数,这些函数申请空间都在堆区。特点手动申请,手动释放
3.静态区:放 全局变量,//静态变量 - 被static修饰的变量。放在静态区的变量,生命周期比较长和程序的生命周期一样

总结9:stctic修饰局部变量

1.本质上影响了变量的的存储类型。
2.一个局部变量是存在栈区的,但是被修饰后就存放在静态。
3.因为存储类型的变化,生命周期跟着变化,边长了。
4.创建时间也有变化://全局变量,静态变量在编译器就把地址分配好了,更早,局部变量进入局部范围(大括号)才创建地址。

作用域 不变:只是生命周期变长了,下次能够接着用。
什么时候用stctic:当这里有个局部变量,你不想让它销毁了,还想能接着用上次遗留的值,有累计的效果。

2.stctic修饰全局变量,要用到多个文件

extern int qa;//声明外部符号,就是声明welt.c文件的全局变量
int main()
{
	printf("%d", qa = );
	return 0;
}
#define   _CRT_SECURE_NO_WARNINGS 1
//定义一个全局变量

int qa = 100;

总结10:static修饰全局变量

1.首先要知道全局变量是具有外边链接属性的,就是在其它源文件想使用,extern声明一下就可以使用。
2.全局变量被static修饰后,外部链接属性,变成内部链接属性,就是这个全局变量,只能在自己所在的.c文件中使用,其它文件看不到,相当于作用域变小了。
3.全局变量被修饰后变成了静态变量。

什么时候用stctic:你不想其它源文件使用,不想让别人看见 + stctic就可以。

3.static修饰函数

跟stctic全局变量几乎一模一样

extern int Add(int x, int y);//函数这里默认本身自带extern,这里也可以不写extern

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int v = Add(a, b);
	printf("%d\n", v);
	return 0;
}
#define   _CRT_SECURE_NO_WARNINGS 1
static int Add(int x, int y)
{
	return x + y;
}

1.理论上不能直接,不申明直接使用,但强行运行还是会出结果。
2.但还是得用extern申明一下这个函数。

3.如果用static去修饰定义Add函数,会报1个无法解析的外部命令的错误。就算声明了也不能再使用

总结11:static修饰函数

1.函数也是有具有外部链接属性,定义的函数在其它源文件里边,只要有合适的声明就能调用
2.但是被static修饰后,外部链接属性就变成了内部链接属性,只能在自己这个源文件使用,不能在其它源文件使用,即使声明了也不能使用。

什么时候用stctic:你写了个函数,你就想一个人使用,不想其它源文件使用。

总结6:
1.extern :当一个符号不管是函数,还是全局变量,只要来自其它源文件,你要在这个源文件使用你就要用extern。
2.要区分static修饰全局变量和局部变量的特点。

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值