查看: 2440|回复: 0

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

[复制链接]

字体大小: 正常放大

杨利霞

5273 主题	82 听众	17万积分

TA的每日心情

	开心 2021-8-11 17:59

签到天数: 17 天

[LV.4]偶尔看看III

网络挑战赛参赛者

自我介绍: 本人女，毕业于内蒙古科技大学，担任文职专业，毕业专业英语。

群组: 2018美赛大象算法课程

群组: 2018美赛护航培训课程

群组: 2019年数学中国站长建

群组: 2019年数据分析师课程

群组: 2018年大象老师国赛优

电梯直达

1^#

发表于 2022-9-12 18:49 |只看该作者 |倒序浏览

|招呼Ta 关注Ta

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

操作符名称
& 取地址符(Address-Of operator)
* 间接寻址运算符(Indirection operator)
.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
() 函数调用运算符(Function-Call operator)
:: 范围解析运算符(Scope-Resolution operator)
如何定义一个指针变量
假设类型T，变量名称name, 指针的定义如下:

T* name;
标识变量名字name, 它是T类型的指针。例如

int n = 0;
int* p_n = &n;
p_n是int指针类型，指向某个int型的对象。

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

指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int，且该变量不能修改。以下两种写法都可以:

const int a = 1;
int const b = 2;
既然指针是也一种变量类型，同样支持被const修饰，表示指针的值/指针的指向不允许修改，指针所指向的那个变量是否允许修改，那是另外修饰。写法如下:

int a = 1;
int b = 2;
int* const cp_a = &a; // 指针的修饰词，放在*号后面。
*cp_a = 10; // 指针指向的值可以修改
cp_a = &b; // 指针不能被修改，报错！
总结带修饰的指针的格式:
只要记住修饰词总是放在被修饰的内容后面。

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

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

Syntax meaning
const 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;
int b = 2;

int* p_a = &a;
*p_a = 10; // 合法
p_a = &b; //合法

const int* cp_a = &a; // const修饰int类型，并非修饰指针
*cp_a = 11; //报错! const int类型不能修改
cp_a = &b; // 合法，指针没有const修饰，指针可以修改。

int* const pc_a = &a; // const修饰指针。类型没有const修饰
*pc_a = 12; // 合法，因为类型没有const修饰，可以修改。
pc_a = &b; //报错！指针被const修饰，不能修改指针。

int const* const cpc_a = &a; // int类型被它后面的const修饰，指针符号*后面也有const修饰
*cpc_a = 13; // 报错！类型被const修饰，不能修改。
cpc_a = &b; // 报错！指针被const修饰，不能修改。

更复杂的指针的指针

int a = 1;
int b = 2;
int* 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*)类型的指针
int** pp1 = &p1;
pp1 = &p2; // 合法,
pp1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)

// (const int) * * pp1; 指向((const int) *)类型的指针
const int** ct_pp1 = &ct_p1;
ct_pp1 = &ct_p2; // 合法
ct_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。

// (const int) (*const)
const int * const ct_cp1 = &a; // 指针也不能修改
const int * const ct_cp2 = &b; // 指针也不能修改
ct_cp1 = &b; // 报错！指针有const修饰

// (const int) (* const) *  指向((const int) (*const))的指针
const int* const * ct_cp_p1 = &ct_p1;
ct_cp_p1 = &ct_cp2; // 合法，指针的指针并没有const修饰，指向的指针有const修饰
*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改

// (const int) (* const) (*const)
// 指向((const int) (*const))的指针,且该指针被const修饰
const int* const * const ct_cp_cp1 = &ct_cp1;
ct_cp_cp1 = &ct_cp2; // 报错！指针的指针被const修饰，不能修改指针指向。

一行声明多个变量
类型 + 名称定义一个变量。
变量的前面可以加*号修饰，表示指针，一个星号代表一层间接。**表示指针的指针。

int a, *b, *c, d, **e;
a = 0;
d = 1;
b = &a;
c = &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;
更重要的是，后面我们表达数组指针，以及函数指针时，括号是不可缺少的，带括号的表达更加统一。

数组指针
数组基本表达
int a[10];  // 定义了类型是int, 元素个数是10的一个数组。
由于c++要支持一行定义一个类型的多个变量。所以数组的[]时放在名称后面的。虽然我觉得

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

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

int a = 0;
int* b = nullptr; // 指针int*
int c[20];
int** d = nullptr; // 指针的指针int**
数组的名称是什么类型
数组元素类型的指针，可以直接指向数组。并且数组跟指针一样，可以通过下标去访问元素。

int a[10];
int* p = a; // 指向a数组的第一个元素
a[1] = 1;
p[1] = 1; // 效果与a[1] = 1一样。
数组可以当作T* const来使用，但是又与T* const有些不同。sizeof()的结果不一样。

int a[10];
int b[10];
int* const p_a = a;
a[0] = 1; // 合法。数组的元素可以修改。
p_a[0] = 1; // 效果与a[0] = 1一样。

a = 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程序

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

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

void Func1(int* p_ary)
{
assert(sizeof(p_ary) == 4); // 32-bit
p_ary[1] = 1;
}

void Func2(int ary[])
{
assert(sizeof(ary) == 4); // 32-bit
ary[1] = 1;
}

void Func3(int ary[10])
{
assert(sizeof(ary) == 4); // 32-bit
ary[1] = 1;
}

int main(int argc, char** argv)
{
int a[10];
int b[20];
Func1(a);
Func2(a);
Func3(a);
Func3(b); // 退化成int* const了，即使数组长度不匹配也不会报错。
return 0;
}

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

int 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]
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]
数组初始化

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

void Print(int* p_ary);

void Test1()
{
int a[10];
a[3] = 3;
a[7] = 7;
Print(&a[0]);
}

void Test2()
{
int a[2][5];
a[0][3] = 3;
a[1][2] = 7;
Print(&a[0][0]);
}

很自然地，多维数组也支持用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;
unsigned 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,
Blue = 2
};
unsigned char rgb_image[576][720][3];
int row = 40;
int 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];
数组指针以及与指针数组的区别
数组指针，是一个指针，指向的对象是数组。数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时，需用用*取得数组对象的引用，再用下标来访问数组元素。
指针数组，是一个数组，数组保存的元素的类型是指针。
数组指针的定义
数组指针定义先定义一个数组。
int a[10];
然后对数组里的名称用括号括起来后再在变量名称前面加个*号
int (*a)[10];
后面你会发现函数指针定义类似。
// 各类定义对比
int a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];

int *f[10]; // 指针数组, f是包含10个元素的数组，数组里每一个元素的类型都是int*
int *(f2[10]); // 指针数组。另外一种定义方式。
int(*f3[10]); // 指针数组。另外一种定义方式。
int(f4)[10]; // int数组
int(*g)[10]; // 数组指针， g是一个指针，这个指针可以指向类型是int，元素个数是10的数组
int* (*h)[10]; // 数组指针， h是一个指针，这个指针可以指向类型是int*，元素个数是10的指针数组

int d[10];
g = &d;

int* e[10];
h = &e;
数组指针的使用
数组指针一般先通过*号取得指针指向的数组对象，然后再用下标操作访问元素。

int a[10];
int(*p_ary)[10] = &a; // p_ary是一个指针，指向"int (*)[10]"类型的数组
for (int i = 0; i < 10; i++) {
// p_ary是一个指向数组的指针，需要先通过间接寻址运算符*(indirection operator)取得数组对象
// 再通过下标操作访问元素。8 @" ?7 W, s0 Y, d- X
(*p_ary) = i;
; B8 \1 S4 ^- U& ~4 `, W}
5 ~8 T/ W! `) b* @; z% S
& u% Y/ t$ [! N& T% ?int b[10];
5 S, d1 ?3 S% Yint c[20];6 m7 D3 u& G& y9 N, N6 U
p_ary = &b; // 合法9 r! _' ]2 K0 d8 w% _' O: D: w
p_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
* d2 S1 }* f6 U. G数组指针指向多维数组的子数组. F2 |1 K$ Q+ |- _* b
int a[10];% ^2 P. Z3 _1 L/ u
int b[4][10];
2 d- P% _! F$ E; Hint(*p_ary)[10] = &a;6 u! i6 Q- w+ c% e' X
for (int i = 0; i < 10; i++) {
. E+ z! |. [8 Q5 k( }! y8 U" i (*p_ary) = 1;
) w/ h3 x4 c5 m2 N8 U" _' W}8 x; K8 \" G* r4 h9 S' @6 {! P0 C
3 E5 x6 {+ l) a3 j; ]) a1 P0 k
p_ary = &b[2]; // 多维数组，可以看作数组的数组，. }0 k: V( Z" U
// b[2][0] ~ b[2][9]的值都被改成2了- I1 T3 f( y! f% J+ }7 D# \1 @2 K
for (int i = 0; i < 10; i++) {7 |% C' S$ W8 h; T/ e# f
(*p_ary) = 2;
* N% ]% T  y' a) e' d0 b}
/ X: l: H7 q  z7 X! W/ U多维数组指针
! e( |8 r2 ]0 ~: T1 ]6 s2 j多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。
6 ?$ v( u5 t' q  r4 B  a6 S2 P7 D- O3 @1 G) w
int a[2][5][10];
, V. l; A9 ?2 i/ J- |8 Nint(*p_ary1)[10] = &a[1][2]; // 1维数组指针
% U# }5 z$ d- jint(*p_ary2)[5][10] = &a[1]; // 2维数组指针9 P1 R( u( P; G2 p1 r6 [
for (int row = 0; row < 5; row++) {
; y0 P: Y0 v% ^7 k8 s2 h8 M% h5 f for (int col = 0; col < 10; col++) {
5 k* L( O- w8 ?2 a% e       (*p_ary2)[row][col] = row * col;
# h3 Q$ L. z+ R. \ }# \# F& v8 G0 D4 N3 T
}# D* M& T# r2 r4 i* T' D+ ]) b, w* l
数组指针和指针数组对比实例
/ c, b( y7 Y0 O, [# F数组指针还是记住两步法即可$ [9 d7 A* g6 q, g5 b& q
% W6 ]8 O! M0 {* e, [: c
定义一个数组
3 F, z4 d* n4 t6 f" X5 n括号包围1中定义的名称，再在名称前加个*号。* t3 z: r* W$ @' @2 T0 ?
int a[10];
1 p4 P) w% a; S+ D! b$ Eint(*ary_pointer1)[10] = &a; // 数组指针/ |  y/ D* O3 o
int* pointer_ary1[10]; // 指针数组。元素类型是int*3 E, ^& L. C, T; y6 l- s  P3 d
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。# y( g5 t) \  R* J3 v4 J7 a
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
6 {/ O. E% `) E  z/ wint c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。) I: S) F4 I8 y7 q8 l

  ?2 [3 S) K/ ^* s6 f8 F// 指针数组可以把每个元素指向数组对应位置的地址。
9 J! h( d4 F( ?+ _& G/ I// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，
, R' B0 _3 [3 B- j$ |1 P+ `// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。
  e' ^' p: A! h4 O2 u# \int* pointer_ary[10]; # o. c! p& @. A$ o( }
for (int i = 0; i < 10; i++) {# `* H) p3 m3 S3 D; s
pointer_ary = &a;
' ?5 D8 C* P) L4 H2 j; X  ]}
. a0 r* T- d) @// 类似遍历原数组效果。
3 J( m2 k  p  K& Hfor (int i = 0; i < 10; i++) {
8 {$ s' v3 F. F' d) R& W. u* H *pointer_ary = i; // 修改原数组。
' a  `3 l4 S& S, [% M}  E& L0 j  U$ ]* i% \. t9 W

2 M) }* o0 V% ?函数指针
: h# }3 T5 h7 H' }取得函数地址# t+ _1 ~& n1 F7 b, H  ^
函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
( x" c' \/ c- ], A: q; }7 a  ]: O: [; J' p* C
void f(int);" D% P* @+ r3 w+ \& _
int main()
5 O5 g4 h/ k4 k; f" [" l" z{3 B  Y! k( L5 f  v: q
void (*p1)(int) = &f;/ B2 [" m. z* f( _5 H
void (*p2)(int) = f; // same as &f
  W, {1 s5 I; `9 e' j8 } return 0;3 F: [! a, V* S3 _0 u3 K8 U- u7 h6 V
}
; U' f# m% x% L7 D翻译成汇编代码， p1和p2的赋值是一样的。
, w3 F3 y9 l4 D* c9 Q" Y# K% n3 a6 k
) M( Z1 |9 L  p* w6 `
( \& b$ E5 b9 F# j, I
函数指针的声明; u! _9 }. L( `8 i
单个函数指针变量定义步骤# o3 I0 q1 \0 I! M: w" j. P
定义一个函数。void fun1(int a, int b); int fun2(double a);
0 L/ L. P- }1 U  E9 J0 X& d- J用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
2 h* g' o) R0 U$ D" q+ Z3 b如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);) p# b: \6 G- N+ `2 _$ x  n
typedef定义函数指针$ f8 g, k" q, E
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。) ]' L: u; l/ [  v9 K' D

+ B: M2 G/ _5 c; F7 c# ntypedef定义函数指针的语法/ j& T2 I' n8 e+ c: h7 j4 y
typedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。
& N6 O- T* }8 L: |- N' V3 b" w/ E% e! b) n
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象: S7 Y$ \* b7 O' l7 g
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针+ q0 p! P; }; ~# U. @
FuncObject* f1 = &Add;1 M# q) z  t0 h  e% ]
FuncPointer f2;
, f' S* ~  K) n/ Lf2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。7 \$ y+ @' T. {0 v
FuncObject f3 = Add; // 报错！函数对象不支持拷贝
6 f; C  I1 D# \/ {FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
1 Q( _( }5 P( V0 K: A1 H3 AFuncObject& f5 = Add; // 正确8 J6 T3 C' c5 S( n4 B
int ret = f5(2, 3); // 正确5 Q$ R9 y4 p* |5 K
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配$ J2 Q- t8 p  T5 [/ Y' q7 V+ x) o
如何记住typedef定义函数指针的步骤
( }0 L$ S& l$ t0 p- J# e9 W8 T像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);
3 ~- F1 O* Y% P9 ~在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);2 [. |6 W) ?4 h8 N# Y. ~
完整例子
' Y4 {) [! \5 j2 x5 }( Atypedef int(*CalFun)(int a, int b);0 X2 n$ Z  A! w( a0 C8 y4 p

5 q  z; r$ P" T! z1 eint Add(int a, int b)* @* J% b5 k; I9 [
{3 k; _0 O$ C: q8 o; b
return (a + b);
- @1 T1 H, w9 i& }}  {/ d3 w( v- C1 q1 ~' A
6 ?$ r) }9 |( D# U+ s7 X
int Sub(int a, int b)
! K" d: n4 w9 M3 K8 e& H9 k+ ]+ ~{
! F6 k( ^' Q6 X0 j. h% e  E$ w return (a - b);% [. b9 ~" z  @0 H9 L2 W/ u( {" `
}8 R. z) H* F# Q- d! U5 y

# |! {, B2 X" Q6 e& Z1 Y- Xint main(int argc, char** argv): H" [2 T# ~7 t  ~* b8 |
{' B4 D" X* s$ ^4 @4 C- ?# n) Y
CalFun f1 = Add;" }  s% d; m6 t
CalFun f2 = Sub;  K; N% s/ K, ^) L
int a = f1(2, 3);  P/ ~1 [& w# o$ \* |2 ^
int b = f2(10, 5);
9 Z! K& o! H# W2 J, c, g+ ~- {. F- O$ D, x4 ?* E5 O
// typedef定义的函数指针数组。. Q* c# A5 X7 N& w4 J
CalFun f_ary[2];2 D- m6 W9 H  D
f_ary[0] = Add;* c- L% o% e  X# d0 V" O
f_ary[1] = Sub;6 r# K6 r# q& b( K
. g: J2 g5 K; B/ s6 U
// 单个定义的函数指针数组。
% K+ W1 q6 J: ^% g int(*f_ary2[2])(int a, int b);! f9 O& }& p& @/ z& C7 s: S
f_ary2[0] = Add;
; b" H' ~7 a4 g f_ary2[1] = Sub;* i$ N3 K: u6 f! l4 a; I

( U6 q; x. K9 N) O return 0;, H9 f' _8 R: O2 V2 v7 }- C& U
}' l/ Q" c2 M# q# s9 V8 r

) x2 m% |' _: Xusing别名定义函数指针
* Y" N9 ]7 N% a# {7 Ec++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
7 c7 F& A! ]4 X1 i, t
% |% ^2 d# B1 M& O0 ptypedef int FuncObject(int a, int b); // FuncObject类型是函数对象& H% t. O; E( b# _& u
using FuncObject = int(int a, int b);2 }9 [0 r4 A$ O+ }
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针- o4 ]- C! k- c/ U( w
using FuncPointer = int(*)(int a, int b);0 s& g( K' C+ r+ X" ?
函数指针的调用. @- p" v- v" M5 F
函数指针和函数对象都可以直接后加括号调用
$ F+ ^0 H# ?# i2 [/ G2 u' ?int f();3 r$ |# T* Y6 D/ ?! N' A
int (*p)() = f;  // pointer p is pointing to f2 `* D, b0 M  W  o; d: `
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
! M9 g) \  N. G  ]6 nr();          // function f invoked through lvalue reference! ^/ p  l, a1 X9 }$ N5 g* ]! ~% x3 |
(*p)();       // function f invoked through the function lvalue/ u( f+ M6 S; e. u6 Z7 V8 t
p();          // function f invoked directly through the pointer
1 _1 q  R6 Y9 v. M2 T4 a如果函数有重载，函数指针会指向匹配的那个版本。8 K% S, P0 ^* r- b
template<typename T>7 J: i) x6 \/ E& k3 f! v3 v
T f(T n) { return n; }2 t! b8 W/ x) g* K% t
* U8 E- u7 Q, f9 ^0 a. Z
double f(double n) { return n; }
/ F9 l5 z  o- n2 ^- j0 r" a, V9 S5 r! g0 n/ R0 \2 W7 H
int main()
) [+ s5 c6 L$ @$ k$ ^8 J- A{4 W/ a, L! ?5 p+ w% b
int (*p)(int) = f; // instantiates and selects f<int>
, g4 Q, T- V/ h( R4 Y! w) }}  k% K" ^+ Q+ u$ x2 T: ]; o# H# S
成员函数指针
& g) k0 ?$ V- ^  x静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。
, y) y5 s' k8 H- w  J( I7 {( ~) k1 ?; V$ J' K
成员函数指针定义。, L, F( L3 W) B, z' @& o
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
+ D) m& d* ~8 r# P6 \7 c, d( E括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
$ M5 S$ n" L9 @/ P2 C4 W在名称的前面加个*号void (ClassName::*func)(int);' N' i% ], Z* ]
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
+ t$ R$ o- B7 U: }9 j成员函数指针如何调用。
/ p; J+ p, b7 f" n, n+ u假设成员函数指针名字为func
9 X- S( @. ?" m& G7 K2 q* A" q
( e" F7 p9 f, Xvoid (ClassName::*func)(int);4 C& I6 f2 a+ N5 S
对象式调用。
" |9 U/ G( e5 zClassName c; // 被调用的对象
& r- H/ }+ s! o* k# C1 M& K- N成员函数指针名字当作正常函数那样写。
+ [5 I( c4 C" i, y+ B# @0 ?# Kc.func(3);4 e- g3 k1 ?; F  \, ~4 t- `
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
4 j) v3 d7 S% E: hc.*func(3);8 {# D- S# Y: P( u  f( u
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。) n# h2 P% \/ p) Y9 U# |
(c.*func)(3);# J$ p% l" X4 a- e: `- H" M
为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外7 H* R' r2 D" F+ S
(c.(*func))(3);& K; q/ `* {. M
这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
, z4 Z1 {) a! @! ]8 E指针式调用
4 w% ^6 B8 u+ t0 |1 N* dClassName* p; // 被调用的对象的指针4 |' J$ j: W% T* H
成员函数指针名字当作正常函数那样写。
" Q3 |- w, H2 w4 r1 q5 up->func(3);6 M- B: z6 L4 Q. C, A& P5 W
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。9 g( G2 }+ g% p5 S+ \
p->*func(3);
1 O' z8 T" }, L1 M最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。4 }4 r) L) c  Z2 {5 \3 p3 i$ p
(p->*func)(3);& N2 `! P3 i8 N8 Z& T. P: S
函数指针使用完整例子
8 ^1 I1 g+ l& L' `5 ~2 j' Fstruct Cal
5 m% [! H; @# G5 K% [{
" O9 M; O0 \5 m, e int add(int a, int b);
! i) L( p3 _7 b0 ~: J int sub(int a, int b);
+ J$ b# {: g5 n( }9 l; u: }3 L0 O9 z};
- c; l# Y# x+ P; o, Z  r+ T! U& B' h
int main()7 \7 [: J1 @5 v' `/ o  t" _# _
{# y! I" s; J% ^, V+ J
int (Cal::*fun)(int, int) = &Cal::add;
4 M! \+ n6 |  U fun = &Cal::sub;6 Y, Y* B9 K8 y+ h
" V" D& x% v. f
Cal* p_cal = new Cal();1 q+ F+ r+ g5 y+ ~; a/ u
int r1 = (p_cal->*fun)(2, 3);" a2 D' y- w: S$ z- T2 K
delete p_cal;
1 I3 F+ v, W: M5 f+ k
9 [  K. Z# i0 C" _, j1 y3 Z Cal local_cal;' ^) d' Q% t& T5 i9 J* \3 \8 x
int r2 = (local_cal.*fun)(8, 6);7 c2 c* e! ~/ @0 W
}6 ?4 T$ X1 s, I+ P$ C' x% _% }

: a7 |# O- i6 H+ `4 y. i成员变量指针8 {- A% [7 i) w% d1 Y8 `% q
成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。1 w+ M3 k2 `0 p1 I  I- C

0 R8 W+ j6 \% G1 j7 x成员变量指针的定义
/ k3 T7 {0 q9 f3 n% _# C1 [6 [假如以下结构体C。" c& ?: n' l5 t  R7 a5 w

7 B# b9 H+ ]/ ?6 d5 ~struct C   N1 p; O3 y9 d
{
5 \- Y6 M2 F+ o# E int m; 2 S- @( O' e9 k
};/ p0 e5 y1 A5 V$ \
单个成员变量指针定义 ; H6 U4 [  C2 V
假设名称为p, 类似静态成员变量定义那样声明; y3 X2 K! B8 c1 ?% _: }" g4 O
int C::p;
: G7 A9 w# h9 ^+ J6 v$ h在名称前面加上指针标识号* 8 }, d' T: i2 l% H
int C::*p;* z9 z. a" _; ]9 ~7 {# F
typedef或using方式定义
( K# y7 i4 T1 B- Z) Atypedef int C::*MemberPointer;
: z) O3 s" m" U1 ]% \using MemberPointer = int C::*;4 l7 D3 P/ Q- y/ G
成员变量指针的使用。
  [! F6 N# u, f1 @  C2 u类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
' R8 Y5 S) V5 R( x成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。
$ C; X$ ^$ B1 b9 M" m7 K% l  `( {' F) G0 H
完整例子- M; {5 z' F3 P# Q6 k" N" j) f
struct C { int m; };
; b5 d! c( R4 |int main()
! ]! C8 [1 n! p{
7 Z( }5 _4 u2 I: [ int C::* p = &C::m;       // pointer to data member m of class C
3 A( J) T( x# F( p C c = {7};
" D8 {0 j" p8 l# P std::cout << c.*p << '\n'; // prints 78 t' O/ `4 ~: X: R4 d! ]
C* cp = &c;
, X' m4 z$ |4 c& U cp->m = 10;3 Y! E/ w* m2 t  @. `( Y
std::cout << cp->*p << '\n'; // prints 10
! ^* M7 W) _/ {2 Z- _. i. x5 X( Q  r8 D0 s* N5 l
————————————————- C9 B, L9 @" \! b
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
# c5 ?1 _% B0 C原文链接：https://blog.csdn.net/m0_64407685/article/details/1267881158 i5 A$ |: x* Q; f" T0 g  z

" Y" i$ a! I0 T) |( _- Z5 _  i- j; |# ^8 e