当前位置：网站首页>C語言函數

#include<stdio.h>
#include<string.h>
int main ()
{
    char arr1[]="abcdef";      //a b c d e f
    char arr2[20]={0};
    strpy(arr1,arr2};
    printf("%s\n",arr2);
    return 0;
}

memset（內存設置）
void * memset ( void * ptr, int value, size_t num );

#include<stdio.h>
#include<string.h>
int main()
{
  char  arr[]="Hello World";
  memset(arr+6,'x',3);

//.設置內存的時候是以字節為單比特,且每個字節的內容都是一樣value，從第六個字節後開始，後面三個為x


 printf("%s\n",arr);
return 0;
}

二.自定義函數

自定義函數也是像庫函數一樣由函數名，返回值類型和函數參數組成。

返回的類型函數名（函數的參數）
{
語句項；
}

如：寫一個兩者比較大小值的函數。

#include<stdio.h>
int get_max(int x,int y)           //int  是返回類型   get_max是函數名   int x,int y是參數
{
   
   return (x>y) ? (x) : (y);       //語句項
}
int main ()
{
   int a=10;
   int b=20;
   int max = get_max(a,b);
 printf("%d\n",max);
return 0;
}

交換整型變量的函數：

//錯誤的形式
#include <stdio.h>
//實現成函數，但是不能完成任務
void Swap1(int x, int y) {
 int tmp = 0;
 tmp = x;
 x = y;
 y = tmp; }
//正確的形式
#include<stdio.h>
void Swap2(int *px, int *py)   //形參
{
 int tmp = 0;
 tmp = *px;
 *px = *py;
 *py = tmp;
 }
int main()
{
 int a= 4;
 int b = 8;
 Swap1(a, b);      //傳值調用
 printf("交換前：a = %d b = %d\n", a, b);
//實參
 Swap2(&a, &b);    //傳址調用
 printf("交換後:a = %d  b = %d\n", a, b);
 return 0;
 }

當實參傳給形參的時候，形參是實參的一份臨時拷貝，對形參的修改不會影響實參。

swap1:在調用過程中，我們將a和b的數值傳給了x，y。然後在函數內將x，y進行數值交換，但沒有改變原來的a，b。因為x，y是形參，用完了就銷毀的東西，僅僅是用於臨時儲存原來的數值，所以根本不能改變a，b的值。

swap2:在調用過程中，傳的是地址，將地址傳給指針*px，*py。*px即a的地址，*py即b的地址，變量儲存在地址中，那麼就可以根據指針定比特到原來的變量。

swap1 和 Swap2 函數中的參數 x，y，px，py 都是形式參數。在main函數中傳給 swap1 的 a,b 和傳給 Swap2 函數的 &a ， &b 是實際參數。Swap1 函數在調用的時候， x ， y 擁有自己的空間，同時擁有了和實參一模一樣的內容。所以我們可以簡單的認為：形參實例化之後其實相當於實參的一份臨時拷貝。

函數的實參：

真實傳給函數的參數，叫實參。
實參可以是：常量、變量、錶達式、函數等。
無論實參是何種類型的量，在進行函數調用時，它們都必須有確定的值，以便把這些值傳送給形參。

函數的形參：

形式參數是指函數名後括號中的變量，因為形式參數只有在函數被調用的過程中才實例化（分配內存單元），所以叫形式參數。形式參數當函數調用完成之後就自動銷毀了。因此形式參數只在函數中有效。

傳值調用:

函數的形參和實參分別占有不同內存塊，對形參的修改不會影響實參。

傳址調用：

傳址調用是把函數外部創建變量的內存地址傳遞給函數參數的一種調用函數的方式。
這種傳參方式可以讓函數和函數外邊的變量建立起真正的聯系，也就是函數內部可以直接操
作函數外部的變量。

函數的嵌套調用：

函數可以嵌套調用，但是不能嵌套定義(在一個函數體內不能包含另一個函數的定義)

#include <stdio.h>
void new_line()
{
 printf("hehe\n");
}
void three_line()
{
    int i = 0;
 for(i=0; i<3; i++)
   {
        new_line();
   }
}
int main()
{
 three_line();
 return 0;
}

main函數中調用了three_line函數，three_line函數每次執行循環都會調用一次new_line函數，new_line函數的作用是打印hehe。所以這個程序的最終結果就是打印3個hehe。這就是嵌套調用。

鏈式訪問：

把一個函數的返回值作為另外一個函數的參數把一個函數的返回值作為另外一個函數的參數。

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
 int ret = strlen(strcat(arr));
 printf("%d\n", ret);
 return 0; 
}
//#include <stdio.h>
//#include <string.h>
//int main()
//{
//    char arr[20] = "hello";
// printf("%d\n", strlen(strcat(arr)));
// return 0; 
//}

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

那這個最後的結果？

先是printf最裏面的然後依次往外。

下面是printf的返回值：（可通過 https://cplusplus.com/ 查詢）

大概意思是返回打印字符的個數。so先打印43 ，結果為

printf("%d", printf("%d"，43))；

因為'43'是兩個字符，所以 printf("%d"，43) 的結果為2.之後：

printf("%d"，2)；

'2'是一個字符，所以打印為1.

最終的結果為4321

函數的聲明：

定義：
1.告訴編譯器有一個函數叫什麼，參數是什麼，返回類型是什麼。但是具體是不是存在，函數聲明决定不了。
2. 函數的聲明一般出現在函數的使用之前。要滿足先聲明後使用。
3. 函數的聲明一般要放在頭文件中的

函數的定義：

定義：函數的定義是指函數的具體實現，交待函數的功能實現。

#include<stdio.h>
//函數的聲明
int add(int x,int y);

int main()
{
  int a=10;
  int b=20;
  int sum=add(a,b);
  printf("%d\n",sum);
}
//函數的定義
int add(int x,int y)
{
  return (x+y);
}

遞歸

程序調用自身的編程技巧稱為遞歸（ recursion）。
遞歸做為一種算法在程序設計語言中廣泛應用。
一個過程或函數在其定義或說明中有直接或間接調用自身的一種方法，它通常把一個大型複雜的問題層層轉化為一個與原問題相似的規模較小的問題來求。
遞歸策略只需少量的程序就可描述出解題過程所需要的多次重複計算，大大地减少了程序的代碼量。
條件：
1.存在限制條件，當滿足這個限制條件的時候，遞歸便不再繼續。
2.每次遞歸調用之後越來越接近這個限制條件

例：接受一個整型值（無符號），按照順序打印它的每一比特。

#include <stdio.h>
void print(int n)
{
 if(n>9)
 {
 print(n/10);
 }
 printf("%d ", n%10);
}
int main()
{
 int num = 1234;
 print(num);
 return 0;
}

print函數可以把num的每一比特按順序打印出來。

首先num被賦值為1234，進入print函數裏。經過/10後為123

再次進入print函數後為12

接著print函數後為1

因為1%10為1，打印出1，然後返回上一個函數裏，print為12的函數裏，12%10為2，打印出2 ，依此打印出3和4

過程：print（1234）---print（123）4---print（12）3 4---print（1） 2 3 4---print 1 2 3 4

例：不允許創建臨時變量，用遞歸模擬strlen求字符串的長度。

#include <stdio.h>
int my_strlen(char* str)
{
	if (*str != '\0')
		return 1 + my_strlen(str+1);
}
int main()
{
	char arr [] = "abcdef";
	int len=my_strlen(arr);
	printf("%d\n",len);
	return 0;
}

求字符串的長度，遇到\0就停止，\0之前有幾個字符就是字符串的長度。

剛開始 str是a不等於\0，str+1就是b，一直繼續下去直到碰到 \0 ,終止代碼。

迭代：

迭代是重複反饋過程的活動，其目的通常是為了逼近所需目標或結果。每一次對過程的重複稱為一次“迭代”，而每一次迭代得到的結果會作為下一次迭代的初始值。重複執行一系列運算步驟，從前面的量依次求出後面的量的過程。此過程的每一次結果，都是由對前一次所得結果施行相同的運算步驟得到的。

例如求n的階乘：(前提是不考慮棧溢出）

#include<stdio.h>
int fac(int n)
{
	if (n < 2)
		return 1;
	else
		return n * fac(n - 1);
 }
int main()
{
	int n = 0;
	scanf_s("%d\n", &n);
	int ret = fac(n);
	printf("%d\n", ret);
	return 0;
}

例2：求第n個斐波那契數列（不考慮棧溢出）

#include <stdio.h>
int count = 0;
int fuc(int n)
{
    if (n == 3)
        count++;//記錄x==3調用了多少次
    if (n <= 2)
        return 1;
    else
        return fuc(n - 2) + fuc(n - 1);
}
int main()
{
    int n;
    printf("請輸入一個數");
    scanf("%d",&n);
    printf("斐波那契數列的第%d項的值為%d", n, fuc(n));
    printf("調用次數為%d", count);
    return 0;
}

因為不考慮棧溢出的情况，當輸入很大的值後，運算就很很麻煩，因為是在一直循環，可以把遞歸改成非遞歸的情况。

階乘改後的情况：

#include <stdio.h>
int fac(int n)
{
    int result = 1;
    while (n > 1)
    {
        result *= n;
        n -= 1;
    }
    return result;
}
int main()
{
    int n;
    printf("請輸入n=>");
    scanf("%d",&n);
    printf("%d的階乘為%d",n,fac(n));   
    return 0;
}

如n>1，就把n的值累乘到result裏面，然後n遞减，繼續累乘，循環下去，直到n<=1了，就返回結果。如果我們輸入5，result=1*5=5→result=5*4=20→20*3=60→60*2=120

斐波那契數列改後：

#include <stdio.h>
int fuc(int n)

{
    int a = 1,b = 1, c = 1;
    int i;
    while (n>2)
    {
            c = a + b;
            a = b;
            b = c;
            n--;
    }
        return c;
    }
int main()
{
    int n;
    printf("請輸入一個數");
    scanf("%d", &n);
    printf("斐波那契數列的第%d項的值為%ld", n, fuc(n));
    return 0;
}