程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> C語言 >> C >> C語言入門知識 >> C語言05指針基礎

C語言05指針基礎

編輯:C語言入門知識

1 局部變量和全局變量

1.1 問題

分別定義一個局部變量和全局變量,測試生命期限和作用域。

1.2 步驟

實現此案例需要按照如下步驟進行。

步驟一:局部變量和全局變量代碼如下所示:

#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;
}
  1.  

上述代碼中,以下代碼:

  1. /*auto*/ int x = 1000;

定義了一個全局變量x,該變量在所有函數中共享。

上述代碼中,以下代碼:

  1. void f1(int a)
  2. {
  3. a = 10;
  4. auto int x = 20;
  5. static int y = 30;
  6. y++;
  7. x++;
  8. printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);
  9. }

定義了一個函數f1,該函數沒有返回值,有一個參數是一個整型變量a。該函數中以下語句:

  1. a = 10;

將參數a賦值為10,參數a是局部變量,只能用在f1函數中。該函數中以下語句:

  1. auto int x = 20;

定義了另一個局部變量x,也只能用在f1函數中。前面的auto關鍵字可有可無。該函數中以下語句:

  1. static int y = 30;

定義了一個static局部變量y,也只能用在f1函數中,但函數返回後該變量不會被釋放,直到主函數退出時,它才會被釋放。該函數中以下語句:

  1. y++;
  2. x++;

對局部變量x和y進行自增操作。

注意:在函數f1中,定義了局部變量x,而在該函數的上面還定義全局變量x,這樣在函數f1中,有兩個x,但C語言規定,在這種情況下,局部變量x將隱藏全局變量x,即全局變量x此時不起作用。

該函數中以下語句:

  1. printf("in f1(),a=%d,x=%d,y=%d\n",a,x,y);

使用函數printf輸出局部變量a和x的值,以及靜態局部變量y的值。

上述代碼中,以下代碼:

  1. void f2()
  2. {
  3. printf("in f2(),x=%d\n",x);
  4. x = 2000;
  5. }

定義了一個無參無返回值的函數f2。該函數中以下語句:

  1. x = 2000;

對全局變量x進行賦值。

上述代碼中,以下代碼:

  1. void f3()
  2. {
  3. printf("in f3(),x=%d\n",x);
  4. }

定義了一個無參無返回值的函數f2。該函數中以下語句:

  1. printf("in f3(),x=%d\n",x);

對全局變量x進行輸出。

上述代碼中,以下代碼:

  1. int main()
  2. {
  3. int x = 30,b=100;

在主函數中,定義了兩個局部變量x和b,並分別初始化為30和100。這兩個局部變量只能用在main函數中。

上述代碼中,以下代碼:

  1. f1(b);
  2. f1(b);

兩次調用函數f1,並用局部變量b作為實參。

注意:兩次調用中,函數f1中的靜態局部變量y輸出值不一樣。因為static關鍵字使該變量在函數f1返回後並不釋放,所以第二次調用時,其值會在上一次調用返回前的基礎上發生變化。

上述代碼中,以下代碼:

  1. printf("in main(),b=%d,x=%d\n",b,x);

使用函數printf輸出局部變量b和局部變量x的值。

注意:在函數main中,定義了局部變量x,而在該函數的上面還定義全局變量x,這樣在函數main中,有兩個x,但C語言規定,在這種情況下,局部變量x將隱藏全局變量x,即全局變量x此時不起作用。

上述代碼中,以下代碼:

  1. f2();
  2. f3();

調用函數f2和f3,從輸出的值上可以看出,全局變量可以在所有函數中共享。

1.3 完整代碼

本案例的完整代碼如下所示:

#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;
}
  1.  

2 指針的基本用法

2.1 問題

定義一個int類型的指針,指向一個整型變量,然後分別使用&和*取得地址或者數據。

2.2 步驟

實現此案例需要按照如下步驟進行。

步驟一:指針的基本用法

代碼如下所示:

  1. #include
  2.  
  3. int main()
  4. {
  5. int a = 10;
  6. int *p;
  7. p = &a;
  8. printf("p = %p\n", p);
  9. printf("&a = %p\n", &a);
  10.  
  11. printf("a = %d\n", a);
  12. printf("*p = %d\n", *p);
  13.  
  14. return 0;
  15. }

上述代碼中,以下代碼:

  1. int a = 10;

定義了一個整型變量a,並初始化為10。

上述代碼中,以下代碼:

  1. int *p;
  2. p = &a;

定義了一個整型指針變量p,並使用取地址運算符&將整型變量a的地址賦值給p。

上述代碼中,以下代碼:

  1. printf("p = %p\n", p);
  2. printf("&a = %p\n", &a);

使用函數printf輸出指針變量p的值和整型變量a的地址值。從輸出結果可以看出,指針變量p中存放的就是整型變量a的地址值。

上述代碼中,以下代碼:

  1. printf("a = %d\n", a);

使用函數printf輸出整型變量a的值。

上述代碼中,以下代碼:

  1. printf("*p = %d\n", *p);

使用函數printf輸出指針變量p所指向的地址單元的值。由於指針變量p被賦值成了整型變量a的地址值,所以,p就指向a的地址,所以輸出的就是a的值。

2.3 完整代碼

本案例的完整代碼如下所示:

  1. #include
  2.  
  3. int main()
  4. {
  5. int a = 10;
  6. int *p;
  7. p = &a;
  8. printf("p = %p\n", p);
  9. printf("&a = %p\n", &a);
  10.  
  11. printf("a = %d\n", a);
  12. printf("*p = %d\n", *p);
  13.  
  14. return 0;
  15. }

3 指針的優勢

3.1 問題

使用指針實現交換變量值的函數swap(),同時編寫不使用指針交換失敗的函數做對比。

3.2 步驟

實現此案例需要按照如下步驟進行。

步驟一:指針的優勢代碼如下所示:

#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);
}
  1.  

定義了一個函數swap,該函數有兩個參數,為整型變量a和b。在該函數中,以下語句:

  1. printf("in swap() a = %d, b = %d\n", a, b);

使用函數printf輸出形參a和b從調用函數傳入的值。在該函數中,以下語句:

  1. int tmp = a;
  2. a = b;
  3. b = tmp;

通過第三個變量tmp,將整型變量a和b的值進行交換。在該函數中,以下語句:

  1. printf("in swap() a = %d, b = %d\n", a, b);

使用函數printf輸出形參a和b交換後的值。

上述代碼中,以下代碼:

  1. void swap1(int *a, int *b)
  2. {
  3. printf("in swap1() *a = %d, *b = %d\n", *a, *b);
  4. int tmp = *a;
  5. *a = *b;
  6. *b = tmp;
  7. printf("in swap1() *a = %d, *b = %d\n", *a, *b);
  8. }

定義了一個函數swap1,該函數有兩個參數,為整型指針變量a和b。在該函數中,以下語句:

  1. printf("in swap1() *a = %d, *b = %d\n", *a, *b);

使用函數printf輸出整型指針變量a和b指向的地址的值。在該函數中,以下語句:

  1. int tmp = *a;
  2. *a = *b;
  3. *b = tmp;

通過第三個變量tmp,將整型指針變量a和b指向的地址的值進行交換。在該函數中,以下語句:

  1. printf("in swap1() *a = %d, *b = %d\n", *a, *b);

使用函數printf輸出整型指針變量a和b指向地址的值交換後的值。

上述代碼中,以下代碼:

  1. int main()
  2. {
  3. int x = 10, y = 20;

在主函數中定義兩個整型變量x和y,並將它們初始化為10和20。

上述代碼中,以下代碼:

  1. printf("in main() x = %d, y = %d\n", x, y);

使用函數printf輸出變量x和y的初始值。

上述代碼中,以下代碼:

  1. swap(x, y);
  2. printf("in main() x = %d, y = %d\n", x, y);

首先,調用函數swap。

然後,使用函數printf輸出整型變量x和y在調用函數swap後的變化情況。從輸出結果可以看出,沒有發生變化。因為swap函數定義的參數是整型變量,這時,實參到形參的傳遞過程是值傳遞,即僅將實參x和y的值傳遞給形參a和b,而形參a和b在函數swap中發生的變化並不會傳回給實參。

上述代碼中,以下代碼:

  1. swap1(&x, &y);
  2. printf("in main() x = %d, y = %d\n", x, y);

首先,調用函數swap1。

然後,使用函數printf輸出整型變量x和y在調用函數swap1後的變化情況。從輸出結果可以看出,確實發生了變化。因為swap1函數定義的參數是整型指針變量,實參將變量x和y的地址傳給了形參a和b,在函數swap1中使用*a和*b操作的是指針a和b指向的地址單元的值,即變量x和y的值。

3.3 完整代碼

本案例的完整代碼如下所示:

#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.  

4 指針的優勢(續1)

4.1 問題

使用指針做參數取函數的返回值,寫一個函數,找出一個數組中的最大值和最小值。

4.2 步驟

實現此案例需要按照如下步驟進行。

步驟一:指針的優勢(續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;
}
  1.  

上述代碼中,下面代碼行:

  1. void maxAndMin(int data[], int size, int *max, int *min)

是自定義函數的函數頭,該函數為無返回值函數,函數名為maxAndMin,函數有四個形參,第一個形參為一個數組,在此數組中找到最大值和最小值;第二個形參為數組的長度;第三個形參是一個指針變量,此參數用於將數組中的最大值帶回主函數;第四個形參也是一個指針變量,此參數用於將數組中的最小值帶回主函數。

上述代碼中,下面代碼行:

  1. *max = data[0];
  2. *min = data[0];

首先假定數組的最大值與最小值都是數組的第一個元素。

上述代碼中,下面代碼行:

  1. for (int i = 0; i < size; i++)
  2. {
  3. if (*max < data[i])
  4. *max = data[i];
  5. if (*min > data[i])
  6. *min = data[i];
  7. }

遍歷數組,逐個元素與最大值和最小值對比,如果比最大值大,替換最大值;如果比最小值小,則替換最小值。

上述代碼中,下面代碼行:

  1. int main(int argc, const char * argv[])
  2. {
  3. int data[10];

在主函數中,定義數組data,有10個元素。

上述代碼中,下面代碼行:

  1. srand((unsigned)time(0));
  2. for (int i = 0; i < 10; i++)
  3. data[i] = rand() % 100;
  4. printf("數組中的數據為:");
  5. for (int i = 0; i < 10; i++)
  6. printf("%d ", data[i]);
  7. printf("\n");

首先,為每個數組元素賦值成一個0~99之間的隨機數。

然後,將數組中數據顯示出來。

上述代碼中,下面代碼行:

  1. int max;
  2. int min;

定義兩個變量,分別用於存儲數組中的最大值和最小值。

上述代碼中,下面代碼行:

  1. maxAndMin(data, 10, &max, &min);

調用maxAndMin函數,數組data作為第一個實參,第二個實參是數組data的長度,第三個實參是變量max的地址,這樣可以將最大值帶回來,第四個實參是變量min的地址,它用於帶回最小值。

4.3 完整代碼

本案例的完整代碼如下所示:

#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;
}
  1.  

5 指針的算術運算

5.1 問題

測試不同類型的指針的算術運算。

5.2 步驟

實現此案例需要按照如下步驟進行。

步驟一:指針的算術運算代碼如下所示:



#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;
}
  1.  

上述代碼中,以下代碼:

  1. int a;
  2. int *pa = &a;
  3. printf("pa = %p, pa + 1 = %p\n", pa, pa + 1);

首先,定義了一個整型變量a。

然後,定義了一個整型指針變量pa,並初始化為整型變量a的地址。

最後,使用函數printf輸出指針pa的值和pa+1的值。從輸出結果可以看出,整型指針變量加1時,相當於加了1*sizeof(int),即4個字節。

上述代碼中,以下代碼:

  1. short s;
  2. short *ps = &s;
  3. printf("ps = %p, ps + 1 = %p\n", ps, ps + 1);

首先,定義了一個短整型變量s。

然後,定義了一個短整型指針變量ps,並初始化為短整型變量s的地址。

最後,使用函數printf輸出指針ps的值和ps+1的值。從輸出結果可以看出,短整型指針變量加1時,相當於加了1*sizeof(short),即2個字節。

上述代碼中,以下代碼:

  1. long l;
  2. long *pl = &l;
  3. printf("pl = %p, pl + 1 = %p\n", pl, pl + 1);

首先,定義了一個長整型變量l。

然後,定義了一個長整型指針變量pl,並初始化為長整型變量l的地址。

最後,使用函數printf輸出指針pl的值和pl+1的值。從輸出結果可以看出,長整型指針變量加1時,相當於加了1*sizeof(long),即8個字節。

上述代碼中,以下代碼:

  1. char c;
  2. char *pc = &c;
  3. printf("pc = %p, pc + 1 = %p\n", pc, pc + 1);

首先,定義了一個字符型變量c。

然後,定義了一個字符型指針變量pc,並初始化為字符型變量c的地址。

最後,使用函數printf輸出指針pc的值和pc+1的值。從輸出結果可以看出,字符型指針變量加1時,相當於加了1*sizeof(char),即1個字節。

上述代碼中,以下代碼:

  1. float f;
  2. float *pf = &f;
  3. printf("pf = %p, pf + 1 = %p\n", pf, pf + 1);

首先,定義了一個浮點型變量f。

然後,定義了一個浮點型指針變量pf,並初始化為浮點型變量f的地址。

最後,使用函數printf輸出指針pf的值和pf+1的值。從輸出結果可以看出,浮點型指針變量加1時,相當於加了1*sizeof(float),即4個字節。

上述代碼中,以下代碼:

  1. double d;
  2. double *pd = &d;
  3. printf("pd = %p, pd + 1 = %p\n", pd, pd + 1);

首先,定義了一個雙精度浮點型變量d。

然後,定義了一個雙精度浮點型指針變量pd,並初始化為雙精度浮點型變量d的地址。

最後,使用函數printf輸出指針pd的值和pd+1的值。從輸出結果可以看出,雙精度浮點型指針變量加1時,相當於加了1*sizeof(double),即8個字節。

5.3 完整代碼

本案例的完整代碼如下所示:

#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;
}
  1.  

6 const的使用

6.1 問題

定義const的普通變量和const指針的三種方式,驗證一下效果。

6.2 步驟

實現此案例需要按照如下步驟進行。

步驟一: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;
}
  1.  

上述代碼中,以下代碼:

  1. int i1=5;

定義了一個整型變量i1,並初始化為5。

上述代碼中,以下代碼:

  1. const int i2 = 10;

定義了一個const整型變量i2,並初始化為10。const是一個C語言的關鍵字,它限定變量i2不允許被改變,如以下代碼:

  1. //i2 = 6;
  2. //i2++;

是錯誤的,如果不注釋,將報編譯錯誤。但以下代碼:

  1. i1 = i2;
  2. i1 = 100;

是正確的,因為變量i1未被const關鍵字修飾。

上述代碼中,以下代碼:

  1. const int *p1 = &i2;

使用關鍵字const修飾了一個整型指針變量。由於關鍵字const在*號的左邊,所以此時限定不能改變的是指針p1指向的地址的值,如以下語句:

  1. //*p1 = 200;

是錯誤的,因為*p1代表指針p1指向的地址的值。但以下代碼:

  1. p1 = &i1;

是正確的。因為關鍵字const在*號的左邊並未限定指針p1本身不能改變。

上述代碼中,以下代碼:

  1. int * const p2 = &i2;

同樣使用關鍵字const修飾了一個整型指針變量。但由於關鍵字const在*號的右邊,所以此時限定不能改變的是指針p1本身的值,如以下語句:

  1. *p2 = 200;

是正確的。因為關鍵字const在*號的右邊並未限定指針p1指向的地址的值。但以下代碼:

  1. //p2 = &i1;

是錯誤的,由於關鍵字const在*號的右邊,所以此時指針p1本身的值不能改變。

6.3 完整代碼

本案例的完整代碼如下所示:

#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;
}
  1.  

7 指針和數組

7.1 問題

定義一個數組,然後賦值給指針,然後互相用對方的方式進行操作。

7.2 步驟

實現此案例需要按照如下步驟進行。

步驟一:指針和數組代碼如下所示:

#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;
}
  1.  

上述代碼中,以下代碼:

  1. int arr[5] = {10, 20, 30, 4, 5};

定義了一個整型數組arr,數組中有5個元素,並對數組進行了初始化。

上述代碼中,以下代碼:

  1. int *po = arr;

定義了一個整型指針變量po,並初始化為數組名arr,這種賦值是合法的,因為數組名就是數組第一個元素arr[0]的地址。

上述代碼中,以下代碼:

  1. printf("arr=%d\n",*(arr+i));

數組名arr是數組第一個元素arr[0]的地址。當i為0時,*(arr+i)等效於*arr,即數組第一個元素arr[0]。當i為1時,arr+1是數組第二個元素arr[1]的地址,*(arr+i)即數組第二個元素arr[1]。依次類推。

上述代碼中,以下代碼:

  1. printf("po=%d\n",*(po+i));

使用函數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]。依次類推。

上述代碼中,以下代碼:

  1. printf("arr[i]=%d\n",i[arr]);

i[arr]是一種不推薦使用的方法。i[arr]與arr[i]是等價的,在編譯時分別被編譯成*(i+arr)和*(arr+i),而它們是一回事。

上述代碼中,以下代碼:

  1. printf("*po=%d\n",*po++);

由於*po++左右有兩個運算符*和++,它們是同優先級的,結合性是自右向左,所以先計算++,但又由於++是後置,所以該語句等效於以下語句:

  1. printf("*po=%d\n",*po);
  2. po = po + 1;

即輸出為*po=10;

上述代碼中,以下代碼:

  1. printf("*po=%d\n",(*po)++);

同樣是因為++是後置的,所以該語句等效於以下語句:

  1. printf("*po=%d\n",*po);
  2. *po = *po + 1;

即輸出為*po=20;不是10的原因是上次等效時,進行了po = po + 1運算。

上述代碼中,以下代碼:

  1. printf("%d\n",*po);

輸出為*po=21,是因為上次等效時,進行了*po = *po + 1運算。

上述代碼中,以下代碼:

  1. po++;
  2. printf("*po=%d\n",*po);

輸出為*po=30,因為po++再次改變了po的值。

上述代碼中,以下代碼:

  1. //arr = arr+1;//arr++;
  2. //printf("*arr=%d\n",*arr);

為錯誤的。因為數組名是一個常量,雖然它是數組第一個元素arr[0]的地址,但它不能改變。

7.3 完整代碼

本案例的完整代碼如下所示:

#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;
}

 

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved