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

杨利霞

C++数组指针、函数指针、成员函数指针
C++数组指针、函数指针、成员函数指针
. A2 c7 L( ^' U8 q( {6 g

操作符名称
& 取地址符(Address-Of operator)
; a( y! r+ K2 i7 T/ Y: F3 f: h+ l* 间接寻址运算符(Indirection operator)
.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
* w: t! z  j& d0 s+ W+ N7 m: y.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
() 函数调用运算符(Function-Call operator)
( |( p( K2 Y# |; L3 k& N:: 范围解析运算符(Scope-Resolution operator)
" v6 m# |# V$ F$ c+ v* s1 ~如何定义一个指针变量
# C& ]: ~. [- Z% t* l假设类型T， 变量名称name, 指针的定义如下:

1 I  Z# ?8 @0 T; W3 {9 AT* name;
4 b+ I* B7 M- r标识变量名字name, 它是T类型的指针。例如
# Q" ~7 k( q% o$ i. u6 d
int n = 0;
int* p_n = &n;
p_n是int指针类型， 指向某个int型的对象。
$ f2 o2 M" D5 K0 J9 u3 P) P9 Z
0 N  L, c/ B( }5 y0 f, q; b指针变量的修饰
指针实际上也是一种变量类型， 只是它保存的内容有些特别， 是指定类型的地址值，通过间接寻址运算符(indirection operator)*, 可以访问到指针指向地址上的指定类型。
, T1 c/ v) o4 J+ ?+ Y$ R
指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int， 且该变量不能修改。以下两种写法都可以:
$ {  E' m7 Z* B$ s. t6 I6 E4 u
const int a = 1;
int const b = 2;
既然指针是也一种变量类型，同样支持被const修饰， 表示指针的值/指针的指向不允许修改， 指针所指向的那个变量是否允许修改， 那是另外修饰。写法如下:

+ O8 X, {5 l- ?/ U7 _: _& Fint a = 1;
int b = 2;
+ b5 s1 m6 A; ?2 sint* const cp_a = &a; // 指针的修饰词，放在*号后面。
7 D4 y- B9 |3 a" {*cp_a = 10; // 指针指向的值可以修改
cp_a = &b; // 指针不能被修改，报错！
9 R7 u5 }. j+ i: N1 [4 o6 P! _总结带修饰的指针的格式:
( [/ \2 T/ r3 @只要记住修饰词总是放在被修饰的内容后面。
6 T2 M' n9 E0 _6 Z
1 {! |7 \! r* u8 Q5 Jcv表示const / volatile修饰词。指针定义形式如下:
1 `& k4 \7 [6 g1 L
T [cv for T] * [cv for pointer] name
注意对T的修饰放在T的前面也是合法的写法。

const int const c = 2;
在mscv编译器下也不会报错。

完整的格式:
[cv for T] T [cv for T] * [cv for pointer] name
5 ^2 h: C( a9 U3 N
8 M1 e* e$ |9 n# _Syntax        meaning
! t- d2 [- m9 p2 E9 J! U% n0 Bconst T*       
pointer to constant object

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;
* B; H7 I6 p/ T6 fint b = 2;
7 r3 p+ }) s- R& a' D7 d! B5 G
0 e; `. K' A* Yint* p_a = &a;
*p_a = 10; // 合法
) k+ H" h, U+ d7 p( Vp_a = &b; //合法
8 a! b; R9 ^6 |5 p, Y$ E) h
: E% u/ D( p% T: uconst int* cp_a = &a; // const修饰int类型， 并非修饰指针
*cp_a = 11; //报错! const int类型不能修改
cp_a = &b; // 合法， 指针没有const修饰，指针可以修改。

8 L- D) n: w; U5 R) tint* const pc_a = &a; // const修饰指针。类型没有const修饰
*pc_a = 12; // 合法， 因为类型没有const修饰，可以修改。
pc_a = &b; //报错！ 指针被const修饰， 不能修改指针。

& d" j8 X9 e8 i4 i$ A5 b2 Z) F3 `1 Uint const* const cpc_a = &a; // int类型被它后面的const修饰， 指针符号*后面也有const修饰
*cpc_a = 13; // 报错！ 类型被const修饰，不能修改。
cpc_a = &b; // 报错！ 指针被const修饰，不能修改。
$ {: I1 W) @/ G2 A
更复杂的指针的指针
# k" H; B% t+ {
3 j5 u" M& C, aint a = 1;
int b = 2;
/ p9 k7 e3 }8 x0 e8 Nint* p1 = &a;
# u6 ?/ a- R8 Y) \; cint* p2 = &b;
$ ]( \3 I# _( c2 n& a4 Vconst int* ct_p1 = &a; // ct for const type
) w: \. C7 U( T6 B' H3 gconst int* ct_p2 = &b; // ct for const type

// int * * pp1; 指向(int*)类型的指针
int** pp1 = &p1;  
pp1 = &p2; // 合法,
& j5 d& o: u/ g) @pp1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)
$ o& p) R  ~7 P8 G' V
9 v+ \3 ?' Z- y9 |// (const int) * * pp1; 指向((const int) *)类型的指针
const int** ct_pp1 = &ct_p1;  
3 C# r* h' A) E. F$ _ct_pp1 = &ct_p2; // 合法
( \" {6 }5 ]8 u% o/ D+ jct_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。

// (const int) (*const)
const int * const ct_cp1 = &a; // 指针也不能修改
% S) m" V+ N5 b( rconst int * const ct_cp2 = &b; // 指针也不能修改
4 z: V# a7 U% C3 c0 a& vct_cp1 = &b; // 报错！指针有const修饰
" {7 q4 b! y4 I8 x  k
4 a; i0 Q* t6 j2 X& N# D// (const int) (* const) *  指向((const int) (*const))的指针
3 J) z6 X) T. A& Vconst int* const * ct_cp_p1 = &ct_p1;  
ct_cp_p1 = &ct_cp2; // 合法， 指针的指针并没有const修饰， 指向的指针有const修饰
*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改
; f+ d- q% N' o  j7 K% \$ k: g
+ x) G" r, N6 d8 p/ E1 X( T! V// (const int) (* const) (*const)  
% J* K: k" @  r% R4 ^/ _" k$ ~// 指向((const int) (*const))的指针,且该指针被const修饰
const int* const * const ct_cp_cp1 = &ct_cp1;
; ~8 \5 y! F  L, Y+ j: j; |ct_cp_cp1 = &ct_cp2; // 报错！ 指针的指针被const修饰， 不能修改指针指向。
8 K' |5 K( W: d. a, m6 x- L
  x2 H* ^4 O$ N6 Q+ k0 s一行声明多个变量
+ {* f) M+ [- r类型 + 名称定义一个变量。
变量的前面可以加*号修饰， 表示指针， 一个星号代表一层间接。**表示指针的指针。
% k2 K5 f- F- L
int a, *b, *c, d, **e;
a = 0;
d = 1;
7 C) Z, |; V0 U4 Z  x1 V4 yb = &a;
c = &d;
e = &b; // e为int**类型 指针的指针
5 n  U0 t* k! @/ h7 h, Ae = &c; // e为int**类型 指针的指针
也可以用括号包围变量和*号。

int (a), (*b), (*c), (d), (**e); // 合法定义。
括号可以省略，某些情况， 个人感觉加上括号更清晰一些。例如
" L5 H1 i% E3 H2 W
4 {0 z9 g' B- o" g: Q, ~3 Y/ h9 Z1 Wint (a), (const *b), (*const c) = &a, (const d), (const* const* const e) = &c;
+ D% s3 L  V" A( L* ?写成

int a, const *b, *const c = &a, const d, const* const* const e = &c;
6 z" F3 ?# A. L3 F. j  c更重要的是， 后面我们表达数组指针，以及函数指针时，括号是不可缺少的， 带括号的表达更加统一。
0 y" H3 A+ n2 l9 ?
数组指针
数组基本表达
6 h8 i* o3 |3 W; H8 H5 Nint a[10];  // 定义了类型是int, 元素个数是10的一个数组。
由于c++要支持一行定义一个类型的多个变量。 所以数组的[]时放在名称后面的。虽然我觉得

' P* X* x$ w/ Kint[10] a;
这样的写法更符合类型 名称的思维， 但是如果类型都这么写的话， 没法兼容以下的写法:

( k. m" l' X1 S2 J8 K! w6 |int a = 0, *b = nullptr, c[20], **d = nullptr;
& Q0 S, O! S6 f- X" pc++标准规定如此，但我们可以通过每一行只定义一个变量的写法， 类型会更加清晰。

int a = 0;
int* b = nullptr; // 指针int*
7 \$ I" P% d- p7 D+ t; Vint c[20];
int** d = nullptr; // 指针的指针int**
数组的名称是什么类型
& z4 d+ h! L- t$ m) J数组元素类型的指针，可以直接指向数组。 并且数组跟指针一样，可以通过下标去访问元素。
% S9 G1 B5 {' i/ v! c
5 S0 L( s' O& s! B6 d2 Wint a[10];
( t! W. p: C$ T% h! U8 e6 Kint* p = a; // 指向a数组的第一个元素
a[1] = 1;
p[1] = 1; // 效果与a[1] = 1一样。
5 J% u2 W5 f2 D" w0 a3 {数组可以当作T* const来使用， 但是又与T* const有些不同。sizeof()的结果不一样。
$ x4 e# [* }8 ^% h
- I! m0 {0 J) j9 o+ i6 Eint a[10];
int b[10];
" V8 G2 f8 M, Uint* const p_a = a;
9 r1 e/ }$ b! C6 l' ea[0] = 1; // 合法。 数组的元素可以修改。
* N1 {: r$ K% ]& r/ r2 {+ o- |p_a[0] = 1; // 效果与a[0] = 1一样。

+ r0 _% w8 P0 H8 K9 y+ m: Q% s9 O  qa = b; // 报错！ 数组本身的指向不能修改。

// 所以数组a可以当作int* const来使用
( T' |: Z2 E4 {; ^; x# \9 Bint *const& ref1 = a; //正确。
4 v8 O  |4 q$ ]3 Q6 ?$ Q8 pint *& ref2 = a; // 报错!
2 l. }% j  c  V% F. M/ M1 Q
; Z5 K3 M9 Z4 v' i9 r8 B6 z5 m// 但是又跟int* const有些区别。
assert(sizeof(p_a) == 4); // 32bit程序。
7 v, @# k) n% _3 I7 Qassert(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个函数翻译成汇编以后，汇编代码是一样的。

* j2 ?1 s& @0 l+ L5 t% x" ]void Func1(int* p_ary)
0 j: j1 N; Z6 q# P- N0 {{
. v! P7 w2 O* I) C    assert(sizeof(p_ary) == 4); // 32-bit
    p_ary[1] = 1;
2 V% G" W  L" Q( Z! g2 g2 V8 g}

void Func2(int ary[])
{
* v  g" q9 ^6 o; d6 J$ X; z% F    assert(sizeof(ary) == 4); // 32-bit
    ary[1] = 1;
}

% o1 ^# m& V  b; Ovoid Func3(int ary[10])
$ {' W. N, v* P{
' m3 ^  M- u* F% x; ^! [% R2 f3 e    assert(sizeof(ary) == 4); // 32-bit
0 _% h* V7 ], R6 _- Z  F4 i, U    ary[1] = 1;
}

4 y, O/ E$ y$ U% X) Y4 O8 fint main(int argc, char** argv)
{
8 \7 u( ~7 v9 M/ o! g  o    int a[10];
    int b[20];
/ ?* M; V. }- v  J" M6 X9 V    Func1(a);
  ]1 Z$ F0 u9 C/ W& B    Func2(a);
, x  q+ Y* c" \" n8 q; P    Func3(a);
    Func3(b); // 退化成int* const了， 即使数组长度不匹配也不会报错。
    return 0;
3 R. V5 Z8 i" s) V}
+ V/ j  m8 C$ Q, C" w: B. V

/ O, c/ I- M9 |1 T
7 @4 Q+ v# n7 e: C9 N多维数组
; J* n! a; D& q: z3 O% V% B! \一个3行，4列的数组， 结构如下:

: V, g1 B! s1 ]) M6 Dint 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]
% N1 s. H( N& k- `$ ]) t& lrow 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]
3 ]& W! M* h9 ]) f数组初始化

int a[3][4] = {
    {0, 1, 2, 3},
    {4, 5, 6, 7},
    {8, 9, 10, 11}
};
实际上多维数组和1维数组在开启速度优化后，翻译成汇编代码是一样的。

5 S9 a$ V, E" n) y5 `" zvoid Print(int* p_ary);

0 |+ }  j! C$ \9 [2 @void Test1()
/ h5 e9 U" ?  F+ T  l5 U, z{
    int a[10];
    a[3] = 3;
, T/ H4 N. E& L, _) ~' B    a[7] = 7;
    Print(&a[0]);
}
+ {: W  p4 m# p; `: J
4 A5 ]: T. N* n3 K) h+ Nvoid Test2()
. B7 x2 v% S; k1 L{
    int a[2][5];
# O9 j8 y3 J: p- p8 v1 s4 \& a    a[0][3] = 3;
1 M! Z  c# b; z. f2 f    a[1][2] = 7;
    Print(&a[0][0]);
" z5 ]/ E: q; E6 K6 ~}
9 @( j) N' r& h+ S7 p
3 M4 N4 T( O) V4 f1 c1 M) z
- A" b4 Q+ `- K* W
很自然地，多维数组也支持用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值。代码如下:

unsigned char* p_rgb_image;
2 d/ K4 s) a$ C5 i0 g4 X/ K" ?+ g( Punsigned char r = p_rgb_image[40*720*3 + 50 + 0];
unsigned char g = p_rgb_image[40*720*3 + 50 + 1];
unsigned char b = p_rgb_image[40*720*3 + 50 + 2];
类似这样的场景， 采用多维数组的写法， 有点类似以索引为参数，可读性更高。相当于程序员和编译器打了一个配合。

enum
{
Red = 0,
Green = 1,
6 G6 ]; W8 U8 Q! f+ t2 v Blue = 2
9 Z# G6 t5 F( E1 z& p% Z2 O$ W};
) r) V: A& w- Q! w* o5 A$ K; }unsigned char rgb_image[576][720][3];
% n$ I( A3 `4 B5 c2 t" }int row = 40;
int col = 50;
unsigned char r = rgb_image[row][col][Red];
unsigned char g = rgb_image[row][col][Green];
; j+ p7 W3 N/ g/ ^4 V0 ounsigned char b = rgb_image[row][col][Blue];
9 V# F6 @2 w6 i7 E; F  `7 f数组指针以及与指针数组的区别
数组指针，是一个指针， 指向的对象是数组。 数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时， 需用用*取得数组对象的引用，再用下标来访问数组元素。
# S' P+ }  v- ^指针数组，是一个数组， 数组保存的元素的类型是指针。
数组指针的定义
数组指针定义先定义一个数组。
9 K0 i: A2 j; W: W9 a: m7 q. Y+ n4 y/ Kint a[10];
然后对数组里的名称用括号括起来后再在变量名称前面加个*号
( X& k" W  Q5 G; n1 D% Y4 hint (*a)[10];
后面你会发现函数指针定义类似。
// 各类定义对比
* O+ H/ q+ T0 F: T, S7 H+ iint a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];

4 U7 X: j) n# f+ ]. tint *f[10]; // 指针数组, f是包含10个元素的数组， 数组里每一个元素的类型都是int*
3 D! g! Q% b1 _, c3 w' |int *(f2[10]); // 指针数组。另外一种定义方式。
' ~3 \& t9 i" B) Z- W' ?; q4 Sint(*f3[10]); // 指针数组。另外一种定义方式。
0 o+ C) n# s% M8 M3 hint(f4)[10]; // int数组
, I; v! t$ Y& g  w* Z- x0 S1 Sint(*g)[10]; // 数组指针， g是一个指针， 这个指针可以指向类型是int，元素个数是10的数组
- y- ^: W2 _6 nint* (*h)[10]; // 数组指针， h是一个指针， 这个指针可以指向类型是int*，元素个数是10的指针数组

( |( ]$ w1 x2 B5 i: \  ^" yint d[10];
g = &d;

& J3 f+ R. a, j* Y# Fint* e[10];
! b# v' o& j1 P% O& {6 W& Kh = &e;
: D8 l9 J. p4 ?1 W) F, U4 s$ t数组指针的使用
: U, x* k% J: A& i数组指针一般先通过*号取得指针指向的数组对象， 然后再用下标操作访问元素。

0 u7 }6 B& T7 O# h1 i7 F9 j' ]int a[10];
) \$ J* a* a* e; N  Z4 Vint(*p_ary)[10] = &a; // p_ary是一个指针， 指向"int (*)[10]"类型的数组
* S  L4 I3 M2 z- E2 ?; \3 N: Q* y5 Mfor (int i = 0; i < 10; i++) {
+ K/ w. h! x* ?9 N) K, s // p_ary是一个指向数组的指针， 需要先通过间接寻址运算符*(indirection operator)取得数组对象
// 再通过下标操作访问元素。
(*p_ary) = i;
2 `- T/ M: r) d: J: ?5 Q}
& I/ j$ N- e1 R! M/ P( j* \1 Q5 U* F
' Z- y( Q: C- y: m& U! Gint b[10];
; y2 m: c" V8 P  N' {int c[20];
p_ary = &b; // 合法
p_ary = &c; // 报错！ 不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
数组指针指向多维数组的子数组
int a[10];
int b[4][10];
int(*p_ary)[10] = &a;
" `. L. H: Z/ T& v8 j" e' Y/ P" Zfor (int i = 0; i < 10; i++) {
(*p_ary) = 1;
, j% s% |9 e: R}

. G" c6 d3 N# D5 S1 Lp_ary = &b[2]; // 多维数组，可以看作数组的数组，
; @4 H& R  f$ |2 H) Y! |// b[2][0] ~ b[2][9]的值都被改成2了
, q2 K& ?7 ^- Jfor (int i = 0; i < 10; i++) {
(*p_ary) = 2;
' a; V( ~. r, r" U3 t}
, I! \0 o, q9 I: o7 M多维数组指针
0 f& e) r7 V) f多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。
: _$ h0 Z3 D7 N0 y
# y3 g2 l3 B& _' O0 Eint a[2][5][10];
7 T# p8 Y) Z' o8 B$ t2 e2 ~int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
6 S2 n- t7 Z+ Bint(*p_ary2)[5][10] = &a[1]; // 2维数组指针
4 H+ y$ @: l: ?( R* Lfor (int row = 0; row < 5; row++) {
    for (int col = 0; col < 10; col++) {
        (*p_ary2)[row][col] = row * col;
    }
0 t: R+ n$ {* k; C}
数组指针和指针数组对比实例
数组指针还是记住两步法即可
' T7 b& S7 v4 z! }3 D* e9 z
定义一个数组
& @8 q' g0 o7 ?9 @5 R' b括号包围1中定义的名称，再在名称前加个*号。
; w( x! O! ^, ]1 Fint a[10];
5 z. X, ]: k0 q" A: e( B  eint(*ary_pointer1)[10] = &a; // 数组指针
int* pointer_ary1[10]; // 指针数组。元素类型是int*
" q' q# i5 y5 Kint *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
7 p2 _2 k! W% c; B* |int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
4 T6 Y! n5 H# t. c3 ^. l
// 指针数组可以把每个元素指向数组对应位置的地址。
0 W, n6 ^7 k8 ?! Y// 这样遍历指针数组， 可以达到遍历数组元素的效果，但是注意每个元素都是指针，
5 `- ]( }; h- Y6 `& t0 |; h// 需要访问原数组的值的话， 需要对指针用*间接寻址运算符。
7 v6 c  d: ]. \/ m9 m/ nint* pointer_ary[10];
for (int i = 0; i < 10; i++) {
7 f$ `: t! K8 X7 L    pointer_ary = &a;
/ v' d+ y) m0 s4 i8 G}
& W! {3 t- `8 X4 R' ]7 ]( e// 类似遍历原数组效果。
for (int i = 0; i < 10; i++) {
    *pointer_ary = i; // 修改原数组。
}
2 l# k% }+ m4 u
0 D" M: d+ w1 x9 ~函数指针
2 r4 q" ^5 C  f1 B4 a9 W取得函数地址
/ Q0 r, U- p, X函数的名称作为参数被传递时，会隐式转换成函数指针， 和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
/ G2 d+ m1 ~# O; Q( n; k7 _2 J) x
4 P0 v! \! V1 Y: v* qvoid f(int);
int main()
# A3 I  n/ d0 E4 t. i{
2 u" U# F  [$ ^3 j: l' Q    void (*p1)(int) = &f;
) F( ]8 d5 l, Z' ]& _. `    void (*p2)(int) = f; // same as &f
5 J! w& u; d! W5 F5 a    return 0;
}
翻译成汇编代码， p1和p2的赋值是一样的。

4 x1 }7 C8 k8 D* J0 g1 U

9 h# B3 J6 s+ B2 R' ?函数指针的声明
单个函数指针变量定义步骤
定义一个函数。void fun1(int a, int b); int fun2(double a);
3 B% e% ~' X- @( j# i用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
typedef定义函数指针
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
5 J( t% C! R- Z  c* c
typedef定义函数指针的语法
typedef有两种做法， 一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值， 但是支持引用。

typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
8 O0 c5 s7 h+ ^" q7 _% k0 A* rtypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
FuncObject* f1 = &Add;
/ E8 o2 [- M7 w8 a6 U" b  DFuncPointer f2;
9 S8 q/ x1 G9 l/ W  G0 D0 Ff2 = f1; // f1, f2类型一样， 都是形式为int(int, int)的函数的指针。
FuncObject f3 = Add; // 报错！ 函数对象不支持拷贝
FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
FuncObject& f5 = Add; // 正确
. t( ]3 [6 U+ l# a' t7 g9 J2 m3 sint ret = f5(2, 3); // 正确
3 @) F1 w, b) M; F$ j2 p) ?- LFuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
如何记住typedef定义函数指针的步骤
# N& W& w# ^  l' v- j像定义一个函数指针那样， 指定一个名称。int (*CalFun)(int a, int b);
  v% b8 m- i; e! C+ ?: j在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
9 i" X- X4 @" D$ e4 K- N完整例子
typedef int(*CalFun)(int a, int b);

) U0 W. l4 x( z4 T" j# yint Add(int a, int b)
* O' U% g+ m! C- R- }0 H{
+ S8 h9 _. K; C* d    return (a + b);
}

int Sub(int a, int b)
7 b+ m. u3 c! t) @% N) w{
    return (a - b);
. ~4 `; h/ U0 c, b9 @, U6 W2 s$ e}

1 M4 q2 j4 H9 r: A5 [int main(int argc, char** argv)
1 R% H" F8 s* G" H{
    CalFun f1 = Add;
7 F2 Z# z" z$ r+ d, R    CalFun f2 = Sub;
    int a = f1(2, 3);
    int b = f2(10, 5);
( G& c/ W4 x) @$ ^' z
    // typedef定义的函数指针数组。
* E+ O2 W" S$ k9 T5 z/ p    CalFun f_ary[2];
    f_ary[0] = Add;
, s  A& r9 X( t9 D5 G# n    f_ary[1] = Sub;

( a, _: G4 a! q. d0 u1 }) A( ]7 d    // 单个定义的函数指针数组。
* {7 n- b- C( j# w  }    int(*f_ary2[2])(int a, int b);
    f_ary2[0] = Add;
    f_ary2[1] = Sub;

7 L8 P4 k7 g0 R3 s" g( L    return 0;
& ^& z8 V7 `) Q5 \+ I' s" o}

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

typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
using FuncObject = int(int a, int b);
# w, A4 Q2 O( t3 K4 ~$ \7 j$ |0 Atypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
using FuncPointer = int(*)(int a, int b);
函数指针的调用
  ^: S" o& p- T+ Z" ^4 G函数指针和函数对象都可以直接后加括号调用
int f();
int (*p)() = f;  // pointer p is pointing to f
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
; S# X& z+ B- C0 r2 U( L9 S: D- Jr();             // function f invoked through lvalue reference
(*p)();          // function f invoked through the function lvalue
. \! j; J% D8 ~1 ^0 p' Y) Mp();             // function f invoked directly through the pointer
如果函数有重载， 函数指针会指向匹配的那个版本。
2 d5 m9 x/ N* Ftemplate<typename T>
T f(T n) { return n; }
* x. i1 q) B; S8 L! u) w- C
double f(double n) { return n; }
$ K4 V& b+ h  P
int main()
{
- e9 @; }* Q0 y+ \0 f    int (*p)(int) = f; // instantiates and selects f<int>
}
成员函数指针
& ~3 \* j1 v3 G7 P6 V9 U6 {( G静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。
. a- ]+ u9 ~. k+ ~
成员函数指针定义。
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
& j0 I/ d- c0 w在名称的前面加个*号void (ClassName::*func)(int);
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
( k& L8 |5 e6 F/ N% @* M  E9 B成员函数指针如何调用。
假设成员函数指针名字为func

7 N) c4 E( o5 X3 j- e; c8 Cvoid (ClassName::*func)(int);
0 ?! A1 x, v* o  T6 m/ k9 U+ q对象式调用。
, ?- K6 q6 g" l/ ]  B. W  v# I7 BClassName c; // 被调用的对象
1 i/ i# [/ _5 w7 ]成员函数指针名字当作正常函数那样写。
# s* F2 m. [6 Lc.func(3);
4 G( k& A0 ^/ W( _5 ]- v0 Y成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
; H. P6 q, r% Z4 a7 cc.*func(3);
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
8 ~  P- f* p8 {3 K# ]3 l(c.*func)(3);
* T+ o0 x& q' h, t& F+ S( ^为何要加上括号？ 根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低， 成员函数指针还没取得对象就被调用了，自然报错。 另外
(c.(*func))(3);
这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
% X: u2 W# j/ o2 x8 P指针式调用
ClassName* p; // 被调用的对象的指针
6 V4 F$ D* \3 |成员函数指针名字当作正常函数那样写。
$ k3 h# L% K! d: W- p. t/ K* qp->func(3);
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
  X) t) I* D0 c! r; X* _p->*func(3);
最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
(p->*func)(3);
函数指针使用完整例子
" U; v. I/ b, u5 q+ ~struct Cal
8 E+ k) m) D8 f{
    int add(int a, int b);
    int sub(int a, int b);
};

" p3 Q3 O1 ]# A2 {9 dint main()
{
+ X6 K2 G6 w& y% p3 Y4 P1 `    int (Cal::*fun)(int, int) = &Cal::add;
    fun = &Cal::sub;
, U7 }# U" N; P# v1 I. B! f
0 d: i8 ^( c% c2 q    Cal* p_cal = new Cal();
    int r1 = (p_cal->*fun)(2, 3);
    delete p_cal;
  z3 X+ C! t- e0 v, `
4 o0 t# s, D4 [3 v7 p    Cal local_cal;
+ z$ Y7 E7 W2 ^0 E4 V    int r2 = (local_cal.*fun)(8, 6);
}
  u; X* x/ v; f, u! {
成员变量指针
7 r% u6 P! G7 ^+ B, i成员变量指针比成员函数指针还要简单些，没有函数调用， 无需考虑函数调用和间接引用符*的优先级问题。
6 w! z9 u4 M1 M% ^5 V$ o
4 N, j4 `- g6 F- O4 `成员变量指针的定义
% S; S' ^* P& y8 O2 f, {( m假如以下结构体C。

  D7 k; Y) t* t6 H* l5 Sstruct C
{
2 I8 c- o8 X3 K. n3 {) Y) _; ]    int m;
};
) ~0 x. i1 T0 `% K单个成员变量指针定义
; x5 z" Y; g& s& I/ @假设名称为p, 类似静态成员变量定义那样声明
5 W6 F( ]; l  C6 Q% l1 G5 a9 Dint C::p;
在名称前面加上指针标识号*
+ E4 z( b5 Q- C/ O# Bint C::*p;
: j/ k* x1 d- Z8 Q& B  stypedef或using方式定义
8 Z/ V; Z; ]; l& b1 I/ o1 htypedef int C::*MemberPointer;
; g, P0 J9 K+ H  q$ Jusing MemberPointer = int C::*;
成员变量指针的使用。
/ P6 x0 {9 \( Z# y. u, {+ O8 J类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
成员变量指针， 能让我们实现一些遍历成员的动态功能。 例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。

6 B2 h0 n4 Y5 `5 O8 q 完整例子
" \0 k1 I" Z4 Pstruct C { int m; };
3 M2 O& \; f5 o. k, Z# m% yint main()
{
    int C::* p = &C::m;          // pointer to data member m of class C
    C c = {7};
    std::cout << c.*p << '\n';   // prints 7
9 `: ~  }0 X7 k    C* cp = &c;
    cp->m = 10;
    std::cout << cp->*p << '\n'; // prints 10
3 _8 ~$ s" ^6 b% R, o. j5 b* p
+ ?- b2 v9 J2 H% w6 [' w& _————————————————
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
- |' ~9 t4 e  B7 K! t# z原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
' |/ c0 }% o' ^2 z: g5 R