指針基礎

一 指針就是地址,地址就是指針.指針存儲的是內存的地址.

二 指針的定義

1.&表示取址運算符,&a 可以取到 a 在內存中的地址;打印地址的占位符為(%p),printf(“%p\n”,&a);

2. 指針變量的定義

指針變量是用來存放地址的.

指針定義的格式:

類型數據 ?*變量名 ?= ?初始值;

int *p = NULL;*在這里表示p 是一個指針變量,不是運算符.

printf(“%p\n”,p); 在打印指針的時候不需要使用取址運算符(&),因為指針本來就是地址.

*p 指針為空時,打印出來0x0的地址,為空.

int ?a = 10;

p = &a;

printf(“%p\n”,p);

訪問內存中的數據有兩種方法:

1.直接訪問內存中的數據.

printf(“%p\n”,a);

2. 通過指針進行訪問.

*也可以作為取值運算符.* p 代表取到 p 指向內存中存儲的數據 ?printf(“%d\n”,*p);

int a = 10,b = 20;

int *p1 = &a;

int *p2 = &b;

對指針重新賦值,意味著指針重指向,也就是說指針指向一個新的地址.

p1 = p2;p1指向 c 的首地址

printf(“*p1 = %d,*?p2 = %d\n”,*p1,*p2);

int a = 15,b = 20;

int *p = &a;

int *p1 = &b;

單獨的* p 表示取值,* p = 11 表示向 p 指向的內存中存入數據.

*p = 11;

printf(“%d\n”,a);

int *p3 = &a;

p3 = p1;

*p1 = 8;

printf(“a = %d,b = %d\n”,a,b);a = 11,b = 8

經典練習

int a?= 6,b?= 8,c = 10;

int *x = &a;

x = &c;

int *y = &b;

int *z = &c;

*z = 5;

*x = 12;

x = y;

*y = *x + *z;

printf(“a?= %d,b = %d,c = %d\n”,a,b,c);

指針中常見的問題

1.內存編號比較小的存儲單元,是由系統控制的,不允許訪問.

int *p = NULL;

*p = 100; ? error

2.野指針,定義時沒有賦初始值,操作野指針是很危險的

int *p;

*p = 100;error

3.定義指針時,*怎么寫?

int *p?= NULL;推薦

int* p1 = NULL;

int *p1 = NULL;

int*p3 = NULL;

4.指針變量在內存中占幾個字節

與數據類型無關,在32位操作系統下,指針所占字節數是4位,在64位操作系統中,指針所占字節數是8位.

printf(“%lu\n”,sizeof(long *));

5. 修飾指針變量數據類型的作用

a. 指針變量數據類型,決定*(取值運算符),取多少個字節的數據;

定義指針的數據類型一定要和指向數據的數據類型一致,這樣才能把數據完整的取出來

int *p = NULL;

int a = 268;

p = &a;

printf(“%d\n”,*p);

char *c = NULL;

c = &a;

printf(“%d\n”,*c);

b.指針類型,決定指針變量加1操作時,跳轉多少個字節

int *p = NULL;

printf(“%p\n”,p); //0x0

printf(“%p\n”,p+1);//0x4

printf(“%p\n”,p+2);//0x8

printf(“%p\n,p++);//打印的結果是:0x4? ?但是實際結果是:0x8

p+1 和 ?p++或++ p 的關系

相同:取到的都是下一個字節的地址

不同:++p和 p++ 造成指針的重指向

6.指針在數組中的應用

int a[5] = {1,2,3,4,5};

數組名就是數組元素的首地址

printf(“%p\n”,a);

printf(“%p\n”,&a[0]);

printf(“%p\n”,p);

printf(“%p\n”,a+1);

printf(“%p\n”,&a[1]);

printf(“%p\n”,p+1);

printf(“%p\n”,a+2);

printf(“%p\n”,&a[2]);

printf(“%p\n”,p+2);

printf(“%d\n”,*a);

printf(“%d\n”,*(a +1));

printf(“%d\n”,*(a+2));

用指針遍歷數組

for(int i= 0;i < 5;i++){

printf(“%d\n”,*(a+i));

}

定義指針變量訪問數組中的元素

int *p =NULL;

p = a;

printf(“%p\n”,a);

printf(“%p\n”,p);

printf(“%d\n”,*p);

printf(“%d\n”,*(p+1));

printf(“%d\n”,*(p+2));

練習

有10個元素的數組,通過指針變量為元素隨機賦值[22 33]

7.數組名(數組元素的首地址) ? 與指向數組首地址的指針變量的區別:

a. 數組名(數組首地址) 是一個常量地址不能被修改

a = NULL;error

指針變量可以修改,可以重指向

b. 數組名(數組的首地址),用sizeof 計算得到的結果,整個數組所占的字節數,而用 sizeof 計算指向數組元素首地址的指針變量得到是一個定值4或者8

printf(“%lu\ n”,sizeof(c));

//定義一個10個元素的數組,通過指針變量為元素隨機賦值[22 33],冒泡排序;

8.指針在字符串中的應用

用% s 打印是從指針指向那個地址開始向后輸出

char string[] = “Canglaoshi”;

printf(“%s\n”,string);

printf(“%s\n”,string+1);

通過指針訪問里面的元素

數組名(數組元素的首地址) ?== 指針

*(string + 3) = ‘\0'

printf(“%s\ n”,string);

通過指針訪問元素

printf(“%c\ n”,*(string +3));

通過指針計算字符串的長度

int i= 0;

*(string +i) ?取到數組中對應位置的值

while(*(string+i) != ‘\0’){//string[i]

i++;

}

printf(“%d\n”,i);

指針變量一定要和指向的數據類型相同

char *p = string;

int i = 0;

while(*(p+i) != ‘\0’){

i++;

}

char string[] = "canglaoshi I love you";//將字符串的首個字母大寫,并且將空格換成下劃線

char string[] = "canglaoshi I love you";

*string -= 32;

char *p = string;

if (string[0] >= 'a' && string[0] <='z') {

string[0] -= 32;

}

int i = 0;

while (*(string+i) != '\0') {

if (*(string + i) == ' ') {

*(string + i) = '-';

}

i++;

}

printf("%s\n",string);

//寫一個函數實現兩變量的交換

int a = 10;

int b = 20;

change(&a,&b);

printf("a = %d,b = %d\n",a,b); int a = 10,b = 20; int sum = 0,sub = 0;

sum = sumAndsub(a,b,&sub); printf("sum = %d,sub = %d\n",sum,sub); float a[10] = {0}; for (int i = 0; i < 10; i++) {

*(a+i) =arc4random()%21+10;

printf("%.2f ",*(a+i));

} printf("\n"); for (int i = 0; i < 10 - 1; i++) { for (int j = 0; j < 10 - i - 1;j++) {//??????????? if (a[j] > a[j + 1]) {//??????????????? float temp = 0;//??????????????? temp = a[j];//??????????????? a[j] = a[j + 1];//??????????????? a[j + 1] = temp;//??????????? } if (*(a + j) > *(a + 1 + j)) { float temp = 0;

temp = *(a +j);

*(a + j) = *(a + j + 1);

*(a + j + 1) = temp;

}

}

} printf("\n"); for (int i = 0; i < 10; i++) {

printf("%.2f ",*(a+i));

}

結構體指針

1.形參和實參的區別

a. 形參:定義的時候寫的參數,(起一個描述的作用,沒有實際的意義)

b. 實參:函數實際調用時傳進來的參數

形參和實參的傳遞是單向的.

2.結構體嵌套

在定義結構體的時候,結構體的成員變量也可以是結構體.

3.結構體指針

指向結構體的指針叫結構體指針.

數據類型 ?+ * ?+?變量名 + 初始值;

Student ?stu1 = {“lisi”,’M’,29};

指針變量指向結構體變量的首地址,相當于指向結構體第一個成員變量的地址

Student *p = &stu1;

結構體指針的訪問

printf(“%s”,(*p).name);

通過指針變量訪問結構體變量的成員

printf(“%s,%c,%d\n”,p->name,p->sex,p->age);

4——>:指向操作符

只有定義的是結構體變量的首地址,才可以使用(—>指向操作符)訪問結構體變量

printf(“%s,%c,%d\n”,p->name,p->sex,p->age);

5.float x1 = 0.1;

float x2 = 1.;

float x3 = 1.f;

float x4 =1.0f;

float x5 = 1;

6.結構體數組與指針的關系

結構體數組的數組名是一個結構體指針常量.

int a[5] = {1,2,3,4,5};

int *p = a;//數組名就是數組的首地址.

printf(“%d\n”,*p);

*stu ? : ? stu[0] ?//代表的都是數組中第一個元素,

*(stu + 1) :stu[1] ?// 代表的都是數組中的第二個元素.

*(stu + 2) ? :stu[2] ?//代表的是數組中的第三個元素.

訪問數組中結構體元素的屬性

*stu.name ? :stu[0].name

(*(stu + 1)).name ?: ?stu[1].name

—>:指向操作符 ?:使用的時候一定要保證指針指向結構體變量的首地址

stu—> name ? :stu[0].name

(stu + 1) —>name ?:stu[1].name

(stu + 2)——>name ? : stu[2].name

7.遍歷結構體數組的時候,需要向函數中傳入數組和長度.

8.指針數組(也就是指向指針的指針)

int ?a?= 3,b = 4,c= ?5;

數組中的元素都是指針(地址)數組,就是指針數組.

int *array[3] = {&a,&b,&c};//3*8個字節

printf(“%p\n”,array[0]);

printf(“%p\n”,&a);

printf(“%d\n”,**array);//*array? 取到地址 ?**array ?取到地址里的值

printf(“%d\ n”,*(*(arrary + 1)));

二.函數指針

函數指針的聲明方法為:

函數類型 ?(標示符 ?指針變量名 )(形參列表);

函數類型說明函數的返回類型,”(標識符 指針變量)”中的括號不能省,若省略整體則成為一個函數說明,說明了一個返回的數據類型是指針的函數,后面的”形參列表"表示指針變量指向的函數所帶來的參數列表.

例如:

int func(int x); 聲明一個函數

int (*f)(int x);

函數指針

1.函數指針類型的確定步驟

1?把函數名換成(*) ? ?void (*)() ? ?int(*)(int,int)

2?如果有參數,把參數名去掉,只保留參數類型 ?void (*)() ? int (*)(int,int)

3?格式

指針類型 ?*指針名 ?= 初始值;

char *p?= NULL;

函數指針的類型

返回值類型(*函數指針變量名)(參數類型1,參數類型2.....) = 初始值;

函數后面的()是函數調用符.

注意: ?函數指針變量名不能和指針重名

int sum(int a,int b){

return a+b;

}

int (*Sum)(int,int);

Sum = sum;

int y = Sum(3,5);

printf(“%d\n”,y);

同一個函數指針可以指向不同的函數,但是(前提是:函數指針的類型必須一致)

2.typedef 原始類型 ?新類型;

給函數指針類型起別名

typedef int (*FUN)(int,int);

typedef void (*HELLO)

typedef ?返回值類型(*新類型名)(參數類型1,參數類型2.....)

3.函數回調

函數回調:就是用函數指針來調用函數

函數名就是指針,存放的函數的首地址

4.動態排序

就是不斷的改變排序的條件,根據不同的條件,調用不同的函數,進行排序.

5.枚舉

定義:一組有符號的整形常量,一一列舉所有的狀態,羅列出所有可能的結果

enum season {

spring,

summer,

autumn,

winter};

printf(“%d\n”,spring);

枚舉經常和 swith 合用

枚舉間接提高了代碼的可讀性

將人能識別的表示符,與計算機能識別的數字建立聯系

6.宏只做簡單的替換,在預編譯的時候完成替換

宏命名規范:

1?純大寫

2?k + ?大駝峰

無參宏直接進行定義,有參宏可以使用常量表達式

#define SUM(A,B) ?((A) - (B))?// 最安全的方式

有參數的宏,只做簡單的替換運算,不會判斷運算符的優先級

int p = SUM(3 + 7,5 + 6) * 3;//3 + 7 * 5 + 6

7.條件編譯

第一種

#ifdef ?MY

printf(“Hello Word!!");

#else

printf(“明天考試!!");

#endif

特點:如果標示符被# define 過,就會執行代碼段1,否則就會執行代碼段2

第二種方式

#ifndef? 標示符

代碼段1

#else

代碼段2

#endif

特點:如果標示符沒有被#define過,就會執行代碼段1;如果被定義過,,就編譯代碼段2

第三種方式

#if ?常量表達式

代碼段1

#else

代碼段2

#endif

#if MY

printf(“你好藍歐!!");

#else

printf(“你好中國!!");

#endif

特點:如果常量表達式非0,就執行代碼段1,否則執行代碼段2

8.const 常量修飾符

被 const修飾的常量是不能重新賦值的

總結

以上是生活随笔為你收集整理的c语言把结构体首地址放入指针,C语言基础———指针,结构体指针,函数指针的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。