C語言指針

時間 2021-08-12

標籤數組 ide 函數工具測試操作系統 3d 指針調試 orm 欄目 OS基礎简体版

原文原文鏈接

(一) 指針知識先導

1. 內存空間與內存地址

int num=100;
計算機中數據都是存儲在內存中，所以讀寫數據的本質實際上是讀寫內存，而目前讀寫內存的惟一方式就是經過變量名，這種方式被稱爲「直接訪問」內存。數組

在計算機中，內存空間的最小單位爲字節，操做系統會爲每個字節內存空間編號，而且這個編號在當前程序中是惟一的。ide

假設圖是賓館中的一排房間，每一個房間中都住着一個球員，例如：101 號房間住着 7號球員、105 號房間住着 2 號球員、113 號房間住着 1 號球員。函數

若是想要在這排房間中找到 2 號球員，只需知道他住 105 號房間便可。101 房號至關於內存地址、101 房間至關於內存空間、7 號球員至關於內存空間中的數據。工具

前面講過，要想找到 7 號球員，必須經過房間號來查找。同理，在計算機中，要想讀寫內存空間中的數據，也能夠先經過內存地址找到該內存空間，而後進行讀寫操做。測試

讀寫內存的 2 種方式：
第 1 種經過變量名讀寫內存。
變量本質上是一塊有名字的內存空間，經過變量名讀寫內存，如圖所示：操作系統

第 2 種經過內存地址讀寫內存。
在計算機內存中，每個字節內存空間都有一個編號，這個編號被稱爲內存地址。經過該地址能夠讀寫對應的內存空間，如圖所示：3d

2. 探索內存

在上一節中，討論了內存空間與內存地址的關係，爲了更加深刻了解這 2 者之間的關係，將使用 VS2012 自帶的工具，來更加形象的分析。指針

測試代碼以下：調試

#includeint main(void)
{
    int num=999;
    printf("%p\n",&num); //輸出變量 num 地址
    getchar();
    return 0;
}

【注意】
第 5 行代碼中，&（shift+7）是 C 語言中的取地址符。&num 表示計算變量 num 所對應內存空間的地址編號，也就是所謂的內存地址。%p 表示以 16 進制格式輸出內存地址。
編寫完上述程序後，下面就來經過工具一步步探索內存空間。
第 1 步測試程序第 6 行，鼠標單擊加斷點：
第 2 步運行程序，控制檯會輸出 16 進制的地址數據（每次運行可能都不同），
如圖所示：orm

第 3 步依次點擊菜單【調試】->【窗口】->【內存】->【內存 1】，打開內存窗口，如圖所示：

第 4 步將控制檯輸出的數據，輸入到【內存 1】窗口的【地址】欄中，而後按下回車鍵，如圖所示：

第 5 步在【內存 1】窗體內右鍵點擊，而後選擇【4 字節整數(4)】、【帶符號顯示】如圖所示：

【說明】
由於 num 是 int 類型，32 位系統下佔 4 字節，因此第 5 步選【4 字節整數】，其餘類型數據依次類推。

第 6 步查看【內存 1】窗口，能夠看到整數+999，其實就是 999 只是顯示了符號位+而已，如圖所示：

分析：
一、以上整個過程，首先第 4 行，經過變量名 num 將整數 999 寫入內存空間中。
二、第 5 行，使用&num 計算出變量 num 對應的內存空間地址 0019FE50。
三、經過斷點調試的方式，查看 0019FE50 地址空間中保存的數據 999。
四、通過以上分析，變量 num 完整內存模型如圖所示：

五、能夠看到，訪問一塊內存空間能夠經過變量名，也能夠內存地址。
【調試技巧】
爲了方便使用【內存 1】查看內存，建議將【列】選項設置爲【自動】，如圖所示：

3. 指針變量

前面介紹過，變量的本質是一塊有名字的內存空間。其實這塊內存空間不只有名字，並且有編號，在 32 位系統下，這個編號是一個 4 字節的整數。經過(&變量名)的方式能夠獲得這個整數，例如：
int num=10;
printf(「%p\n」,&num); //以 16 進制格式輸出
這個編號與一塊內存空間是一一對應的，經過這個編號能夠找到對應內存空間。相似於現實生活中，知道某我的的家庭地址，就能夠經過地址找他家同樣。在 C 語言程序中將這個編號形象的稱呼爲「內存地址」，經過內存地址就能夠找到對應的內存空間。

現階段目前，在程序中獲得內存地址的惟一方式就是：&變量名。因爲這種方式獲得的內存地址就是變量所對應的內存空間地址，又是經過變量名獲得的，所以能夠稱爲「變量地址」。這裏務必清楚，變量地址本質上就是內存地址。

用於保存內存地址的變量，稱爲指針變量。在 C 語言程序中不只變量有類型，數據也是有類型的，例如：1(整數)、3.14(浮點數)、’c’(字符)，須要使用與之匹配的類型變量進行保存。同理，內存地址也是一種數據，這種數據都是指針類型，所以須要指針類型變量來保存這種數據。

4. 指針變量定義與初始化

定義指針變量的通常形式爲：
類型名 *變量名;
類型名錶示該指針變量只能保存該類型變量的地址，*表示該變量是指針變量只能保存地址數據，變量名即該變量的名稱。
例如：int *p_a;
int 表示該指針變量只能保存 int 類型變量的地址，*表示變量 p_a 是指針變量只能保存地址數據，p_a 即指針變量的名稱。

指針變量和普通變量初始化方式相同，能夠在變量定義時初始化，也能夠先定義後初始化。例如：

int a=10;
int* p_a=&a; //定義 int 指針變量 p_a，並將變量 a 地址賦值給 p_a
或者
int a=10;
int*p_a; //先定義 int 指針變量 p_a
p_a=&a; //而後將變量 a 地址賦值給變量 p_a

在 C 語言程序中，將某個變量的地址賦值給指針變量，就認爲該指針變量指向了某個變量，例如：

int a=10;
int*p_a=&a;

上述程序中，將整數變量 a 的地址賦值給指針變量 p_a，就認爲 p_a 指向了變量 a，如圖所示：

能夠看到，變量 a 中存儲的是整數 10，而變量 p_a 中存儲的是變量 a 的地址。有點像現實生活中的中介，想要訪問數據 10，必須先找到指針變量 p_a，經過變量 p_a 中的數據&a，再找到變量 a，最後訪問數據 10。

5. 引用指針變量

指針變量的引用分 2 種狀況：
第 1 種引用指針變量。

#includeint main(void)
{
    int a=10;
    int b=20;
    int *p1,*p2; //定義指針變量 p一、p2
    p1=&a; //p1 指向變量 a
    p2=p1; //p2 指向變量 a。p2 指向 p1 當前指向的變量
    printf("&a=%p p1=%p p2=%p\n",&a,p1,p2);
    p1=&b; //p1 指向變量 b
    p2=p1; //p2 指向變量 b
    printf("&b=%p p1=%p p2=%p\n",&b,p1,p2);
    getchar();
    return 0;
}

運行結果如圖所示（每次運行結果可能都不同）：

第 2 種引用指針變量指向的變量。

#includeint main(void)
{ 
    int a=10;
    int* p=&a; //p 指向變量 a
    printf("a=%d *p=%d\n",a,*p);
    *p=20; //修改 p 指向變量 a 中的數據
    printf("a=%d *p=%d\n",a,*p);
    getchar();
    return 0;
}

運行結果如圖所示：

【易混】在定義變量的時候，*放到變量前，表名變量是指針類型；在使用變量的時候用來讀寫指針變量指向的值。
速記：

&取變量地址；
*定義時表示是指針變量；*使用時表示讀寫指針變量的值。

6. 指針變量作函數參數

在 C 語言中，函數參數不只能夠是字符型、整型、浮點型……等，還能夠是指針類型，做用是將變量地址傳遞給函數形參。
主要目的就是：函數內部修改外部變量的值。
下面經過兩個例子來講明指針變量作函數參數的用法。

案例 1，函數內部改變外部變量的值

void test1(int* p)
{
    printf("函數內讀取指針指向的值：%d\n",*p);
    *p=*p+1;
}
int main(void)
{
    int num=999;
    test1(&num);
    printf("函數外讀取變量的值：%d\n",num);
    getchar();
    return 0;
}

案例 2：封裝函數，交換兩個整型變量的值。

#includevoid swap(int* p_a,int* p_b)
{
    int temp=*p_a;
    *p_a=*p_b;
    *p_b=temp;
}
int main(void)
{
    int a=10;
    int b=20;
    swap(&a,&b);
    printf("交換後 a=%d b=%d\n",a,b);
    getchar();
    return 0;
}

7. scanf 獲取輸入數據函數

scanf 函數原型:
int scanf(const char * _Format, ...)
頭文件：
#include參數列表：
_Format ：格式控制字符串，與 printf 函數中格式控制做用相同。
… ：地址列表，由若干個地址組成。
功能：
獲取用戶按鍵輸入的數據，並以指定格式寫入到變量、或數組中。

#includeint main(void)
{
    int a;
    scanf("%d",&a); //從鍵盤輸入一個整數，寫入變量 a 中
    printf("%d",a); //輸出變量 a 的值
    getchar(); //接收使用 scanf 時按下的回車鍵
    getchar(); //程序暫停，等待用戶輸入
    return 0;
}
int main(void)
{
    int i,j;
    printf("請輸入第一個數：\n");
    scanf("%d",&i);
    printf("請輸入第二個數：\n");
    scanf("%d",&j);
    printf("%d\n",i+j);
    getchar();
    getchar();
    return 0;
}

scanf 還能夠接收多個輸入數據，例如：

#includeint main(void)
{
    int a,b;
    scanf("%d %d",&a,&b); //獲取輸入數據，寫入到變量 a、b
    printf("a=%d\n",a); //輸出變量 a
    printf("b=%d",b); //輸出變量 b
    getchar();
    getchar();
    return 0;
}

輸入：1 2 (1 和 2 之間以空格隔開)，而後按下回車鍵，運行結果如圖所示：

scanf 中數據類型必定不能用錯，float 類型必須使用%f、double 類型必須用%lf、int 類型必須使用%d，若是使用錯了就會發現結果很奇怪。

使用 scanf 須要注意的問題
(1)scanf 函數中應該傳入變量地址，而不是變量名，例如：
int a,b;
scanf(「%d %d」,a,b);
這種寫法是錯誤的，應該將「a,b」修改成「&a,&b」。

(2)從鍵盤獲取多個數據時，相鄰數據之間可使用空格、回車、tab 鍵做爲兩個數據之間的分隔符。例如：
int a,b;
scanf(「%d %d」,&a,&b);
第 1 種輸入方式：
1 2 //1 和 2 之間以空格分隔
第 2 種輸入方式：
1 2 //1 和 2 之間以 tab 鍵分隔
第 3 種輸入方式：
1
2 //1 和 2 之間以回車分隔

(3)*若是在 scanf 函數中的格式控制字符串中除了佔位符以外，還有其餘字符，則在輸入時也必須在對應的位置上輸入相同的字符。例如：
int a,b,c;
scanf(「%d,%d,%d」,&a,&b,&c); //注意 scanf 中%d 之間以「,」分隔
輸入:
1,2,3 (輸入數據時，也必須以「,」分隔)

(4)使用 scanf 獲取字符串時，只需傳入字符數組名便可，取地址符&能夠省略不寫。例如：
char c[10];
scanf(「%s」,c); //能夠省去&
輸入：
hello
注意使用%s 的時候，字符串中不要有空格，不然行爲很怪異。
scanf 有不少怪異的行爲和坑，可是深刻的東西研究價值不大，所以只要會常規的用法便可。

(二) 數組與指針

數組本質上是一片連續的內存空間，每一個數組元素都對應一塊獨立的內存空間，它們都有相應的地址。所以，指針變量既然能夠指向變量，也就能夠指向數組元素。

1.數組元素地址初識

1、數組元素地址

在 C 語言中數組能夠看做是相同類型變量的集合。通俗點講，數組中每一個元素類型都是相同的。例如：
char ch[10] //數組 ch 能夠看做是由 10 個 char 變量組成
int a[10] //數組 a 能夠看做是由 10 個 int 變量組成
float f[10] //數組 f 能夠看做是由 10 個 float 變量組成

數組本質上是一片連續的內存空間，數組元素又能夠看做是單獨的內存空間，數組就好像是一排房間，數組元素是單獨的一個房間。所以，每一個數組元素也都有本身的內存空間地址，簡稱數組元素地址。

可使用指針變量來保存數組元素地址，例如：
int a[5]={1,2,3,4,5}; //定義長度爲 5 的 int 數組
int* p_a; //定義指向 int 變量的指針變量 p_a
p_a=&a[0] //把 a 數組第 0 個元素地址賦給指針變量 p_a。至關於&(a[0])
p_a 中保存了數組 a 第 0 個元素地址，能夠認爲指針變量 p_a 指向數組 a 第 0 個元素，
如圖所示：

2、引用指向數組元素的指針變量

由於數組元素本質上能夠看做是單獨的變量，因此引用指向數組元素的指針變量與引用指向變量的指針變量方式相同，直接使用*指針變量名便可。

#includeint main(void)
{
    int i[5]={1,2,3,4,5};
    int*p_i;
    p_i=&i[0];
    printf("i[0]=%d *p_i=%d\n",i[0],*p_i);
    p_i=&i[1];
    printf("i[1]=%d *p_i=%d\n",i[1],*p_i);
    getchar();
    return 0;
}

和訪問變量方式相似，能夠將經過數組名訪問元素方式稱爲「直接訪問」，將經過數組元素地址訪問元素方式稱爲「間接訪問」。

2.數組元素地址深刻分析

在計算機中內存的最小單位是字節，每一個字節都對應一個地址。若是一個變量佔用多個字節，就會佔用多個內存地址。例如：char 類型變量佔 1 字節就對應 1 個地址、short 類型變量佔 2 字節對應 2 個地址、int 類型變量佔 4 字節對應 4 個地址…..其餘類型依次類推。同理，數組元素類型不一樣佔用的內存地址也不一樣。

#includeint main(void)
{
    char c[5];
    short s[5];
    int i;
    for (i=0;i<5;i++)
    {
        printf("&c[%d]=%p ", i , &c[i]);
        printf("&s[%d]=%p \n", i ,&s[i]);
    }
    getchar();
    return 0;
}

運行結果如圖所示：

3.數組名與數組首元素地址

在 C 語言中，數組名與數組首元素地址等價。

#includeint main(void)
{
    int num[5];
    printf("%p\n",num); //輸出數組名
    printf("%p\n",&num[0]); //輸出數組首元素地址
    getchar();
    return 0;
}

運行結果如圖所示：

4.指針加、減運算

指針本質上就是內存地址，在 32 位操做系統下，內存地址只是 4 字節的整數。既然是整數，就能夠進行加、減、乘、除…..等算術運算。不過須要注意，在 C 語言中通常只討論指針加、減運算，乘、除等其餘算術運算是沒有意義。

在實際開發中，指針加、減多用於數組（或者連續內存空間）。當指針變量 p 指向數組元素時，p+1 表示指向下一個數組元素，p-1 表示指向上一個數組元素。注意加減運算都不是「移動一個字節」，而是移動一個「單元」，對於 int 來說一個單元是 4 個字節。

#includeint main(void)
{
    int a[3]={1,2,3};
    int* p=&a[0]; //p 指向 a[0]
    printf("%p %d\n",p,*p); //輸出 p、p 指向的元素
    p=p+1; //p 加 1
    printf("%p %d\n",p,*p); //輸出 p、p 指向的元素
    getchar();
    return 0;
}

運行結果如圖所示：

指針的加減法是指針和普通整數運算纔有意義，兩個指針加法沒意義：p=p+n 表示 p 向下指 n 個單元，p=p-1 表示 p 向上指 n 個單元。

下面經過例子來了解一下指針減法。

#includeint main(void)
{ 
    int a[3]={1,2,3};
    int* p=&a[1]; //p 指向 a[1]
    printf("%p %d\n",p,*p); //輸出 p、p 指向的元素
    p=p-1; //p 減 1
    printf("%p %d\n",p,*p); //輸出 p、p 指向的元素
    getchar();
    return 0;
}

運行結果如圖所示：

當指針變量 p 指向數組元素時，p+一、p-1 分別表示指向下一個、上一個數組元素。依次類推，p+i、p-i 分別表示指向下 i 個元素，上 i 個元素。
p+i 不能超過數組最後一個元素，p-i 不能小於數組第一個元素。不然就會發生數組越界。

兩個指針的加法沒意義，兩個指針的減法表示相差的單元的個數。
還常用到兩個指針相減，例如：p2-p1。
當 p1 和 p2 都指向同一個數組中的元素時，p2-p1 纔有意義。以數組 int a[5]爲例：假設p2 指向元素 a[2]，p1 指向元素 a[0]，執行 p2-p1 時不是表示隔了多少個字節，而是表示 p2所指向的元素與 p1 所指向的元素之間隔了多少個元素。

下面經過例子來了解兩個指針相減。

#includeint main(void)
{
    int a[5]={1,2,3,4,5};
    int* p1=&a[0]; //p1 指向元素 a[0]
    int* p2=&a[2]; //p2 指向元素 a[2]
    printf("p1=%p\n",p1); //輸出 p1
    printf("p2=%p\n",p2); //輸出 p2
    printf("%d\n",p2-p1); //輸出 p2-p1
    getchar();
    return 0;
}

運行結果如圖所示：

總結：

兩個指針之間的減法表示：相差的單元的個數。
兩個指針之間的加法，沒有意義；
指針+普通整數表示指針向挪 n 個單元；指針-普通整數表示指針後挪 n 個單元；

5.數組作函數參數

函數參數不只能夠是變量，也能夠是數組，它的做用是將數組首元素地址傳給函數形參。

【說明】
在 C 語言中，數組作函數參數時，是沒有副本機制的，只能傳遞地址。也能夠認爲，數組作函數參數時，會退化爲指針。

下面經過例子來了解數組作形參時，退化爲指針。

#includevoid getSize(int nums[5])//(int *nums)
{
    int size=sizeof(nums);
    printf("size=%d\n",size);
}
int main(void)
{
    int nums[5]={1,2,3,4,5};
    int size=sizeof(nums); //計算數組 nums 總字節數
    printf("size=%d\n",size);
    getSize(nums);
    getchar();
    return 0;
}

運行結果如圖所示：

能夠看到 2 次輸出結果不同。這是由於當數組作函數形參時，會退化爲指針。
void getSize(int nums[5])
退化爲：
void getSize(int *nums)
在 32 位系統下，全部指針變量都佔 4 個字節，所以第 5 行輸出結果爲 4。

因爲數組作函數參數時，會退化爲指針，致使沒法在被調函數中計算傳入的數組大小以及長度。爲了解決這種問題，規定數組作函數參數時，必須傳入數組長度，例如：
void getSize(int *nums，int length);
其中形參 length 表示數組 nums 的長度。

#includevoid show(int *nums,int length) //定義函數show
{
    int i;
    for (i=0;i<length;i++) //遍歷數組
    {
        printf("%d ",nums[i]);
    }
}
int main(void)
{
    int nums[5]={1,2,3,4,5};
    int length=sizeof(nums)/sizeof(int); //計算數組長度
    show(nums,length); //調用show函數
    getchar();
    return 0;
}

總結：

只有在數組聲明的函數中才能經過sizeof(數組名)算出來數組的字節數；
int nums[]={1,5,8,9,666}; int *p=nums;這種狀況sizeof(p)=4，由於p是指針，爲啥sizeof(nums)就能算出20呢，由於編譯器特殊對待。
由於C編譯器比較低級，函數參數聲明中即便使用數組類型void dy(int data[])，也會被退化成指針類型：void dy(int *data)，所以在給函數傳遞數組的時候，要傳遞數組的名字，同時要在聲明數組的函數中經過sizeof把數組元素個數算出來，穿進去，函數內部是算不出數組有幾個元素的。

6.*(a+i)與 a[i]等效

在 C 語言中，數組名等價於數組首元素地址。例如：int a[5]，a 與&a[0]徹底等價。能夠認爲 a+i 等價於&a[i]，a+i 指向 a[i]，那麼*(a+i)就是 a+i 所指向的數組元素 a[i]。所以，*(a+i)與 a[i]等價。

#includeint main(void)
{
    int a[5]={1,2,3,4,5};
    int i;
    int len=sizeof(a)/sizeof(int);
    for (i=0;i<len;i++)
    {
        printf("%d ",*(a+i));
    }
    getchar();
    return 0;
}

不管是對於數組名來說仍是對於指針來說：*(a+i)與 a[i]等效
除了在聲明數組時候 sizeof(數組名)和 sizeof(指針變量名)的不一樣，其餘時候「數組名」和「指針變量名」用法都是同樣的。

(三) 字符串與指針

在 C 語言中字符串本質上就是採用字符數組形式進行存儲。前面介紹過，指針能夠指向數值類型數組元素，也就能夠指向字符類型的數組元素。本節將介紹指向字符數組元素的指針。

1. 字符串的內存

在 C 語言中，字符串存放在字符數組中，要想引用字符串有兩種方式：

使用字符數組存放字符串，經過數組名引用字符串，經過下標引用字符串中的字符
使用字符指針變量指向字符串，經過字符指針變量引用字符串、字符串中的字符。

下面的代碼很簡單：

#includeint main(void)
{
    char str[]="hello"; //定義字符數組 str
    printf("%s\n",str); //以%s 格式輸出 str
    printf("%c",str[2]); //以%c 格式輸出一個字符
    getchar();
    return 0;
}

固然也能夠這樣使用：

#includeint main(void)
{
    char *str="hello";
    printf("%s\n",str);
    printf("%c",str[2]); //*(str+i)
    getchar();
    return 0;
}

兩個 sizeof 同樣嗎？

char s1[]="hello";
char *s2="hello";
printf("%d,%d\n",sizeof(s1),sizeof(s2));
//6,4

【說明】
須要注意的是，不論是經過字符數組，仍是經過字符指針引用字符串。編譯器都會自動在字符串末尾添加 0，下面經過內存工具，來查看字符串在內存中是如何存儲的。

第 1 步編寫測試程序

#includeint main(void)
{
    char *str="hello";
    printf("%p\n",str); //輸出字符串地址
    getchar();
    return 0;
}

第 2 步在 getchar 添加斷點。

第 3 步運行程序，記錄 str 指向字符串地址。

第 4 步在【內存 1】中輸入字符串地址，而後按下回車鍵，如圖所示：

【說明】
若是沒有顯示出如圖的效果，能夠參考如下步驟配置查看內存方式。
右鍵窗口任意位置，依次選擇【1 字節整數】、【不帶符號顯示】、【ANSI 文本】。

能夠看到字符串在內存中，是按照字符的 ASCII 碼進行存儲的，而且最後一位是 0 做爲字符串結束標誌。

(四) 字符串處理函數

在 C 語言中字符串是很是重要的概念，字符串處理函數是針對字符串進行操做的一系列函數。主要包含在頭文件中，本節將介紹經常使用的字符串處理函數。

1.strcpy

str：string
cpy：copy
函數原型：
char *strcpy(char* dest, char *src);
頭文件：
#include參數列表：
dest：目標字符數組。
src：源字符串。
功能：
把 src 指向的字符串複製到 dest 指向的字符數組中。
返回值：
返回 dest 指向的內存地址。
應用 strcpy 實現字符串複製

#include#includeint main(void)
{
    char *src="hello";
    char dest[10]={0};
    strcpy(dest,src);
    printf("%s\n",src);
    printf("%s\n",dest);
    getchar();
    return 0;
}

2.memcpy

mem：memory，cpy：copy
函數原型：
void *memcpy(void*dest, const void *src, int size);
頭文件：#include參數列表：
dest：目標地址空間
src: 源地址空間
size: 要複製的字節個數
功能：
從 src 指向的內存空間起始位置開始，拷貝 size 個字節到 dest 指向的內存空間中。
返回值：
返回 dest 指向的目標地址。

#include#includeint main(void)
{
    char* src="helloworld";
    char dest[7]={0};
    memcpy(dest,src,6);
    printf("%s",dest);
    getchar();
    return 0;
}

strcpy 和 memcpy 的區別：strcpy 是把源和目標都看過字符串類型，所以會碰到'\0'中止；而 memcpy 則會原樣複製。

3.strcmp

string compare
對於指針變量來說，==是比較是不是同一個地址。
函數原型：
int strcmp(char*str1,char*str2);
頭文件：
#include
參數列表：
str1：字符串 1
str2：字符串 2
功能：
從 str1 與 str2 的首字符開始逐個比較(比較字符的 ASCII 碼)，直到出現不一樣的字符或遇
到’\0’爲止。
返回值：
(1) 字符串 str1 小於 str2，返回值爲負數。
(2) 字符串 str1 等於 str2，返回值爲 0。
(3) 字符串 str1 大於 str2，返回值爲正數。

ANSI 標準規定，返回值爲正數、負數、0 。而確切數值是依賴不一樣的 C 實現的，好比有的平臺就是返回一、-一、0。

【說明】
字符串比較大小，不能使用算術運算符進行比較，例如：
str1>str二、str1==str二、str1<str2

使用算術運算符比較的是字符串首元素的地址，並非比較字符串的內容。

#include#includeint main(void)
{
    char *str1="hello";
    char *str2="HELLO";
    int result=strcmp(str1,str2);
    if (result>0)
    {
        printf("str1 大於 str2");
    }
    else if(0==result)
    {
        printf("str1 等於 str2");
    }
    else
    {
        printf("str1 小於 str2");
    }
    getchar();
    return 0;
}

4.stricmp

i:ignore case，忽略大小寫。
stricmp：string ignore case compare
函數原型：
int stricmp(char*str1,char*str2);
頭文件：
#includestrcmp 與 stricmp 用法基本相同，只是忽略了大小寫進行比較而已。

#include#includeint main(void)
{
    char *str1="hello";
    char *str2="Hello";
    int result=stricmp(str1,str2);
    if (result>0)
    {
        printf("str1 大於 str2");
    }
    else if(0==result)
    {
        printf("str1 等於 str2");
    }
    else
    {
        printf("str1 小於 str2");
    }
    getchar();
    return 0;
}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。