第一部分：復習
1、預處理階段主要進行了3個工作：宏定義、文件包含、條件編譯
2、宏定義：用宏值代替宏名。分為不帶參數宏定義和帶參數宏定義
3、宏定義語句：#define 宏名(參數列表) 字符串。
4、宏定義僅僅是簡單的替換，不進行語法正確性檢查
5、文件包含：將其他文件的內容全部包括進本文件中
6、文件包含語句：#include<文件> 或 #include"文件"。使用<>與""的區別在于：<>會去C庫函數中尋找，""會先尋找當前目錄，當前目錄下沒有的時候再取C庫函數中去尋找
7、#include一次只能包含一個文件。
8、條件編譯：利用某些條件指定哪段代碼或哪些文件參與編譯
9、條件編譯語句：
①#ifdef 標識符
程序段1
#else
程序段2
#endif
②#ifndef 標識符
程序段1
#else
程序段2
#endif
③#if 表達式
程序段1
#else
程序段2
#endif
10、格式化輸入輸出：printf();scanf();
11、寬度修飾符：%md、%m.nf
12、字符輸入輸出：putchar();getchar();


第二部分：一維數組
我們之前所學過的數據類型都屬于基本數據類型（整型、浮點型、字符型）。實際上C語言不僅僅可以操作基本數據類型，還可以操作構造數據類型（如結構體、數組等）。
數組是有序數據的結合，數組中的每個元素都屬于同一種數據類型。
每個數組都有一個數組名，數組名代表了數組的起始地址。
數組中的元素由下標（或索引）標識，下標是從0開始到n-1（數組長度為n）的整數。
示例：一個擁有10個元素的int型數組a
int a[10];
其元素是a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9]
數組同基本數據類型變量一樣，必須要先定義再使用
1、數組的定義：
數據類型 數組名[長度]
其中長度必須是整數必須大于0。以下的定義都是合法的
int a[10];
float f[10];
int b[2*3];
獲取數組元素：數組名[下標]。下標可以是變量、常量或常量表達式。
數組在定義后，就在內存中劃分了一塊空間用于存儲數組。以int a[n]為例（n大于0）：
內存中劃分出一塊空間用于存儲數組，這塊空間的大小是sizeof(int)*n，劃分成n塊來順序存儲a[0]~a[n-1]。數組名代表這塊空間的首地址（也就是a[0]的地址）
計算數組所占內存空間的大小：sizeof(a);//計算數組a占內存空間大小
思考：已知一個數組（如int a[n]），在只知道數組名，不知道數組元素個數的情況下，如何算出數組中元素個數（即求出n的值）？
答案：sizeof(a)/sizeof(a[0]);
2、數組的初始化：
1）數組初始化的一般形式：
類型 數組名[數組長度]={值1,值2……};
示例：int a[10]={0,1,2,3,4,5,6,7,8,9};
將花括號內的值一一對應賦值到數組各個元素中
2）如果只給數組一部分元素賦值，則剩下的會變成0
示例：int a[10]={1,2,3};
則a[3]及以后的值都是0
如果想使一個int型數組中元素全部為0可以這樣寫：
int a[10]={0};
3）對數組內全部元素賦值時，由于元素個數已經確定，因此可以不指定數組長度。
示例：int a[5]={1,2,3,4,5};<---等價--->int a[]={1,2,3,4,5};
如果采取第二種寫法，系統就會根據后面花括號內的個數來分配數組長度是5。但若數組長度與提供初值個數不同，則數組長度不可省略。
示例：定義一個數組，反序輸出
#include<stdio.h>
int main()
{
int i,a[]={0,1,2,3,4,5,6,7,8,9};//定義數組并初始化，系統分配數組長度是10
for(i=9;i>=0;i--)
{
printf("%d ",a[i]);//將數組反序輸出
}
printf("\n");
return 0;
}
練習1：使用數組存儲斐波那契數列前30項，并輸出
答案：
#include <stdio.h>
#define MAX 30
int main()
{
int i,fibonacci[MAX];
fibonacci[0]=1;
fibonacci[1]=1;
for(i=2;i<MAX;i++)
? ? {
? ? ? ? fibonacci[i]=fibonacci[i-1]+fibonacci[i-2];
? ? }
? ? for(i=0;i<MAX;i++)
? ? {
? ? ? ? printf("%d\t",fibonacci[i]);
? ? }
? ? printf("\n");
return 0;
}
練習2：從鍵盤輸入10個學生的成績，如果遇到大于100或者小于0的成績需要提示輸入錯誤重新輸入。之后計算10個學生的總成績和平均成績
答案：
#include <stdio.h>
#define MAX 10
int main()
{
int a[MAX];
int i,sum=0;
float avg=0;
for(i=0;i<MAX;i++)
? ? {
? ? ? ? printf("請輸入第%d個學生的成績：",i+1);
? ? ? ? scanf("%d",&a[i]);
? ? ? ? if(a[i]<0 || a[i]>100)
? ? ? ? {
? ? ? ? ? ? printf("輸入非法數據，請重新輸入！\n");
? ? ? ? ? ? i--;
? ? ? ? }
? ? }
? ? for(i=0;i<MAX;i++)
? ? {
? ? ? ? sum += a[i];
? ? }
? ? avg = (float)sum/MAX;
? ? printf("總成績是%d\n平均成績是%f\n",sum,avg);
return 0;
}
練習3（選做）：使用數組法解決約瑟夫環問題
約瑟夫入獄，監獄內共有33個犯人。某日33名犯人圍成一圈，從第一個犯人開始報數，報到數字7的犯人出列，被槍斃，下一名犯人重新從1開始報數。依次類推，直至剩下最后1名犯人可被赦免。聰明的約瑟夫在心里稍加計算，算出了最后槍斃的位置，他站在這個位置，最終避免了自己被槍斃，逃出升天。
問：約瑟夫算出的是哪個位置？
提示：對于約瑟夫環問題來說，需要解決4個問題
⒈需要一個長度為33的數組，數組內需要存儲什么？
⒉如何解決數組循環的問題？
⒊如何解決“逢7一殺”這個邏輯？
⒋如何處理“已死之人”？
答案：
#include<stdio.h>
int main()
{
int fanren[33]={0};//用0/1表示犯人是否存活，0表示存活，1表示死亡
int i,j,k=-1;
for(i=0;i<32;i++)//外層循環表示要槍斃32個犯人
? ? {
? ? ? ? for(j=0;j<7;j++)//內層循環表示每隔7個犯人
? ? ? ? {
? ? ? ? ? ? k++;//表示當前犯人下標
? ? ? ? ? ? if(k==33)//越界處理
? ? ? ? ? ? ? ? k=0;
? ? ? ? ? ? if(fanren[k]==1)//如果該犯人已死，則應在報數中-1
? ? ? ? ? ? ? ? j--;
? ? ? ? }
? ? ? ? fanren[k]=1;//找到第7個犯人
? ? ? ? printf("第%d號已被槍斃\n",k+1);
? ? }
? ? for(i=0;i<33;i++)
? ? {
? ? ? ? if(fanren[i]==0)//跳過所有已被槍斃的犯人
? ? ? ? ? ? printf("第%d號存活\n",i+1);
? ? }
return 0;
}
練習4（選做）：從鍵盤輸入10個各不相同的整數，存儲在數組中，使用冒泡排序法將數組排序并輸出
冒泡排序：是一種簡單的排序算法
1）比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2）對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。
3）針對所有的元素重復以上的步驟，除了最后一個。
4）持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
答案：
#include <stdio.h>
#define MAX 10
int main()
{
int a[MAX];
int i,j,tmp;
//輸入10個數
for(i=0;i<MAX;i++)
? ? {
? ? ? ? scanf("%d",&a[i]);
? ? }
? ? //輸入完畢
? ? //冒泡排序
? ? for(i=0;i<MAX-1;i++)//外層循環表示循環MAX-1次
? ? {
? ? ? ? for(j=0;j<MAX-i-1;j++)//內層循環表示操作當前的數組元素下標
? ? ? ? {
? ? ? ? ? ? if(a[j]>a[j+1])//如果比它后面的大就交換
? ? ? ? ? ? {
? ? ? ? ? ? ? ? tmp = a[j];
? ? ? ? ? ? ? ? a[j] = a[j+1];
? ? ? ? ? ? ? ? a[j+1] = tmp;
? ? ? ? ? ? }
? ? ? ? }
? ? }
? ? //冒泡排序end
? ? //打印輸出
? ? for(i=0;i<MAX;i++)
? ? {
? ? ? ? printf("%d ",a[i]);
? ? }
? ? printf("\n");
return 0;
}


第三部分：二維數組
C語言中不僅可以存儲一維數組，還可以存儲二維數組。二維數組類似矩陣，有行/列等
1、二維數組的定義：數據類型 數組名[常量表達式1][常量表達式2];
示例：
int a[2][3];//定義一個2*3的二維int型數組
float f[3][4];//定義一個3*4的二維float型數組
2、二維數組的存儲方式：
C語言對二維數組的存儲方式是：將二維數組視為一種特殊的一維數組，它的元素又是一個一維數組。例如，對于二維數組：
int a[3][4];
它的存儲方式是：
a[0]-------a[0][0] ?a[0][1] ?a[0][2] ?a[0][3]
a[1]-------a[1][0] ?a[1][1] ?a[1][2] ?a[1][3]
a[2]-------a[2][0] ?a[2][1] ?a[2][2] ?a[2][3]
在內存中的存儲順序是：
a[0][0]->a[0][1]->a[0][2]->……->a[2][3]
獲取數組元素：類似一維數組：數組名[下標1][下標2]
3、二維數組的初始化
1）分行給二維數組賦值。例如：
int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
每行的元素使用花括號分隔開，中間用逗號分隔開
2）把所有的元素都寫在一個花括號內，這樣會按照數組在內存中的存儲順序給二維數組賦值。例如：
int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};
類似于一維數組，如果有未寫的則默認為0
3）可以對二維數組的部分元素賦值：例如：
int a[3][4]={{1},{5},{9}};
則賦值結果是a[0][0]=1,a[1][0]=5,a[2][0]=9
int a[3][4]={{1},{0,6},{0,0,11}};
則賦值結果是a[0][0]=1,a[1][1]=6,a[2][2]=11
這種方法對非0元素較少時比較方便。
4）可以提供全部元素的初值，這樣常量表達式1（即第一個下標）可以缺省不寫，系統會根據輸入的多少來計算行數。但常量表達式2（即第二個下標）不可缺省。例如：
int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};
則系統自動計算出這個二維數組是a[3][4]
思考：如果int a[][4]={1,2,3,4,5,6,7,8,9,10};則該二維數組是多少？
答案：同樣是a[3][4]，只不過10以后的兩個元素未初始化，變成默認值0


注意：C語言對于數組下標越界不予檢查。因此對于數組的操作要十分注意其邊界值。如果指定了數組長度而初始化元素個數多余指定的數組元素個數，如：
int a[2][3]={1,2,3,4,5,6,7,8,9};
則會只取前n個數據進行初始化（n是指定長度，如這里n=6），后面的剩余數據舍棄。編譯期間編譯器會報warning。


練習1：自定義一個3*4的矩陣，輸出矩陣中值最大的元素，并輸出其數組下標
答案：
#include <stdio.h>
#define LINE 3
#define COL 4
int main()
{
int a[LINE][COL]={55,11,77,33,22,88,44,100,121,66,555,99};//自定義
int i,j,max,x=0,y=0;
max=a[x][y];
for(i=0;i<LINE;i++)
? ? {
? ? ? ? for(j=0;j<COL;j++)
? ? ? ? {
? ? ? ? ? ? if(a[i][j]>max)
? ? ? ? ? ? {
? ? ? ? ? ? ? ? x=i;
? ? ? ? ? ? ? ? y=j;
? ? ? ? ? ? ? ? max=a[i][j];
? ? ? ? ? ? }
? ? ? ? }
? ? }
? ? printf("最大元素是%d\n數組下標是%d和%d\n",max,x,y);
return 0;
}
練習2：打印楊輝三角型前10行
楊輝三角型：楊輝三角型是形如以下矩陣的三角形：
1
1 1
1 2 1
1 3 3 ?1
1 4 6 ?4 ?1
1 5 10 10 5 1
……
答案：
#include <stdio.h>
#define LINE 10
int main()
{
? ? int yanghui[LINE][LINE]={0};
? ? int i,j;
? ? //構造楊輝三角型
? ? for(i=0;i<LINE;i++)
? ? {
? ? ? ? for(j=0;j<=i;j++)
? ? ? ? {
? ? ? ? ? ? if(j==0)
? ? ? ? ? ? ? ? yanghui[i][j]=1;
? ? ? ? ? ? else if(i==j)
? ? ? ? ? ? ? ? yanghui[i][j]=1;
? ? ? ? ? ? else
? ? ? ? ? ? ? ? yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
? ? ? ? }
? ? }
? ? //構造楊輝三角型end
? ? //打印楊輝三角型
? ? for(i=0;i<LINE;i++)
? ? {
? ? ? ? for(j=0;j<LINE;j++)
? ? ? ? {
? ? ? ? ? ? if(yanghui[i][j]!=0)
? ? ? ? ? ? ? ? printf("%-4d",yanghui[i][j]);
? ? ? ? }
? ? ? ? printf("\n");
? ? }
? ? //打印楊輝三角型end
return 0;
}


4、使用數組的注意事項：
1）二維數組的第一個下標可以省略不寫，編譯器會根據我們初始化值的多少計算出數組的第一個下標。而第二個下標不可以省略不寫。例如：
int a[3][]={1,2,3,4,5};//非法
如果這樣寫，編譯器在分配內存的過程中不知道需要分配多大的空間（因為第二個下標未定），因此會報錯。
2）不能為數組整體賦值。如：
int a[10]=1;
int a[10];a={1,2,3,4,5,6,7,8,9,10};
以上2種都是錯誤的


第四部分：字符數組
1、字符數組的定義：
字符數組的定義方法與之前介紹的一維數組的類似。例如：
char c[10];
2、字符數組的初始化：
字符數組的初始化與之前介紹的一維數組的類似。例如：
char c[]={'I',' ','a','m',' ','a',' ','s','t','u','d','e','n','t'};
練習：輸入以下代碼，編譯，運行，查看結果。
#include<stdio.h>
int main()
{
char diamond[][5]={{' ',' ','*'},{' ','*',' ','*'},{'*',' ',' ',' ','*'},{' ','*',' ','*'},{' ',' ','*'}};
int i,j;
for(i=0;i<5;i++)
{
for(j=0;j<5;j++)
{
printf("%c",diamond[i][j]);
}
printf("\n");
}
return 0;
}
3、字符串
如果我們一個字符一個字符鍵入的話，不僅操作不便，而且還容易出現錯誤。因此對于字符型數組，我們可以使用字符串來操作。
字符串：由雙引號""引起來的字符序列。
字符串中每個字符都視為一個字符型數組的元素，存儲占1字節。
字符串的結束標志是'\0'
/*************************************關于'\0'************************************************************/
'\0'是轉義字符，在ASCII表中的編碼為0（NULL）。它不是一個可見的字符，而是一個空操作符，即什么都不做。用'\0'表示字符串結束標志不會產生其他的附加操作，只是提供一個標識。
/*************************************關于'\0'end*********************************************************/
思考：0、'0'、'\0'、"0"相同么？有什么區別？
答案：
⒈0代表數字0
⒉'0'代表字符零，在ASCII表中的編碼是48，是一個可見字符
⒊'\0'代表NULL，在ASCII表中的編碼是0，是一個不可見字符、空操作符，作為字符串的結束標志。
⒋"0"代表字符串"零"，這是一個字符串，實際上等價于'0''\0'（字符0后面加字符串結束標志'\0'）


使用字符串常量對字符數組進行初始化：
char c[]={"I am student"};
或者省略花括號直接寫成：
char c[]="I am student";
使用這種方式為字符數組賦值，訪問數組內元素的方法同一維數組
c[0]--->I
c[1]--->' '（空格）
……
如果使用字符串常量給字符數組賦值，則字符數組的最后一個元素不是't'而是'\0'
char c[]="China";<---等價--->char c[]={'C','h','i','n','a','\0'};//多出的'\0'是字符串結束標志
因此，字符串與字符數組有稍許差別，不完全等價。字符數組若不人為添加，末尾是不會出現'\0'的，而字符串末尾系統會自動添加'\0'表示字符串結束。
輸出字符串不必使用for()循環遍歷整個數組，直接使用%s格式控制符即可。
printf("%s",c);
示例：
int main()
{
char c[]="I am a Student.";
printf("%s\n",c);
return 0;
}
當然，我們也可以使用%s在scanf()函數中直接輸入一個字符串：
scanf("%s",c);
不過，使用%s輸入整個字符串需要注意以下2點：
⒈因為C語言不檢查數組下標越界問題，因此如果直接鍵入字符串給字符數組，需要將字符數組設置的足夠大，這樣才不會丟失數據。
⒉輸入字符串給字符數組，注意scanf()的第二個參數不要帶&（取地址符）。因為數組名就代表了數組的地址。
示例：
int main()
{
char c[64];//申請一塊足夠大的空間作為輸入的字符串的存儲空間
scanf("%s",c);
printf("%s\n",c);
return 0;
}


第五部分：字符串處理函數
C語言提供各種處理字符串的函數，可以簡便地處理字符串。
字符串處理函數在頭文件string.h中，使用時不要忘了包含頭文件
1、字符串輸入輸出函數：puts()和gets()
1）puts()函數
函數原型：
int puts(char *string);
使用方法：
puts(字符數組名 或 字符串指針);
說明：
puts()函數將一個字符串輸出到標準輸出流中，再輸出到屏幕上。注意puts()函數只能輸出字符串，不能進行其他操作
puts()函數等價于：printf("%s\n",string);
示例：
#include<stdio.h>
#include<string.h>
int main()
{
puts("Hello World!");
return 0;
}
2）gets()函數
函數原型：
char* gets(char *string);
使用方法：
gets(字符數組名);
說明：
gets()函數從標準輸入流中獲得一個字符串，直至接收換行符\n或EOF為止。將獲得的字符串儲存到字符數組內，讀取出的換行符轉換成'\0'
注意：
gets()函數不會檢查待存儲的字符數組的大小，若沒有接收到換行符或EOF則會無限制讀取下去。因此待存儲的字符數組一定要足夠大。
事實上gets()函數缺點很多，因此我們不推薦使用。推薦使用scanf()或fgets()函數。
gets()函數和puts()函數一次只能操作一個字符串，不能寫成
gets(str1,str2);
gets()和scanf("%s")的區別：當鍵入空格時，scanf("%s")認為該字符串已經結束，空格后的是下一個字符串內容。而gets()函數則會當空格做本字符串的一部分。


2、字符串連接函數：strcat()
函數原型：
char* strcat(char *s1,const char *s2);
使用方法：
strcat(字符數組1,字符數組2);
說明：
strcat是string catenate的縮寫，作用是把后一個字符串（字符數組2）拼接到前一個字符串（字符數組1）之后，結果存放在字符數組1中。
示例：
#include<stdio.h>
#include<string.h>
int main()
{
char str1[30]="Hello ";
char str2[]="World!";
strcat(str1,str2);
printf("%s\n",str1);
return 0;
}
注意：
1）字符數組1的空間需要足夠大以能夠存儲得下兩個字符串，否則數組長度不夠，編譯階段會報warning，并且不會輸出正確結果。
2）兩個字符串拼接時，字符數組1之后的'\0'會取消，只在拼接后的新的字符數組之后添加'\0'
練習：自定義2個字符數組，不使用系統提供的strcat()函數，實現strcat()函數功能。
答案：
#include<stdio.h>
int main()
{
char s1[30]="Hello ";
char s2[]="World!";
int i=0,j=0;
while(s1[i]!='\0')//尋找s1中'\0'的位置
? ? {
? ? ? ? i++;
? ? }
? ? while(s2[j]!='\0')//開始字符串拼接，直至s2出現'\0'（即字符串2結束）為止
? ? {
? ? ? ? s1[i]=s2[j];
? ? ? ? i++;
? ? ? ? j++;
? ? }
s1[i]='\0';//不要忘了添加字符串結束符'\0'
? ? printf("%s\n",s1);//輸出
return 0;
}


3、字符串復制函數：strcpy()和strncpy()
1）strcpy()函數
函數原型：
char* strcpy(char *str1,const char *str2);
使用方法：
strcpy(字符數組1,字符數組2或字符串2);
說明：
strcpy()是string copy的縮寫，表示“字符串復制函數”，將字符數組2或字符串2的內容復制給字符數組1。
示例：
#include<stdio.h>
#include<string.h>
int main()
{
char s1[10],s2[]="China";
strcpy(s1,s2);
printf("%s\n",s1);
return 0;
}
注意：
1）字符數組之間不能互相賦值。以下這種方式是非法的：
char s1[];
char s2[]="China";
s1=s2;
因此如果給字符數組間賦值，必須使用strcpy()函數。
2）字符數組1的空間必須足夠大以能夠容納字符數組2或字符串2的所有字符。這點與strcat()相同。
3）strcpy()的兩個參數，第一個參數必須是字符數組名，第二個參數可以是字符數組名或直接是一個字符串常量。例如：
strcpy(s1,"China");
4）如果字符數組2或字符串2比字符數組1短，則在復制操作后，字符數組1內沒被復制所覆蓋掉的內容將會保留
練習：自定義2個字符數組，不使用系統提供的strcpy()函數，實現strcpy()函數功能。
答案：
#include<stdio.h>
int main()
{
char s1[30];
char s2[]="Hello World!";
int i=0;
while(s2[i]!='\0')
? ? {
? ? ? ? s1[i]=s2[i];
? ? ? ? i++;
? ? }
? ? s1[i]='\0';//不要忘了添加字符串結束符'\0'
? ? printf("%s\n",s1);
return 0;
}


2）strncpy()函數
函數原型：
char* strncpy(char *s1,const char *s2,int n);//實際上第三個參數是size_t型
使用方法：
strncpy(字符數組1,字符數組2或字符串2,長度);
說明：
類似strcpy()函數，只不過是取出字符數組2或字符串2前n個字符復制到字符數組1中。
注意：n的值不能超過字符數組2或字符串2的總長度。


4、字符串比較函數：strcmp()
函數原型：
int strcmp(const char *s1,const char *s2);
使用方法：
strcmp(字符數組1或字符串1,字符數組2或字符串2);
說明：
字符串比較的規則是：將字符串1和字符串2的第一個字符拿出比較ASCII碼，如果字符串1大則返回一個正數，如果字符串2大則返回一個負數。如果相等則比較下一個字符。直至遇到不同字符或遇到字符串結尾'\0'。如果兩個字符串相同，則返回0。
示例：
#include<stdio.h>
#include<string.h>
int main()
{
char s1[]="Hello";
char s2[]="World";
if(strcmp(s1,s2)>0)
{
printf("s1字符串大\n");
}
else if(strcmp(s1,s2)<0)
{
printf("s2字符串大\n");
}
else
{
printf("兩個字符串相同\n");
}
return 0;
}
注意：
字符數組或字符串之間不能直接使用關系運算符來比較大小，以下的操作都是非法的：
str1<str2;str1==str2;str1>str2;
必須使用strcmp函數來比較字符串
練習：自定義2個字符數組，不使用系統提供的strcmp()函數，實現strcmp()函數功能
答案：
//注意：這里不是main()函數而是另一個自定義函數。有關函數的使用方法我們將在接下來的課程中學習
#include<stdio.h>
int my_strcmp(char *s1,char *s2)
{
? ? int i=0,j=0;
? ? while(s1[i]!='\0' && s2[j]!='\0')
? ? {
? ? ? ? if(s1[i]>s2[j])
? ? ? ? ? ? return 1;
? ? ? ? else if(s1[i]<s2[j])
? ? ? ? ? ? return -1;
? ? ? ? i++;
? ? ? ? j++;
? ? }
? ? if(s1[i]!='\0' && s2[j]=='\0')
? ? ? ? return 1;
? ? else if(s1[i]=='\0' && s2[j]!='\0')
? ? ? ? return -1;
? ? return 0;
}
int main()//主函數，程序入口
{
char s1[]="Hello";
char s2[]="World";
switch(my_strcmp(s1,s2))//在這里調用my_strcmp()函數
{
? ? case 1:
? ? ? ? printf("s1大\n");break;
? ? case 0:
? ? ? ? printf("一樣大\n");break;
? ? case -1:
? ? ? ? printf("s2大\n");break;
}
return 0;
}


5、測字符串長度函數：strlen()
函數原型：
int strlen(const char *s);//實際不是int類型而是size_t類型
使用方法：
strlen(字符數組 或 字符串);
說明：
strlen()函數是string length的縮寫，其功能是測試字符串的長度（不包括'\0'）
示例：
#include<stdio.h>
#include<string.h>
int main()
{
char s1[]="Hello World";
printf("長度是%d\n",strlen(s1));
return 0;
}
注意：
sizeof()與strlen()的區別：
sizeof()的長度是整個字符數組的總長度，其中包括'\0'；而strlen()不包括'\0'。例如：
char s1[]="Hello";
則sizeof(s1)=6，而strlen(s1)=5。
練習：自定義1個字符數組，不使用系統提供的strlen()函數，實現strlen()函數功能
答案：
#include<stdio.h>
int my_strlen(char *s1)
{
? ? int i;
? ? for(i=0;s1[i]!='\0';i++);
? ? return i;
}
int main()
{
? ? char s1[]="Hello World";
? ? printf("%d\n",my_strlen(s1));
? ? return 0;
}

總結

以上是生活随笔為你收集整理的数组、字符串及字符串相关函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。