C++数组指针、函数指针、成员函数指针

杨利霞

C++数组指针、函数指针、成员函数指针
C++数组指针、函数指针、成员函数指针

- k0 P3 w- z+ L2 u0 t9 g
" G' [, H+ @2 u0 @操作符名称
& 取地址符(Address-Of operator)
- t5 c5 a4 s2 d8 s* 间接寻址运算符(Indirection operator)
.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
- K9 N! n+ ^, H# H- R.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
() 函数调用运算符(Function-Call operator)
:: 范围解析运算符(Scope-Resolution operator)
如何定义一个指针变量
假设类型T， 变量名称name, 指针的定义如下:
  X4 J7 O) i: X/ U4 E! d: l- r  L( h$ l
$ m7 ^( t/ o2 s' ^. ~& RT* name;
标识变量名字name, 它是T类型的指针。例如

: V8 X. Y0 n; j0 sint n = 0;
5 H( }2 r& c+ P3 Pint* p_n = &n;
p_n是int指针类型， 指向某个int型的对象。
& _" v: F+ z; [( m  |' [& G6 p$ ]+ E7 D
指针变量的修饰
指针实际上也是一种变量类型， 只是它保存的内容有些特别， 是指定类型的地址值，通过间接寻址运算符(indirection operator)*, 可以访问到指针指向地址上的指定类型。

: S8 D3 R5 Q6 C% H9 P) u指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int， 且该变量不能修改。以下两种写法都可以:

/ ]1 p" T0 j" b/ w2 V+ nconst int a = 1;
int const b = 2;
既然指针是也一种变量类型，同样支持被const修饰， 表示指针的值/指针的指向不允许修改， 指针所指向的那个变量是否允许修改， 那是另外修饰。写法如下:

, E! u3 b% ?( c; ^: m" O* @+ bint a = 1;
+ ^! F7 g# g4 m+ X5 Q0 mint b = 2;
+ ^7 |& B3 R; R: g+ j/ L% L- ?0 `int* const cp_a = &a; // 指针的修饰词，放在*号后面。
& O$ ^/ C7 J5 m*cp_a = 10; // 指针指向的值可以修改
3 i, _, ^2 Y9 P6 l/ u/ lcp_a = &b; // 指针不能被修改，报错！
总结带修饰的指针的格式:
/ C" t9 x$ B8 k" ~& `只要记住修饰词总是放在被修饰的内容后面。
. s1 G- `2 G! j7 E
cv表示const / volatile修饰词。指针定义形式如下:

T [cv for T] * [cv for pointer] name
注意对T的修饰放在T的前面也是合法的写法。

const int const c = 2;
在mscv编译器下也不会报错。
) ]9 r5 E. _$ V  p, g
完整的格式:
! U( Q, v0 j- _7 x) q1 i* y[cv for T] T [cv for T] * [cv for pointer] name
1 t( O5 A5 {2 M% N1 b2 [( K
9 u. x* U' i2 m" `Syntax        meaning
% o: ~/ m- x3 x# [/ wconst T*       
& E0 J$ m1 s3 W6 e3 z7 ?8 l9 ppointer to constant object

T const*        pointer to constant object
T* const        constant pointer to object
7 }4 c' Q- l& k) j& A% h! a' jconst T* const        constant pointer to constant object
3 g) c& H2 Z7 a3 I8 OT const* const        constant pointer to constant object
上面格式中T还可以是一种指针， 指针的指针仍然是按照修饰词总是修饰前面的标识(T或者*)来确定修饰的意图。

int a = 1;
int b = 2;
  K/ c" _3 Y6 h$ i( V1 W
1 o( d* R3 _6 G& \; a7 Yint* p_a = &a;
6 F$ j* F2 A# \4 L6 M*p_a = 10; // 合法
. m; P; A+ U2 H2 Ap_a = &b; //合法
, a# ]0 h, L6 C+ [
const int* cp_a = &a; // const修饰int类型， 并非修饰指针
*cp_a = 11; //报错! const int类型不能修改
4 B8 Q+ B; F* s& g5 fcp_a = &b; // 合法， 指针没有const修饰，指针可以修改。
7 e' \/ X  q& N1 e5 Q
int* const pc_a = &a; // const修饰指针。类型没有const修饰
; v5 x+ z5 c7 ]/ P6 u. ^+ s*pc_a = 12; // 合法， 因为类型没有const修饰，可以修改。
pc_a = &b; //报错！ 指针被const修饰， 不能修改指针。

. T( P% \- B" I5 Jint const* const cpc_a = &a; // int类型被它后面的const修饰， 指针符号*后面也有const修饰
*cpc_a = 13; // 报错！ 类型被const修饰，不能修改。
* }2 F) ]$ p' z- \! \cpc_a = &b; // 报错！ 指针被const修饰，不能修改。
& B: \0 x# g# G. b4 S. T: c# v9 N
( E& K" ]" i! K- T 更复杂的指针的指针

( d# q# W0 D  ^1 zint a = 1;
7 d% P8 n& w4 lint b = 2;
( C: @/ G; u8 ]" m+ ~int* p1 = &a;
int* p2 = &b;
/ S; U/ h% L0 ?5 e& tconst int* ct_p1 = &a; // ct for const type
const int* ct_p2 = &b; // ct for const type
% T% z6 L  Z# N; u5 j
// int * * pp1; 指向(int*)类型的指针
int** pp1 = &p1;  
pp1 = &p2; // 合法,
5 c5 R) q; y! App1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)
1 x9 y2 W5 w( A3 Z7 f5 p
// (const int) * * pp1; 指向((const int) *)类型的指针
const int** ct_pp1 = &ct_p1;  
ct_pp1 = &ct_p2; // 合法
" i1 @) _9 Q6 j' M8 i3 J# S. e9 Ict_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。

4 X+ Q8 }0 M( M. x* Q// (const int) (*const)
* p3 J: J( ?+ u/ N1 J8 J! uconst int * const ct_cp1 = &a; // 指针也不能修改
0 P5 H& ~6 s: F$ B' aconst int * const ct_cp2 = &b; // 指针也不能修改
ct_cp1 = &b; // 报错！指针有const修饰

7 _2 m8 H. E2 J5 r% }2 J1 s0 t// (const int) (* const) *  指向((const int) (*const))的指针
const int* const * ct_cp_p1 = &ct_p1;  
ct_cp_p1 = &ct_cp2; // 合法， 指针的指针并没有const修饰， 指向的指针有const修饰
*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改
6 m& v1 V) E  k  J( `
1 G5 t" i. V- I* @# G8 v9 A( ]// (const int) (* const) (*const)  
// 指向((const int) (*const))的指针,且该指针被const修饰
9 X1 d/ `; J+ W/ o. d& Wconst int* const * const ct_cp_cp1 = &ct_cp1;
, s* _+ U6 B+ o* f0 `ct_cp_cp1 = &ct_cp2; // 报错！ 指针的指针被const修饰， 不能修改指针指向。
3 }8 f- n; d9 u+ c  p
一行声明多个变量
类型 + 名称定义一个变量。
' W4 o+ l9 s! J  n5 I变量的前面可以加*号修饰， 表示指针， 一个星号代表一层间接。**表示指针的指针。

int a, *b, *c, d, **e;
0 N9 `# S; h$ d9 G& P+ la = 0;
d = 1;
6 x+ T  Q* W8 l% n3 Zb = &a;
' t% a3 s- Q4 V6 s* W8 n$ G; bc = &d;
  ]) w  {# U  K3 ?: j0 Me = &b; // e为int**类型 指针的指针
e = &c; // e为int**类型 指针的指针
也可以用括号包围变量和*号。
( Q7 n) y9 w5 g2 t/ V
- p" ~0 ~. }" ^/ s# `* fint (a), (*b), (*c), (d), (**e); // 合法定义。
括号可以省略，某些情况， 个人感觉加上括号更清晰一些。例如
4 P" A. s/ R! x- F& ?4 k3 t' }& V: X
int (a), (const *b), (*const c) = &a, (const d), (const* const* const e) = &c;
写成
- n" J# z* R$ F1 S8 B# z+ c- L- p
6 T: i: a  Z3 D; E1 M7 ^int a, const *b, *const c = &a, const d, const* const* const e = &c;
更重要的是， 后面我们表达数组指针，以及函数指针时，括号是不可缺少的， 带括号的表达更加统一。
) C) ^% A. P5 k" E
数组指针
8 R6 v& l. m9 x8 {4 Q, G数组基本表达
int a[10];  // 定义了类型是int, 元素个数是10的一个数组。
# n& W3 M& h' w由于c++要支持一行定义一个类型的多个变量。 所以数组的[]时放在名称后面的。虽然我觉得

int[10] a;
这样的写法更符合类型 名称的思维， 但是如果类型都这么写的话， 没法兼容以下的写法:

int a = 0, *b = nullptr, c[20], **d = nullptr;
c++标准规定如此，但我们可以通过每一行只定义一个变量的写法， 类型会更加清晰。
/ G( g& S- X# @3 G
2 I2 n" Y* {, ?* U7 yint a = 0;
int* b = nullptr; // 指针int*
% A, }( l! Y! x4 \+ f, ]int c[20];
int** d = nullptr; // 指针的指针int**
数组的名称是什么类型
1 m1 b# M$ y) d' e; ]数组元素类型的指针，可以直接指向数组。 并且数组跟指针一样，可以通过下标去访问元素。
6 G9 X! a7 n1 [( I7 j
int a[10];
int* p = a; // 指向a数组的第一个元素
a[1] = 1;
p[1] = 1; // 效果与a[1] = 1一样。
数组可以当作T* const来使用， 但是又与T* const有些不同。sizeof()的结果不一样。
- V& a% `2 p4 Y  N
8 b( y8 O' _) S# b* `int a[10];
int b[10];
int* const p_a = a;
a[0] = 1; // 合法。 数组的元素可以修改。
p_a[0] = 1; // 效果与a[0] = 1一样。
1 a- A' w3 S. Y. Q$ n* R' q
# V! h5 P2 Z" G7 |! ya = b; // 报错！ 数组本身的指向不能修改。
8 p$ F( [8 |9 F+ E4 v. Z  N
// 所以数组a可以当作int* const来使用
/ S7 J7 v$ y9 c" zint *const& ref1 = a; //正确。
int *& ref2 = a; // 报错!
9 K5 W3 R( Q" Z" Z8 P
// 但是又跟int* const有些区别。
* {' Z% {# K- Eassert(sizeof(p_a) == 4); // 32bit程序。
assert(sizeof(a) == 4*10); // 32bit程序

数组跟元素指针的作用很相似，都可以通过下标去访问元素， 但调用sizeof()函数的结果不一样。元素指针的sizeof()返回值是4(32-bit应用)或者8(64-bit应用)， 数组的sizeof()返回值是数组实际占用的空间。数组可以当作指向第一个元素地址的T* const来用其实就是我们常说的数组到指针的隐式转换。当数组作为函数参数传递后，会自动退化成T* const, 在被调用的函数内部调用sizeof()的返回值跟T* const指针大小一样。 数组传递作为函数参数后， 在被调用函数的内部与T* const是没有任何区别，只有在数组定义的可见范围内sizeof()才有获取数组占用空间大小的效果。
0 v# c% Q0 Y" G% q6 o& B
* n" N, o/ N! l2 U0 [# p- ^以下3个函数翻译成汇编以后，汇编代码是一样的。

void Func1(int* p_ary)
+ O3 Z% E+ W4 C: z4 i{
. ?& R: j6 D$ s    assert(sizeof(p_ary) == 4); // 32-bit
0 V0 y! {) l2 O  i7 o    p_ary[1] = 1;
# Y% t7 V! D% l; f4 o0 S. U; l}
+ p$ P* V$ M# G$ l- ~) a
1 [0 t2 m* f) _: V6 S( X6 p0 Rvoid Func2(int ary[])
  {; V! p: I8 \! n2 W" X$ z7 Y{
0 a( u/ \  B3 b6 y2 q0 b, x    assert(sizeof(ary) == 4); // 32-bit
; `# b" @/ f. f8 l2 D: M( e    ary[1] = 1;
2 F$ B/ h, x4 Y' q7 P}

: X- o* X. H: B' d, Zvoid Func3(int ary[10])
{
    assert(sizeof(ary) == 4); // 32-bit
    ary[1] = 1;
# d9 O% h" a$ D; p, s1 f4 ]}

int main(int argc, char** argv)
{
+ s. Q) A" Q( Y6 u& Q8 V) x    int a[10];
    int b[20];
  F, D, T: z: F% e9 d    Func1(a);
    Func2(a);
1 V: n; R# h2 R- x1 I* m# A% o4 `$ n    Func3(a);
0 r8 ]$ w) Q1 ]4 R* f0 z    Func3(b); // 退化成int* const了， 即使数组长度不匹配也不会报错。
" F0 n. M, d  a# n! w1 J' N: p    return 0;
}
; F2 C$ X; w# r3 {+ \
/ j$ C6 N8 h) t

4 t9 f/ ]3 @/ d. k多维数组
一个3行，4列的数组， 结构如下:
" T% T/ Q) O9 \! i2 S  ^, _
int a[3][4];
column 0        column 1        column 2        column 3
row 0        a[0][0]        a[0][1]        a[0][2]        a[0][3]
4 ~0 C( s& f6 f; Y4 Nrow 1        a[1][0]        a[1][1]        a[1][2]        a[1][3]
+ `$ x8 n( [$ T  O8 v: arow 2        a[2][0]        a[2][1]        a[2][2]        a[2][3]
数组初始化
7 S4 K) Q6 a2 ^
1 V1 Z' f. ?, v; A) U* C# J# [/ T. w/ Hint a[3][4] = {
7 k4 [: N+ ^* Q6 W. r    {0, 1, 2, 3},
    {4, 5, 6, 7},
1 N& @$ [4 W5 \6 Y1 j9 @; |3 z; |    {8, 9, 10, 11}
};
: [( i' ^% q7 N0 X* W 实际上多维数组和1维数组在开启速度优化后，翻译成汇编代码是一样的。
+ r0 ?$ C+ }, o# `0 {$ `, K+ I) e
void Print(int* p_ary);
& E+ d$ r/ V. P6 u( }
void Test1()
' b4 _* d! ~; D; \8 P3 Z0 P{
0 Q! g) o6 h4 |5 X- W/ D/ n* D9 A    int a[10];
" w* _' u% j" ^3 t' ]7 Y) `    a[3] = 3;
4 \2 e8 S7 ?- i# }! U) e& k8 h    a[7] = 7;
2 J7 E7 d+ @6 W. b    Print(&a[0]);
}

( }+ }4 \: B) x. e+ [void Test2()
{
, a- u5 z4 N% f" \$ ]    int a[2][5];
    a[0][3] = 3;
    a[1][2] = 7;
$ G+ c# P. w- G9 I9 p    Print(&a[0][0]);
}
- j1 f- _* E4 n& ?  G, y

. u3 u3 N1 j$ S* \- C7 e6 ^$ y
很自然地，多维数组也支持用1维数组的方式去初始化。

int a[3][4] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
既然多维数组与1维数组没什么区别， 为什么还需要多维数组？

假设有一幅RGB图像720*576个像素，每个像素有RGB三个通道，每个通道的值是8bit大小。给出图像的首地址p_rgb_image， 我们要取第40行，第50个像素的R,G,B值。代码如下:
* N' D. c  u7 I! l: o* l
unsigned char* p_rgb_image;
7 N" F' \+ v, b$ Z7 ^6 Nunsigned char r = p_rgb_image[40*720*3 + 50 + 0];
unsigned char g = p_rgb_image[40*720*3 + 50 + 1];
/ j$ b* z- \9 w, ?: q& Sunsigned char b = p_rgb_image[40*720*3 + 50 + 2];
" f8 ^$ y1 X; p* d& a类似这样的场景， 采用多维数组的写法， 有点类似以索引为参数，可读性更高。相当于程序员和编译器打了一个配合。
* C) \: }5 I" g8 E6 ?. M
6 J7 f$ ]0 h. e3 T+ Ienum
0 V% K+ A4 _& ?7 b: _* e{
Red = 0,
Green = 1,
3 K9 a2 b  k3 ~$ K% H& _ Blue = 2
};
unsigned char rgb_image[576][720][3];
int row = 40;
& L1 ~2 I; l8 U5 B0 l8 aint col = 50;
' P1 s, \7 _; [unsigned char r = rgb_image[row][col][Red];
unsigned char g = rgb_image[row][col][Green];
& ^% y' V; r  Z' F6 Hunsigned char b = rgb_image[row][col][Blue];
  h; s$ [7 `+ g数组指针以及与指针数组的区别
数组指针，是一个指针， 指向的对象是数组。 数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时， 需用用*取得数组对象的引用，再用下标来访问数组元素。
/ R8 E5 y2 V' q- ?" |) `指针数组，是一个数组， 数组保存的元素的类型是指针。
; e5 A0 i5 z  O6 d, H+ p数组指针的定义
& ?- v: O; _' B" v+ R8 `$ T! Z+ p$ s数组指针定义先定义一个数组。
int a[10];
$ Q/ q' `1 n# e# G8 t然后对数组里的名称用括号括起来后再在变量名称前面加个*号
& {# u) h; `( n$ Z  d; Yint (*a)[10];
1 V" b* K# \' G# C9 ?; J: s后面你会发现函数指针定义类似。
, z6 P" u5 A! W/ t. z( p# `// 各类定义对比
int a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];
6 j% t8 k; a9 d( m  \" r4 U' w
int *f[10]; // 指针数组, f是包含10个元素的数组， 数组里每一个元素的类型都是int*
2 x* |. l! f1 \; r5 aint *(f2[10]); // 指针数组。另外一种定义方式。
  x4 I. ~0 v& x* ^$ q8 Bint(*f3[10]); // 指针数组。另外一种定义方式。
int(f4)[10]; // int数组
int(*g)[10]; // 数组指针， g是一个指针， 这个指针可以指向类型是int，元素个数是10的数组
* J& c/ z$ ^4 M2 v# l9 |7 L$ Xint* (*h)[10]; // 数组指针， h是一个指针， 这个指针可以指向类型是int*，元素个数是10的指针数组

3 n6 K0 m$ y3 Q2 Pint d[10];
g = &d;
) }) Y8 E+ m  c' [. M1 q
int* e[10];
5 A! y/ B/ V5 M+ I$ ?  ^; d2 Vh = &e;
数组指针的使用
数组指针一般先通过*号取得指针指向的数组对象， 然后再用下标操作访问元素。
& Z" |8 a& z2 \3 n& r1 }
int a[10];
: B% ^" \7 c, k/ Jint(*p_ary)[10] = &a; // p_ary是一个指针， 指向"int (*)[10]"类型的数组
+ Q' Q. C: z' P% i2 ]2 `for (int i = 0; i < 10; i++) {
// p_ary是一个指向数组的指针， 需要先通过间接寻址运算符*(indirection operator)取得数组对象
// 再通过下标操作访问元素。
9 k: |: S, D! H% I  D+ g0 Z (*p_ary) = i;
}
# j- M, M( B8 Z, V, n, R
7 d" r* _% u% R0 t6 |. h( p) ?int b[10];
int c[20];
p_ary = &b; // 合法
p_ary = &c; // 报错！ 不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
! c6 n% j5 \, |, o% G5 @% y数组指针指向多维数组的子数组
& o* z' k* c7 Q& A. u. D  k8 Qint a[10];
int b[4][10];
int(*p_ary)[10] = &a;
  c; E* r7 \9 ^  A# nfor (int i = 0; i < 10; i++) {
) ^* S( q4 z: \3 y (*p_ary) = 1;
, F5 J5 |4 d6 {+ |/ J}
( v, }5 l; ]  Q* b4 ^; f, `
; J6 N' r6 g; J+ C# e* L, Lp_ary = &b[2]; // 多维数组，可以看作数组的数组，
7 z0 E% L! e8 @' {- h; G  d% R// b[2][0] ~ b[2][9]的值都被改成2了
  q$ U# [2 [) u. q& W, T  Tfor (int i = 0; i < 10; i++) {
; |+ W" S+ @+ {5 `) C2 g  @ (*p_ary) = 2;
}
. p: N: A5 n* ^: ^多维数组指针
多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。
3 M- G+ @9 u; t
9 A/ n7 _5 P8 B( a0 ^( aint a[2][5][10];
' s. }9 Q+ f) uint(*p_ary1)[10] = &a[1][2]; // 1维数组指针
int(*p_ary2)[5][10] = &a[1]; // 2维数组指针
, T+ p# q" E. \( {) V8 ufor (int row = 0; row < 5; row++) {
    for (int col = 0; col < 10; col++) {
        (*p_ary2)[row][col] = row * col;
1 k1 [( t8 m9 D8 M    }
}
数组指针和指针数组对比实例
/ E- M3 K  O$ m% B数组指针还是记住两步法即可
* l# o/ L0 a9 d+ a
定义一个数组
$ o# e$ M* H, }" m' A括号包围1中定义的名称，再在名称前加个*号。
1 m8 o. H& [! }% j8 ~) nint a[10];
int(*ary_pointer1)[10] = &a; // 数组指针
int* pointer_ary1[10]; // 指针数组。元素类型是int*
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
# O: ~6 W8 d/ W- Y% T+ l! G, Eint c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
: ~" X* g( D& Q) _: u
// 指针数组可以把每个元素指向数组对应位置的地址。
// 这样遍历指针数组， 可以达到遍历数组元素的效果，但是注意每个元素都是指针，
// 需要访问原数组的值的话， 需要对指针用*间接寻址运算符。
# [. X9 G! S& u( _& t; i4 T7 @! Kint* pointer_ary[10];
3 m3 p) K* t9 o( {0 U0 Ofor (int i = 0; i < 10; i++) {
. Q$ Q/ c/ Z% C0 N7 j% H    pointer_ary = &a;
* G- c0 _2 }0 n( H}
( U+ t5 q* z+ ~. R1 c& E// 类似遍历原数组效果。
. t& N) f4 x& F6 g* jfor (int i = 0; i < 10; i++) {
    *pointer_ary = i; // 修改原数组。
}
  j( {* l# `! R; c$ S6 X+ b
4 T" ^: g4 {+ X- n: k函数指针
7 d( R' d, f2 q# H: P( Y取得函数地址
  O5 l2 C% X- R% I: v+ p函数的名称作为参数被传递时，会隐式转换成函数指针， 和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
+ J1 }) G, i. q
void f(int);
$ B7 ^$ S1 r0 H/ k. Z: m! W1 Vint main()
* w" p! e% _1 _) t# l{
8 E8 d+ C3 N+ \" w' K4 M    void (*p1)(int) = &f;
* w7 w; c# A0 w4 i" j  C    void (*p2)(int) = f; // same as &f
) I+ X$ d& L+ `2 W    return 0;
}
翻译成汇编代码， p1和p2的赋值是一样的。

' l' K; W5 [) ~2 A# U) r7 p" W

函数指针的声明
& {9 D7 ^& C8 l  B* _单个函数指针变量定义步骤
定义一个函数。void fun1(int a, int b); int fun2(double a);
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
1 A; ?- u9 G) D6 L6 {+ x( vtypedef定义函数指针
: W' z7 f9 C8 V% c; r可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
" A: W! F2 G0 P; V7 T2 t9 F7 R
9 Y  u$ X# _: M( y# Etypedef定义函数指针的语法
  j  m9 ^4 x' }( r- xtypedef有两种做法， 一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值， 但是支持引用。
. r3 r! m. k2 H* j3 U- S2 E/ f
; ?6 M: _9 y  @% L0 x! [/ ?/ \typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
9 f0 |6 d. M0 a4 M+ Z5 fFuncObject* f1 = &Add;
FuncPointer f2;
f2 = f1; // f1, f2类型一样， 都是形式为int(int, int)的函数的指针。
; J0 \( R( p8 B& d4 nFuncObject f3 = Add; // 报错！ 函数对象不支持拷贝
8 Y" ?/ j% e/ T- B1 g+ sFuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
8 q8 |- N. d, M" ?1 i3 E* oFuncObject& f5 = Add; // 正确
int ret = f5(2, 3); // 正确
3 U8 n- k, _% M* a, BFuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
如何记住typedef定义函数指针的步骤
' _1 `: w; R  i2 V) b像定义一个函数指针那样， 指定一个名称。int (*CalFun)(int a, int b);
% t9 X( m( V! {在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
完整例子
typedef int(*CalFun)(int a, int b);
# K7 Y4 I$ k! d8 |2 F8 J
2 [& h, M; F7 Sint Add(int a, int b)
& E" a' Y/ I, z) B2 c$ y{
    return (a + b);
# H! F- h  b) D* j  G}

int Sub(int a, int b)
{
    return (a - b);
9 c" N/ |7 E3 ?/ X}

  D8 s: f2 t6 k" u5 Jint main(int argc, char** argv)
8 d9 M& t3 |% l1 L{
. f/ c& W* Z: o2 V' a' z    CalFun f1 = Add;
5 h7 {3 i7 ?9 l) b2 ]4 e4 M    CalFun f2 = Sub;
    int a = f1(2, 3);
2 \9 u4 |5 C5 ^" N    int b = f2(10, 5);

    // typedef定义的函数指针数组。
    CalFun f_ary[2];
1 W% i$ U* w5 G. u; ?5 E- K4 [7 P& l    f_ary[0] = Add;
( G; k1 |! }) b8 {    f_ary[1] = Sub;

5 F% R: ?$ j: F% [    // 单个定义的函数指针数组。
    int(*f_ary2[2])(int a, int b);
* ?! R: e  {$ W0 U    f_ary2[0] = Add;
    f_ary2[1] = Sub;
  F8 ~2 P+ o  j+ G1 D* K. k+ e1 `
; U1 g8 T1 e# ^4 A+ k5 h. e% ^  h) l    return 0;
}

4 ?/ A% k4 r9 m6 Pusing别名定义函数指针
! ^0 k5 [- G7 h% z4 o/ gc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。

2 [, F0 P" i; Y& ?" |/ ]) Qtypedef int FuncObject(int a, int b); // FuncObject类型是函数对象
( G# M/ x& p. v: D8 u+ _  Ousing FuncObject = int(int a, int b);
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
using FuncPointer = int(*)(int a, int b);
函数指针的调用
函数指针和函数对象都可以直接后加括号调用
int f();
; a# _0 y5 w, V2 ^' o/ kint (*p)() = f;  // pointer p is pointing to f
& F  U. G+ P! L. K: _; D$ bint (&r)() = *p; // the lvalue that identifies f is bound to a reference
r();             // function f invoked through lvalue reference
(*p)();          // function f invoked through the function lvalue
: {+ ?) G8 c& Hp();             // function f invoked directly through the pointer
9 h9 k/ u  u" b. D8 w. I如果函数有重载， 函数指针会指向匹配的那个版本。
' d" N# W! c' _: Stemplate<typename T>
T f(T n) { return n; }

2 k' p! P& i. ]7 d+ u4 Kdouble f(double n) { return n; }
# \! R7 G/ J+ B$ x, B
int main()
{
/ G+ {, e- Z. o    int (*p)(int) = f; // instantiates and selects f<int>
2 d( w4 \, H: `( Q3 A* g}
" Z8 I+ e, `" C8 g) @* s5 Q& k8 J成员函数指针
9 i* v6 e" H5 E0 \  h" ~: ^- i静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。

) x8 v. e& ~# n4 l& S成员函数指针定义。
: v. O  Z/ I0 n( L9 J4 K& ~像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
0 |7 S5 Y: N, C9 Z$ X; L" A, o- i括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
在名称的前面加个*号void (ClassName::*func)(int);
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
! m7 t: C. e2 L' J# `成员函数指针如何调用。
假设成员函数指针名字为func
( T: ^7 z; d2 a+ n9 c
  f$ S4 F. N1 h' @: r* ?4 Cvoid (ClassName::*func)(int);
  u0 j) L8 N; D. A- I) s对象式调用。
ClassName c; // 被调用的对象
成员函数指针名字当作正常函数那样写。
c.func(3);
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
+ E% [; n. q7 j, t) ^c.*func(3);
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
0 N, d! Q* Y7 V. A4 s' Y/ A(c.*func)(3);
9 h0 Y- S. {- M# q- {6 D% }' s- G为何要加上括号？ 根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低， 成员函数指针还没取得对象就被调用了，自然报错。 另外
  B8 L8 v( m9 v* q(c.(*func))(3);
2 @  e' l' C0 N- J4 B' {) X+ D这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
9 O5 x9 G, q' Q- R/ c. b6 k2 |指针式调用
ClassName* p; // 被调用的对象的指针
成员函数指针名字当作正常函数那样写。
p->func(3);
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
p->*func(3);
& v, c8 t9 n4 ]" m' G- @+ ]7 x最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
(p->*func)(3);
函数指针使用完整例子
9 b" H. j" B$ g3 lstruct Cal
{
    int add(int a, int b);
    int sub(int a, int b);
};

int main()
{
    int (Cal::*fun)(int, int) = &Cal::add;
    fun = &Cal::sub;

0 T* b+ f1 q, f& J( a; r: _    Cal* p_cal = new Cal();
6 w, }  `2 P, W6 l) L    int r1 = (p_cal->*fun)(2, 3);
7 J  M/ T- @- Z! O5 A    delete p_cal;
. B) T- k: Y+ L7 Z
6 V7 H5 I$ v9 G( f2 `" p9 r    Cal local_cal;
+ ~& J# S7 g  m0 h    int r2 = (local_cal.*fun)(8, 6);
$ J: @' F' {5 E! L2 t: t1 h}
4 h$ s2 t1 Y* B2 d8 Q; ]
* x1 h- Q* ^4 l成员变量指针
* E5 g! }4 m* w3 l& S成员变量指针比成员函数指针还要简单些，没有函数调用， 无需考虑函数调用和间接引用符*的优先级问题。
$ _; U; \* S" c, x: G" [
成员变量指针的定义
假如以下结构体C。
& T2 S, f8 u9 ~& t: Q' t
1 R9 f# i+ |  \$ ?struct C
{
$ J) t. f$ H5 d6 ]% \! m/ Z, ?    int m;
};
单个成员变量指针定义
1 A) {' X: i. e, e; x) Z* d5 i4 x假设名称为p, 类似静态成员变量定义那样声明
; R+ @* U5 K8 |5 R9 B4 L8 Uint C::p;
在名称前面加上指针标识号*
( B; e2 ?4 j$ c) |& aint C::*p;
typedef或using方式定义
2 i, \3 D8 E' t# utypedef int C::*MemberPointer;
, ]: x% K, s, s0 ausing MemberPointer = int C::*;
成员变量指针的使用。
+ D$ l3 n* E( H$ O9 M类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
1 D) ~3 u8 v% G, |2 W; J成员变量指针， 能让我们实现一些遍历成员的动态功能。 例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。
4 `8 ?; |. k* W1 c2 w
' U$ U  Z7 e$ U& [! B 完整例子
+ B, u! {, N1 F- g! a6 Pstruct C { int m; };
int main()
; f3 [, E8 O: V7 d( @: U{
$ T2 g/ L3 U  e, q; ~' T    int C::* p = &C::m;          // pointer to data member m of class C
    C c = {7};
# o0 w" q& i+ R- Y7 Z    std::cout << c.*p << '\n';   // prints 7
    C* cp = &c;
' q7 G2 t! f. V, t" M6 L% Y    cp->m = 10;
3 B3 M7 ~) H  k7 x& N; }    std::cout << cp->*p << '\n'; // prints 10

————————————————
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
6 Z! W6 n; b# i7 X& E- P' I5 ^原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
/ s. q+ b& a  x) x4 M! L5 S3 j- [

+ C3 {; D. |2 Z) E/ O; l2 C/ H