函式：“程式碼塊"

每一個具體功能，都可以寫成一個函式

C語言：以函式為主體

一、函式定義

1.語法格式:

//返回值型別 函式名（形參表）   //函式頭
{
    //函式體
    
}    

2.解釋：

返回值型別：反饋

函式名：合法識別符號（一般是動詞）

形參表：規定引數格式

函式體：程式碼

3.舉例

函式程式碼及呼叫

#include<stdio.h>
#include<iostream>
using namespace std;

int add(int a, int b);

void func1();

//函式的宣告
int main()
{
    int c=add(3,5);//作右值
    //返回了一個值，所以定義一個int c去接收這個值
    printf("c=%d\n",c);
    cout<<add(3,5)<<end;//直接列印
    
    func1();//獨立語句
    return 0;
}

int add(int a, int b)  //因為是計算兩個值的和
{						//所以肯定需要一個返回的答案
	//int c=a+b;		//也要int的型別
	//return c;			//和兩個引數值，你自己填
	return a + b;
}

void func1()
{
    printf("fun1 was been used \n");

    

 

型別：

1.有型別，無引數

2.有型別，有引數

3.無型別，有引數

4.無型別，無引數

函式宣告定義時小括號裡的叫形參

函式呼叫時小括號裡實際給的值，叫實參

二、函式宣告

//返回值型別 函式名（形參表）; //函式頭

三、函式呼叫

1.語法

//函式名（實參表）;

2.函式呼叫流程

1.從主函式進入被呼叫函式

主調函式：主函式

被呼叫函式：自己定義的

2.給形參分配臨時記憶體，將實參的值拷貝給形參==》定義，宣告階段，形參沒有記憶體

3.進入被調函式，執行函式體

4.系統自動回收臨時記憶體

5.回到主調函式，有返回值的，帶回返回值

3.用法

1.可以作為獨立語句

2.如果有返回值，可以作右值，給變數賦值

3.可以直接用於列印

4.有返回值的，可以做實參

5.可以作為判斷條件

#include<stdio.h>
#include<iostream>
using namespace std;

int add(int a, int b);

void func1();

//函式的宣告
int main()
{
    //作右值
    int c=add(3,5);//返回了一個值，所以定義一個int c去接收這個值
    printf("c=%d\n",c);
    
    //直接列印
    cout<<add(3,5)<<end;
    
    //獨立語句
    func1();
    //有返回值的，可以做實參
    cout<<add(1,add(3,5))<<endl;
    
    //可以作判斷條件
    if(add(3,4) > 6)
    {
		printf("add(3,4)>6\n");
    }
    return 0;
}

int add(int a, int b)  //因為是計算兩個值的和
{						//所以肯定需要一個返回的答案
	//int c=a+b;		//也要int的型別
	//return c;			//和兩個引數值，你自己填
	return a + b;
}

void func1()
{
    printf("fun1 was been used \n");

    

 

4.引數傳遞

1.值傳遞

只能改變形參的值，不能改變實參的值

//寫函式，交換兩個數的值
	//值傳遞
void exchange1(int a1, int b1)
{
	printf("交換前a1=%d b1=%d\n", a1, b1);
	a1 = a1 ^ b1;
	b1 = a1 ^ b1;
	a1 = a1 ^ b1;
	printf("交換後a1=%d b1=%d\n", a1, b1);
}
int main()
{
    int m=10,n=20;
    exchange1(m,n);
    printf("m=%d n=%d\n",m,n);
}

2.址傳遞

可以改變實參的值

//址傳遞
void exchange3(int* a2, int* b2)
{
	printf("交換前a1=%d b1=%d\n", *a2, *b2);
	*a2 = *a2 ^ *b2;
	*b2 = *a2 ^ *b2;
	*a2 = *a2 ^ *b2;
	printf("交換後a1=%d b1=%d\n", *a2, *b2);
}
int main()
{
    int m = 10, n = 20;
	printf("交換前m=%d n=%d\n", m, n);
	//exchange3(&m, &n); 或者
    int *pm=&m,*pn=&n;
    exchange3(pm,pn);
    //也可以交換m和n的值
	printf("交換後m=%d n=%d\n", m, n);
    return 0;
}

3.引用傳遞

可以改變實參的值

//引用傳遞
//因為用的是引用，所以a2就是m，b2就是n
void exchange2(int& a2, int& b2)
{
	printf("交換前a1=%d b1=%d\n", a2, b2);
	a2 = a2 ^ b2;
	b2 = a2 ^ b2;
	a2 = a2 ^ b2;
	printf("交換後a1=%d b1=%d\n", a2, b2);
}
int main()
{
    int m=10,n=20;
    exchange2(m,n);
    printf("m=%d n=%d\n");
}

四、檔案引用

include 系統檔案

include"xxx" 自定義檔案

box.h==>宣告函式

box.cpp==>實現函式

main.cpp==>呼叫函式

五、函式與指標

1.指標函式

返回值是指標的叫指標函式

注意：使用指標函式，不能指向返回棧區變數的指標

int* function()
{
	int mn = 10;  //a:棧區變數
	int* p = &mn; //p:指標，指向棧區變數
	return p;   //1.返回p   2.釋放a==>變成了野指標
}
int main()
{
	int* pa = function();
	printf("%d\n", *pa);
	printf("%d\n", *pa);
	return 0;
}

2.函式指標 函式本身有地址

指標本身的型別：指標指向的型別和*

指標指向的型別(函式本身的型別)：

typedef int(*pp)(int int);

void func1()
{
    printf("func1 is used\n");
}
//對於這個函式
//他的型別是 void ()

//指向的型別： void(*)()

int func2(inta , int b)
{
    printf("func2 is used\n");
    return 0;
}

int main()
{
    void (*p)()=&func1;//函式指標
    (*p)();
    //效果和 func1一樣
    
    //或者
    void (*p1)()=func1;
    p1();//效果一樣
    (*p1)();//效果一樣
    //可以取內容，也可以不取內容
    //型別符合的函式都可以指==》同樣的型別
    
    int(*pp)(int int)=func2;
    pp(1,2);
    //或者
    //（*pp)(1,2);
    
    pp pfunc=func2;
    //呼叫
    pfunc(1,2);
    return 0;
}

巨集定義===》完全替換

#define sum(n,m) n+m
int main()
{
    int x=sum(2,5)*sum(6,5);
    printf("%d",x);
    //答案是2+5*6+5=37
    return 0;
}