C++指针之间的赋值与转换规则总结
Note:以下结论不适用于类的成员函数指针,关于类的成员函数指针会单独讨论。
一、任何类型的指针变量均可直接赋值给const void *
任何类型的非const指针变量均可直接赋值给void *
const指针变量不可直接赋值给void *,除非通过强制类型转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
class
A
{
};
typedef
int
(*pFun)(string);
//函数指针
int
*pInt;
const
int
*pInt_c;
char
*pChar;
const
char
*pChar_c;
double
*pDouble;
const
double
*pDouble_c;
A *pA;
//自定义类型指针
const
A *pA_c;
pFun pf;
//函数指针
void
* pVoid;
const
void
* pVoid_c;
// 1.任何类型的指针变量均可直接赋值给const void *
pVoid_c = pInt;
//ok
pVoid_c = pInt_c;
//ok
pVoid_c = pChar;
//ok
pVoid_c = pChar_c;
//ok
pVoid_c = pDouble;
//ok
pVoid_c = pDouble_c;
//ok
pVoid_c = pA;
//ok
pVoid_c = pA_c;
//ok
pVoid_c = pf;
//ok
// 2.任何类型的非const指针变量均可直接赋值给void *
pVoid = pInt;
//ok
pVoid = pChar;
//ok
pVoid = pDouble;
//ok
pVoid = pA;
//ok
pVoid = pf;
//ok
// 3.const指针变量不可直接赋值给void *,除非通过强制类型转换
pVoid = pInt_c;
//error: cannot convert from 'const int *' to 'void *'
pVoid = pChar_c;
//error: cannot convert from 'const char *' to 'void *'
pVoid = pDouble_c;
//error: cannot convert from 'const double *' to 'void *'
pVoid = pA_c;
//error: cannot convert from 'const A *' to 'void *'
pVoid = (
void
*)pInt_c;
//ok
pVoid = (
void
*)pChar_c;
//ok
pVoid = (
void
*)pDouble_c;
//ok
pVoid = (
void
*)pA_c;
//ok
|
二、任意类型指针变量之间均可以强制类型转换,包括const与非const指针变量之间的强制类型转换。
1
2
3
4
5
6
7
8
9
|
pInt = (
int
*)pDouble;
//ok
pInt = (
int
*)pf;
//ok
pInt = (
int
*)pInt_c;
//ok:由const指针变量转非const指针变量
pInt = (
int
*)pA_c;
//ok:由const指针变量转非const指针变量
pA = (A*)pA_c;
//ok:由const指针变量转非const指针变量
pA = (A*)pDouble;
//ok
pA = (A*)pf;
//ok
pf = (pFun)pDouble;
//ok
pf = (pFun)pA;
//ok
|
三、有继承关系的自定义类型之间:子类型指针变量可直接赋值给父类型指针变量
父类型指针变量不可直接赋值给子类型指针变量,除非通过强制类型转换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
class
A
{};
class
B :
public
A
// B继承自A
{};
class
C
{};
A* pA;
B* pB;
C* pC;
pA = pB;
//ok: 子类型指针变量可直接赋值给父类型指针变量
pB = pA;
//error: 父类型指针变量不可直接赋值给子类型指针变量,除非强制类型转换
//以下适用规则二:
pA = (A*)pC;
//ok
pB = (B*)pA;
//ok
pB = (B*)pC;
//ok
pC = (C*)pA;
//ok
pC = (C*)pB;
//ok
|
补充:
1、对于类的成员函数指针,以上原则不适用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
class
A
{};
typedef
void
(A::*AFunPointer)(
void
);
typedef
void
(*FunPtr)(
void
);
void
* pVoid;
int
* pInt;
FunPtr fp;
AFunPointer afp;
pVoid = afp;
//error: cannot convert from 'AFunPointer' to 'void *'
pInt = (
int
*)afp;
//error: 'type cast' : cannot convert from 'AFunPointer' to 'int *'
fp = (FunPtr)afp;
//error: 'type cast' : cannot convert from 'AFunPointer' to 'FunPtr'
afp = (AFunPointer)pInt;
//error: 'type cast' : cannot convert from 'int *' to 'AFunPointer'
afp = (AFunPointer)pVoid;
//error: 'type cast' : cannot convert from 'void *' to 'AFunPointer'
afp = (AFunPointer)fp;
//error: 'type cast' : cannot convert from 'FunPtr' to 'AFunPointer'
|
我们可以这样理解:类的成员函数指针被限定在具体的某个类的作用域中了,他不能和域外的指针之间转换。
2、除去类的成员函数指针,虽然任意类型指针变量之间均可以强制类型转换,也即可以将const指针强转为非const指针。
但是应注意:如果将const指针强转为非const指针而用于原本const的对象,则产生未定义行为(C++语言未对此种情况进行规定)。如:
1
2
3
4
5
6
7
|
const
int
a = 50;
// 定义const变量及常量
const
int
* p = &a;
// const指针变量p指向const变量a
int
* q = (
int
*)p;
// const指针强转为非const指针,则非const指针变量q指向const变量a
*q = 56;
// 行为未定义,以下输出为VS2008下的输出结果
cout << a << endl;
//输出: 50
cout << *p << endl;
//输出: 56,很显然,p已经不指向a了
cout << *q << endl;
//输出: 56,很显然,q已经不指向a了
|
3、关于一般函数指针的强制转换,以下当然也是OK的。
class A; typedef void (*pFun1)(int, int); typedef int (*pFun2)(A*, double); pFun1 pf1; pFun2 pf2; pf2 = (pFun2)pf1; // OK