(一) 指標知識先導

1. 記憶體空間與記憶體地址

int num=100;
計算機中資料都是存盤在記憶體中，因此讀寫資料的本質其實是讀寫記憶體，而目前讀寫記憶體的唯一方式就是通過變數名，這種方式被稱為“直接訪問”記憶體，

在計算機中，記憶體空間的最小單位為位元組，作業系統會為每一個位元組記憶體空間編號，并且這個編號在當前程式中是唯一的，

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

如果想要在這排房間中找到 2 號球員，只需知道他住 105 號房間即可，101 房號相當于記憶體地址、101 房間相當于記憶體空間、7 號球員相當于記憶體空間中的資料，

前面講過，要想找到 7 號球員，必須通過房間號來查找，同理，在計算機中，要想讀寫記憶體空間中的資料，也可以先通過記憶體地址找到該記憶體空間，然后進行讀寫操作，

讀寫記憶體的 2 種方式：
第 1 種通過變數名讀寫記憶體，
變數本質上是一塊有名字的記憶體空間，通過變數名讀寫記憶體，如圖所示：

第 2 種通過記憶體地址讀寫記憶體，
在計算機記憶體中，每一個位元組記憶體空間都有一個編號，這個編號被稱為記憶體地址，通過該地址可以讀寫對應的記憶體空間，如圖所示：

2. 探索記憶體

在上一節中，討論了記憶體空間與記憶體地址的關系，為了更加深入了解這 2 者之間的關系，將使用 VS2012 自帶的工具，來更加形象的分析，

測驗代碼如下：

#include<stdio.h>
int 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 進制的地址資料（每次運行可能都不一樣），
如圖所示：

第 3 步依次點擊選單【除錯】->【視窗】->【記憶體】->【記憶體 1】，打開記憶體視窗，如圖所示：

第 4 步將控制臺輸出的資料，輸入到【記憶體 1】視窗的【地址】欄中，然后按下回車鍵，如圖所示：

第 5 步在【記憶體 1】表單內右鍵點擊，然后選擇【4 位元組整數(4)】、【帶符號顯示】如圖所示：

【說明】
因為 num 是 int 型別，32 位系統下占 4 位元組，所以第 5 步選【4 位元組整數】，其他型別資料依次類推，

第 6 步查看【記憶體 1】視窗，可以看到整數+999，其實就是 999 只是顯示了符號位+而已，如圖所示：

分析：
1、以上整個程序，首先第 4 行，通過變數名 num 將整數 999 寫入記憶體空間中，
2、第 5 行，使用&num 計算出變數 num 對應的記憶體空間地址 0019FE50，
3、通過斷點除錯的方式，查看 0019FE50 地址空間中保存的資料 999，
4、經過以上分析，變數 num 完整記憶體模型如圖所示：

5、可以看到，訪問一塊記憶體空間可以通過變數名，也可以記憶體地址，
【除錯技巧】
為了方便使用【記憶體 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 種參考指標變數，

#include<stdio.h>
int main(void)
{
    int a=10;
    int b=20;
    int *p1,*p2; //定義指標變數 p1、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 種參考指標變數指向的變數，

#include<stdio.h>
int 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：封裝函式，交換兩個整型變數的值，

#include<stdio.h>
void 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<stdio.h>
引數串列：
_Format ：格式控制字串，與 printf 函式中格式控制作用相同，
… ：地址串列，由若干個地址組成，
功能：
獲取用戶按鍵輸入的資料，并以指定格式寫入到變數、或陣列中，

#include <stdio.h>
int 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 還可以接收多個輸入資料，例如：

#include <stdio.h>
int 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.陣列元素地址初識

一、陣列元素地址

在 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 個元素，
如圖所示：

二、參考指向陣列元素的指標變數

因為陣列元素本質上可以看作是單獨的變數，所以參考指向陣列元素的指標變數與參考指向變數的指標變數方式相同，直接使用*指標變數名即可，

#include<stdio.h>
int 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 個地址…..其他型別依次類推，同理，陣列元素型別不同占用的記憶體地址也不同，

#include<stdio.h>
int 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 語言中，陣列名與陣列首元素地址等價，

#include<stdio.h>
int 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 個位元組，

#include<stdio.h>
int 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 個單元，

下面通過例子來了解一下指標減法，

#include<stdio.h>
int 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+1、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 所指向的元素之間隔了多少個元素，

下面通過例子來了解兩個指標相減，

#include<stdio.h>
int 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 語言中，陣列做函式引數時，是沒有副本機制的，只能傳遞地址，也可以認為，陣列做函式引數時，會退化為指標，

下面通過例子來了解陣列做形參時，退化為指標，

#include<stdio.h>
void 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 的長度，

#include<stdio.h>
void 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]等價，

#include<stdio.h>
int 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 語言中，字串存放在字符陣列中，要想參考字串有兩種方式：

使用字符陣列存放字串，通過陣列名參考字串，通過下標參考字串中的字符
使用字符指標變數指向字串，通過字符指標變數參考字串、字串中的字符，

下面的代碼很簡單：

#include<stdio.h>
int main(void)
{
    char str[]="hello"; //定義字符陣列 str
    printf("%s\n",str); //以%s 格式輸出 str
    printf("%c",str[2]); //以%c 格式輸出一個字符
    getchar();
    return 0;
}

當然也可以這樣使用：

#include<stdio.h>
int 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 步撰寫測驗程式

#include<stdio.h>
int 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<string.h>
引數串列：
dest：目標字符陣列，
src：源字串，
功能：
把 src 指向的字串復制到 dest 指向的字符陣列中，
回傳值：
回傳 dest 指向的記憶體地址，
應用 strcpy 實作字串復制

#include<stdio.h>
#include <string.h>
int main(void)
{
    char *src="https://www.cnblogs.com/wangyueping/archive/2021/04/05/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<string.h>
引數串列：
dest：目標地址空間
src: 源地址空間
size: 要復制的位元組個數
功能：
從 src 指向的記憶體空間起始位置開始，拷貝 size 個位元組到 dest 指向的記憶體空間中，
回傳值：
回傳 dest 指向的目標地址，

#include<stdio.h>
#include <string.h>
int main(void)
{
    char* src="https://www.cnblogs.com/wangyueping/archive/2021/04/05/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 實作的，比如有的平臺就是回傳 1、-1、0，

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

使用算術運算子比較的是字串首元素的地址，并不是比較字串的內容，

#include<stdio.h>
#include<string.h>
int 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);
頭檔案：
#include<string.h>
strcmp 與 stricmp 用法基本相同，只是忽略了大小寫進行比較而已，

#include<stdio.h>
#include<string.h>
int 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;
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/272756.html

標籤：其他

上一篇：非科班想入門計算機，應該怎么樣？中國大學MOOC來幫忙！

下一篇：CQGUI框架之樣式管理

C語言指標

(一) 指標知識先導

1. 記憶體空間與記憶體地址

2. 探索記憶體

3. 指標變數

4. 指標變數定義與初始化

5. 參考指標變數

6. 指標變數做函式引數

7. scanf 獲取輸入資料函式

(二) 陣列與指標

1.陣列元素地址初識

一、陣列元素地址

二、參考指向陣列元素的指標變數

2.陣列元素地址深入分析

3.陣列名與陣列首元素地址

4.指標加、減運算

5.陣列做函式引數

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

(三) 字串與指標

1. 字串的記憶體

(四) 字串處理函式

1.strcpy

2.memcpy

3.strcmp

4.stricmp