2 X+ c9 f" t1 u+ P. @7 I char *ip = new char; 0 j$ Q, h( Y( w/ ^; Z- Z! p. C, T4 U. ^ g% n, g9 y6 u
(2)指针ip被free或者delete之后,没有置为NULL,让人误以为ip是个合法的指针。- i; I) s7 M/ Q- N% J, T& `* y
- v: h8 f) d; t5 k- x (3)指针操作超越了变量的作用范围。这种情况让人防不胜防,示例程序如下: ; S$ y' ?5 e2 i; C% ?: w0 c+ ?+ I4 t1 ^( w# R) _) R* C
class A 3 o: D. o4 S" Y& h3 \5 K1 } & x/ @( W/ d2 w: j, p& U% X{! v& h: k& z* i
2 D5 g4 h' N7 |
public:) }5 c6 h* b/ L4 z8 _( O
4 I/ P0 H; E$ z+ z M0 H+ I. P void Func(void){ std::cout << “Func of class A” << std::endl; } ) v5 O* S: G ^9 B5 E9 e" d$ ^: A* n- h6 Z% Q8 W: f# ]: o
}; : _- h6 f2 Y' q5 x) c6 q $ @# s6 ?4 A5 e8 u. D% B5 Lvoid Test(void)) h+ W% M# _6 a. e5 P6 f
' t# c- K9 ~: o h/ h7 a- Q
{ 1 E' k# O3 A8 \0 p% S* [7 P: x. Q2 J4 A4 C: W$ u* X
A *p; & N" R3 T) ^- R- Z; ?$ R5 B' k( p7 r$ C2 [0 Z7 J0 B6 V/ f/ ^( j
{ 9 l0 ?3 R7 N M, m5 W0 u; m& _
A a; 7 V% ^) f j7 Y% `2 V3 |$ J # I: n6 H& ?) K+ p6 n+ W p = &a; // 注意 a 的生命期 _# i# G8 C) p5 x7 d0 D& \$ C0 G
}, T' j; w1 s" C- _( j& s1 f* b. ~
! f1 j8 i$ U! y( \3 [: U3 c4 A p->Func(); // p是“野指针”8 p/ C$ f( H! k7 ^3 O6 E$ \4 h. S# W
8 x$ y* Y! D" n5 _- Q; O% |
} # \ m+ w* s }: T4 ~9 c$ N- Q6 D 7 g' L( z# @( t! k1 D! v/ `4 `3 p- L, F0 i: H8 H, E6 J
函数Test在执行语句p->Func()时,对象a已经消失,而p是指向a的,所以p就成了“野指针”。但奇怪的是有些编译器运行这个程序时居然没有出错,这可能与编译器有关。 # i* O' \& b7 K6 X4 z8 s& G- `7 ~9 e9 x# |* `: k2 _
1.3.6指针参数是如何传递内存的?8 e) G5 }( x6 ]" y) C
( A3 r+ X0 l ^' g' ]* k
如果函数的参数是一个指针,不要指望用该指针去申请动态内存。见如下例子: - f8 P$ _7 {+ @9 G G; s + }/ Y5 k& G, R/ O% y* ^# t void GetMemory(char *ip, int num)5 Q L% P1 A. D7 a
% b: E" s @% G4 z% f free(str); 6 p$ L7 O4 e# c5 u2 r( Q2 S5 Q9 p' i( ?9 z c6 M+ P" l
} $ p) Q8 {5 U; e$ F ' E! `3 r9 m% r1 M; V' y( A" _2 E& _2 }8 x
w: J: Y) b6 G" X; k8 t
用函数返回值来传递动态内存# @4 I9 C5 a# Z0 c
5 ?8 h/ |0 M: f i* P' N
用函数返回值来传递动态内存这种方法虽然好用,但是常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针,因为该内存在函数结束时自动消亡,见如下示例:; X" I" B; S6 T+ `
+ a2 P Z0 q7 w8 n T5 V7 y
char *GetString(void)% t5 c# r4 W- S& d7 O$ M4 d
3 w% Y3 W/ K D{; c; p3 `1 y# O
0 g/ Z$ t2 t) T/ Y+ ~( D char p[] = "hello world";! H0 N v/ V& p9 H) I
+ Y. ^9 T6 t8 H. \ return p; // 编译器将提出警告, [% O% r8 K5 b! f
/ I0 u3 S( G2 \0 ^} 5 Z: l4 J7 z5 z8 o( m3 K 4 z2 C! Z. b% d6 Rvoid Test(void) b8 P. k" ], O: b3 ? / ^/ Y; j- ^) x' p) E{& l {- O: L- `5 m6 ]# |% {
( {/ I9 K1 R; f7 [, |$ _
char *str = NULL;# x( t% q) C, i# i2 L( z; d3 j
1 t" j1 Z$ p% o+ i
str = GetString(); // str 的内容是垃圾& h! [( X. m6 p
0 @4 {/ U: j2 F; l8 Z, N) i
std::cout<< str << std::endl;$ i% p, |9 `) H2 g
9 A8 l0 V" W1 H$ ?* p
}% \, x& W5 J, s: b' f* Z5 e# s
& X5 @; \4 Y! |; G$ b6 ^: [3 o
2 e( Q, J( `+ {1 r
return语句返回指向“栈内存”的指针 I7 x! b# u) F2 ^ M2 {- P' w & E$ N/ }. z) f3 A% `$ {1 o 最后,根据以上阐述,我们总结如下使用规则供大家参考:% t2 ]5 }* q C6 `, ~% W' Y5 z. e
7 m: }; R: m/ i3 f 【规则1】用malloc或new申请内存之后,应该立即检查指针值是否为NULL.防止使用指针值为NULL的内存。 O2 D6 M& x' c7 b7 z- S A$ l# b7 g t
【规则2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。 ! Q% r1 T4 A! w1 S7 I7 Y8 b, R t * Y; M& C% c- k- x( j9 K 【规则3】避免数组或指针的下标越界,特别要当心发生“多1”或者“少1”操作。4 X8 n/ m( p; V, K. m
% O v: R/ c' |* y
【规则4】动态内存的申请与释放必须配对,防止内存泄漏。 : V' A' i+ T! T l; c, z y" O, J# s: |! B3 [2 \: v6 I 【规则5】用free或delete释放了内存之后,立即将指针设置为NULL,防止产生“野指针”。0 v/ L# k# m" S% K: o! E
1 x, S7 P$ U, o
2 @3 N) B4 n8 M, U3 T 1.4.1.2 把一个变量的地址赋予指向相同数据类型的指针变量。例如:2 v+ o, w$ q& m
/ d6 C7 Z2 S) k int a;/ u0 g. F3 `7 x9 g( t$ x& G) S: C* K1 \
; `2 ?, [# x. _9 W8 K* S( U4 }
int *ip; - i4 n* X# q* P% a. u5 L9 j" [2 Z4 l/ s! N% c
ip=&a; //把整型变量a的地址赋予整型指针变量ip1 ~/ n9 |/ Q$ z7 Q8 q' y
2 A7 S( e2 B8 L; Q! y 1.4.1.3把一个指针变量的值赋予指向相同类型变量的另一个指针变量。例如:: [8 a& _: ?' Z; F
9 ?+ G W2 _3 G int a; : u' q4 S( `# e. q, S8 T/ @ % I1 [- a* i; T3 @ int *pa=&a; 2 {! Y- I4 F& H3 E& W/ y: r- R, n; H# s. U# p' F) F4 [; X0 g6 M% K
int *PB; ! `' n% J- W+ _7 P6 X1 b5 t% I) [$ _* c. p1 S3 {
pb=pa; //把a的地址赋予指针变量pb* m) i5 c+ x; h2 e3 N
/ d3 E! U5 H- [8 i% N- M 由于pa,pb均为指向整型变量的指针变量,因此可以相互赋值。 & P7 p9 O V& p- C! A$ @6 N$ S4 [* k6 W
1.4.1.4把数组的首地址赋予指向数组的指针变量。例如:! O3 y# K* m* _0 U. J/ |" q
& Z: ]6 v4 j6 t* M; o' i int a[5],*pa;) j. \4 b0 C; s+ |7 Y6 A @
" D' u' @; u. \2 m
pa=a; //数组名表示数组的首地址,故可赋予指向数组的指针变量pa $ x) D+ Z2 u, R1 F# T" _ $ `) y( @! s1 l* j' k 也可写为:/ [, N' v7 t1 L0 Z
& y0 P( I# ?* F
pa=&a[0]; //数组第一个元素的地址也是整个数组的首地址也可赋予pa ! Y5 p* G5 ~* `! ` w3 r. p! j3 }8 k
当然也可采取初始化赋值的方法:* U, @' m) d2 b+ ~" e
9 a7 s" F8 d5 _" y/ X. E
int a[5],*pa=a;, }2 N5 E) n+ _9 a
9 h" X! s& O% `3 M7 |3 y
以上是一些基本的数组赋值方法,后面我们会详细讨论指针在数组中的使用。 : k9 n; h8 f' ~2 D: \! n7 t4 J( ?3 I9 G; A6 r/ W
1.4.1.5把字符串的首地址赋予指向字符类型的指针变量。例如:# @" @! H- X& h. W4 L7 M* \
1 }3 @3 V* S1 Q4 [6 n6 X4 j char *pc;- [$ D% L8 r* {/ x
5 z" S, g" y3 m4 b. d
pc="c language";6 S. I* N( `7 U7 o
$ [& \* A) Q: {. y7 v7 } 或用初始化赋值的方法写为: ) b; |" x7 ^% Y) [4 h& @# _$ f5 o- w+ r: [- D5 X
char *pc=" c language ";. B" Y v5 P6 c ]0 ~0 T
6 R. R* l8 z) _3 N( G6 j/ a! b- L 这里应说明的是并不是把整个字符串装入指针变量, 而是把存放该字符串的字符数组的首地址装入指针变量。/ \+ [7 f1 ` L, r- C+ z
+ a W' a2 i2 K. \6 m% D, H) b- X
1.4.1.6把函数的入口地址赋予指向函数的指针变量。例如:& K3 M5 h3 U9 @9 R; P
; d8 L j* d# S' [" S int (*pf)(); 1 z2 C7 d' B2 g" ^' x. a' D' U" n7 K7 _7 n Q1 q
pf=f; //f为函数名* ?# D' E3 W U
" P3 J0 Z& q; }5 j, D7 ^! U
1.4.2加减运算5 h/ z& N! n G# _/ w: C7 G2 }
5 W8 ]& h. }3 X& q, ]
对于指向数组的指针变量,可以加上或减去一个整数n.设ip是指向数组a的指针变量,则ip+n,ip-n,ip++,++ip,ip——,——ip 运算都是合法的。指针变量加或减一个整数n的意义是把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。应该注意,数组指针变量向前或向后移动一个位置和地址加1或减1 在概念上是不同的。因为数组可以有不同的类型, 各种类型的数组元素所占的字节长度是不同的。如指针变量加1,即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1.看如下例子:5 r! |$ Y1 M) Q3 R. z
5 ]5 a1 I% Y& L0 Q
D4 Q* D2 j- F6 c F' L2 v char a[20]; ( X3 X1 E- X; |, R S
int*ip=a; : M H4 ]( E: A2 C, ^
... ' I8 V6 |% s" D4 `6 F
ip++; & R- K4 y$ x# m: j8 e; X& O9 ? ) Y( Y" K: ~8 Q# M0 J& a % G9 t; _ k; H0 w 在上例中,指针ip的类型是int*,它指向的类型是int,它被初始化为指向整形变量a.接下来的第3句中,指针ip被加了1,编译器是这样处理的:它把指针ip的值加上了sizeof(int),在32位程序中,是被加上了4.由于地址是用字节做单位的,故ip所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。& f) d* L7 F7 a2 P
+ I+ Y* S5 j, f/ Z8 q# c
由于char类型的长度是一个字节,所以,原来ptr是指向数组a的第0号单元开始的四个字节,此时指向了数组a中从第4号单元开始的四个字节。再看如下例子:& ]9 ?4 N- d8 g1 Z4 p3 w8 l
2 g! }) _3 j6 S1 d2 {4 }5 I, T0 R1 j+ F
char a[20]; * |' w- H. u8 m5 k$ i2 G4 l
int*ip=a; 7 O" A$ m$ C0 f* g- _3 @. c0 m
... $ Z1 s" u8 w) R& h) x8 x4 ]% V ip+=5; + ^; Q9 O" _: s, B0 e/ R) c) K 6 {* X! m3 h/ R+ z/ m, a/ A' O* X
2 j! _2 s/ g, L5 k9 A/ r
在这个例子中,ip被加上了5,编译器是这样处理的:将指针ip的值加上5乘sizeof(int),在32位程序中就是加上了5乘4=20.由于地址的单位是字节,故现在的ip所指向的地址比起加5后的ip所指向的地址来说,向高地址方向移动了20个字节。在这个例子中,没加5前的ip指向数组a的第0号单元开始的四个字节,加5后,ptr已经指向了数组a的合法范围之外了。虽然这种情况在应用上会出问题,但在语法上却是可以的。这也体现出了指针的灵活性。 3 }4 N7 G4 t# Q0 b5 Q8 h . D) q p& o* c: G5 `! b1 y 如果上例中,ip是被减去5,那么处理过程大同小异,只不过ip的值是被减去5乘sizeof(int),新的ip指向的地址将比原来的ip所指向的地址向低地址方向移动了20个字节。2 ]) p! T8 w# ~; _; \7 V5 ~% V
& H; F6 p- j$ v4 p4 f# Q4 w+ H
总结一下,一个指针ipold加上一个整数n后,结果是一个新的指针ipnew,ipnew的类型和ipold的类型相同,ipnew所指向的类型和ipold所指向的类型也相同。ipnew的值将比ipold的值增加了n乘sizeof(ipold所指向的类型)个字节。就是说,ipnew所指向的内存区将比ipold所指向的内存区向高地址方向移动了n乘sizeof(ipold所指向的类型)个字节。 / b8 R. I" }# C9 z/ y: g' p; ]4 m
一个指针ipold减去一个整数n后,结果是一个新的指针ipnew,ipnew的类型和ipold的类型相同,ipnew所指向的类型和ipold所指向的类型也相同。ipnew的值将比ipold的值减少了n乘sizeof(ipold所指向的类型)个字节,就是说,ipnew所指向的内存区将比ipold所指向的内存区向低地址方向移动了n乘sizeof(ipold所指向的类型)个字节。 # m/ S% s( H* T( @
# u+ H& p/ e6 R5 m2 N8 d1.4.3关系运算3 _8 |# l& }* k
: y# c4 V1 g1 h0 _4 @ 指向同一个数组中的不同元素的两个指针可以进行各种关系运算。例如: * m# M) g* z- _4 [2 `6 l* H I5 @; }# q4 k4 N$ }- v( o/ q- W. s
ip1==ip2表示ip1和ip2指向同一数组元素$ [8 T- q4 d9 ]3 O! p+ h
0 Z4 @& I+ V8 r) q
ip1>ip2表示ip1处于高地址位置% y/ u* \# a" ?/ A! C4 X: O% A
9 N6 q' a- m( `" P* P
ip1<IP2表示IP2处于低地址位置< p> 9 z' Z9 P" X0 g q9 f3 [
6 W9 C# W0 b4 C5 Z
指针变量还可以与0比较。设ip为指针变量,则ip==0表明ip是空指针,它不指向任何变量;ip!=0表示ip不是空指针。空指针是由对指针变量赋予0值而得到的。例如:# C# q1 V6 }2 H5 i2 u, N
. O) X3 _% v( _% p, V #define NULL 01 T; A; N+ H$ d/ h, I
1 r$ [7 R" Y) n \ int *ip=NULL; p9 w5 D$ w: G* a/ M* J
8 N9 f2 i/ F7 ~' ~5 p
对指针变量赋0值和不赋值是不同的。指针变量未赋值时,可以是任意值,是不能使用的。否则将造成意外错误。而指针变量赋0值后,则可以使用,只是它不指向具体的变量而已。: B- V. O" w/ ]6 z) {; r