分別定義一個局部變量和全局變量，測試生命期限和作用域。
實現此案例需要按照如下步驟進行。
步驟一：局部變量和全局變量代碼如下所示：
#include
/*auto*/ int x = 1000;
void f1(int a)
{
a = 10;
auto int x = 20;
static int y = 30;
y++;
x++;
printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);
}
void f2()
{
printf("in f2(),x=%d\n",x);
x = 2000;
}
void f3()
{
printf("in f3(),x=%d\n",x);
}
int main()
{
int x = 30,b=100;
f1(b);
f1(b);
printf("in main(),b=%d,x=%d\n",b,x);
f2();
f3();
return 0;
}
上述代碼中，以下代碼：
定義了一個全局變量x，該變量在所有函數中共享。
上述代碼中，以下代碼：
定義了一個函數f1，該函數沒有返回值，有一個參數是一個整型變量a。該函數中以下語句：
將參數a賦值為10，參數a是局部變量，只能用在f1函數中。該函數中以下語句：
定義了另一個局部變量x，也只能用在f1函數中。前面的auto關鍵字可有可無。該函數中以下語句：
定義了一個static局部變量y，也只能用在f1函數中，但函數返回後該變量不會被釋放，直到主函數退出時，它才會被釋放。該函數中以下語句：
對局部變量x和y進行自增操作。
注意：在函數f1中，定義了局部變量x，而在該函數的上面還定義全局變量x，這樣在函數f1中，有兩個x，但C語言規定，在這種情況下，局部變量x將隱藏全局變量x，即全局變量x此時不起作用。
該函數中以下語句：
使用函數printf輸出局部變量a和x的值，以及靜態局部變量y的值。
上述代碼中，以下代碼：
定義了一個無參無返回值的函數f2。該函數中以下語句：
對全局變量x進行賦值。
上述代碼中，以下代碼：
定義了一個無參無返回值的函數f2。該函數中以下語句：
對全局變量x進行輸出。
上述代碼中，以下代碼：
在主函數中，定義了兩個局部變量x和b，並分別初始化為30和100。這兩個局部變量只能用在main函數中。
上述代碼中，以下代碼：
兩次調用函數f1，並用局部變量b作為實參。
注意：兩次調用中，函數f1中的靜態局部變量y輸出值不一樣。因為static關鍵字使該變量在函數f1返回後並不釋放，所以第二次調用時，其值會在上一次調用返回前的基礎上發生變化。
上述代碼中，以下代碼：
使用函數printf輸出局部變量b和局部變量x的值。
注意：在函數main中，定義了局部變量x，而在該函數的上面還定義全局變量x，這樣在函數main中，有兩個x，但C語言規定，在這種情況下，局部變量x將隱藏全局變量x，即全局變量x此時不起作用。
上述代碼中，以下代碼：
調用函數f2和f3，從輸出的值上可以看出，全局變量可以在所有函數中共享。
本案例的完整代碼如下所示：
#include
/*auto*/ int x = 1000;
void f1(int a)
{
a = 10;
auto int x = 20;
static int y = 30;
y++;
x++;
printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);
}
void f2()
{
printf("in f2(),x=%d\n",x);
x = 2000;
}
void f3()
{
printf("in f3(),x=%d\n",x);
}
int main()
{
int x = 30,b=100;
f1(b);
f1(b);
printf("in main(),b=%d,x=%d\n",b,x);
f2();
f3();
return 0;
}
定義一個int類型的指針，指向一個整型變量，然後分別使用&和*取得地址或者數據。
實現此案例需要按照如下步驟進行。
步驟一：指針的基本用法
代碼如下所示：
上述代碼中，以下代碼：
定義了一個整型變量a，並初始化為10。
上述代碼中，以下代碼：
定義了一個整型指針變量p，並使用取地址運算符&將整型變量a的地址賦值給p。
上述代碼中，以下代碼：
使用函數printf輸出指針變量p的值和整型變量a的地址值。從輸出結果可以看出，指針變量p中存放的就是整型變量a的地址值。
上述代碼中，以下代碼：
使用函數printf輸出整型變量a的值。
上述代碼中，以下代碼：
使用函數printf輸出指針變量p所指向的地址單元的值。由於指針變量p被賦值成了整型變量a的地址值，所以，p就指向a的地址，所以輸出的就是a的值。
本案例的完整代碼如下所示：
使用指針實現交換變量值的函數swap()，同時編寫不使用指針交換失敗的函數做對比。
實現此案例需要按照如下步驟進行。
步驟一：指針的優勢代碼如下所示：
#include
void swap(int a, int b)
{
printf("in swap() a = %d, b = %d\n", a, b);
int tmp = a;
a = b;
b = tmp;
printf("in swap() a = %d, b = %d\n", a, b);
}
void swap1(int *a, int *b)
{
printf("in swap1() *a = %d, *b = %d\n", *a, *b);
int tmp = *a;
*a = *b;
*b = tmp;
printf("in swap1() *a = %d, *b = %d\n", *a, *b);
}
int main()
{
int x = 10, y = 20;
printf("in main() x = %d, y = %d\n", x, y);
swap(x, y);
printf("in main() x = %d, y = %d\n", x, y);
swap1(&x, &y);
printf("in main() x = %d, y = %d\n", x, y);
return 0;
}
上述代碼中，以下代碼：
void swap(int a, int b)
{
printf("in swap() a = %d, b = %d\n", a, b);
int tmp = a;
a = b;
b = tmp;
printf("in swap() a = %d, b = %d\n", a, b);
}
定義了一個函數swap，該函數有兩個參數，為整型變量a和b。在該函數中，以下語句：
使用函數printf輸出形參a和b從調用函數傳入的值。在該函數中，以下語句：
通過第三個變量tmp，將整型變量a和b的值進行交換。在該函數中，以下語句：
使用函數printf輸出形參a和b交換後的值。
上述代碼中，以下代碼：
定義了一個函數swap1，該函數有兩個參數，為整型指針變量a和b。在該函數中，以下語句：
使用函數printf輸出整型指針變量a和b指向的地址的值。在該函數中，以下語句：
通過第三個變量tmp，將整型指針變量a和b指向的地址的值進行交換。在該函數中，以下語句：
使用函數printf輸出整型指針變量a和b指向地址的值交換後的值。
上述代碼中，以下代碼：
在主函數中定義兩個整型變量x和y，並將它們初始化為10和20。
上述代碼中，以下代碼：
使用函數printf輸出變量x和y的初始值。
上述代碼中，以下代碼：
首先，調用函數swap。
然後，使用函數printf輸出整型變量x和y在調用函數swap後的變化情況。從輸出結果可以看出，沒有發生變化。因為swap函數定義的參數是整型變量，這時，實參到形參的傳遞過程是值傳遞，即僅將實參x和y的值傳遞給形參a和b，而形參a和b在函數swap中發生的變化並不會傳回給實參。
上述代碼中，以下代碼：
首先，調用函數swap1。
然後，使用函數printf輸出整型變量x和y在調用函數swap1後的變化情況。從輸出結果可以看出，確實發生了變化。因為swap1函數定義的參數是整型指針變量，實參將變量x和y的地址傳給了形參a和b，在函數swap1中使用*a和*b操作的是指針a和b指向的地址單元的值，即變量x和y的值。
本案例的完整代碼如下所示：
#include
void swap(int a, int b)
{
printf("in swap() a = %d, b = %d\n", a, b);
int tmp = a;
a = b;
b = tmp;
printf("in swap() a = %d, b = %d\n", a, b);
}
void swap1(int *a, int *b)
{
printf("in swap1() *a = %d, *b = %d\n", *a, *b);
int tmp = *a;
*a = *b;
*b = tmp;
printf("in swap1() *a = %d, *b = %d\n", *a, *b);
}
int main()
{
int x = 10, y = 20;
printf("in main() x = %d, y = %d\n", x, y);
swap(x, y);
printf("in main() x = %d, y = %d\n", x, y);
swap1(&x, &y);
printf("in main() x = %d, y = %d\n", x, y);
return 0;
}
使用指針做參數取函數的返回值，寫一個函數，找出一個數組中的最大值和最小值。
實現此案例需要按照如下步驟進行。
步驟一：指針的優勢(續1)代碼如下所示：
#include
#include
#include
void maxAndMin(int data[], int size, int *max, int *min)
{
*max = data[0];
*min = data[0];
for (int i = 0; i < size; i++)
{
if (*max < data[i])
*max = data[i];
if (*min > data[i])
*min = data[i];
}
}
int main(int argc, const char * argv[])
{
int data[10];
srand((unsigned)time(0));
for (int i = 0; i < 10; i++)
data[i] = rand() % 100;
printf("數組中的數據為：");
for (int i = 0; i < 10; i++)
printf("%d ", data[i]);
printf("\n");
int max;
int min;
maxAndMin(data, 10, &max, &min);
printf("最大值為：%d\n", max);
printf("最小值為：%d\n", min);
return 0;
}
上述代碼中，下面代碼行：
是自定義函數的函數頭，該函數為無返回值函數，函數名為maxAndMin，函數有四個形參，第一個形參為一個數組，在此數組中找到最大值和最小值；第二個形參為數組的長度；第三個形參是一個指針變量，此參數用於將數組中的最大值帶回主函數；第四個形參也是一個指針變量，此參數用於將數組中的最小值帶回主函數。
上述代碼中，下面代碼行：
首先假定數組的最大值與最小值都是數組的第一個元素。
上述代碼中，下面代碼行：
遍歷數組，逐個元素與最大值和最小值對比，如果比最大值大，替換最大值；如果比最小值小，則替換最小值。
上述代碼中，下面代碼行：
在主函數中，定義數組data，有10個元素。
上述代碼中，下面代碼行：
首先，為每個數組元素賦值成一個0~99之間的隨機數。
然後，將數組中數據顯示出來。
上述代碼中，下面代碼行：
定義兩個變量，分別用於存儲數組中的最大值和最小值。
上述代碼中，下面代碼行：
調用maxAndMin函數，數組data作為第一個實參，第二個實參是數組data的長度，第三個實參是變量max的地址，這樣可以將最大值帶回來，第四個實參是變量min的地址，它用於帶回最小值。
本案例的完整代碼如下所示：
#include
#include
#include
void maxAndMin(int data[], int size, int *max, int *min)
{
*max = data[0];
*min = data[0];
for (int i = 0; i < size; i++)
{
if (*max < data[i])
*max = data[i];
if (*min > data[i])
*min = data[i];
}
}
int main(int argc, const char * argv[])
{
int data[10];
srand((unsigned)time(0));
for (int i = 0; i < 10; i++)
data[i] = rand() % 100;
printf("數組中的數據為：");
for (int i = 0; i < 10; i++)
printf("%d ", data[i]);
printf("\n");
int max;
int min;
maxAndMin(data, 10, &max, &min);
printf("最大值為：%d\n", max);
printf("最小值為：%d\n", min);
return 0;
}
測試不同類型的指針的算術運算。
實現此案例需要按照如下步驟進行。
步驟一：指針的算術運算代碼如下所示：
#include
int main()
{
int a;
int *pa = &a;
printf("pa = %p, pa + 1 = %p\n", pa, pa + 1);
short s;
short *ps = &s;
printf("ps = %p, ps + 1 = %p\n", ps, ps + 1);
long l;
long *pl = &l;
printf("pl = %p, pl + 1 = %p\n", pl, pl + 1);
char c;
char *pc = &c;
printf("pc = %p, pc + 1 = %p\n", pc, pc + 1);
float f;
float *pf = &f;
printf("pf = %p, pf + 1 = %p\n", pf, pf + 1);
double d;
double *pd = &d;
printf("pd = %p, pd + 1 = %p\n", pd, pd + 1);
return 0;
}
上述代碼中,以下代碼：
首先，定義了一個整型變量a。
然後，定義了一個整型指針變量pa，並初始化為整型變量a的地址。
最後，使用函數printf輸出指針pa的值和pa+1的值。從輸出結果可以看出，整型指針變量加1時，相當於加了1*sizeof（int），即4個字節。
上述代碼中,以下代碼：
首先，定義了一個短整型變量s。
然後，定義了一個短整型指針變量ps，並初始化為短整型變量s的地址。
最後，使用函數printf輸出指針ps的值和ps+1的值。從輸出結果可以看出，短整型指針變量加1時，相當於加了1*sizeof（short），即2個字節。
上述代碼中,以下代碼：
首先，定義了一個長整型變量l。
然後，定義了一個長整型指針變量pl，並初始化為長整型變量l的地址。
最後，使用函數printf輸出指針pl的值和pl+1的值。從輸出結果可以看出，長整型指針變量加1時，相當於加了1*sizeof（long），即8個字節。
上述代碼中,以下代碼：
首先，定義了一個字符型變量c。
然後，定義了一個字符型指針變量pc，並初始化為字符型變量c的地址。
最後，使用函數printf輸出指針pc的值和pc+1的值。從輸出結果可以看出，字符型指針變量加1時，相當於加了1*sizeof（char），即1個字節。
上述代碼中,以下代碼：
首先，定義了一個浮點型變量f。
然後，定義了一個浮點型指針變量pf，並初始化為浮點型變量f的地址。
最後，使用函數printf輸出指針pf的值和pf+1的值。從輸出結果可以看出，浮點型指針變量加1時，相當於加了1*sizeof（float），即4個字節。
上述代碼中,以下代碼：
首先，定義了一個雙精度浮點型變量d。
然後，定義了一個雙精度浮點型指針變量pd，並初始化為雙精度浮點型變量d的地址。
最後，使用函數printf輸出指針pd的值和pd+1的值。從輸出結果可以看出，雙精度浮點型指針變量加1時，相當於加了1*sizeof（double），即8個字節。
本案例的完整代碼如下所示：
#include
int main()
{
int a;
int *pa = &a;
printf("pa = %p, pa + 1 = %p\n", pa, pa + 1);
short s;
short *ps = &s;
printf("ps = %p, ps + 1 = %p\n", ps, ps + 1);
long l;
long *pl = &l;
printf("pl = %p, pl + 1 = %p\n", pl, pl + 1);
char c;
char *pc = &c;
printf("pc = %p, pc + 1 = %p\n", pc, pc + 1);
float f;
float *pf = &f;
printf("pf = %p, pf + 1 = %p\n", pf, pf + 1);
double d;
double *pd = &d;
printf("pd = %p, pd + 1 = %p\n", pd, pd + 1);
return 0;
}
定義const的普通變量和const指針的三種方式，驗證一下效果。
實現此案例需要按照如下步驟進行。
步驟一：const的使用代碼如下所示：
#include
int main()
{
int i1=5;
const int i2 = 10;
//i2 = 6;
//i2++;
i1 = i2;
i1 = 100;
printf("i2=%d\n",i2);
const int *p1 = &i2;
//*p1 = 200;
p1 = &i1;
int * const p2 = &i2;
*p2 = 200;
//p2 = &i1;
printf("i2=%d\n",i2);
return 0;
}
上述代碼中，以下代碼：
定義了一個整型變量i1，並初始化為5。
上述代碼中，以下代碼：
定義了一個const整型變量i2，並初始化為10。const是一個C語言的關鍵字，它限定變量i2不允許被改變，如以下代碼：
是錯誤的，如果不注釋，將報編譯錯誤。但以下代碼：
是正確的，因為變量i1未被const關鍵字修飾。
上述代碼中，以下代碼：
使用關鍵字const修飾了一個整型指針變量。由於關鍵字const在*號的左邊，所以此時限定不能改變的是指針p1指向的地址的值，如以下語句：
是錯誤的，因為*p1代表指針p1指向的地址的值。但以下代碼:
是正確的。因為關鍵字const在*號的左邊並未限定指針p1本身不能改變。
上述代碼中，以下代碼：
同樣使用關鍵字const修飾了一個整型指針變量。但由於關鍵字const在*號的右邊，所以此時限定不能改變的是指針p1本身的值，如以下語句：
是正確的。因為關鍵字const在*號的右邊並未限定指針p1指向的地址的值。但以下代碼:
是錯誤的，由於關鍵字const在*號的右邊，所以此時指針p1本身的值不能改變。
本案例的完整代碼如下所示：
#include
int main()
{
int i1=5;
const int i2 = 10;
//i2 = 6;
//i2++;
i1 = i2;
i1 = 100;
printf("i2=%d\n",i2);
const int *p1 = &i2;
//*p1 = 200;
p1 = &i1;
int * const p2 = &i2;
*p2 = 200;
//p2 = &i1;
printf("i2=%d\n",i2);
return 0;
}
定義一個數組，然後賦值給指針，然後互相用對方的方式進行操作。
實現此案例需要按照如下步驟進行。
步驟一：指針和數組代碼如下所示：
#include
int main()
{
int arr[5] = {10, 20, 30, 4, 5};
int *po = arr;
for(int i = 0; i < 5; i++)
{
printf("arr=%d\n",*(arr+i));
printf("po=%d\n",*(po+i));
printf("arr[i]=%d\n",i[arr]);//*(arr+i)
}
printf("*po=%d\n",*po++);
printf("*po=%d\n",(*po)++);
printf("%d\n",*po);
po++;
printf("*po=%d\n",*po);
//arr = arr+1;//arr++;
//printf("*arr=%d\n",*arr);
return 0;
}
上述代碼中，以下代碼：
定義了一個整型數組arr，數組中有5個元素，並對數組進行了初始化。
上述代碼中，以下代碼：
定義了一個整型指針變量po，並初始化為數組名arr，這種賦值是合法的，因為數組名就是數組第一個元素arr[0]的地址。
上述代碼中，以下代碼：
數組名arr是數組第一個元素arr[0]的地址。當i為0時，*（arr+i）等效於*arr，即數組第一個元素arr[0]。當i為1時，arr+1是數組第二個元素arr[1]的地址，*（arr+i）即數組第二個元素arr[1]。依次類推。
上述代碼中，以下代碼：
使用函數printf輸出指針po+i指向的地址的值，當i為0時，指針po+0就是數組名arr的值，而arr又是數組第一個元素arr[0]的地址，所以*（po+0）就是arr[0]。當i為1時，指針po+1就是數組名arr+1的值，而arr+1又是數組第二個元素arr[1]的地址，所以*（po+1）就是arr[1]。依次類推。
上述代碼中，以下代碼：
i[arr]是一種不推薦使用的方法。i[arr]與arr[i]是等價的，在編譯時分別被編譯成*（i+arr）和*（arr+i），而它們是一回事。
上述代碼中，以下代碼：
由於*po++左右有兩個運算符*和++，它們是同優先級的，結合性是自右向左，所以先計算++，但又由於++是後置，所以該語句等效於以下語句：
即輸出為*po=10；
上述代碼中，以下代碼：
同樣是因為++是後置的，所以該語句等效於以下語句：
即輸出為*po=20；不是10的原因是上次等效時，進行了po = po + 1運算。
上述代碼中，以下代碼：
輸出為*po=21，是因為上次等效時，進行了*po = *po + 1運算。
上述代碼中，以下代碼：
輸出為*po=30，因為po++再次改變了po的值。
上述代碼中，以下代碼：
為錯誤的。因為數組名是一個常量，雖然它是數組第一個元素arr[0]的地址，但它不能改變。
本案例的完整代碼如下所示：
#include
int main()
{
int arr[5] = {10, 20, 30, 4, 5};
int *po = arr;
for(int i = 0; i < 5; i++)
{
printf("arr=%d\n",*(arr+i));
printf("po=%d\n",*(po+i));
printf("arr[i]=%d\n",i[arr]);//*(arr+i)
}
printf("*po=%d\n",*po++);
printf("*po=%d\n",(*po)++);
printf("%d\n",*po);
po++;
printf("*po=%d\n",*po);
//arr = arr+1;//arr++;
//printf("*arr=%d\n",*arr);
return 0;
}
