c語言的指針

一、 指針前奏

1. 指針的重要性

指針是C語言中很是重要的數據類型，若是你說C語言中除了指針，其餘你都學得很好，那你乾脆說沒學過C語言。

2. 小需求

● void change(int  n)函數調用完畢後，改變實參的值

● 分析：修改實參的值->找到存儲空間->地址

 

二、 指針變量的定義

1. 定義的格式

● 類名標識符  *指針變量名;

● int *p;

2. 先定義後賦值

● 簡單取值

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

 

● 簡單改值

*p = 9;

3. 定義的同時賦值

int a = 10;

int *p = &a;

4. 實現修改實參

(*pp) == p

    

    *(*pp) == *p = a

    

    **pp == *p = a = 20

 

5. 注意點

● int *p;   p = 1000;

● int *p;   *p = 100;

● int *p;  *p = &a;  不正確寫法

● %p輸出指針裏面存儲的地址值

● 其餘指針類型說明，好比float *p;  char *p;

● 不能亂用類型，好比int a = 10;  float *p = &a;

6. 清空指針

● p = 0;

● p = NULL;

 

三、 指針實例  

1. 換值

 1 #include <stdio.h>
 2 void swap(int *v1, int *v2);
 3 
 4 int main()
 5 {
 6     int a2 = 90;
 7     int b2 = 89;
 8     
 9     swap(&a2, &b2);
10     
11     printf("a2=%d, b2=%d\n", a2, b2);
12     return 0;
13 }
14     // 完成兩個整型變量值的互換
15 void swap(int *v1, int *v2)
16 {
17     int temp = *v1;
18     *v1 = *v2;
19     *v2 = temp;
20 }

 

2. int sumAndMinus(int a, int b, int *minus)

 

 1 #include <stdio.h>
 2 int sumAndMinus(int n1, int n2, int *n3);
 3 
 4 int main()
 5 {
 6     int a = 10;
 7     int b = 7;
 8     
 9     // 存儲和
10     int he;
11     // 存儲差
12     int cha;
13     
14     he = sumAndMinus(a, b, &cha);
15     
16     printf("和是%d, 差是%d\n", he, cha);
17     
18     return 0;
19 }
20 
21 // 返回值是
22 int sumAndMinus(int n1, int n2, int *n3)
23 {
24     *n3 = n1 - n2;
25     
26     return n1 + n2;
27 }

 

四、 指針探究

1. 指針變量所佔用的存儲空間

2. 爲什麼指針變量要分類型？  例如：

 1 #include <stdio.h>
 2 int main()
 3 {
 4     // 0000 0000 0000 0000 0000 0000 0000 0010
 5     int i = 2;
 6     // 0000 0001
 7     char c = 1;
 8     
 9     int *p;
10     p = &c;  
11     printf("c的值是%d\n", *p);
12     
13     return 0;
14 }

 

 int *p=&c; 本應該是char類型的，寫成了int類型

Printf（「c的值是%d\n」,*p）;  打印結果爲513，而非1

Printf（「c的值是%d\n」,c）;  值爲1

 由於0000 0001

       0000 0010

 　　0000 0000

 　　0000 0000

 -----> 0000 0000 0000 0000 0000 0010 0000 0001 

 

五、 指針與數組

1. 指向一維數組元素的指針  例如：int ages[5] = {1,2,3,4,5 };

1)數組元素的訪問方式

 int ages[5];

 int *p;

 p = ages;

 1> 數組名[下標]  ages[i]

 2> 指針變量名[下標] p[i]

 3> *(p + i)

2)指針變量+1，地址值究竟加多少，取決於指針的類型

 int *   4

 char *  1

 double * 8

3)void change(int array[])等價於void change(int *array)

   array[2] = *(array+2)

4) 元素的地址：

第一個元素的地址  p      &ages[0]

第二個元素的地址p+1    &ages[1]

第三個元素的地址p+2    &ages[2]

第i個元素的地址  p + i   &ages[i]

  元素的值：

　　*p        　　ages[0]

　　*(p+1) 　　ages[1]

　　*(p+2) 　　ages[2]

2. 用指針遍歷一維數組元素  int *p;

                                     p =&ages[0]

 

3. 習題

1> 利用一個指針來接收一個數組，指針變量array指向了數組的首元素

 1 #include <stdio.h>
 2 
 3 void change(int *array)
 4 {
 5     printf("%d\n", array[2]);
 6     //printf("%d\n", *(array+2));
 7 }
 8 
 9 
10 int main()
11 {
12     // 20個字節
13     int ages[5] = {10, 11, 19, 78, 67};
14     
15     change(ages);
16     
17     return 0;
18 }

 

六、 指針與字符串

1. 字符串回顧

char s[] = 「mj」;

2. 其餘定義字符串的方式

char *s = 「mj」;

或者

char *s;

s = 「mj」;

3. 兩種定義方式的區別

● 內存分析

● 畫圖分析

● 常量和變量字符串的區別

● 常量的內存地址查看

 1.常量區

 存放一些常量字符串

 2.堆

 對象

 3.棧

 存放局部變量

     掌握：

 定義字符串的2種方式

 1> 利用數組

 char name[] = "itcast";

 * 特色：字符串裏面的字符是能夠修改的

 * 使用場合：字符串的內容須要常常修改

 2> 利用指針

 char *name = "itcast";

 * 特色：字符串實際上是一個常量字符串，裏面的字符是不能修改

 * 使用場合：字符串的內容不須要修改，並且這個字符串常用

4. 習題

1> 編寫一個int string_len(char *s)，返回字符串s的字符長度

 1 #include <stdio.h>
 2 int string_len(char *s);
 3 
 4 int main()
 5 {
 6     int size = string_len("sdtrgfgds56");
 7     
 8     printf("%d\n", size);
 9     return 0;
10 }
11 
12 int string_len(char *s)
13 {
14     // 1.定義一個新的指針變量指向首字符
15     char *p = s;
16     
17     /*
18      while ( *s != '\0' )
19      {
20      s++;
21      }*/
22     
23     while ( *s++ ) ;
24     
25     return s - p - 1;
26 }
27 
28 /*
29  int string_len(char *s)
30  {
31  // 記錄字符的個數
32  int count = 0;
33  
34  // 若是指針當前指向的字符不是'\0'
35  // 首先*s取出指向的字符
36  // 而後s++
37  while ( *s++ )
38  {
39  // 個數+1
40  count++;
41  
42  // 讓指針指向下一個字符
43  //s = s + 1;
44  //s++;
45  }
46  
47  return count;
48  }
49  */
50 
51 /*
52  int string_len(char *s)
53  {
54  // 記錄字符的個數
55  int count = 0;
56  
57  // 若是指針當前指向的字符不是'\0'
58  while ( *s != '\0')
59  {
60  // 個數+1
61  count++;
62  
63  // 讓指針指向下一個字符
64  //s = s + 1;
65  s++;
66  }
67  
68  return count;
69  }*/

 

七、 返回指針的函數

● 指針也是C語言中的一種數據類型，所以一個函數的返回值確定能夠是指針類型的

● 返回指針的函數的通常形式爲：類型名 * 函數名(參數列表)

 1 #include<stdio.h>
 2 
 3 char  *test();
 4 
 5 int main()
 6 
 7 {
 8     
 9     char *name=test();
10     
11     printf("name=%s\n",name);
12     
13     return 0;
14     
15 }
16 
17 
18 
19 char *test() //返回指針的函數
20 
21 {
22     
23     return "rose";
24     
25 }

 

 

八、 指向函數的指針

1. 爲何指針能夠指向一個函數？

函數做爲一段程序，在內存中也要佔據部分存儲空間，它也有一個起始地址，即函數的入口地址。函數有本身的地址，那就好辦了，咱們的指針變量就是用來存儲地址的。所以，能夠利用一個指針指向一個函數。其中，函數名就表明着函數的地址。

2. 指向函數的指針的定義

定義的通常形式：函數的返回值類型 (*指針變量名)(形參1, 形參2, ...);

3. 使用注意

● 因爲這類指針變量存儲的是一個函數的入口地址，因此對它們做加減運算(好比p++)是無心義的

● 指向函數的指針變量主要有兩個用途：

•  調用函數

•  將函數做爲參數在函數間傳遞

 指針總結

1、指針變量的定義

1. 格式：變量類型 *指針變量名;

2. 舉例：int *p;   char *p2;

3. 注意：定義變量時的*僅僅是指針變量的象徵

 

2、利用指針變量簡單修改其餘變量的值

1.指向某個變量

int a;

 

int *p;

p = &a;

或者

int *p = &a;

 

2.修改所指向變量的值

*p = 10;

 

3.在函數內部修改外面變量的值

int a = 10;

change(&a);

 

void change(int *n)

{

    *n = 20;

}

 

3、指針與數組

1.將數組當作函數參數傳入時，會自動轉爲指針

 

4、指針與字符串

1.定義字符串的2種方式

1> 利用數組

char name[] = "itcast";

* 特色：字符串裏面的字符是能夠修改的

* 使用場合：字符串的內容須要常常修改

 

2> 利用指針

char *name = "itcast";

* 特色：字符串實際上是一個常量字符串，裏面的字符是不能修改

* 使用場合：字符串的內容不須要修改，並且這個字符串常用

 

2.定義字符串數組

1> 利用二維字符數組

char names[2][10] = {"jack", "rose"};

 

2> 利用指針數組

char *names[2] = {"jack", "rose"};

做業1

 1 /*
 2 編寫一個函數，判斷某個字符串是否爲迴文。
 3 迴文就是從左邊開始讀 和 從右邊開始讀 都是同樣的，好比"abcba"
 4 */
 5 
 6 #include <string.h>
 7 #include <stdio.h>
 8 int isHuiwen(char *str);
 9 
10 int main()
11 {
12     printf("%d\n", isHuiwen("abcdcba"));
13     return 0;
14 }
15 
16 /*
17  返回1表明是迴文
18  返回0表明不是迴文
19  */
20 int isHuiwen(char *str)
21 {
22     // 1.定義一個指向變量left指向字符串的首字符
23     char *left = str;
24     // 2.定義一個指向變量right指向字符串的末字符
25     char *right = str + strlen(str) - 1;
26     
27     while (left < right)
28     {
29         // 若是左邊和右邊的字符不同
30         if (*left++ != *right--)
31         {
32             return 0;
33         }
34     }
35     
36     return 1;
37 }

 
做業2

 1 /*
 2 編寫一個函數void strlink(char s[], char t[])
 3  將字符串t鏈接到字符串s的尾部
 4 */
 5 #include <stdio.h>
 6 
 7 void strlink(char s[], char t[]);
 8 
 9 int main()
10 {
11     char s1[20] = "michael ";
12     char s2[] = "jackson";
13     
14     strlink(s1, s2);
15     
16     printf("%s\n", s1);
17     
18     return 0;
19 }
20 
21 void strlink(char s[], char t[])
22 {
23     int i = 0;
24     
25     // 判斷s[i]是否爲字符串的尾部
26     while ( s[i] != '\0' )
27     {
28         i++;
29     }
30     
31     int j = 0;
32     // 拷貝t的內容到s的後面
33     while ( (s[i] = t[j]) != '\0' )
34     {
35         i++;
36         j++;
37     }
38 }
39 
40 /*
41  更加精簡的寫法，僅做爲參考(會有警告信息)
42 void strlink2(char s[], char t[])
43 {
44     int i = -1;
45     
46     // 判斷s[i]是否爲字符串的尾部
47     while (s[++i]) ;
48     
49     int j = 0;
50     // 拷貝t的內容到s的後面
51     while (s[i++] = t[j++]) ;
52 }*/