很多人遇到指针就糊涂,搞不清到底指向什么,其实是你没搞清楚 * 修饰谁,还有一些关键字修饰谁。$ T6 U/ M7 F" F5 b
看下面的例子,定义一个无符号字符变量x,然后同时定义一个可以指向x的指针p,即可以将x的地址放到指针变量p里面,然后又定义了一个可以存放p地址的指针pp:- 0 O8 g2 o, f+ h- \
- #include "stdio.h"
6 a0 r# P& Y( l8 q+ u - int main(void)
0 u: `3 }8 j& | - {
8 B! Y2 F7 E; b' i5 ?( n& {: y - //无符号字符变量x,指向无符号字符变量类型的指针p,指向指针类型p的指针pp.
G8 Z& B I1 d5 e - unsigned char x,*p,**pp;
! j b$ [4 D+ _; b - x=12;
1 ]. |/ S6 z% b* N. ~ - p=&x;
( H! J) w% `/ M [ - pp=&p;$ U: E8 s& t" p5 i$ D$ d) u( \
- //const是修饰指针指向的对象属性,意思是指针kp只能指向一个const常量,而kp可以被修改指向不同的const常量,但是不能通过kp指针修改指向变量的值。" G. |, v2 U; S/ D8 v' @' s
- int const *kp,k=20,kv=32;* |# s/ _% o; O0 b) I, {2 N6 R
- kp=&k;* _/ \ y b! I
- kp=&kv;
" F2 {1 @( @$ `1 Q0 d7 Q% U! g - //const是修饰指针mp,mp将指向固定的地址,因此在定义的时候就应该指定好该地址,之后无法修改该指针内的地址。4 z1 Q) t6 V4 a6 I4 ]* u
- int mv=14;# D! H1 {$ _5 V9 u" q z
- int *const mp=&mv;
X1 x: K; ^) o8 n. Q3 m- } - //可以让kp指向mv的地址,但是不能通过kp,修改mv的值; 7 r/ N6 O" O0 U s5 V0 p
- kp=&mv;
: _3 y1 @: R' F. X - /*
. ?# c* n% ?6 C* r, M6 y - 总结: const *p 表示*p是一个整体,即指针p指向的某个变量,而const修饰该变量;
- t* h% y) H" ~; ~& v* f- w9 A - * const p表示const p是一个整体,const 修饰指针p,即指针p存放的地址不能变。( k5 M7 L5 P, u6 s: _; q( ]2 f
- */
. R0 j4 I( i" E2 g1 I# F# x+ \ - printf("*p=%d\n",*p);& W% v y! ]% @# D, d
- printf("**pp=%d\n",**pp);
+ ~$ B( F6 S; P5 `( s - printf(" p=%d\n",p);
' h" x4 b# x+ }4 q3 T9 `, K - printf("pp=%d\n",pp);+ ~, X5 F) y0 Z- d9 Z9 k& m$ D4 N' [1 j
- printf("pp=%d\n",&pp);) _& i2 S- A [8 N/ N
- }
复制代码
l( P3 E0 h/ d5 L很多时候还会遇到const关键字,很多人不知道该如何结合,到底const修饰谁?. J+ N. _2 X# l6 @; x
这里你可以将定义看成是从右到左的结合。6 x% U& G' d H' u- q, A! n- U) e
int const *kp;
: b* o9 t% K0 _4 ~; G$ M% |int *const mp;/ x: d0 f3 e, s6 Y
例如例子中的这两个,你看好了,从右到左
, l# G% A9 t; V u- g; p: E. M3 D int const (*kp);
0 ]; \; |& M/ S0 P' ~! Eint *(const mp);
3 V; K% A& ]3 P& U( \- W) Y 第一个括号里是表示kp指针指向的某个变量,该变量是个const常量,不可变。
" o) |. N9 E: r! }4 f- @3 U2 |9 Q, a# L第二个是const直接修饰了指针mp,意思是指针存放的内容是不可变的,就是地址不可变。
1 F* ]$ n% s" w: A* b5 C4 K- @ }1 e2 l2 p5 M7 ^
*与&是一对逆操作,*的出现用于定义指针,在使用的时候用于通过指针找到指向的变量。" c6 R1 z" Y0 r" g3 `
而&用于取出变量的地址。
8 [+ t& B% b$ s& Q) ^4 l' q/ P5 s+ P: \$ C, J- D" {, c
在PC测试上,推荐一个C语言的IDE,是C语言入门圣经 C primer plus上推荐的一款:Pelles C IDE
9 V4 h$ v. c0 Z, g! Q
7 N! u6 p2 B6 Z* |! u
如果想使用中文界面可以访问下面这个中文链接:https://www.pellesc.cn/
5 N& g' L0 \; z5 l( _例如一个指向固定地址的指针,若想修改它指向的地址,那么会报错
6 R( p9 `* r6 R9 }
; o7 u/ I6 _8 E2 }9 ^# B/ z( [上面的报错信息意思是赋值错误,'='的操作数有不兼容的类型'int *'和'int',分配到了固定的地址。该固定的地址是不可以被修改的。
6 A! k0 k% a# n- A 另外需要注意,如果一个变量定义为指向常量的指针,那么该指针还是可以指向一个可变的变量,但是无法通过该指针修改该变量。该变量的属性就是通过它操作指向的变量都当做不可修改常量看待。# W- k, }7 i' s( h+ T: Z# b& \
报错内容如下:3 t0 d+ z% i( w
" ?, g% _9 M! W$ c8 O. N5 E) t
: a0 G' G! i# G3 A" T8 _0 b# p6 H) ?! j7 n0 u% F# ~
最后奉上,注释掉不合法的语句后的完整学习代码
, G! q0 v5 F4 `. Z- J- #include "stdio.h"
' n5 F2 V' W7 B( B2 e; Q _* M/ l& R# N
7 q' O- e0 c3 S* G5 ^3 n- int main(void)+ ?) `. i4 ~& _$ J! U3 `: }* ?
- {6 l! W! x$ [! Q6 P
- //无符号整形变量x,指向无符号整形变量类型的指针p,指向指针类型p的指针pp.% ^( L) \7 U# j! K
- unsigned int x,*p,**pp;+ d8 B7 j# R4 |4 F1 V; p
- x=12;9 E L* Y( Y% u, C2 ?' q
- p=&x;
b- G1 x$ N; j - pp=&p;
8 {* E! k0 y; t X - printf("通过指针p,打印x的值12:*p=%d\n",*p);
& m* N3 G/ B# T( Z$ D; K7 n - printf("通过指针pp,打印pp存放的指针p指向的变量x的值:**pp=%d\n",**pp);
/ \, \8 u; Q9 | - printf("打印变量x的地址: &x=%p\n",&x);8 G5 b) F; | ~4 K, h# L2 O5 R. L
- printf("打印指针p存放的变量x的地址:p=%p\n",p);
* B9 c) q4 T- y: y6 A$ n - printf("打印指针p的地址: pp=%p\n",pp);7 D: r- O8 [+ C3 Z- f+ h+ Z1 C- O/ v
- printf("打印指针变量pp的地址: pp=%p\n",&pp);
+ p, ~! s5 u9 u( |; f, c - printf("--------------------------------------------\n");- [8 x8 e1 w& {
- //const是修饰指针指向的对象属性,意思是指针kp只能指向一个const常量,而kp可以被修改指向不同的const常量,但是不能通过kp指针修改指向变量的值。+ n, P6 x8 {( K4 Y5 x1 |
- int const *kp,k=20,kv=32;
' E( a W0 V+ T1 `6 B - kp=&k;
6 w, U( {) H6 S. {6 I - printf("通过指针kp访问固定的数k,*kp=%d\n",*kp);$ D$ |: Y# y' [2 v- M0 h0 `
- kp=&kv;8 F, F6 {4 d; l8 w5 U
- printf("通过指针kp访问固定的数kv,*kp=%d\n",*kp);. ?3 G u+ d% M' Y5 Z+ `5 g" ?6 ^
- // 通过kp不可以修改指向地址存放变量的固定值。
; X- q/ C3 u2 O5 K - // *kp=21;
' K( ~3 O0 x* q: W+ B
7 B: c* u6 K7 f' y. T- ; L7 ]0 Y' _ }3 O$ H
- : H2 K% f# E' N& \/ t8 I f
- //const是修饰指针mp,mp将指向固定的地址,因此在定义的时候就应该指定好该地址,之后无法修改该指针内的地址。9 e, l' J& X" f# t; w3 s+ [2 A
- int mv=14,mx=24;
7 q' R# M W9 y- ]. s: [. ^ G, ^ - int *const mp=&mv;
# t! `3 Z5 E' Q! Y - printf("通过存放固定地址的指针访问指向的变量mv=14:*mp=%d\n",*mp);
1 i9 O/ @1 @3 Y+ `% { - *mp=15;
7 Q4 P& d6 g% H8 Y' L. B - printf("通过存放固定地址的指针修改指向的变量mv=15:*mp=%d\n",*mp);
7 |' m: F! C" z5 |2 ^ - //可以让kp指向mv的地址,但是不能通过kp,修改mv的值; 5 [ z9 t. @ B; }# x- l8 o
- kp=&mx;
- O% t3 e$ h, B, p7 m) u# v - printf("将指向固定数据的指针kp指向一个可以修改的变量mx=24,*kp=%d\n",*kp);
0 j1 p/ j. [' X% W - // 试图通过指向固定常量的指针kp修改指向的可修改变量mx时候,失败了。; G. g- n8 z: _/ C& B
- // *kp=25;" s( X/ ~) ]6 U9 k7 b
- ! T6 y0 r" u7 B8 V/ ~
- //因为mp指针指向的地址是const类型,所以下面的操作是非法的,会报错。 " }# R* F5 }8 i7 V$ I
- // mp=&24;- m' F% _0 X7 A' l9 Z/ `% T' J
5 i: g8 G h* b3 i: Z# m- /*
! E% o7 c3 b2 q! X1 l; q1 z - 总结: const *p 表示*p是一个整体,即指针p指向的某个变量,而const修饰该变量;
3 c& Z) e! ]" o - * const p表示const p是一个整体,const 修饰指针p,即指针p存放的地址不能变。( k% ^2 F3 i* I: S" d- |2 E
- */. P' r6 Z$ D" F8 N2 d' f
- }
复制代码 * Q3 L: I/ O3 l4 r& t9 I
. p7 _# c3 W5 x4 j) s" L6 f
|