C语言 函数（做个笔记）

1，函数的基本情况

 类型 函数名(形参)             //函数首部

{

        函数体......

}

 2，函数的定义

<类型>函数名(形参)

（1） 形参之间用逗号分割，每个形参前面的类型必须写明

int fact(int a,int b)
{
     ......   
}

(2)可以接受0个或多个参数

3，调用函数

函数名(实参表)

（1）实参可以是常量、变量或表达式

（2）即使没有参数，()必须有

（3）调用其他函数的函数成为主函数，如main(),被调用的函数称为被调函数

（4）

#include <stdio.h>
double grade(int a,double b)
{
    .....
}

int main(){
    grade(num_1,num_2);   //grade(2,3.5); 
    return 0;
}

形参必须是变量，实参可以是常量、变量或表达式
形参和实参应一一对应，数量相同，类型一致。实参的值依次传递给形参

 4，函数的返回  return

（1）return 只能返回一个值

（2）函数执行过程中遇到return 停止执行，并返回一个值

（3）一个函数可以出现多个return 

用途：传给变量赋值、再传给函数、输出返回值

5，无返回函数  <void>函数名（）

（1) 不能使用带值的return 

（2）可以不使用return,       有返回值的函数，需使用带值的return 

(3)void不能省略，若省略。函数默认返回类型为int

6，函数的声明

函数类型 函数名 (参数表);    //以分号结束

int grade(int a,int b);

（1）获取参数类型，值返回类型，函数名

（2）参数名可以不用写。

int grade(int,int);

7,参数的传递

(1)类型转换

若形参与实参类型不同，编译器会帮忙转换。实参类型-->形参类型

#include <stdio.h>
void shuchu(int a);
int main(){
	shuchu(2.4);
	return 0;
} 

void shuchu(int a){
	printf("%d",a);
}

输出2

每个函数都有自己的变量空间，参数也位于这个独立空间内，和其他函数无关

 （2）本地变量

定义在函数内部的变量就是本地变量

1. 本地变量是定义在块内的。

• 它可以是定义在函数的块内
• 也可以定义在语句的块内
• 甚至可以随便拉一对大括号来定义变量

    2. 程序运行进入这个块之前，其中的变量不存在，离开这个块, 变量就消失了。

int main(){
	int a=2;
	int sum=0;
	{
		int b=40;
	}
	sum=b+a;
	return 0;
} 

[Error] 'b' was not declared in this scope





int main(){
	int a=2,c=0;
	int sum=0;
	if(c==0){
		int b=40;
	}
	sum=b+a;
	return 0;
} 

[Error] 'b' was not declared in this scope

3. 块外面定义的变量在里面仍然有效

int main(){
	int a=2;
	{
		int b=40;
		printf("%d",a);
	}
	return 0;
} 

输出2

4.  块里面定义了和外面同名的变量则掩盖了外面的。

int main(){
	int a=2;
	{
		int a=2000;
		int b=40;
		printf("%d",a);
	}
	return 0;
} 

输出2000

5. 不能在一个块内定义同名的变量

6. 本地变量不会被默认初始化

7. 参数在进入函数的时候被初始化了

因为实参给形参传递值了，这个值初始化参数了

8，其他

（1）函数不能嵌套定义

（2）逗号运算符 与 函数调用的括号区分

fact(a,b);  //认为是标点符号

fact((a,b));  //先算括号里面的（逗号运算符），再传参

（3）int i,j,sum(int a, int b);

定义了i,j变量。 sum函数  不建议这么写

（4）return (i);     

这个括号没什么意义 ，还容易使人误解调用return 函数

（5）int main()函数

return 0;

把0返回给调用它那个的代码.  之后上报给系统(windows),执行相应功能

若返回为非0 ，一般会出错

（6）不定型

#include <stdio.h>
void fact();            //不确定参数
int main(){
	int a=2;
	int b=6;
	fact(a,b);          //根据实参，编译器默认给你准备了两个int形参
	return 0;
} 

void fact(int a,int b)    //定义时，一样。符合。那就行了
{
	printf("a = %f\n",a);
	printf("b = %f",b);
}

这样写，有的编译器会报错的

9，全局变量

定义在函数外，而不属于任何函数的变量称为全局变量

默认赋值为0

定义全局指针，默认NULL

（1）改变全局变量

#include <stdio.h>
int x;           //定义全局变量
void fact(int num_1);
int main(){
	int a;
	x=0;  //初始化全局变量x,使他的值为0
	a=2;
	fact(a);
	printf("%d",x);
	return 0;
} 

void fact(int num_1)
{
	x=num_1;   //全局变量的值改变了
}

输出2

（2）若同名参数

int x;  //定义全局变量
int fact();
int main(){
	int a;
	int b,sum=0;
	x=1; //全局变量值为1
	a=2;
	b=fact();
	sum=a+b+x;
	printf("a=%d b=%d x=%d\n",a,b,x);
	printf("sum = %d",sum);
	return 0;
} 

int fact()
{
	int x=4;  //x为局部变量，在本函数中，全局变量x不起作用，所以x的值不变
	return x;   
}

输出     a=2 b=4 x=1
        sum = 7

(3) 全局变量尽量不要有联系

例如这样  

#include <stdio.h>
int a=12;
int b=a;
int main(){
    printf("%d",b);
    return 0;
}


非常不建议

10，静态局部变量

 （1）定义

static 类型名 变量表

 （2）只能作用于所定义的函数内

赋值，只在第一次调用起作用。若没有赋值，默认为0

//某个函数（求阶乘）
int fact(num_1)
{	static int product=1;   //定义局部变量为1，下次调用时，接上次的值（意思是下次调用时，值不再是1）
	product=product*num_1;  //上次的值，再乘以num_1
	return x;   
}

（3）静态局部变量就是特殊的全局变量

#include <stdio.h>
int a=12;
void f();
int main(){
    f();
    return 0;
}

void f(){
    int c=5;
    static int b=3;
    printf("a = %p\n",&a);
    printf("b = %p\n",&b);
    printf("c = %p\n",&c);
}


输出：
a = 0000000000403010
b = 0000000000403014
c = 000000000062FDEC

a,b地址位于相同内存区域
本地变量c位于另一个内存区域

静态局部变量是

全局生存期

本地作用域（函数内的局部作用域，只能在函数内部访问）

11，返回指针的函数

• 返回本地变量地址的函数很危险

#include <stdio.h>
int* f(int c);
int* g(int x);
int main(){
    int* p=f(5);
    printf("%d\n",*p);
    p=g(5);
    printf("%d",*p);
    return 0;
}

int* f(int c){
	int num=5;
    return &num;
}

int* g(int x){
	int num_1=12;
    return &num_1;
}



输出：
5
num_1= 6487516
12

f和g两个函数之间存在什么关系？为什么f里的i和g里的k的地址是一样的？

f函数调用完以后，占用的内存就释放了，这时候立马就调用g函数了，将f函数释放的内存又分配给g函数了，这样f里的i和g里的k的地址就是一样的了

12，题目

以下哪句不是正确的函数原型？     D

A.int f();

B.int f(int i);

C.int f(int);

D.int f() {}

A选项，没有写参数，则是不定型参数，是可以定义的

D选项，类比int main()函数。 要有返回值

对于不返回值而且只有一个int类型的参数的函数，以下哪些函数原型是正确的？  A,B,C

A.void f(int x);

B.void f();

C.void f(int);

D.void f(x);

B选项，不定型参数。编译器会根据函数调用时，你给的参数判断

D选项，没有参数的类型

int x = 5, y = 7;
void swap ( )
{
      int z ;

      z = x ;  x = y ;  y = z ;
}
int main(void)
{
      int x = 3, y = 8;
      swap ( ) ;
      printf ("%d,%d \n", x , y ) ;

      return 0 ;
}

输出：3,8

先调用swap()函数，因为没有传参数，所以使用的是全局变量，进行交换。之后退出函数，返回main()函数里，因为main()函数定义了x,y.所以又把全局变量给掩盖了，所以输出的是3,8