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

杨利霞

C++数组指针、函数指针、成员函数指针
5 m! i$ o4 ~) P" yC++数组指针、函数指针、成员函数指针
" T, _: `# N* r7 h3 v! c8 o$ f

操作符名称
& 取地址符(Address-Of operator)
* 间接寻址运算符(Indirection operator)
# X+ z' _, S7 `4 n9 k.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
() 函数调用运算符(Function-Call operator)
:: 范围解析运算符(Scope-Resolution operator)
如何定义一个指针变量
假设类型T， 变量名称name, 指针的定义如下:
: |7 r9 L( j( P! E
T* name;
标识变量名字name, 它是T类型的指针。例如
. f( n+ Z: m, h- R* w5 n5 v
int n = 0;
' V* b3 E& T7 S( J3 s- Q  sint* p_n = &n;
3 Y$ T# ?! \+ T: H" m. ]p_n是int指针类型， 指向某个int型的对象。

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

( K# x" d' n3 T4 l- l9 C指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int， 且该变量不能修改。以下两种写法都可以:

const int a = 1;
int const b = 2;
既然指针是也一种变量类型，同样支持被const修饰， 表示指针的值/指针的指向不允许修改， 指针所指向的那个变量是否允许修改， 那是另外修饰。写法如下:
2 l; ~+ q$ l# D. }( K  j1 n" j
4 _& h/ r' I2 x4 V3 l+ X6 Bint a = 1;
int b = 2;
, ?  E) a+ _$ E) e4 k. V( }int* const cp_a = &a; // 指针的修饰词，放在*号后面。
: m1 K$ k5 n/ o/ R$ O' e$ a*cp_a = 10; // 指针指向的值可以修改
cp_a = &b; // 指针不能被修改，报错！
8 F: |* _8 q( m. o0 T0 M6 a# V8 Q$ [! H总结带修饰的指针的格式:
$ Q# m8 p, M# X! Q只要记住修饰词总是放在被修饰的内容后面。
3 D/ d, h, z: E
) T! X0 ^7 l6 K+ T& M+ ~cv表示const / volatile修饰词。指针定义形式如下:
* X1 C/ T1 f" ~$ R
7 G3 D( L" u0 b8 h, c4 b! H, w0 c6 UT [cv for T] * [cv for pointer] name
注意对T的修饰放在T的前面也是合法的写法。
& p. t& ?/ D, g4 [4 v8 Y7 h
const int const c = 2;
在mscv编译器下也不会报错。
' A4 \* O) C* ]6 V% ~
完整的格式:
[cv for T] T [cv for T] * [cv for pointer] name
" F; y3 G% H/ d: {
Syntax        meaning
* B: [! i0 O! F6 nconst T*       
pointer to constant object

T const*        pointer to constant object
; @( r5 M5 Z* }$ sT* 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;
& K& D5 K$ p$ I' g$ Z8 X
, p  S* U! P+ Y( ?0 s7 Mint* p_a = &a;
4 T' h" W! L- K! v8 [*p_a = 10; // 合法
p_a = &b; //合法

$ k1 n) R! p% K3 x" _4 |const int* cp_a = &a; // const修饰int类型， 并非修饰指针
*cp_a = 11; //报错! const int类型不能修改
cp_a = &b; // 合法， 指针没有const修饰，指针可以修改。

int* const pc_a = &a; // const修饰指针。类型没有const修饰
9 e& G. h0 r9 ?' t*pc_a = 12; // 合法， 因为类型没有const修饰，可以修改。
pc_a = &b; //报错！ 指针被const修饰， 不能修改指针。
. v' d1 l3 z3 @: h- ?# |
0 ?( p' \- Z& b  F! [/ W: vint const* const cpc_a = &a; // int类型被它后面的const修饰， 指针符号*后面也有const修饰
$ g  k) h( s) `4 A/ X- a*cpc_a = 13; // 报错！ 类型被const修饰，不能修改。
cpc_a = &b; // 报错！ 指针被const修饰，不能修改。
; b3 E* S, g: X6 l. h
更复杂的指针的指针

* U+ U! _& X: sint a = 1;
int b = 2;
+ n3 [4 d$ r- y0 C$ n' {' Tint* p1 = &a;
int* p2 = &b;
/ y( ^7 {3 E/ L! n) {- X, Mconst int* ct_p1 = &a; // ct for const type
& M) o! }/ [. ]) Sconst int* ct_p2 = &b; // ct for const type
* X! M$ L! D% D& f: G
// int * * pp1; 指向(int*)类型的指针
int** pp1 = &p1;  
' H% Y0 m; M, a& E4 p3 Vpp1 = &p2; // 合法,
6 n' W5 J* ?1 W- y) z8 g. |' xpp1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)

// (const int) * * pp1; 指向((const int) *)类型的指针
5 z- t1 v3 D3 i: K, A! Uconst int** ct_pp1 = &ct_p1;  
' g/ l& h# w3 ~* J# lct_pp1 = &ct_p2; // 合法
! p9 M5 l( [2 i) x9 o: h5 s$ f# ict_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。
! C2 W0 @8 H: B. k% h# `( {
6 d, w5 j6 d  o3 ~/ [// (const int) (*const)
const int * const ct_cp1 = &a; // 指针也不能修改
const int * const ct_cp2 = &b; // 指针也不能修改
9 @* P) P/ c8 T0 z) m& v4 P" nct_cp1 = &b; // 报错！指针有const修饰

% l' R1 Z) A- R% T0 q// (const int) (* const) *  指向((const int) (*const))的指针
8 R( n8 ?2 p+ k7 A) J# econst int* const * ct_cp_p1 = &ct_p1;  
ct_cp_p1 = &ct_cp2; // 合法， 指针的指针并没有const修饰， 指向的指针有const修饰
1 G6 C" c6 t* _- _*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改
2 `& d+ P9 n+ y. O0 }+ M9 B& i2 N2 y
$ Y  \! K, b. Z- H7 ~// (const int) (* const) (*const)  
// 指向((const int) (*const))的指针,且该指针被const修饰
' d% W/ ]- y" x0 Fconst int* const * const ct_cp_cp1 = &ct_cp1;
9 o; E* \- n: n- h( `( e/ {* _ct_cp_cp1 = &ct_cp2; // 报错！ 指针的指针被const修饰， 不能修改指针指向。

; H5 n' j! t9 e, v一行声明多个变量
% X. r4 j# y. i3 q* k9 u, \; B类型 + 名称定义一个变量。
变量的前面可以加*号修饰， 表示指针， 一个星号代表一层间接。**表示指针的指针。
* F, p3 B+ K- A. _
; c+ n  o4 E* M+ S: V, Q2 `int a, *b, *c, d, **e;
3 ~4 u, N8 T9 ~% I# r$ Za = 0;
" z, o. z) O' rd = 1;
b = &a;
  `  S5 u" }$ E/ X3 h# Z$ C# zc = &d;
e = &b; // e为int**类型 指针的指针
e = &c; // e为int**类型 指针的指针
  b1 H9 h" y1 Z: }也可以用括号包围变量和*号。

) w- h1 z( ?8 fint (a), (*b), (*c), (d), (**e); // 合法定义。
括号可以省略，某些情况， 个人感觉加上括号更清晰一些。例如
* d0 `" B( s. u$ L
! M* f. V$ V- ^int (a), (const *b), (*const c) = &a, (const d), (const* const* const e) = &c;
写成
  W$ T/ I: A5 R& [
8 k& F* f/ C, @! J0 N  Mint a, const *b, *const c = &a, const d, const* const* const e = &c;
: o7 M7 E9 A% Z. q更重要的是， 后面我们表达数组指针，以及函数指针时，括号是不可缺少的， 带括号的表达更加统一。
2 \) q) j3 n6 V2 I9 o
- e/ Y' C6 V  H: K) M数组指针
数组基本表达
4 r+ Z) A$ E8 D7 \8 ^: Vint a[10];  // 定义了类型是int, 元素个数是10的一个数组。
# g! U0 N( ?2 L  k5 I, q7 w0 s& R& Y: n由于c++要支持一行定义一个类型的多个变量。 所以数组的[]时放在名称后面的。虽然我觉得

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

int a = 0, *b = nullptr, c[20], **d = nullptr;
7 m9 P& \$ h* G- x9 N5 Kc++标准规定如此，但我们可以通过每一行只定义一个变量的写法， 类型会更加清晰。

0 {& N1 M# `8 m8 Wint a = 0;
/ `* l; W% o# h5 @! `+ H- C9 {int* b = nullptr; // 指针int*
int c[20];
int** d = nullptr; // 指针的指针int**
数组的名称是什么类型
$ }; L: o5 z4 H数组元素类型的指针，可以直接指向数组。 并且数组跟指针一样，可以通过下标去访问元素。

6 l. j$ G/ U9 E9 sint a[10];
3 J* P% h4 m# i2 jint* p = a; // 指向a数组的第一个元素
4 w$ T' o1 y/ l% qa[1] = 1;
p[1] = 1; // 效果与a[1] = 1一样。
; P9 }) N$ P' L, \数组可以当作T* const来使用， 但是又与T* const有些不同。sizeof()的结果不一样。

int a[10];
int b[10];
9 c3 Y8 a2 s. ]/ x: Bint* const p_a = a;
a[0] = 1; // 合法。 数组的元素可以修改。
  W: T" j5 X8 t" ^5 |p_a[0] = 1; // 效果与a[0] = 1一样。
  S/ f7 J% T8 i- `' _$ t8 ~! T$ R
. T, c/ }' C- v* @+ F) b! Ja = b; // 报错！ 数组本身的指向不能修改。

// 所以数组a可以当作int* const来使用
int *const& ref1 = a; //正确。
/ ^5 e0 R/ `. V, \# Kint *& ref2 = a; // 报错!
9 b" Y$ I# h& D7 n- ?* C% k) h- I
// 但是又跟int* const有些区别。
1 Z9 S, Q- k+ v: ?assert(sizeof(p_a) == 4); // 32bit程序。
assert(sizeof(a) == 4*10); // 32bit程序
1 ^' a/ i' T, _7 J# u+ |
/ P9 r4 @% _3 w% \( S3 w' Z' ], B数组跟元素指针的作用很相似，都可以通过下标去访问元素， 但调用sizeof()函数的结果不一样。元素指针的sizeof()返回值是4(32-bit应用)或者8(64-bit应用)， 数组的sizeof()返回值是数组实际占用的空间。数组可以当作指向第一个元素地址的T* const来用其实就是我们常说的数组到指针的隐式转换。当数组作为函数参数传递后，会自动退化成T* const, 在被调用的函数内部调用sizeof()的返回值跟T* const指针大小一样。 数组传递作为函数参数后， 在被调用函数的内部与T* const是没有任何区别，只有在数组定义的可见范围内sizeof()才有获取数组占用空间大小的效果。
4 ~. K. X4 i, \* ?
3 e; Q. [1 g6 S7 o以下3个函数翻译成汇编以后，汇编代码是一样的。

7 v, E& H8 I3 Z* x6 }( h/ ]void Func1(int* p_ary)
{
    assert(sizeof(p_ary) == 4); // 32-bit
    p_ary[1] = 1;
}
/ N& |3 J+ x6 x7 o/ {
7 g+ H% H' ]7 g, R: U2 lvoid Func2(int ary[])
# W! o! y4 K/ d! N0 A2 G{
    assert(sizeof(ary) == 4); // 32-bit
    ary[1] = 1;
}

) V0 N% t9 @  V  H, a! x! H3 m* evoid Func3(int ary[10])
{
& [2 T1 r" T/ R    assert(sizeof(ary) == 4); // 32-bit
3 F& o! C0 k: z    ary[1] = 1;
& q$ X/ Z7 }" {, C}

7 [$ y0 G. _; v- d4 Hint main(int argc, char** argv)
. _5 M( z, m$ W7 z' b; l1 Q5 w{
    int a[10];
; s3 o) [( P7 C4 [( @    int b[20];
+ m- @/ Y9 P6 x    Func1(a);
- |' i1 V) n3 I5 u( C2 p6 Z2 c    Func2(a);
    Func3(a);
    Func3(b); // 退化成int* const了， 即使数组长度不匹配也不会报错。
    return 0;
}
& w8 a" A- W7 K2 \, a3 t, T- R
+ m0 e6 M* Q1 {3 ~( A3 P* t
# s) O+ ]' ^. p: L1 d; |, p
多维数组
一个3行，4列的数组， 结构如下:
" ?5 H1 i" n/ {7 G
4 ~# U& g  o( W8 K) f  z" |, B5 Y( Eint a[3][4];
! d8 w: Z, {. W0 h# M7 {9 ]column 0        column 1        column 2        column 3
/ s1 j! A$ y3 ^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]
. H" P: _& B6 a( M. ^; |& [. @: g数组初始化
& {& G  s/ _  W1 ?  u5 q/ E6 G5 C
int a[3][4] = {
" n% J8 ~% L+ V4 A    {0, 1, 2, 3},
    {4, 5, 6, 7},
( F" L, ?) |/ j: h- i: l, d/ P' ~    {8, 9, 10, 11}
% r8 e; L, n. v+ I! a};
# C& a) T$ S# g, M3 q0 z) f 实际上多维数组和1维数组在开启速度优化后，翻译成汇编代码是一样的。
" r& {  P9 ?1 s' J( u4 j
void Print(int* p_ary);

void Test1()
{
- o1 E& t+ \* D; n+ h$ S4 F# n    int a[10];
6 O- r0 }/ F1 j% V+ r( x    a[3] = 3;
    a[7] = 7;
    Print(&a[0]);
+ Z, p9 R( ]- b  ~6 G" Q}

3 n# L# b* w7 T1 A* U- o4 m6 xvoid Test2()
{
4 V+ L0 _* `* P5 a5 p# x    int a[2][5];
/ w/ M0 n% h) g- x0 x# d    a[0][3] = 3;
    a[1][2] = 7;
    Print(&a[0][0]);
0 n3 _! u' M! V! O' y6 r}
0 H: ~  {+ b; T' @. N6 A/ X

4 F, V  y9 y; g' q$ X: c
$ D4 H" e7 u5 P: s+ d很自然地，多维数组也支持用1维数组的方式去初始化。
( a/ h% E1 a7 f4 F+ N! j" S* Z
' N, S0 G8 x: tint a[3][4] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
) K! Z5 v. o# c既然多维数组与1维数组没什么区别， 为什么还需要多维数组？
0 e  ~, C) [7 u! c' q
假设有一幅RGB图像720*576个像素，每个像素有RGB三个通道，每个通道的值是8bit大小。给出图像的首地址p_rgb_image， 我们要取第40行，第50个像素的R,G,B值。代码如下:

unsigned char* p_rgb_image;
unsigned char r = p_rgb_image[40*720*3 + 50 + 0];
2 j! t3 K! `! D; ~( s8 x4 aunsigned char g = p_rgb_image[40*720*3 + 50 + 1];
% p0 y( p' P: s5 o) m5 Xunsigned char b = p_rgb_image[40*720*3 + 50 + 2];
类似这样的场景， 采用多维数组的写法， 有点类似以索引为参数，可读性更高。相当于程序员和编译器打了一个配合。

0 J; ~. w- Q0 _/ Z5 Q7 oenum
1 f0 {( R6 s4 E$ j{
Red = 0,
7 x) V" ?4 C9 {( y Green = 1,
3 W3 y6 z8 {- y% V Blue = 2
6 J& k% O1 C& s/ |  e};
- m# g* ], I/ v+ H& ~7 p/ \unsigned char rgb_image[576][720][3];
( _& j, a7 S+ E; X3 t* bint row = 40;
# P4 ^8 P4 j+ R8 pint col = 50;
unsigned char r = rgb_image[row][col][Red];
9 G. W( r' s4 p7 R  Q) ]* ^unsigned char g = rgb_image[row][col][Green];
unsigned char b = rgb_image[row][col][Blue];
数组指针以及与指针数组的区别
数组指针，是一个指针， 指向的对象是数组。 数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时， 需用用*取得数组对象的引用，再用下标来访问数组元素。
指针数组，是一个数组， 数组保存的元素的类型是指针。
数组指针的定义
$ R" W0 u6 l, B2 H数组指针定义先定义一个数组。
0 W# w- d  _* m. r8 Z, ?3 iint a[10];
然后对数组里的名称用括号括起来后再在变量名称前面加个*号
int (*a)[10];
6 q8 L. ^, c4 V! N% {5 H. w后面你会发现函数指针定义类似。
) b! Z1 o7 _$ {" I* _4 {9 ~// 各类定义对比
int a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];
& p  \1 U: Z/ o. _, `% J' ^
int *f[10]; // 指针数组, f是包含10个元素的数组， 数组里每一个元素的类型都是int*
int *(f2[10]); // 指针数组。另外一种定义方式。
, i0 H4 u! i4 O& Pint(*f3[10]); // 指针数组。另外一种定义方式。
7 {9 L, l: C/ T) ^( A/ S" u( X8 ^int(f4)[10]; // int数组
; X$ M% z0 o; Y, L0 R; Kint(*g)[10]; // 数组指针， g是一个指针， 这个指针可以指向类型是int，元素个数是10的数组
int* (*h)[10]; // 数组指针， h是一个指针， 这个指针可以指向类型是int*，元素个数是10的指针数组

. o/ Z! y/ ]4 |3 ^3 U1 T) Jint d[10];
g = &d;

int* e[10];
h = &e;
, e- @/ w& T1 j数组指针的使用
数组指针一般先通过*号取得指针指向的数组对象， 然后再用下标操作访问元素。
/ i7 d8 {$ B1 j/ G" a
int a[10];
int(*p_ary)[10] = &a; // p_ary是一个指针， 指向"int (*)[10]"类型的数组
for (int i = 0; i < 10; i++) {
// p_ary是一个指向数组的指针， 需要先通过间接寻址运算符*(indirection operator)取得数组对象
, Q9 U6 d2 t0 W: d6 I) y // 再通过下标操作访问元素。
(*p_ary) = i;
}

3 S; M) o* q- T- ^- W9 {int b[10];
int c[20];
p_ary = &b; // 合法
* Q9 n, e8 I4 A" M4 d( Xp_ary = &c; // 报错！ 不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
( z5 p, z& |& z8 a数组指针指向多维数组的子数组
5 m) Z- G( A+ s$ V" Q$ [) i# `int a[10];
, p8 l6 m# c6 h8 b; g- vint b[4][10];
int(*p_ary)[10] = &a;
for (int i = 0; i < 10; i++) {
% |# E- S0 w( k& b8 M (*p_ary) = 1;
+ b8 W  y8 g  M* E# o; c0 R}
& k! @* N( o" q/ e
: k7 Q6 n: j" mp_ary = &b[2]; // 多维数组，可以看作数组的数组，
; j% C1 t5 E: H// b[2][0] ~ b[2][9]的值都被改成2了
for (int i = 0; i < 10; i++) {
(*p_ary) = 2;
}
多维数组指针
# T9 f; _, x; w0 l: R多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。
, M; }8 d* r- f. k7 s
: P% B( @+ ]0 J2 Q" @: h6 ]int a[2][5][10];
9 Z4 Y' D. h9 d& x4 ]% xint(*p_ary1)[10] = &a[1][2]; // 1维数组指针
int(*p_ary2)[5][10] = &a[1]; // 2维数组指针
for (int row = 0; row < 5; row++) {
5 G* U5 d6 A5 `* }- j; K    for (int col = 0; col < 10; col++) {
$ d5 r8 X1 G; u        (*p_ary2)[row][col] = row * col;
# s) H: |2 @! Y" {7 [' w( `    }
! Y3 i  T1 l2 V4 q' v- n6 |) }}
6 o8 m1 _, x( L# A3 E: I) Q5 ^8 m数组指针和指针数组对比实例
数组指针还是记住两步法即可
3 B" {( e! J4 x1 @7 g/ t
4 T- X4 l0 T+ {) |定义一个数组
括号包围1中定义的名称，再在名称前加个*号。
7 `+ q( P- h' v5 {3 k: nint a[10];
# M9 |- r- O; j5 g( K( [! sint(*ary_pointer1)[10] = &a; // 数组指针
! Q/ N9 i& \" D9 g0 n5 X1 wint* pointer_ary1[10]; // 指针数组。元素类型是int*
& ?4 r! k, X7 N6 dint *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
* @5 t0 C& R, \
- g' E& P. M2 X0 q// 指针数组可以把每个元素指向数组对应位置的地址。
// 这样遍历指针数组， 可以达到遍历数组元素的效果，但是注意每个元素都是指针，
0 ~$ I# r0 r' T, ]// 需要访问原数组的值的话， 需要对指针用*间接寻址运算符。
) `5 h* O1 G! u. Nint* pointer_ary[10];
9 t7 I0 @$ G+ [! u! Dfor (int i = 0; i < 10; i++) {
2 Y, U3 J, J* d- S, X    pointer_ary = &a;
}
// 类似遍历原数组效果。
" ], y* S8 y/ [2 Bfor (int i = 0; i < 10; i++) {
+ W$ }: x) I& {( O    *pointer_ary = i; // 修改原数组。
1 ~5 X4 x9 P. j! ], `6 b' ]2 W}

函数指针
5 H1 ~5 x( M# L! b/ `取得函数地址
, d0 j% v7 V7 ~9 B$ t% t函数的名称作为参数被传递时，会隐式转换成函数指针， 和在函数名称前加取地址符&等价。建议带上更加统一和清晰。

0 o; q  T0 s4 Z# B/ y+ Uvoid f(int);
int main()
{
    void (*p1)(int) = &f;
1 [& a6 e4 Z- _6 a  C( K7 q    void (*p2)(int) = f; // same as &f
    return 0;
}
) ]8 D" d* }. Y. T; d翻译成汇编代码， p1和p2的赋值是一样的。


- ~9 V/ z! m$ v: A1 ]4 ^
* K3 `# m5 e, P$ ]3 E- z函数指针的声明
单个函数指针变量定义步骤
5 i- A- H6 `8 E# }4 J& y/ [! E3 `定义一个函数。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);
3 h* i. f$ g, u0 M$ @typedef定义函数指针
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。

typedef定义函数指针的语法
# `" w! S# W9 {typedef有两种做法， 一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值， 但是支持引用。
' z" O& ]. |( ?- i: t
3 y  H# X* S; Utypedef int FuncObject(int a, int b); // FuncObject类型是函数对象
( F9 G) U6 K; {typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
FuncObject* f1 = &Add;
. R, n! s# O# S" v: V4 |5 pFuncPointer f2;
f2 = f1; // f1, f2类型一样， 都是形式为int(int, int)的函数的指针。
0 [; \, n& J# W2 ?, N1 }3 VFuncObject f3 = Add; // 报错！ 函数对象不支持拷贝
FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
" x5 j! Q5 j  D/ JFuncObject& f5 = Add; // 正确
" \* w+ _( s1 l4 s& jint ret = f5(2, 3); // 正确
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
如何记住typedef定义函数指针的步骤
- c* |1 i+ b0 f* ~4 w像定义一个函数指针那样， 指定一个名称。int (*CalFun)(int a, int b);
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
% B3 Q! T- N- |6 u+ A! Y( ]完整例子
typedef int(*CalFun)(int a, int b);

int Add(int a, int b)
0 T. t% ?: S% x' X{
- R* l5 G# Q# k1 D  S    return (a + b);
" V! B0 y4 h1 x  f5 P; e9 R; Z" @}
6 P5 m1 Z% S! O
int Sub(int a, int b)
- Z1 ~& K' {1 s. G{
" u$ j/ l6 a1 ^3 b4 ?' o+ h    return (a - b);
- x, o0 o+ y2 i( Q' A: }}

- X/ `: |5 p8 O: T, U6 \& Q3 Lint main(int argc, char** argv)
{
: C0 D8 B+ [5 A, ?# P    CalFun f1 = Add;
% S' [3 @4 n0 w* H    CalFun f2 = Sub;
+ I0 u4 P: L9 P# z/ m1 S  ~    int a = f1(2, 3);
9 o0 W% i7 z. \/ n    int b = f2(10, 5);
- |- l8 J  M/ S
0 B0 T( {, C7 a    // typedef定义的函数指针数组。
8 H3 M" o9 d; a; X    CalFun f_ary[2];
    f_ary[0] = Add;
    f_ary[1] = Sub;
7 ~4 g* t- N6 D. m9 q- [
    // 单个定义的函数指针数组。
    int(*f_ary2[2])(int a, int b);
    f_ary2[0] = Add;
$ U" {$ b' f% K* l: y5 q    f_ary2[1] = Sub;

& m" `# u3 n4 f0 o! l- D* i8 v8 h    return 0;
}
" ]. r6 ^4 T2 W2 I6 X: I4 Z
using别名定义函数指针
+ c, ~0 s2 T: n4 y7 @: p1 cc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
1 V, S+ D- G* R' h- {3 B
# v  q3 D) W/ Ztypedef int FuncObject(int a, int b); // FuncObject类型是函数对象
using FuncObject = int(int a, int b);
, G& j4 _0 p+ L, J# k' T- utypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
using FuncPointer = int(*)(int a, int b);
函数指针的调用
函数指针和函数对象都可以直接后加括号调用
int f();
) F/ \9 W; x% K& m" `int (*p)() = f;  // pointer p is pointing to f
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
2 O9 a* K$ W) ~0 j/ n0 R. I' sr();             // function f invoked through lvalue reference
1 z( T, ?2 M/ d(*p)();          // function f invoked through the function lvalue
p();             // function f invoked directly through the pointer
4 i: I, [2 p7 ]4 C% U如果函数有重载， 函数指针会指向匹配的那个版本。
template<typename T>
5 f; B' r4 w- e, R. `% ^9 lT f(T n) { return n; }

double f(double n) { return n; }
# r$ l( a+ }$ O
int main()
{
" D4 K- z& O, m- M    int (*p)(int) = f; // instantiates and selects f<int>
}
成员函数指针
1 B( ~; X- S3 A" {1 P5 x. M静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。

成员函数指针定义。
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
, X: T/ ?% B. t& ^* l- P括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
. o5 K& g1 U9 e* G5 S' k. g在名称的前面加个*号void (ClassName::*func)(int);
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
成员函数指针如何调用。
假设成员函数指针名字为func

  `7 n8 K7 I$ o4 K2 z; b- }void (ClassName::*func)(int);
0 A; ?  }+ ?* R  q, [& C7 R' d对象式调用。
3 C3 V/ a2 ]3 y; @2 ^7 Z% q. ^ClassName c; // 被调用的对象
成员函数指针名字当作正常函数那样写。
c.func(3);
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
/ Q& e* U, U* T$ F4 Wc.*func(3);
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
2 X9 x% V/ f  r8 ?+ ?(c.*func)(3);
为何要加上括号？ 根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低， 成员函数指针还没取得对象就被调用了，自然报错。 另外
* [" ~  @) n  U1 z7 {(c.(*func))(3);
这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
指针式调用
" }4 j8 f7 @0 }# {2 x5 zClassName* p; // 被调用的对象的指针
: w  i3 k2 E* S0 d- I( C. j0 V成员函数指针名字当作正常函数那样写。
p->func(3);
7 S1 k, R5 s' n8 x: y$ r成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
p->*func(3);
最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
(p->*func)(3);
函数指针使用完整例子
/ ?1 p, `3 X/ ?' F( D7 U2 Cstruct Cal
{
& m) M1 q( L& D7 x    int add(int a, int b);
    int sub(int a, int b);
};
5 ]% W" s( x0 A& i/ I, u5 N! ?
4 L5 d, H  ]  p% gint main()
0 p' G9 H/ H% f; e3 H{
1 R( i9 g  p, H8 y8 I    int (Cal::*fun)(int, int) = &Cal::add;
    fun = &Cal::sub;

" E4 A/ e1 Y3 y0 d    Cal* p_cal = new Cal();
    int r1 = (p_cal->*fun)(2, 3);
5 e% q- P. @$ G7 L    delete p_cal;

    Cal local_cal;
    int r2 = (local_cal.*fun)(8, 6);
}

  `' G9 c# e- g) a, a7 w; m成员变量指针
/ P2 \; }* [' @5 x8 q  \' J成员变量指针比成员函数指针还要简单些，没有函数调用， 无需考虑函数调用和间接引用符*的优先级问题。

成员变量指针的定义
+ O7 t5 |' V7 E假如以下结构体C。
5 e, y' B5 n6 H# C! m, Q1 R8 ~8 o
; i' ^6 u: [4 s. B; h! a8 vstruct C
$ [" s% L: c0 l  x) @{
. K  I) ~8 a- F! X4 z$ R4 V$ f# W    int m;
. Y, L* L  p1 f! p  U8 C};
单个成员变量指针定义
假设名称为p, 类似静态成员变量定义那样声明
int C::p;
# d$ U: B0 a" P  c: L在名称前面加上指针标识号*
3 o4 g( b. t) S) Q7 \) Wint C::*p;
4 t( Q6 M$ C  S% Itypedef或using方式定义
typedef int C::*MemberPointer;
using MemberPointer = int C::*;
成员变量指针的使用。
# l" S$ U2 Z' H. D  q; ?$ F类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
5 \+ z* a. h# Z' ]" j8 }4 C成员变量指针， 能让我们实现一些遍历成员的动态功能。 例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。

2 c& E/ G* e: p+ \/ y1 \ 完整例子
struct C { int m; };
int main()
0 q; @' [) ], J{
9 P7 r! k8 R( a% M9 ~6 Q6 R1 g6 \    int C::* p = &C::m;          // pointer to data member m of class C
1 {5 {3 _, u% t6 h6 I    C c = {7};
    std::cout << c.*p << '\n';   // prints 7
    C* cp = &c;
  W/ ]* t! Z1 |0 \% o) V; n    cp->m = 10;
    std::cout << cp->*p << '\n'; // prints 10

————————————————
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
) K" [, ^( o, u2 E" N+ o" N原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
6 h* c6 b; a/ H# @, `8 j) d