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

杨利霞

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


操作符名称
+ u, ?+ _" K1 _4 l# W+ v1 e. o- n& 取地址符(Address-Of operator)
* 间接寻址运算符(Indirection operator)
' s& Y) F* W/ A; m$ d7 T: k.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
$ @, v, |2 _9 x.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
( e+ j3 @% u6 f() 函数调用运算符(Function-Call operator)
3 }8 ?1 H7 A3 _6 G; Y. ^8 x:: 范围解析运算符(Scope-Resolution operator)
如何定义一个指针变量
( C9 u- g# E/ }. |# z3 @假设类型T， 变量名称name, 指针的定义如下:
1 a6 S2 N* b1 k1 r! e5 M- k+ U
T* name;
% [" S/ L1 J8 X& Q标识变量名字name, 它是T类型的指针。例如

8 K: C8 @9 {5 ]5 }  Pint n = 0;
int* p_n = &n;
p_n是int指针类型， 指向某个int型的对象。

指针变量的修饰
3 Q( D# Z9 H  ~* P! b4 N指针实际上也是一种变量类型， 只是它保存的内容有些特别， 是指定类型的地址值，通过间接寻址运算符(indirection operator)*, 可以访问到指针指向地址上的指定类型。
7 O# J6 A5 t+ C# f  n* z
指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int， 且该变量不能修改。以下两种写法都可以:

const int a = 1;
int const b = 2;
' C9 V6 ~, j) b7 J既然指针是也一种变量类型，同样支持被const修饰， 表示指针的值/指针的指向不允许修改， 指针所指向的那个变量是否允许修改， 那是另外修饰。写法如下:
7 i+ c* Y* i, B2 S0 @+ [% Y
int a = 1;
int b = 2;
+ X" z; A" P) y3 ^% k5 bint* const cp_a = &a; // 指针的修饰词，放在*号后面。
0 E3 p+ J/ }0 {6 N*cp_a = 10; // 指针指向的值可以修改
% ^: D: w& e7 A9 q8 n3 Wcp_a = &b; // 指针不能被修改，报错！
1 _. p- q7 Z7 b  z总结带修饰的指针的格式:
3 K* q% |7 Y! r! Y: `只要记住修饰词总是放在被修饰的内容后面。

6 ^! N% L; `" z+ h& s7 Zcv表示const / volatile修饰词。指针定义形式如下:
  `' c8 U$ C/ a! G
T [cv for T] * [cv for pointer] name
& @$ b6 s6 N- V' m5 ]/ Z2 z! f' A注意对T的修饰放在T的前面也是合法的写法。

2 T) ^0 `( B( Hconst int const c = 2;
在mscv编译器下也不会报错。

: _" F3 S. ?" F6 X$ c) H; i完整的格式:
9 q) {$ V7 O; I- y; B9 g% u8 m+ h[cv for T] T [cv for T] * [cv for pointer] name

# Q. U6 V6 h; p$ kSyntax        meaning
& M* J2 O! K; m. `) L* M( c. O2 zconst T*       
$ e7 F6 w; h; w3 w, v# e. mpointer to constant object
$ o7 @) f9 u: H3 V
T const*        pointer to constant object
! S, S- G( o- U' sT* const        constant pointer to object
5 t5 O2 E' h+ o2 k: O" ?* m) Dconst T* const        constant pointer to constant object
( q: w/ ^( K0 \! G. ]; a# [/ QT const* const        constant pointer to constant object
上面格式中T还可以是一种指针， 指针的指针仍然是按照修饰词总是修饰前面的标识(T或者*)来确定修饰的意图。
! L7 A; B! U" X5 m% g% x
1 W5 @3 |; Z* C* k" N( Y% Rint a = 1;
int b = 2;
9 L( ]- E7 L- g! n  T; [+ C+ d
int* p_a = &a;
6 Y1 y; C0 P  [! v# S8 h5 h! |*p_a = 10; // 合法
: q! t: _3 o$ i/ r8 J$ V. sp_a = &b; //合法

const int* cp_a = &a; // const修饰int类型， 并非修饰指针
) U# b- @, C2 x- m*cp_a = 11; //报错! const int类型不能修改
cp_a = &b; // 合法， 指针没有const修饰，指针可以修改。

int* const pc_a = &a; // const修饰指针。类型没有const修饰
*pc_a = 12; // 合法， 因为类型没有const修饰，可以修改。
) f5 D8 D) k8 L" j+ {pc_a = &b; //报错！ 指针被const修饰， 不能修改指针。
4 a1 B' x( |- {+ v' T
2 Q/ j7 l( a) c5 i! x( w: M- |int const* const cpc_a = &a; // int类型被它后面的const修饰， 指针符号*后面也有const修饰
4 s2 e5 @" D9 Q8 ]*cpc_a = 13; // 报错！ 类型被const修饰，不能修改。
9 Y. A- g" S( p& |5 Kcpc_a = &b; // 报错！ 指针被const修饰，不能修改。
6 Z( |9 _% i, G
更复杂的指针的指针
: K$ t4 Q; n: z  S$ o5 m/ K
int a = 1;
int b = 2;
! [; `/ V3 ?; T4 F  ^+ z- v* pint* p1 = &a;
int* p2 = &b;
const int* ct_p1 = &a; // ct for const type
const int* ct_p2 = &b; // ct for const type

// int * * pp1; 指向(int*)类型的指针
) G: Y3 K0 s, u4 m; |int** pp1 = &p1;  
pp1 = &p2; // 合法,
pp1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)
. \# B8 l: E: {/ H3 a: n
1 `# F6 a6 Z3 d& _1 S& a7 _// (const int) * * pp1; 指向((const int) *)类型的指针
; |1 B1 N' b$ t  @; S& n0 p3 g+ Gconst int** ct_pp1 = &ct_p1;  
; L' O/ [  k  c5 l' r  Jct_pp1 = &ct_p2; // 合法
! ^' w  t$ ^2 q) V! Wct_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。

// (const int) (*const)
( T" B" l) R1 q% J- h, \const int * const ct_cp1 = &a; // 指针也不能修改
const int * const ct_cp2 = &b; // 指针也不能修改
$ ^: L8 {2 T: [" ~, Xct_cp1 = &b; // 报错！指针有const修饰

// (const int) (* const) *  指向((const int) (*const))的指针
& a4 y. m, h' f* z, Z4 Q2 t0 E, J* Nconst int* const * ct_cp_p1 = &ct_p1;  
ct_cp_p1 = &ct_cp2; // 合法， 指针的指针并没有const修饰， 指向的指针有const修饰
*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改
1 L6 X. Y' p2 `) O" ]) [
// (const int) (* const) (*const)  
7 x- m) G9 j8 w9 g3 |6 c* q// 指向((const int) (*const))的指针,且该指针被const修饰
const int* const * const ct_cp_cp1 = &ct_cp1;
+ i' j7 m% k/ ]8 C- e' W" p1 mct_cp_cp1 = &ct_cp2; // 报错！ 指针的指针被const修饰， 不能修改指针指向。

一行声明多个变量
7 T+ u' |: K# c* ]类型 + 名称定义一个变量。
变量的前面可以加*号修饰， 表示指针， 一个星号代表一层间接。**表示指针的指针。

$ X( j, y) [& e8 Gint a, *b, *c, d, **e;
a = 0;
6 I+ Q/ M% b3 h0 td = 1;
b = &a;
% Y3 f% h- R+ D9 I" N1 u3 ?5 k# b$ sc = &d;
7 X& s; E0 ]* [4 \& }6 He = &b; // e为int**类型 指针的指针
. L0 k1 R) z8 N, Ie = &c; // e为int**类型 指针的指针
也可以用括号包围变量和*号。
5 c) A$ }& J0 m8 n( B
; P& b3 _& t( }7 Vint (a), (*b), (*c), (d), (**e); // 合法定义。
括号可以省略，某些情况， 个人感觉加上括号更清晰一些。例如

int (a), (const *b), (*const c) = &a, (const d), (const* const* const e) = &c;
写成

int a, const *b, *const c = &a, const d, const* const* const e = &c;
6 }; @0 y! b3 ^4 M更重要的是， 后面我们表达数组指针，以及函数指针时，括号是不可缺少的， 带括号的表达更加统一。

( S& C0 {# i+ _' Z4 W' K数组指针
数组基本表达
8 i; n- C+ \! a7 ~* uint a[10];  // 定义了类型是int, 元素个数是10的一个数组。
由于c++要支持一行定义一个类型的多个变量。 所以数组的[]时放在名称后面的。虽然我觉得
1 E1 x+ G; q" ]  l) x. \
( I+ N" C3 D' o  ^9 _int[10] a;
3 q4 n) l0 E& r4 w) m这样的写法更符合类型 名称的思维， 但是如果类型都这么写的话， 没法兼容以下的写法:

9 ?, ?4 w( ]* Q# ^int a = 0, *b = nullptr, c[20], **d = nullptr;
0 x1 A5 C7 c4 K2 s/ O# H/ D1 Nc++标准规定如此，但我们可以通过每一行只定义一个变量的写法， 类型会更加清晰。

1 F1 j7 u$ V, iint a = 0;
. k( d( {' J; c3 z% x0 N' x4 {int* b = nullptr; // 指针int*
- |/ ?) G. J+ E' Qint c[20];
6 H# y% S; ~  o/ g9 z2 H1 X' Bint** d = nullptr; // 指针的指针int**
数组的名称是什么类型
数组元素类型的指针，可以直接指向数组。 并且数组跟指针一样，可以通过下标去访问元素。
8 M0 ]5 `$ J. Z. r( M" @% Y
int a[10];
int* p = a; // 指向a数组的第一个元素
a[1] = 1;
p[1] = 1; // 效果与a[1] = 1一样。
数组可以当作T* const来使用， 但是又与T* const有些不同。sizeof()的结果不一样。
+ s% J5 H. _. \# x  a. w
int a[10];
int b[10];
int* const p_a = a;
a[0] = 1; // 合法。 数组的元素可以修改。
# S1 N6 k, Y# N7 G9 x/ mp_a[0] = 1; // 效果与a[0] = 1一样。

  J+ r- Q8 }" D1 ~  u4 `6 e$ o5 h7 Ha = b; // 报错！ 数组本身的指向不能修改。
6 _2 Q( S# G) N
1 M/ @: d4 _2 ~' |// 所以数组a可以当作int* const来使用
int *const& ref1 = a; //正确。
int *& ref2 = a; // 报错!

// 但是又跟int* const有些区别。
assert(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()才有获取数组占用空间大小的效果。

以下3个函数翻译成汇编以后，汇编代码是一样的。

. _9 m$ j) n% W/ i/ svoid Func1(int* p_ary)
{
) \1 q" Q/ @3 X8 }# G    assert(sizeof(p_ary) == 4); // 32-bit
; Y+ N3 `' [6 H: q, [  Q, z8 D    p_ary[1] = 1;
}

void Func2(int ary[])
{
    assert(sizeof(ary) == 4); // 32-bit
  |/ F* M( w: X5 Y. K, |    ary[1] = 1;
}
& G: P3 y3 R, }. b# |/ c
$ B: G$ E8 t; ~; Dvoid Func3(int ary[10])
+ d& q: J5 A  e- \1 G: Y: U& }6 [0 B* C{
    assert(sizeof(ary) == 4); // 32-bit
    ary[1] = 1;
}
' u3 p( [  Z: j% `! r. I2 e
+ e9 F4 r$ W& q9 Iint main(int argc, char** argv)
{
3 O$ ^8 K4 b3 N4 b6 f5 o    int a[10];
% i# S+ X8 |* g& a8 D    int b[20];
    Func1(a);
5 T. J8 Y0 t  N9 g$ w5 ^2 J( F/ O    Func2(a);
& S! W5 F8 t  K/ E1 N    Func3(a);
, ]% W$ A. \  F, o7 r9 b7 U4 S    Func3(b); // 退化成int* const了， 即使数组长度不匹配也不会报错。
: W6 Z2 ^2 J' |* o, |  N    return 0;
. _% r2 \6 U4 ]1 p8 h! {2 C. f}

. B. ?$ [7 p/ p- j0 X9 `

多维数组
% L; h# `: Y; b0 P一个3行，4列的数组， 结构如下:

int a[3][4];
column 0        column 1        column 2        column 3
  E0 P6 Q0 Q* g( [- Xrow 0        a[0][0]        a[0][1]        a[0][2]        a[0][3]
row 1        a[1][0]        a[1][1]        a[1][2]        a[1][3]
row 2        a[2][0]        a[2][1]        a[2][2]        a[2][3]
; P2 L5 h8 G5 N数组初始化
" S# h7 h' O# `3 y8 a" B
6 t* J0 R8 T" y) Pint a[3][4] = {
+ W8 o! i; b! i5 W+ `: L$ I    {0, 1, 2, 3},
- Z( w* I3 O& }& Q2 {4 S    {4, 5, 6, 7},
    {8, 9, 10, 11}
};
实际上多维数组和1维数组在开启速度优化后，翻译成汇编代码是一样的。
" I  i! R+ d% u2 L8 b# y
void Print(int* p_ary);

* K3 }! U1 w8 G$ p) S* Dvoid Test1()
1 i0 n/ r8 ?0 G! `+ T1 G* j{
    int a[10];
5 |7 U  X3 n3 S; d" h    a[3] = 3;
    a[7] = 7;
8 g' A3 o5 q3 ~    Print(&a[0]);
3 o1 E1 {0 [2 x; {}
4 `4 ?# K6 w1 r5 m' E, h
6 j0 v: v/ A8 k; G% t8 ?3 yvoid Test2()
{
2 H7 ~+ h2 w; @: A    int a[2][5];
    a[0][3] = 3;
. @% ^$ k) q% s" m3 t. X    a[1][2] = 7;
% f8 L/ j' F) ^. Q- x    Print(&a[0][0]);
. v( B$ Y% b3 Q}

9 W% j9 L! @9 D) x
; p/ D0 ]# g# Q; B
: \6 t. u# N- F( s( ?" w. P8 g很自然地，多维数组也支持用1维数组的方式去初始化。
* `5 M' n; @+ h( n0 d9 H
int a[3][4] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
4 d$ C% {) Y5 E7 b9 e既然多维数组与1维数组没什么区别， 为什么还需要多维数组？

' b$ V6 E" u" M% q3 ?. k假设有一幅RGB图像720*576个像素，每个像素有RGB三个通道，每个通道的值是8bit大小。给出图像的首地址p_rgb_image， 我们要取第40行，第50个像素的R,G,B值。代码如下:
& H4 `' |; N, T7 E/ x
2 ~9 `/ Z) c% N. e- Q5 A3 hunsigned char* p_rgb_image;
unsigned char r = p_rgb_image[40*720*3 + 50 + 0];
unsigned char g = p_rgb_image[40*720*3 + 50 + 1];
. T& _$ r" ~! h$ Uunsigned char b = p_rgb_image[40*720*3 + 50 + 2];
3 M) ^/ d( x3 U+ S类似这样的场景， 采用多维数组的写法， 有点类似以索引为参数，可读性更高。相当于程序员和编译器打了一个配合。

enum
{
Red = 0,
% b, A  G6 k: c) g Green = 1,
: U3 i/ j7 }: o" o3 E Blue = 2
1 T3 _( I" _% @, C, Y& P' ]};
unsigned char rgb_image[576][720][3];
int row = 40;
2 l8 k9 ]$ o9 h0 u5 M7 gint col = 50;
unsigned char r = rgb_image[row][col][Red];
unsigned char g = rgb_image[row][col][Green];
unsigned char b = rgb_image[row][col][Blue];
) A. G9 C- @- t- `: \) L  m2 B数组指针以及与指针数组的区别
数组指针，是一个指针， 指向的对象是数组。 数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时， 需用用*取得数组对象的引用，再用下标来访问数组元素。
指针数组，是一个数组， 数组保存的元素的类型是指针。
数组指针的定义
数组指针定义先定义一个数组。
int a[10];
然后对数组里的名称用括号括起来后再在变量名称前面加个*号
int (*a)[10];
' P, H9 ~; b. ?+ Y: G后面你会发现函数指针定义类似。
// 各类定义对比
$ N) o9 a& D) ]/ wint a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];

# E! U0 D. D) \) M& R) _int *f[10]; // 指针数组, f是包含10个元素的数组， 数组里每一个元素的类型都是int*
int *(f2[10]); // 指针数组。另外一种定义方式。
/ [( u- i) T% C# eint(*f3[10]); // 指针数组。另外一种定义方式。
( f# x3 O1 F( }4 }& jint(f4)[10]; // int数组
int(*g)[10]; // 数组指针， g是一个指针， 这个指针可以指向类型是int，元素个数是10的数组
int* (*h)[10]; // 数组指针， h是一个指针， 这个指针可以指向类型是int*，元素个数是10的指针数组
( c8 Q" k7 m. L/ T0 M* D. j: P; ?
int d[10];
% S1 V$ a5 S/ dg = &d;

int* e[10];
, U  b, m) }: _8 a$ T  sh = &e;
数组指针的使用
数组指针一般先通过*号取得指针指向的数组对象， 然后再用下标操作访问元素。

int a[10];
- S8 g+ {6 O  h0 w, Aint(*p_ary)[10] = &a; // p_ary是一个指针， 指向"int (*)[10]"类型的数组
for (int i = 0; i < 10; i++) {
3 z0 H5 y, q% G9 l( x // p_ary是一个指向数组的指针， 需要先通过间接寻址运算符*(indirection operator)取得数组对象
! }5 b+ X) l% u) V8 f" h* Y  ~ // 再通过下标操作访问元素。
6 e9 p2 N6 T" a0 p4 m (*p_ary) = i;
}

int b[10];
int c[20];
' c( ~; d/ t" V/ L$ w' Fp_ary = &b; // 合法
p_ary = &c; // 报错！ 不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
. @+ y. v* q+ W, i数组指针指向多维数组的子数组
) E! g' U1 G8 W; T: O5 h4 pint a[10];
& o1 f$ D/ z5 x% Y1 j& y  kint b[4][10];
int(*p_ary)[10] = &a;
) }; A, d8 T# U  n$ M. efor (int i = 0; i < 10; i++) {
(*p_ary) = 1;
4 o- m/ S7 y& d4 z7 Q0 ?' O}
% y/ f, _) B0 ?% t- b% h
" z8 V( J* R: {* y* M3 }p_ary = &b[2]; // 多维数组，可以看作数组的数组，
// b[2][0] ~ b[2][9]的值都被改成2了
for (int i = 0; i < 10; i++) {
(*p_ary) = 2;
}
7 S8 K! B6 h2 j! K, b, N8 H多维数组指针
多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。

9 w3 L5 I; K- m/ @$ h1 `int a[2][5][10];
: M  p8 ^& g! Z% {4 b$ ^int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
int(*p_ary2)[5][10] = &a[1]; // 2维数组指针
$ `1 e* a1 r/ `; ~; R" c$ gfor (int row = 0; row < 5; row++) {
5 Z9 @/ ?! x# ?9 [: a    for (int col = 0; col < 10; col++) {
' {  m- t6 u/ r' E        (*p_ary2)[row][col] = row * col;
5 S/ f$ u& M3 K    }
- k' k7 }4 g4 G5 P+ p3 n& [}
数组指针和指针数组对比实例
数组指针还是记住两步法即可
# {+ |% W/ I) d+ [5 P1 h7 t) P
定义一个数组
括号包围1中定义的名称，再在名称前加个*号。
int a[10];
int(*ary_pointer1)[10] = &a; // 数组指针
" F! E) {, U% M2 R8 f- _int* pointer_ary1[10]; // 指针数组。元素类型是int*
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
. i  q! B, c! Z$ o  X. R5 `7 Kint (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
  g# D, t' T" G% J
; c4 y; A, ^7 e* G: `5 q// 指针数组可以把每个元素指向数组对应位置的地址。
, s9 I( d! Y7 A* A// 这样遍历指针数组， 可以达到遍历数组元素的效果，但是注意每个元素都是指针，
// 需要访问原数组的值的话， 需要对指针用*间接寻址运算符。
int* pointer_ary[10];
* h: Z( @+ \1 ^. S: lfor (int i = 0; i < 10; i++) {
    pointer_ary = &a;
9 \- C* S8 T0 ]}
) c8 v3 c/ c1 [// 类似遍历原数组效果。
# t3 ?3 _9 ~& L+ Vfor (int i = 0; i < 10; i++) {
* G' }; m7 ^4 e) b( W    *pointer_ary = i; // 修改原数组。
}

函数指针
6 z! q  C% V7 S1 z6 e取得函数地址
6 i. ?  K  M$ I& R0 N6 @! r, ~函数的名称作为参数被传递时，会隐式转换成函数指针， 和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
, t# w" H$ M4 s2 H) C6 @
void f(int);
  c0 z- }9 v8 v) c; n6 {) `1 T" nint main()
{
2 W2 f. y- E+ g0 J% o    void (*p1)(int) = &f;
    void (*p2)(int) = f; // same as &f
    return 0;
}
4 q. A) O7 s" U* ~4 i7 P翻译成汇编代码， p1和p2的赋值是一样的。


, `1 `# `8 f" X4 f, B% A2 V
+ e" F, y) w( Y5 r; j; ]! V函数指针的声明
单个函数指针变量定义步骤
/ D# Z: R( w9 y0 e. S$ r+ S定义一个函数。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);
typedef定义函数指针
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。

8 `7 x' Z* T4 }0 q/ G4 B9 ^. A5 rtypedef定义函数指针的语法
typedef有两种做法， 一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值， 但是支持引用。

4 D5 R; ]8 [& _7 U! n* h' j7 \typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
# \5 U) C7 A" l5 C  a' a" V* J' WFuncObject* f1 = &Add;
FuncPointer f2;
f2 = f1; // f1, f2类型一样， 都是形式为int(int, int)的函数的指针。
FuncObject f3 = Add; // 报错！ 函数对象不支持拷贝
/ U3 D, D( R- z0 b% l+ i4 o. VFuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
& m; F4 `# R2 r  ^5 j- u( HFuncObject& f5 = Add; // 正确
$ V; X3 N) s: y$ a" p! qint ret = f5(2, 3); // 正确
& L5 a# w' B+ Q. }6 cFuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
如何记住typedef定义函数指针的步骤
像定义一个函数指针那样， 指定一个名称。int (*CalFun)(int a, int b);
5 @. B# |$ K$ E1 P6 e7 N在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
完整例子
typedef int(*CalFun)(int a, int b);
6 `5 }* E/ X+ B, p
; @) R) }. A4 D( @: Jint Add(int a, int b)
{
# r. |: n* J. t7 X" j/ R+ i, v( G    return (a + b);
}
1 r5 L% W3 k( G: q6 ?+ A2 v1 f
int Sub(int a, int b)
{
. n& o* `# n; N( R    return (a - b);
$ k) W$ R' r/ ?$ d}
" d+ `; n& {' C; ]# {- O9 }
int main(int argc, char** argv)
{
    CalFun f1 = Add;
! z- Q8 t9 j/ q    CalFun f2 = Sub;
    int a = f1(2, 3);
    int b = f2(10, 5);
/ f% X4 ^) ~8 m' E9 `) |
, S) Q9 j% x: l0 W) I    // typedef定义的函数指针数组。
    CalFun f_ary[2];
: \. K, R+ |  {& v  a+ J    f_ary[0] = Add;
    f_ary[1] = Sub;
& q7 s7 d9 ]1 x* t
! U# S# |' z1 h    // 单个定义的函数指针数组。
    int(*f_ary2[2])(int a, int b);
' R" D  l) j9 n, n' A" K    f_ary2[0] = Add;
    f_ary2[1] = Sub;
0 ?! W  H& W# ~0 O' t) e
, I1 u" {6 r8 G. t# i( j    return 0;
9 |6 d# q! w8 @+ m% v5 K. a. f* f}
( }% }2 F5 M  S
using别名定义函数指针
4 O: A, M. Z1 zc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
4 j. c+ b6 G0 x) q
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
using FuncObject = int(int a, int b);
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
' F  q, A! A  L) o  P* y$ z) |using FuncPointer = int(*)(int a, int b);
函数指针的调用
+ D' _0 F' Z0 J. {函数指针和函数对象都可以直接后加括号调用
int f();
; r7 d- [( p; _) E/ Iint (*p)() = f;  // pointer p is pointing to f
1 X& j4 p' L+ {# Q, G- rint (&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
p();             // function f invoked directly through the pointer
如果函数有重载， 函数指针会指向匹配的那个版本。
template<typename T>
T f(T n) { return n; }

; F7 r/ H" T" Y8 tdouble f(double n) { return n; }
1 ?6 G9 _  b; K: ^$ l9 q& `
- ]& p$ [/ [; N% O" Zint main()
& r; j5 l4 R+ Q* n{
    int (*p)(int) = f; // instantiates and selects f<int>
}
% X) v# I) e5 f7 _3 _4 E成员函数指针
% ]4 N& a' r) \" x/ B5 M! J静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。

成员函数指针定义。
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
在名称的前面加个*号void (ClassName::*func)(int);
  T9 B' M, T0 M成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
成员函数指针如何调用。
假设成员函数指针名字为func

3 n. B" {9 U# N, Qvoid (ClassName::*func)(int);
4 y, h' f( L1 j1 }对象式调用。
ClassName c; // 被调用的对象
成员函数指针名字当作正常函数那样写。
+ e' V; |4 I0 D# H$ u, k* I5 u! oc.func(3);
& s* f$ m0 e& y, P3 j* j& o8 `  _成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
: X+ l# l* z; v( V* S$ Dc.*func(3);
) f( `6 N6 ^4 @最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
7 O& k/ `  Q* ^* @3 e* L8 M5 K(c.*func)(3);
为何要加上括号？ 根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低， 成员函数指针还没取得对象就被调用了，自然报错。 另外
- X! A" p6 q2 v, e. N* I+ d" r(c.(*func))(3);
这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
& ^2 j  y0 G0 g1 E, p4 ?8 ]% X( l5 m指针式调用
' p. \  f  J: u% VClassName* p; // 被调用的对象的指针
成员函数指针名字当作正常函数那样写。
p->func(3);
; z. \( e' g2 L; a7 U成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
; N: m9 l' z+ R$ lp->*func(3);
最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
(p->*func)(3);
函数指针使用完整例子
6 B2 J- x7 D# O# l- H  m* qstruct Cal
- }  c8 r2 Y, v{
    int add(int a, int b);
    int sub(int a, int b);
};

int main()
6 ^/ U5 `' a8 t# b{
    int (Cal::*fun)(int, int) = &Cal::add;
, d+ t% C) W7 W0 `% |, C    fun = &Cal::sub;

    Cal* p_cal = new Cal();
    int r1 = (p_cal->*fun)(2, 3);
" ?. }7 s4 N' E% V6 H    delete p_cal;

% O6 a8 c- G4 j) b    Cal local_cal;
8 W/ }( p% B. V2 i% u0 b# D    int r2 = (local_cal.*fun)(8, 6);
0 H# ?" S$ ~3 E8 w$ K, ~, N8 k$ F, `; v" v}
! Z) T: O0 |* Y4 H8 j! V
# U* _4 k6 ~: Q7 w! D( J; N成员变量指针
, m' N/ `9 X. P# O) Y& O成员变量指针比成员函数指针还要简单些，没有函数调用， 无需考虑函数调用和间接引用符*的优先级问题。
6 ?8 E! T' n7 w) }& ~& {
( Q" l# @, a  W. _; n( q成员变量指针的定义
假如以下结构体C。
- q5 j* X( w3 g
struct C
5 O* b( l( i" ?# c: ^1 Y{
' W' E. g# Q' a    int m;
. i5 R8 F2 J4 {+ V& n};
2 I& w$ r. B% u5 q* N1 e( y* D单个成员变量指针定义
假设名称为p, 类似静态成员变量定义那样声明
* R! n( v6 o9 e' O. Sint C::p;
在名称前面加上指针标识号*
7 {# N# D  E% ]" m1 V! Dint C::*p;
typedef或using方式定义
typedef int C::*MemberPointer;
using MemberPointer = int C::*;
成员变量指针的使用。
) c: g. q1 ]3 t0 t1 r类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
成员变量指针， 能让我们实现一些遍历成员的动态功能。 例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。
- b$ o& ?8 t: ^! i) m
完整例子
struct C { int m; };
int main()
1 C: L# P/ _# e4 W+ h8 y4 b{
- A' U9 b& h! Z: L0 q3 E    int C::* p = &C::m;          // pointer to data member m of class C
    C c = {7};
6 L2 G2 A+ S! j    std::cout << c.*p << '\n';   // prints 7
2 M: y# W2 K; r- Z% d    C* cp = &c;
. z6 k- o5 `! [' i) K5 ?. S1 [    cp->m = 10;
  w9 J, _6 ]' ?) E9 c! n, q, G    std::cout << cp->*p << '\n'; // prints 10
: I( x. x- O3 [- C  ]
————————————————
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
8 y/ |4 p) ]! i+ \0 L
; g( Y* S( I* A# O: o
, o" J- R3 c4 Q* G; P2 G