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

杨利霞

C++数组指针、函数指针、成员函数指针
C++数组指针、函数指针、成员函数指针
: m8 T( P% z& \) {  s# c

( `% ~0 D4 n% M! D7 C! B操作符名称
7 q- K; {" z/ |- {& t2 D. L& 取地址符(Address-Of operator)
- o1 _9 i9 t& N* 间接寻址运算符(Indirection operator)
9 w8 Q3 v7 i, T1 n) F: C* ~9 ^.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
7 U& k2 \; U; y8 m; z" R.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
() 函数调用运算符(Function-Call operator)
:: 范围解析运算符(Scope-Resolution operator)
; c$ _: Y9 P9 D  {( m0 k, D9 N如何定义一个指针变量
假设类型T， 变量名称name, 指针的定义如下:

T* name;
标识变量名字name, 它是T类型的指针。例如
* `% ]$ O2 B: S! ~0 X* L
3 R7 N2 {1 P; _$ tint n = 0;
int* p_n = &n;
- m3 n* P# q7 W. Z' N( f! }' }p_n是int指针类型， 指向某个int型的对象。

指针变量的修饰
指针实际上也是一种变量类型， 只是它保存的内容有些特别， 是指定类型的地址值，通过间接寻址运算符(indirection operator)*, 可以访问到指针指向地址上的指定类型。

" W7 z  n3 C$ R# U8 X指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int， 且该变量不能修改。以下两种写法都可以:
' L2 [9 q9 T5 r
const int a = 1;
int const b = 2;
既然指针是也一种变量类型，同样支持被const修饰， 表示指针的值/指针的指向不允许修改， 指针所指向的那个变量是否允许修改， 那是另外修饰。写法如下:

3 B7 J( [, s- ~5 b9 a" O- i# v' fint a = 1;
int b = 2;
int* const cp_a = &a; // 指针的修饰词，放在*号后面。
*cp_a = 10; // 指针指向的值可以修改
cp_a = &b; // 指针不能被修改，报错！
总结带修饰的指针的格式:
只要记住修饰词总是放在被修饰的内容后面。

0 Y$ A5 L$ z. ucv表示const / volatile修饰词。指针定义形式如下:
3 @7 ]7 {- l- U1 e2 W- |
T [cv for T] * [cv for pointer] name
5 M2 e. j! N/ G. D注意对T的修饰放在T的前面也是合法的写法。

const int const c = 2;
在mscv编译器下也不会报错。
( ]" U  G* u3 r/ j) A
3 p# j& |7 _5 Y" Q2 J7 O5 |完整的格式:
; U# [# o( v" x$ I7 w[cv for T] T [cv for T] * [cv for pointer] name

Syntax        meaning
  b4 d8 l3 z! w! iconst T*       
, x! h% d. F0 e( t5 f' J# \" b# Kpointer to constant object
/ J2 @0 P: f2 Z$ ]
T const*        pointer to constant object
T* const        constant pointer to object
const T* const        constant pointer to constant object
T const* const        constant pointer to constant object
上面格式中T还可以是一种指针， 指针的指针仍然是按照修饰词总是修饰前面的标识(T或者*)来确定修饰的意图。

int a = 1;
int b = 2;

int* p_a = &a;
" B: \! U: {1 B5 o6 x5 h*p_a = 10; // 合法
p_a = &b; //合法

const int* cp_a = &a; // const修饰int类型， 并非修饰指针
*cp_a = 11; //报错! const int类型不能修改
cp_a = &b; // 合法， 指针没有const修饰，指针可以修改。
- b$ K2 Y0 ]+ u- ~
$ n# Y; H) C: s1 q7 H. C6 D8 J; ^int* const pc_a = &a; // const修饰指针。类型没有const修饰
*pc_a = 12; // 合法， 因为类型没有const修饰，可以修改。
pc_a = &b; //报错！ 指针被const修饰， 不能修改指针。

int const* const cpc_a = &a; // int类型被它后面的const修饰， 指针符号*后面也有const修饰
! T0 o2 c" ^7 f' P% A' D*cpc_a = 13; // 报错！ 类型被const修饰，不能修改。
cpc_a = &b; // 报错！ 指针被const修饰，不能修改。

* ~8 G" g4 V0 X2 I, d, k. J 更复杂的指针的指针

* v  r! u$ q+ q4 J7 m& v1 Bint a = 1;
% `. x$ j1 y; Jint b = 2;
int* p1 = &a;
  n# s: s6 {6 w% V8 @& W" [/ hint* p2 = &b;
; d$ `# n: j+ G4 X" Hconst int* ct_p1 = &a; // ct for const type
( F4 Q) E1 `0 Qconst int* ct_p2 = &b; // ct for const type
0 v2 r8 G' {9 N* t# ^4 c/ h
( n. k8 j3 ?5 I3 w: F: @// int * * pp1; 指向(int*)类型的指针
int** pp1 = &p1;  
pp1 = &p2; // 合法,
pp1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)

/ p4 I+ T- p  O" }4 K// (const int) * * pp1; 指向((const int) *)类型的指针
const int** ct_pp1 = &ct_p1;  
ct_pp1 = &ct_p2; // 合法
ct_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。
# S( W  g3 h" {7 w/ T' W
// (const int) (*const)
4 \/ P; B3 T* _const int * const ct_cp1 = &a; // 指针也不能修改
) o$ L* S# d4 U9 h. l1 v9 `const int * const ct_cp2 = &b; // 指针也不能修改
- c" A# Z/ B# F5 P* V3 Sct_cp1 = &b; // 报错！指针有const修饰
& y7 M# C: b* m% ]
// (const int) (* const) *  指向((const int) (*const))的指针
const int* const * ct_cp_p1 = &ct_p1;  
0 O* K% C6 Q) U: c; ect_cp_p1 = &ct_cp2; // 合法， 指针的指针并没有const修饰， 指向的指针有const修饰
8 p/ Z9 V" Z* L8 p, _7 j*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改

// (const int) (* const) (*const)  
! Z* D, ^+ W3 p" o$ E- b// 指向((const int) (*const))的指针,且该指针被const修饰
9 \& Z# j8 W: `" C- d2 Nconst int* const * const ct_cp_cp1 = &ct_cp1;
8 \# I% E9 k+ O/ b. Oct_cp_cp1 = &ct_cp2; // 报错！ 指针的指针被const修饰， 不能修改指针指向。
, k$ B/ h/ j  z, w) b+ X$ F
' H$ M; D* a. T! g4 q( ], W2 m: \/ R一行声明多个变量
类型 + 名称定义一个变量。
+ J. G+ j* z# l1 u. S2 N变量的前面可以加*号修饰， 表示指针， 一个星号代表一层间接。**表示指针的指针。
/ h! l4 w& f: H1 K
int a, *b, *c, d, **e;
a = 0;
/ I( o  H  u6 D- h1 H6 a* _d = 1;
* l* |9 n) c( f: k6 f, v$ D, eb = &a;
  q) [1 K6 S# V; L" Kc = &d;
e = &b; // e为int**类型 指针的指针
e = &c; // e为int**类型 指针的指针
也可以用括号包围变量和*号。

int (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;
/ a& A  X8 C  w3 T- r更重要的是， 后面我们表达数组指针，以及函数指针时，括号是不可缺少的， 带括号的表达更加统一。
' x; M7 }8 i# m' c2 A, ]
数组指针
数组基本表达
* ]; ^) V1 _& g* ?2 [& Bint a[10];  // 定义了类型是int, 元素个数是10的一个数组。
由于c++要支持一行定义一个类型的多个变量。 所以数组的[]时放在名称后面的。虽然我觉得

- d/ v; F' X: v" \) M  M" p8 oint[10] a;
这样的写法更符合类型 名称的思维， 但是如果类型都这么写的话， 没法兼容以下的写法:
9 Y- s/ D# d# O7 ^
& r" f6 f) |6 d0 d. oint a = 0, *b = nullptr, c[20], **d = nullptr;
c++标准规定如此，但我们可以通过每一行只定义一个变量的写法， 类型会更加清晰。

5 s* m( r7 v" Y1 J7 H( M: ]+ h# n  ^int a = 0;
: w3 b3 p9 M% F/ z& b# d! {6 \" \int* b = nullptr; // 指针int*
; l5 G. E( J2 a. b% q$ C* {int c[20];
" E- ]# G7 E# ?( P9 p$ Uint** d = nullptr; // 指针的指针int**
数组的名称是什么类型
数组元素类型的指针，可以直接指向数组。 并且数组跟指针一样，可以通过下标去访问元素。
4 p" W$ d+ p  E0 ]& i
: A; e; D' {5 b. [2 g. cint a[10];
int* p = a; // 指向a数组的第一个元素
a[1] = 1;
p[1] = 1; // 效果与a[1] = 1一样。
5 I6 ~' D/ @) Y- l" W数组可以当作T* const来使用， 但是又与T* const有些不同。sizeof()的结果不一样。
! U0 H' F8 c5 N4 Z2 K
int a[10];
& k6 S  t6 j) Z3 G$ A- s. ?int b[10];
int* const p_a = a;
a[0] = 1; // 合法。 数组的元素可以修改。
  ^; x% Z' x  c+ v) y5 ^; j8 Ep_a[0] = 1; // 效果与a[0] = 1一样。

# U, Y! o3 v% ?a = b; // 报错！ 数组本身的指向不能修改。
! O* n3 b( T9 Z9 u% \1 u$ j
// 所以数组a可以当作int* const来使用
7 t% o: P; A& M. }) C' ]3 ~int *const& ref1 = a; //正确。
% Y/ [/ S/ ^9 n# w7 O# N2 uint *& ref2 = a; // 报错!
  t6 P" X- ?% s. f2 i
// 但是又跟int* const有些区别。
4 e: f4 @2 L0 M; k( _4 x# Zassert(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()才有获取数组占用空间大小的效果。

& D1 ]6 R" F. n/ X以下3个函数翻译成汇编以后，汇编代码是一样的。

+ Z: W+ x+ g: `# evoid Func1(int* p_ary)
! ?; U8 l) s  i! v* x/ E( j{
/ s6 _' F" ?9 |+ `' o* i8 }    assert(sizeof(p_ary) == 4); // 32-bit
    p_ary[1] = 1;
7 N( i4 n: V% q) L% U8 Y6 G}

7 D( V* w9 C' l2 e: ivoid Func2(int ary[])
{
    assert(sizeof(ary) == 4); // 32-bit
    ary[1] = 1;
}

void Func3(int ary[10])
4 w- w- t- v7 U6 v2 T{
( s7 S# l) E! C( a4 O    assert(sizeof(ary) == 4); // 32-bit
0 I7 h( U8 S/ x- e% `  c    ary[1] = 1;
}

' x& X7 [0 y0 [9 T8 ?) nint main(int argc, char** argv)
{
    int a[10];
6 S5 E4 V, L' F8 b/ S    int b[20];
    Func1(a);
4 e$ b5 @4 M1 h0 A$ M    Func2(a);
    Func3(a);
    Func3(b); // 退化成int* const了， 即使数组长度不匹配也不会报错。
" d  M; W- e* M    return 0;
}



多维数组
一个3行，4列的数组， 结构如下:

int a[3][4];
column 0        column 1        column 2        column 3
: L. L  m. G( I+ r( p: Q6 grow 0        a[0][0]        a[0][1]        a[0][2]        a[0][3]
( F* c0 p( R3 W, F: ~row 1        a[1][0]        a[1][1]        a[1][2]        a[1][3]
, v( I6 n$ q& o% y: Hrow 2        a[2][0]        a[2][1]        a[2][2]        a[2][3]
数组初始化
* Q9 e' r% s+ A
/ z* y! n2 v, v# x' j2 O. K7 \int a[3][4] = {
  t$ n! J- z7 r1 q% y4 q8 z    {0, 1, 2, 3},
    {4, 5, 6, 7},
$ g2 i! e9 T+ x2 Y    {8, 9, 10, 11}
! z& H8 `2 W7 |. C: x" w7 {};
: B4 U; G' m( y( Y& y# g 实际上多维数组和1维数组在开启速度优化后，翻译成汇编代码是一样的。
5 E6 P7 j  F: K: c% l
" t7 n2 i9 q# a# s- Xvoid Print(int* p_ary);
6 Q+ w( e$ x9 h5 {
void Test1()
; K6 A3 G  ^2 R; H* L9 C! _% q{
0 Q; U6 D0 O$ U8 W' ?7 I. l    int a[10];
( n6 J+ x3 H) Z) P    a[3] = 3;
    a[7] = 7;
( X: J- u. ]( x: ?, ^; e9 W    Print(&a[0]);
7 y; a1 y% c4 Q# R+ g}

! V# p' o6 M% ]# p. r  P$ Svoid Test2()
{
8 I3 b: L- R' m3 ?9 {# W- x6 Q    int a[2][5];
    a[0][3] = 3;
    a[1][2] = 7;
    Print(&a[0][0]);
}


# p; ~  R5 h: M3 B# I
很自然地，多维数组也支持用1维数组的方式去初始化。
+ Q. x1 C2 @. x; t* w6 k$ |8 D7 U
- g* v2 v1 N$ S# w* Pint a[3][4] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
3 ]3 q% c2 `- ~' n% ?既然多维数组与1维数组没什么区别， 为什么还需要多维数组？
4 S" N+ m6 e) I# I+ p% o8 ?/ x1 Z
假设有一幅RGB图像720*576个像素，每个像素有RGB三个通道，每个通道的值是8bit大小。给出图像的首地址p_rgb_image， 我们要取第40行，第50个像素的R,G,B值。代码如下:
9 a% a4 v/ ?3 T3 L6 A: E
0 f; T( g8 V) P" F& cunsigned char* p_rgb_image;
' ]% r; q  \& H0 u: a9 e/ g& a: dunsigned char r = p_rgb_image[40*720*3 + 50 + 0];
unsigned char g = p_rgb_image[40*720*3 + 50 + 1];
3 @8 W1 X; D/ R9 B9 }  Zunsigned char b = p_rgb_image[40*720*3 + 50 + 2];
类似这样的场景， 采用多维数组的写法， 有点类似以索引为参数，可读性更高。相当于程序员和编译器打了一个配合。

- {1 ?8 S: E0 k/ oenum
{
Red = 0,
Green = 1,
& H. d1 e0 b; q* ]/ }8 r Blue = 2
};
unsigned char rgb_image[576][720][3];
int row = 40;
1 u3 C5 F8 L6 ?" y, B+ vint col = 50;
+ k" T  `$ g* Z+ C- X0 Y4 Funsigned char r = rgb_image[row][col][Red];
unsigned char g = rgb_image[row][col][Green];
unsigned char b = rgb_image[row][col][Blue];
数组指针以及与指针数组的区别
0 u' P, ^0 @- N( u数组指针，是一个指针， 指向的对象是数组。 数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时， 需用用*取得数组对象的引用，再用下标来访问数组元素。
- Y5 [! j8 j+ ^' h2 G指针数组，是一个数组， 数组保存的元素的类型是指针。
2 t- X; ^- O# ~# X5 ~数组指针的定义
  k1 k) y4 U7 |. |' Y6 c4 y数组指针定义先定义一个数组。
int a[10];
然后对数组里的名称用括号括起来后再在变量名称前面加个*号
int (*a)[10];
( l# N7 q  y0 v9 K* a; x, r  |后面你会发现函数指针定义类似。
// 各类定义对比
int a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];

int *f[10]; // 指针数组, f是包含10个元素的数组， 数组里每一个元素的类型都是int*
int *(f2[10]); // 指针数组。另外一种定义方式。
+ d# H- i/ ^9 J. dint(*f3[10]); // 指针数组。另外一种定义方式。
int(f4)[10]; // int数组
int(*g)[10]; // 数组指针， g是一个指针， 这个指针可以指向类型是int，元素个数是10的数组
int* (*h)[10]; // 数组指针， h是一个指针， 这个指针可以指向类型是int*，元素个数是10的指针数组
: ~1 ^0 C- x) \( C' R
) }$ I; E. d9 m" A/ Aint d[10];
' ]& ?' i4 j4 R' y% G4 \g = &d;
3 a& S3 [4 v7 v" F2 b! l
; x  w2 c9 p1 h6 F2 l! qint* e[10];
h = &e;
数组指针的使用
数组指针一般先通过*号取得指针指向的数组对象， 然后再用下标操作访问元素。
, V4 K8 K3 @  X! E  F
int a[10];
, y; V' k. n4 m* n6 @9 J. e4 D0 v* Yint(*p_ary)[10] = &a; // p_ary是一个指针， 指向"int (*)[10]"类型的数组
0 C  `( n7 w2 q( Dfor (int i = 0; i < 10; i++) {
# ?5 u4 r$ R' ]" M; u // p_ary是一个指向数组的指针， 需要先通过间接寻址运算符*(indirection operator)取得数组对象
// 再通过下标操作访问元素。
(*p_ary) = i;
& J1 d) ?% [3 m3 u+ ]# I}

9 Q, C/ d8 X+ r% ^9 ^5 P$ S0 ]" eint b[10];
& |; d- P" f  d( lint c[20];
( g" A' d9 v. {. z. \p_ary = &b; // 合法
' N$ d7 s* z" f4 o% d- F9 \p_ary = &c; // 报错！ 不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
数组指针指向多维数组的子数组
8 x8 d$ V6 U% oint a[10];
int b[4][10];
int(*p_ary)[10] = &a;
* @# |+ @3 P8 a: c% F- f7 a( Pfor (int i = 0; i < 10; i++) {
4 d7 j. k! y6 f+ r9 ^  N+ t (*p_ary) = 1;
}

p_ary = &b[2]; // 多维数组，可以看作数组的数组，
// b[2][0] ~ b[2][9]的值都被改成2了
  K0 \  N' l. }  V* lfor (int i = 0; i < 10; i++) {
+ F5 j& M( T. [9 E( m3 e$ G (*p_ary) = 2;
}
  Y$ L6 F3 r8 @  u0 q  N多维数组指针
1 J* B- r  ]$ l) k: e' F$ g5 w多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。

int a[2][5][10];
int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
8 N5 B$ V% E) g1 U9 H$ |2 J: Nint(*p_ary2)[5][10] = &a[1]; // 2维数组指针
) {7 L! k% h/ \# _" x# Cfor (int row = 0; row < 5; row++) {
    for (int col = 0; col < 10; col++) {
        (*p_ary2)[row][col] = row * col;
    }
4 z+ U' ~0 v8 V* J( g! C}
1 U# O; [; d6 H数组指针和指针数组对比实例
数组指针还是记住两步法即可
. i/ v6 O( h9 N7 V/ A
2 p7 M% d+ L9 I) s# B定义一个数组
1 @: M' U$ [& T4 w1 N9 u括号包围1中定义的名称，再在名称前加个*号。
int a[10];
int(*ary_pointer1)[10] = &a; // 数组指针
int* pointer_ary1[10]; // 指针数组。元素类型是int*
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
: Q, ?# p9 [' R
( O6 Y1 T: \0 h3 b9 l$ M// 指针数组可以把每个元素指向数组对应位置的地址。
! U0 [9 F+ b+ n! w4 ~2 e// 这样遍历指针数组， 可以达到遍历数组元素的效果，但是注意每个元素都是指针，
// 需要访问原数组的值的话， 需要对指针用*间接寻址运算符。
int* pointer_ary[10];
& M9 h& r: P) }9 I  Ifor (int i = 0; i < 10; i++) {
    pointer_ary = &a;
& y, e8 M. n& l4 v, j, ?}
// 类似遍历原数组效果。
for (int i = 0; i < 10; i++) {
    *pointer_ary = i; // 修改原数组。
- H3 S; T8 R3 v0 d}
/ x$ k9 |. H) W) O
函数指针
+ J; D2 J+ d9 N4 B& x# l取得函数地址
0 i( `  p2 r: }3 m4 B函数的名称作为参数被传递时，会隐式转换成函数指针， 和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
2 {& H9 y# b9 p# ]5 t; |
void f(int);
3 D/ O7 K3 }( I% u4 x7 W. y) o6 i7 W) j" Jint main()
* d4 l2 s8 c9 v{
    void (*p1)(int) = &f;
    void (*p2)(int) = f; // same as &f
% x0 r# w( r& h* f& ]    return 0;
}
8 L, m8 P" B: R+ z+ s) U* l) e翻译成汇编代码， p1和p2的赋值是一样的。


5 [, j, ]8 _# y& z4 l3 I5 _
函数指针的声明
% s- T+ c/ @; u, D: ?. {5 N4 f单个函数指针变量定义步骤
定义一个函数。void fun1(int a, int b); int fun2(double a);
: O+ w* F9 o- ^! T, v0 L! y, ?用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
* d0 ~" @0 \) f如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
typedef定义函数指针
) K: ~1 [0 Z; H. `$ b可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
; D+ O; l# O: S! ], `
typedef定义函数指针的语法
typedef有两种做法， 一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值， 但是支持引用。
$ k4 P. H8 s* Z, W2 }
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
2 S& i& i4 v6 ]! }4 ]0 @( hFuncObject* f1 = &Add;
+ B# E3 W0 T+ |FuncPointer f2;
f2 = f1; // f1, f2类型一样， 都是形式为int(int, int)的函数的指针。
FuncObject f3 = Add; // 报错！ 函数对象不支持拷贝
FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
/ h- J. K  _) FFuncObject& f5 = Add; // 正确
int ret = f5(2, 3); // 正确
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
5 L5 `1 l! U8 \9 M+ V/ R如何记住typedef定义函数指针的步骤
9 `  s. ]* W. U4 D; |- l像定义一个函数指针那样， 指定一个名称。int (*CalFun)(int a, int b);
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
/ N) z- u0 |; }3 x+ z& w完整例子
typedef int(*CalFun)(int a, int b);

2 Z, b0 j/ J( z# [4 Y* K' Bint Add(int a, int b)
{
# k1 n: f3 g; f  R) u  m/ {# t6 i' R    return (a + b);
}

9 Q7 I: E' O! C8 O9 E" |$ L. Eint Sub(int a, int b)
{
    return (a - b);
}

; M; i' T0 U" j9 ^" ~int main(int argc, char** argv)
' w# y9 D4 z2 D& j' R$ ~{
    CalFun f1 = Add;
8 f. U3 f# p+ h8 u0 H6 @1 e: [' h    CalFun f2 = Sub;
' u# Q4 w- a  `# G+ p+ _" w& ~  K    int a = f1(2, 3);
5 |" K3 Y/ K7 n1 v$ j    int b = f2(10, 5);

) E: _& r9 {) Z+ m7 h    // typedef定义的函数指针数组。
    CalFun f_ary[2];
    f_ary[0] = Add;
    f_ary[1] = Sub;

% O! @9 p& e8 t! m: `# \9 E, N$ O    // 单个定义的函数指针数组。
$ W1 {8 a8 a- G    int(*f_ary2[2])(int a, int b);
4 Q, T' N2 n7 C    f_ary2[0] = Add;
8 W8 s8 R* |7 s( \  y1 g    f_ary2[1] = Sub;
( x* }4 X# r  I( c7 ^
. i7 a( {" f6 o  A" o    return 0;
% \* v" d% v+ R% e$ G9 h# O: c}

using别名定义函数指针
1 v- Q1 m! E" b% E9 O) Kc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
3 f' Y  o& f- x
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
using FuncObject = int(int a, int b);
! K  r. g5 d' ?( z0 @& H' P. E0 Utypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
: Z( @, |6 r5 _. W# [7 gusing FuncPointer = int(*)(int a, int b);
% j3 j' r. T+ ]% R( j函数指针的调用
函数指针和函数对象都可以直接后加括号调用
) \  \# z' b, C  sint f();
int (*p)() = f;  // pointer p is pointing to f
  }% K; H% r9 Nint (&r)() = *p; // the lvalue that identifies f is bound to a reference
; B$ a4 `' n( C6 yr();             // function f invoked through lvalue reference
3 x6 m5 d0 \+ h. h(*p)();          // function f invoked through the function lvalue
) u- h5 `9 N; v3 _; T0 J# I! i8 {p();             // function f invoked directly through the pointer
如果函数有重载， 函数指针会指向匹配的那个版本。
template<typename T>
T f(T n) { return n; }

double f(double n) { return n; }
# |6 J9 n0 w; ?
int main()
) w8 A9 k& G, k- v, Z, D0 s{
' N8 B+ Z2 V. f1 X; [    int (*p)(int) = f; // instantiates and selects f<int>
8 L- H& [+ D% Z9 b8 ?  n' @}
/ |* V( s. Z$ g成员函数指针
静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。

( R! Q4 |% R- G! e8 c成员函数指针定义。
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
: S% V/ i% N. I" c3 ~括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
在名称的前面加个*号void (ClassName::*func)(int);
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
成员函数指针如何调用。
0 P6 p$ Y& n; o) Z假设成员函数指针名字为func

6 V" u3 {+ c7 mvoid (ClassName::*func)(int);
3 q9 R) }+ Q" q" g对象式调用。
1 e5 D& ^8 K/ {0 N+ rClassName c; // 被调用的对象
成员函数指针名字当作正常函数那样写。
c.func(3);
6 m) y, Z& P& ]* \1 F成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
c.*func(3);
" d! E) H, U' Z( \最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
& @# B$ f" V2 E8 m(c.*func)(3);
为何要加上括号？ 根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低， 成员函数指针还没取得对象就被调用了，自然报错。 另外
(c.(*func))(3);
) ~; [* B" T; q2 {这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
; k% }* b5 P' B0 _指针式调用
) t$ P7 \% t. S6 U) MClassName* p; // 被调用的对象的指针
0 e, j& n+ ?4 b+ \5 d成员函数指针名字当作正常函数那样写。
3 C$ ^6 ^, b4 N( E4 V# xp->func(3);
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
1 Y% Z, q1 ]4 K8 {p->*func(3);
& E% u! n' p" ]4 k7 G& U0 d最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
(p->*func)(3);
: i% n5 _5 s$ J4 X- C9 E! L5 ~% k函数指针使用完整例子
5 E0 N/ B2 C6 m% I* f9 _0 kstruct Cal
{
    int add(int a, int b);
7 I8 r" d3 ~$ @4 s8 S    int sub(int a, int b);
};

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

( T" c1 y. e& P; c- S* D+ Y    Cal* p_cal = new Cal();
    int r1 = (p_cal->*fun)(2, 3);
    delete p_cal;
& }/ H3 g- D6 X7 W7 }
    Cal local_cal;
6 ^6 I) t6 |; q2 D! H# a    int r2 = (local_cal.*fun)(8, 6);
}

* h* D2 d8 H& ~& F成员变量指针
成员变量指针比成员函数指针还要简单些，没有函数调用， 无需考虑函数调用和间接引用符*的优先级问题。
" M: G+ Q0 E. n& U
成员变量指针的定义
2 ]& z9 N4 S  s# R5 S假如以下结构体C。
4 R; l6 L3 Q- t  J& H$ o# G
struct C
$ k1 l" P/ p) \2 M' w{
    int m;
};
单个成员变量指针定义
* k& b  |% G+ S7 r( K- [假设名称为p, 类似静态成员变量定义那样声明
int C::p;
在名称前面加上指针标识号*
int C::*p;
typedef或using方式定义
typedef int C::*MemberPointer;
' W! p6 P  r! G, b0 o2 o4 W- Vusing MemberPointer = int C::*;
; H& l' K7 m, U5 @6 U" Q$ s+ D成员变量指针的使用。
# T& Y! ]: ?( w& |/ M* L. v类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
成员变量指针， 能让我们实现一些遍历成员的动态功能。 例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。

完整例子
struct C { int m; };
: l) e6 t, b  f. `- }4 |! ]int main()
$ _2 H; P$ \& I8 d{
5 i9 _! ?" D$ L$ a. g9 z% h' p, b    int C::* p = &C::m;          // pointer to data member m of class C
    C c = {7};
9 w# u. G" I  v% B# K    std::cout << c.*p << '\n';   // prints 7
: S6 L# x/ y# S; [# S    C* cp = &c;
    cp->m = 10;
6 |$ R- R' V% s* w( F0 _    std::cout << cp->*p << '\n'; // prints 10

————————————————
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
; _4 @$ q3 Q% Q* G+ ]9 l