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

杨利霞

C++数组指针、函数指针、成员函数指针
% b" u7 x5 h3 v: g; KC++数组指针、函数指针、成员函数指针
# V% o0 W( Y' H, a

2 U# ^& ~/ w7 t& V操作符名称
( T* @1 P, p0 ]. y: A: m& 取地址符(Address-Of operator)
* 间接寻址运算符(Indirection operator)
.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
. t  i, F3 O9 V! H% L7 E6 o() 函数调用运算符(Function-Call operator)
:: 范围解析运算符(Scope-Resolution operator)
7 ]" F5 e/ e' E' ^如何定义一个指针变量
( B1 n8 w, D/ G# G. c假设类型T， 变量名称name, 指针的定义如下:
- Y. D; Z( F/ S3 C+ S8 z
% L/ a8 u4 j  ~T* name;
标识变量名字name, 它是T类型的指针。例如

int n = 0;
% d# Y7 a3 F  x7 [8 uint* p_n = &n;
* q' |) J) n- x$ l1 D4 ~2 b1 H5 Zp_n是int指针类型， 指向某个int型的对象。
& j  L# U7 U1 n
指针变量的修饰
指针实际上也是一种变量类型， 只是它保存的内容有些特别， 是指定类型的地址值，通过间接寻址运算符(indirection operator)*, 可以访问到指针指向地址上的指定类型。

& Q7 j- X* W- X* L; n/ ?; i指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int， 且该变量不能修改。以下两种写法都可以:

& f) A+ F% F9 g( A' Bconst int a = 1;
int const b = 2;
既然指针是也一种变量类型，同样支持被const修饰， 表示指针的值/指针的指向不允许修改， 指针所指向的那个变量是否允许修改， 那是另外修饰。写法如下:
. \8 B: Q, p5 S9 _
int a = 1;
int b = 2;
/ A# ^) F& |9 nint* const cp_a = &a; // 指针的修饰词，放在*号后面。
*cp_a = 10; // 指针指向的值可以修改
cp_a = &b; // 指针不能被修改，报错！
) Y4 ~7 m: _# A2 h总结带修饰的指针的格式:
只要记住修饰词总是放在被修饰的内容后面。

cv表示const / volatile修饰词。指针定义形式如下:

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

7 g7 J5 q0 }3 F' _$ Lconst int const c = 2;
6 S+ ]$ Z& j% v+ c- ~/ o在mscv编译器下也不会报错。

1 [7 X( A$ z, b9 u完整的格式:
6 k2 J* G/ o/ A8 X[cv for T] T [cv for T] * [cv for pointer] name
5 b6 s9 M7 {! q1 D
/ z7 y9 U4 w' TSyntax        meaning
- F. I: E. L8 N. `+ L  `* aconst T*       
pointer to constant object

$ G$ c7 B) e& t$ W: nT const*        pointer to constant object
T* const        constant pointer to object
- L0 c% _' N3 f, G5 m) \const T* const        constant pointer to constant object
T const* const        constant pointer to constant object
上面格式中T还可以是一种指针， 指针的指针仍然是按照修饰词总是修饰前面的标识(T或者*)来确定修饰的意图。
8 i/ i( ]0 M+ H. B- i$ O2 y
" q: B: R: x6 G$ O: P4 x9 A+ y* Nint a = 1;
int b = 2;

! q3 o9 @4 B! nint* p_a = &a;
*p_a = 10; // 合法
p_a = &b; //合法

const int* cp_a = &a; // const修饰int类型， 并非修饰指针
8 F6 p+ B/ x- `% O4 f/ X*cp_a = 11; //报错! const int类型不能修改
! g' Z% o3 a4 z( fcp_a = &b; // 合法， 指针没有const修饰，指针可以修改。

int* const pc_a = &a; // const修饰指针。类型没有const修饰
*pc_a = 12; // 合法， 因为类型没有const修饰，可以修改。
pc_a = &b; //报错！ 指针被const修饰， 不能修改指针。
, u" N6 n4 s6 k8 Z1 R4 {+ U8 E
1 x+ A% h! G2 F9 ]4 gint const* const cpc_a = &a; // int类型被它后面的const修饰， 指针符号*后面也有const修饰
*cpc_a = 13; // 报错！ 类型被const修饰，不能修改。
; f* {6 r6 s% Z8 M1 i) ]$ Acpc_a = &b; // 报错！ 指针被const修饰，不能修改。

4 w9 p% k4 U! J# a4 g7 S1 r 更复杂的指针的指针

int a = 1;
int b = 2;
int* p1 = &a;
int* p2 = &b;
8 x& n9 \+ K7 |! nconst int* ct_p1 = &a; // ct for const type
const int* ct_p2 = &b; // ct for const type

// int * * pp1; 指向(int*)类型的指针
. G% t4 Z& g* s8 X3 ~int** pp1 = &p1;  
pp1 = &p2; // 合法,
pp1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)
: A' J7 J  l& e% E& _9 \& R0 v
// (const int) * * pp1; 指向((const int) *)类型的指针
const int** ct_pp1 = &ct_p1;  
ct_pp1 = &ct_p2; // 合法
ct_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。

# x- D& @1 o: m: ^// (const int) (*const)
const int * const ct_cp1 = &a; // 指针也不能修改
2 B8 H' i6 [+ p. T- P  lconst int * const ct_cp2 = &b; // 指针也不能修改
2 Q7 q& v1 P/ c: q5 A2 s( ~1 M1 ^ct_cp1 = &b; // 报错！指针有const修饰

" o, J0 C1 y% }' E// (const int) (* const) *  指向((const int) (*const))的指针
const int* const * ct_cp_p1 = &ct_p1;  
/ w; [5 L/ e" k7 t4 i8 Y8 @ct_cp_p1 = &ct_cp2; // 合法， 指针的指针并没有const修饰， 指向的指针有const修饰
2 P" J9 i, V, W# C; G7 U*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改

- D' i4 t* d8 q% g4 l3 h// (const int) (* const) (*const)  
7 K/ C+ H0 k& J, Z$ c# L; o* M. e// 指向((const int) (*const))的指针,且该指针被const修饰
const int* const * const ct_cp_cp1 = &ct_cp1;
ct_cp_cp1 = &ct_cp2; // 报错！ 指针的指针被const修饰， 不能修改指针指向。

一行声明多个变量
0 Y) ~# k& G! P9 I, t类型 + 名称定义一个变量。
变量的前面可以加*号修饰， 表示指针， 一个星号代表一层间接。**表示指针的指针。
, \- m( }4 d" g
int a, *b, *c, d, **e;
a = 0;
d = 1;
b = &a;
$ A3 r7 q$ c/ h6 M0 T5 O4 s7 `c = &d;
e = &b; // e为int**类型 指针的指针
/ @( t4 R; [$ Le = &c; // e为int**类型 指针的指针
也可以用括号包围变量和*号。

  f' _! o# z% j: l" S' x$ W9 Xint (a), (*b), (*c), (d), (**e); // 合法定义。
9 Q7 ?7 t& O* E; i括号可以省略，某些情况， 个人感觉加上括号更清晰一些。例如
" ^2 X( U( v2 |4 f! `* z# o  M9 m5 m# j
int (a), (const *b), (*const c) = &a, (const d), (const* const* const e) = &c;
写成

  D( K, h$ Q. O: S! {int a, const *b, *const c = &a, const d, const* const* const e = &c;
0 N7 `) a$ J" r# Z. W更重要的是， 后面我们表达数组指针，以及函数指针时，括号是不可缺少的， 带括号的表达更加统一。

数组指针
" F# j8 n2 c2 H# r数组基本表达
7 j" @9 s, S" D4 z+ fint a[10];  // 定义了类型是int, 元素个数是10的一个数组。
由于c++要支持一行定义一个类型的多个变量。 所以数组的[]时放在名称后面的。虽然我觉得

' H: F1 r" Y3 c# aint[10] a;
% d* K' j  W8 O  t这样的写法更符合类型 名称的思维， 但是如果类型都这么写的话， 没法兼容以下的写法:

9 u9 k8 C" s, i) X! m4 V0 s0 `int a = 0, *b = nullptr, c[20], **d = nullptr;
' |( ]( L$ n6 T4 ^6 E. A( C" i/ pc++标准规定如此，但我们可以通过每一行只定义一个变量的写法， 类型会更加清晰。

( F: k: G# z+ Y* B& z) iint a = 0;
- V+ Q6 U  b; oint* b = nullptr; // 指针int*
int c[20];
" ~0 r; N& v6 R; [int** d = nullptr; // 指针的指针int**
0 F! @$ l4 G6 S4 Q. L8 x数组的名称是什么类型
数组元素类型的指针，可以直接指向数组。 并且数组跟指针一样，可以通过下标去访问元素。

int a[10];
int* p = a; // 指向a数组的第一个元素
a[1] = 1;
7 y1 F/ Z& `$ r# c" a7 z$ ]p[1] = 1; // 效果与a[1] = 1一样。
数组可以当作T* const来使用， 但是又与T* const有些不同。sizeof()的结果不一样。

* o7 ~4 ^' Y- s) T+ Qint a[10];
int b[10];
. q  w! M* b) ]int* const p_a = a;
9 y7 M5 c5 k0 D- J4 E! E, {a[0] = 1; // 合法。 数组的元素可以修改。
' v" c# e  _8 ~p_a[0] = 1; // 效果与a[0] = 1一样。
& m/ m4 {  y1 U+ |# }- R" Z) D
% x& `; e) R5 r& T0 J4 aa = b; // 报错！ 数组本身的指向不能修改。

// 所以数组a可以当作int* const来使用
int *const& ref1 = a; //正确。
int *& ref2 = a; // 报错!

// 但是又跟int* const有些区别。
assert(sizeof(p_a) == 4); // 32bit程序。
assert(sizeof(a) == 4*10); // 32bit程序

* y3 e0 w3 k) F0 g数组跟元素指针的作用很相似，都可以通过下标去访问元素， 但调用sizeof()函数的结果不一样。元素指针的sizeof()返回值是4(32-bit应用)或者8(64-bit应用)， 数组的sizeof()返回值是数组实际占用的空间。数组可以当作指向第一个元素地址的T* const来用其实就是我们常说的数组到指针的隐式转换。当数组作为函数参数传递后，会自动退化成T* const, 在被调用的函数内部调用sizeof()的返回值跟T* const指针大小一样。 数组传递作为函数参数后， 在被调用函数的内部与T* const是没有任何区别，只有在数组定义的可见范围内sizeof()才有获取数组占用空间大小的效果。

以下3个函数翻译成汇编以后，汇编代码是一样的。
1 q/ c- Y) l$ r) f+ Q: l# a
  ~5 |6 \( @9 \+ z6 Gvoid Func1(int* p_ary)
" H- L9 F! W6 G" m1 e/ A% [{
+ L& s( E$ M; h8 t' z! q% ]7 t, h5 M    assert(sizeof(p_ary) == 4); // 32-bit
' I" v. V* l' y: D3 F    p_ary[1] = 1;
}
; O. r$ B6 a9 O1 ?* S4 k
void Func2(int ary[])
& y- j: D. }) b. Q* s9 v# O{
9 m7 ?1 r8 U! Q  q* _. o: J% b# s    assert(sizeof(ary) == 4); // 32-bit
  s% ?4 b1 a/ D5 G5 E* j6 i. d  H    ary[1] = 1;
}

void Func3(int ary[10])
{
+ G6 F0 E/ D8 S7 G: |    assert(sizeof(ary) == 4); // 32-bit
    ary[1] = 1;
- I3 b  R6 M- m; t5 K- b}
1 @/ E( a: j% Q2 z  Z
int main(int argc, char** argv)
{
' @5 r9 ]! r) D+ q) I  l! F, M0 F) E- c    int a[10];
, }  S8 R2 w! N    int b[20];
    Func1(a);
    Func2(a);
    Func3(a);
3 G$ }. U0 \7 {$ w4 T    Func3(b); // 退化成int* const了， 即使数组长度不匹配也不会报错。
8 H1 O* v  X6 v" [+ m    return 0;
2 [2 ]( B- u* p* r* i# c) g, V/ p}

6 I( @# e1 p) n# O  g9 T0 s

& K' n0 O& J/ W( z多维数组
' W4 l2 G$ g: O$ q一个3行，4列的数组， 结构如下:

int a[3][4];
/ e8 T% c2 U; r: Z  ?+ o0 @+ \( ecolumn 0        column 1        column 2        column 3
, {( k* O( U* D9 S, N7 ^row 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]
数组初始化
  v( ]+ g7 [' A
int a[3][4] = {
4 Q/ h3 q: c5 I- N6 b    {0, 1, 2, 3},
    {4, 5, 6, 7},
# [5 ~" f( P+ H4 [8 ~    {8, 9, 10, 11}
& c3 c9 t9 G2 K7 C* @$ k0 h};
+ Q4 O/ V5 S' o4 D! u 实际上多维数组和1维数组在开启速度优化后，翻译成汇编代码是一样的。

6 o' S1 O& q# K2 h2 Y" Y+ Wvoid Print(int* p_ary);
2 Z9 p  U: E* u" T0 G
void Test1()
{
+ D/ R5 F6 G$ ^& L) D4 Y( [! ]    int a[10];
    a[3] = 3;
7 p1 G" {# g& h) S    a[7] = 7;
9 [1 [! d' a: v7 Y    Print(&a[0]);
}

5 K! o* z8 i+ D- n- Lvoid Test2()
) G" c- Y: h% M* ]  L! b{
3 J* I$ T2 @8 R+ r1 W. O4 ~! G    int a[2][5];
: I8 ~- z2 ]- t& Q    a[0][3] = 3;
    a[1][2] = 7;
    Print(&a[0][0]);
8 w2 P8 y; ^$ d}
/ v% {9 ?3 B: S8 V

3 ^, a; B( [# D3 l$ N# r; R0 s  f
. c& A( J' S2 I. V4 m8 K很自然地，多维数组也支持用1维数组的方式去初始化。

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

假设有一幅RGB图像720*576个像素，每个像素有RGB三个通道，每个通道的值是8bit大小。给出图像的首地址p_rgb_image， 我们要取第40行，第50个像素的R,G,B值。代码如下:
6 |) _9 `, Z. l3 b
unsigned 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];
& [3 x- q  P5 a5 ounsigned char b = p_rgb_image[40*720*3 + 50 + 2];
类似这样的场景， 采用多维数组的写法， 有点类似以索引为参数，可读性更高。相当于程序员和编译器打了一个配合。

" m( k  E: t3 H# z9 h  ^; Denum
0 a# }* r; y" h{
Red = 0,
Green = 1,
Blue = 2
" q; k. a4 O- _};
* K4 v& s: b: W! c6 J3 f0 n$ }unsigned char rgb_image[576][720][3];
/ L1 l( c" M" M4 eint row = 40;
int col = 50;
: `% T! |5 u  z( X) punsigned char r = rgb_image[row][col][Red];
# x7 x. b* Z4 c, o8 B# J$ t5 kunsigned char g = rgb_image[row][col][Green];
unsigned char b = rgb_image[row][col][Blue];
数组指针以及与指针数组的区别
数组指针，是一个指针， 指向的对象是数组。 数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时， 需用用*取得数组对象的引用，再用下标来访问数组元素。
$ _9 q8 j, J! T1 F; e* F指针数组，是一个数组， 数组保存的元素的类型是指针。
数组指针的定义
数组指针定义先定义一个数组。
int a[10];
然后对数组里的名称用括号括起来后再在变量名称前面加个*号
8 m2 z2 X* K/ f) d1 `5 v! cint (*a)[10];
后面你会发现函数指针定义类似。
) {2 C# L3 G' `/ h' B7 ?( V// 各类定义对比
3 I( N# O+ C& q& xint a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];
: M0 X$ L3 l/ d7 T4 B+ s( ?
int *f[10]; // 指针数组, f是包含10个元素的数组， 数组里每一个元素的类型都是int*
8 r0 b" y% H1 N7 Xint *(f2[10]); // 指针数组。另外一种定义方式。
int(*f3[10]); // 指针数组。另外一种定义方式。
int(f4)[10]; // int数组
int(*g)[10]; // 数组指针， g是一个指针， 这个指针可以指向类型是int，元素个数是10的数组
int* (*h)[10]; // 数组指针， h是一个指针， 这个指针可以指向类型是int*，元素个数是10的指针数组

int d[10];
4 E  d; b% Q8 x& |g = &d;

int* e[10];
  v! ]5 I: S: K" W) U3 e, lh = &e;
数组指针的使用
0 C& D0 b+ V" i* N. b  ?数组指针一般先通过*号取得指针指向的数组对象， 然后再用下标操作访问元素。

& b$ t9 g3 E" Jint a[10];
! I& X$ [& j. r. R2 N8 ^int(*p_ary)[10] = &a; // p_ary是一个指针， 指向"int (*)[10]"类型的数组
for (int i = 0; i < 10; i++) {
// p_ary是一个指向数组的指针， 需要先通过间接寻址运算符*(indirection operator)取得数组对象
// 再通过下标操作访问元素。
(*p_ary) = i;
}
2 \" f. t$ ?1 v  D
6 W' {$ a$ S* v; d1 uint b[10];
5 L! ~4 C2 m. x9 K4 s$ X/ \int c[20];
& B# q: G: t- D: u! A8 K8 ep_ary = &b; // 合法
p_ary = &c; // 报错！ 不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
( U1 z, u% u/ o- x数组指针指向多维数组的子数组
int a[10];
int b[4][10];
int(*p_ary)[10] = &a;
for (int i = 0; i < 10; i++) {
, M3 C# d& Z6 U (*p_ary) = 1;
4 ^! }4 H) x" `/ |& k6 c9 Z6 c}
" Y6 ], ^& b5 Y9 t: }1 e7 X5 q; S
p_ary = &b[2]; // 多维数组，可以看作数组的数组，
// b[2][0] ~ b[2][9]的值都被改成2了
  x) e7 |' m+ }9 L# Zfor (int i = 0; i < 10; i++) {
3 J; Y) K* y' A- s: J2 ~ (*p_ary) = 2;
+ L6 \; E$ w% F. p2 m# p0 w( |; |}
多维数组指针
多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。

int a[2][5][10];
int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
6 S8 C0 P8 r$ g! ]5 ]+ vint(*p_ary2)[5][10] = &a[1]; // 2维数组指针
for (int row = 0; row < 5; row++) {
    for (int col = 0; col < 10; col++) {
! s* p" Q7 P+ ^+ Z- F; E        (*p_ary2)[row][col] = row * col;
! [0 i  ^" h: Z: c; X# j# ], ]) z& R/ J    }
. D$ D& D( m5 o. e, ?3 ]4 T4 g}
数组指针和指针数组对比实例
% L0 N* d7 g  r1 E" Q2 J( V数组指针还是记住两步法即可
3 N% c! K- V: N. a
定义一个数组
, d5 v' d/ ^9 b, _' k括号包围1中定义的名称，再在名称前加个*号。
! q$ }9 u$ i, T1 K9 jint a[10];
" ^% I% B& N" R+ hint(*ary_pointer1)[10] = &a; // 数组指针
& ?/ r# T* T% S+ c2 u6 p  lint* pointer_ary1[10]; // 指针数组。元素类型是int*
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
3 Y" T' X( Q1 gint c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。

; W; b  S+ O. A6 |3 A// 指针数组可以把每个元素指向数组对应位置的地址。
  U7 Y6 z' D% E( K5 j) t: m// 这样遍历指针数组， 可以达到遍历数组元素的效果，但是注意每个元素都是指针，
0 F( U$ q  ]; t/ j1 i" S$ w// 需要访问原数组的值的话， 需要对指针用*间接寻址运算符。
int* pointer_ary[10];
for (int i = 0; i < 10; i++) {
    pointer_ary = &a;
}
// 类似遍历原数组效果。
for (int i = 0; i < 10; i++) {
    *pointer_ary = i; // 修改原数组。
: a6 `8 B4 F% [3 R! A9 |}
/ h7 I( u- h9 S
' p! o+ ]% y# p函数指针
取得函数地址
/ [( g/ N: o  M- r' e# A函数的名称作为参数被传递时，会隐式转换成函数指针， 和在函数名称前加取地址符&等价。建议带上更加统一和清晰。

& Z% j& u3 B" E8 Z+ pvoid f(int);
( @) X- x* f5 \1 Uint main()
; o4 E' J5 P! W( w. {7 p9 _7 J{
    void (*p1)(int) = &f;
    void (*p2)(int) = f; // same as &f
" a2 G0 Y6 z* a    return 0;
}
9 K1 h6 X: P( m0 ]7 f# \翻译成汇编代码， p1和p2的赋值是一样的。


- V; X& ^+ a- l
函数指针的声明
单个函数指针变量定义步骤
  I8 ^$ b  l* Q定义一个函数。void fun1(int a, int b); int fun2(double a);
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
0 }# @, V8 e4 M3 J- p如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
" J' b% d4 Q0 J% qtypedef定义函数指针
! p8 E+ e0 O  z' W- `& C可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。

, d7 E  T0 S4 Z. w. J) U. h7 ytypedef定义函数指针的语法
$ V& M) l- R. ?! a4 C. H, _  wtypedef有两种做法， 一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值， 但是支持引用。

typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
1 H* j6 W, y" e3 X; c. b9 ntypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
FuncObject* f1 = &Add;
FuncPointer f2;
, U) s" t+ t& y8 o1 W$ v; p0 E' Uf2 = f1; // f1, f2类型一样， 都是形式为int(int, int)的函数的指针。
( @8 ^+ K8 N5 OFuncObject f3 = Add; // 报错！ 函数对象不支持拷贝
) g( {3 @& N5 cFuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
FuncObject& f5 = Add; // 正确
5 {: P) p  e1 I, n  Uint ret = f5(2, 3); // 正确
  C4 [8 X/ x- v: J1 t0 [5 [2 NFuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
如何记住typedef定义函数指针的步骤
; ~+ I+ t+ @0 x  Z1 j) v& H, F5 f像定义一个函数指针那样， 指定一个名称。int (*CalFun)(int a, int b);
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
完整例子
typedef int(*CalFun)(int a, int b);
% o/ M2 m; _" {/ [0 s9 H
int Add(int a, int b)
4 a2 n- k) V- }; q; w{
    return (a + b);
1 x; V0 }7 ?( j+ Z}
% H! N5 p7 O5 s; Y8 N! e
int Sub(int a, int b)
{
! b) `0 w7 x9 ^( [' S) _! W; z, W    return (a - b);
; h8 H0 d5 `$ W7 W) r4 M) m3 k}

9 b( o; ~6 a  Q# Cint main(int argc, char** argv)
{
) L/ {- r2 F4 Z0 p9 }    CalFun f1 = Add;
$ p2 L8 q( \+ s0 s, f/ Z. E    CalFun f2 = Sub;
7 c- r3 t$ Y* S7 f    int a = f1(2, 3);
. ]6 d0 e  Q1 M* w    int b = f2(10, 5);

' \. ]6 P( c9 h9 L6 p    // typedef定义的函数指针数组。
    CalFun f_ary[2];
    f_ary[0] = Add;
6 h& s2 z" B8 M! H    f_ary[1] = Sub;
" G' F+ ]: o% i* _! D- Y
. I. M. z1 Z9 n9 j5 T9 o    // 单个定义的函数指针数组。
    int(*f_ary2[2])(int a, int b);
    f_ary2[0] = Add;
    f_ary2[1] = Sub;
9 `+ N7 v' Y2 C
    return 0;
1 x3 @' O8 Q" n- K}

using别名定义函数指针
c++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。

typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
1 s: N3 @# z4 \7 ]3 nusing FuncObject = int(int a, int b);
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
/ m" {6 F0 n& P/ S5 F- busing FuncPointer = int(*)(int a, int b);
函数指针的调用
2 v$ U* |$ j0 B1 }函数指针和函数对象都可以直接后加括号调用
int f();
: \+ V/ Y' X+ U  yint (*p)() = f;  // pointer p is pointing to f
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
$ @' Z1 m: c. Q" K/ or();             // function f invoked through lvalue reference
(*p)();          // function f invoked through the function lvalue
+ O! h$ w7 d, Rp();             // function f invoked directly through the pointer
如果函数有重载， 函数指针会指向匹配的那个版本。
template<typename T>
T f(T n) { return n; }

0 `5 C! `' |) o* g0 `double f(double n) { return n; }
: {, j  m: l* n0 b' j9 J! q& l0 W
# }( _$ M1 ^/ H& |* nint main()
{
    int (*p)(int) = f; // instantiates and selects f<int>
}
成员函数指针
3 R9 a( c, |; n- ?$ V静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。

8 h$ d2 D4 f/ K' }5 ?成员函数指针定义。
; J: [/ @9 A3 H4 y' b, z像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
在名称的前面加个*号void (ClassName::*func)(int);
1 W+ S+ m: `) Z8 q, v成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
成员函数指针如何调用。
3 ~0 p2 j+ U& C  ?9 g, X/ t8 l假设成员函数指针名字为func

void (ClassName::*func)(int);
对象式调用。
) m8 y. `7 B, x: A' M: uClassName c; // 被调用的对象
% l$ I& U( s9 L6 w/ D, l成员函数指针名字当作正常函数那样写。
% \$ ]: y$ M9 y. yc.func(3);
8 O0 e5 N4 N$ s" G( e成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
6 O, U! C4 R* oc.*func(3);
6 V- a7 c4 X) p3 `6 K. @4 q" ]最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
6 ^! t+ I; Q9 q) ]8 j7 @(c.*func)(3);
为何要加上括号？ 根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低， 成员函数指针还没取得对象就被调用了，自然报错。 另外
; _7 i) x- S- O: C# q/ x(c.(*func))(3);
0 f4 m7 E$ F3 a这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
$ O; @0 W" k* K1 u. @5 G指针式调用
ClassName* p; // 被调用的对象的指针
4 c% r" x: J0 Z# Q8 e  A成员函数指针名字当作正常函数那样写。
p->func(3);
6 Z2 @' @/ G- ~2 b成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
; S  q) G6 H2 Z6 N# U* n2 Ap->*func(3);
' o2 l7 I% s! S# b+ ]最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
$ V0 Y* L5 u4 z. r(p->*func)(3);
函数指针使用完整例子
0 ~" ~5 I% R$ R0 M5 i5 t5 |/ y# tstruct Cal
& [6 Y( P( P7 k{
$ k7 _7 X1 ]2 X- Q    int add(int a, int b);
    int sub(int a, int b);
9 n- Y2 Z# g# B5 @3 U- h. E};

1 `# N  x6 n) A2 v4 e( J+ o& Lint main()
{
    int (Cal::*fun)(int, int) = &Cal::add;
2 x* |& K% n. ^3 w7 E2 q3 k    fun = &Cal::sub;
8 p7 m2 n0 w' Q
. Z! i/ ~+ W6 }* _+ a0 L    Cal* p_cal = new Cal();
. k* g2 U) q' Y3 k* b    int r1 = (p_cal->*fun)(2, 3);
    delete p_cal;
- z" k* g9 M5 `( k; u) `1 D3 Y% E: T. K
8 a' L6 k+ ]9 {4 ^  x0 N( T    Cal local_cal;
$ i# p* T' K! Y    int r2 = (local_cal.*fun)(8, 6);
}
3 _) G+ z/ ~, ?. C# M' n
% d# \  h3 s4 |4 S. z* s$ }成员变量指针
$ U9 N. U) B$ k+ e成员变量指针比成员函数指针还要简单些，没有函数调用， 无需考虑函数调用和间接引用符*的优先级问题。
3 `' S( _+ o' n3 i: C. ~2 `3 z! c
' c. I5 \; W( R) T3 d$ {成员变量指针的定义
- a) {- |5 d6 }假如以下结构体C。

0 f1 s% P% I: Q; nstruct C
; y) y: H8 g7 E& F  m. y{
    int m;
' @3 `6 T3 n! i$ i! c};
* C, Z/ ]6 N5 R, Q: `8 i单个成员变量指针定义
假设名称为p, 类似静态成员变量定义那样声明
int C::p;
% f$ l# t; b, S% t4 _' N在名称前面加上指针标识号*
+ ?! d$ y/ g5 P" }, o) n9 ?int C::*p;
# R: ?4 D& e, d9 [6 X7 L1 L& mtypedef或using方式定义
: m9 ^1 J7 x9 ]( s/ u* {7 Utypedef int C::*MemberPointer;
2 t+ a- M. n' O# q. x" L; I$ H1 Iusing MemberPointer = int C::*;
成员变量指针的使用。
5 O9 l+ V) n0 l- ?& }3 Z# J! o类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
9 z1 o1 i5 {+ Z# u成员变量指针， 能让我们实现一些遍历成员的动态功能。 例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。

完整例子
: P, z( }/ u. k$ C. a) mstruct C { int m; };
" L+ X4 U# C- Z- J# lint main()
" K. \  j( a) d* `! w{
    int C::* p = &C::m;          // pointer to data member m of class C
; c9 ~. h; i  s' z9 S, i# k    C c = {7};
    std::cout << c.*p << '\n';   // prints 7
    C* cp = &c;
    cp->m = 10;
    std::cout << cp->*p << '\n'; // prints 10
& I$ Y3 p% A5 X- p6 G7 q0 q
————————————————
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
) Q% t# N9 h6 t% S; H

( m5 O( @* n/ `' r