查看: 2417|回复: 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)取得数组对象
// 再通过下标操作访问元素。2 t8 Z! U9 a1 Y. X5 X4 C( s
(*p_ary) = i; ; L, v6 p* B% P0 x2 b! v* J
}
+ X9 R- S( M' D) [& i; M# U4 k- g0 V! w# |( t/ I
int b[10];( r% O9 A9 h" D2 U+ i8 ]
int c[20];) ?$ G' Z/ Z- [9 r+ s6 @
p_ary = &b; // 合法* f' R# H5 {& @4 }8 s
p_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
- V9 K+ W6 m- e数组指针指向多维数组的子数组" v1 W: h- l. L& F8 b3 e/ ?9 u
int a[10];
+ a; h, r; H/ o9 J& oint b[4][10];
. w1 s- k) n) Aint(*p_ary)[10] = &a;
# ]3 _% k2 Q/ P- C% H. Qfor (int i = 0; i < 10; i++) {
6 v* ?" S" ?# O( ?9 S' u; E (*p_ary) = 1; 0 c8 r( l9 x/ i$ U
}
, i5 k9 v2 {& `( Q0 O$ j. E7 j. a  I/ F& V; D5 @
p_ary = &b[2]; // 多维数组，可以看作数组的数组，
' q7 r' f% A: o# w// b[2][0] ~ b[2][9]的值都被改成2了- _. [. Z' W( N+ U" Y5 k$ @
for (int i = 0; i < 10; i++) {
0 A3 E8 X9 B+ ~; |& g (*p_ary) = 2;' y. _' I" K$ {) z/ o
}& M7 y. q* M0 T7 I/ L' J7 w
多维数组指针
, e1 \2 K6 }. N/ a: Q- H( w( M多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。
) B3 l8 m2 E) \$ }/ N! w' H0 ]0 Z) b, f% Y0 K
int a[2][5][10];
8 m; c( ~- r. j) [) cint(*p_ary1)[10] = &a[1][2]; // 1维数组指针. k% n( C1 e: o- q$ E7 C/ P
int(*p_ary2)[5][10] = &a[1]; // 2维数组指针
, q: Z+ s8 P, S! w7 J0 yfor (int row = 0; row < 5; row++) {1 I+ P7 e( L* l& N+ z
for (int col = 0; col < 10; col++) {7 f5 L: _  J1 k& Z( h+ ]5 ]
      (*p_ary2)[row][col] = row * col;
6 A4 W6 z( \9 `  t, u$ j }0 h* X8 B/ D, b/ s
}9 v: Y! L: Z' S: A; X
数组指针和指针数组对比实例
3 ]" t, s# A$ [. G+ k( b数组指针还是记住两步法即可
1 v% H# k: k$ A  R- `3 N3 b5 }! g% i; i5 c& \0 ]5 X- ^/ V& g5 p- G
定义一个数组+ D1 _) \5 T4 Y" E: m
括号包围1中定义的名称，再在名称前加个*号。
- G8 |( O2 W+ H% [2 Oint a[10];
  O5 x3 F( r/ t0 W1 fint(*ary_pointer1)[10] = &a; // 数组指针0 w. L7 X% U: M1 c$ H
int* pointer_ary1[10]; // 指针数组。元素类型是int*
5 e. T, X2 a) u( A! @9 {. }int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
1 j: V2 T& [0 P+ [int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。1 h$ S+ [8 A0 u
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。2 h# E, n% Z: J' u# b$ v

- r$ y6 Z- r6 L; E/ o5 g6 `5 a# M' R: i// 指针数组可以把每个元素指向数组对应位置的地址。
) A6 h( \+ O% c- S+ g// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，% R6 `+ V" S7 u9 U- I
// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。
# }8 z! h/ I5 n" y& e; Z4 r' q  Cint* pointer_ary[10];
( O" l9 e% I! |  P- Kfor (int i = 0; i < 10; i++) {& |1 l: q, i9 C7 C7 a' Q3 _
pointer_ary = &a;
; _" r5 `! n) Q1 Z2 c7 T  m5 _}  @: z7 c1 w1 J" x# Y0 l# S2 h
// 类似遍历原数组效果。. d3 i6 t. R: z* u8 O
for (int i = 0; i < 10; i++) {
8 E, o' c# w: k. Z, l; y *pointer_ary = i; // 修改原数组。) t( @1 d0 w4 c5 P$ l/ F9 O9 i! ~
}
+ a5 H, x' c, [& i4 c+ B! q
3 V+ @- o) ?( W5 B函数指针
: c. ?2 F  U. _7 H取得函数地址
' _8 o; w8 j( R: R1 ^& `& {; d函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。+ Z3 V* B( ~) w8 x

8 Y" z1 x* r* O& [! ?6 A. v: h8 S8 w! evoid f(int);
# z0 S, U% S- N- \4 zint main()$ x. S4 y# Y) M* U$ k' D  k
{
  m$ U8 J; t6 k( B, M5 j6 F% s void (*p1)(int) = &f;
( `/ t. N) u8 F, o  Q/ q: Y void (*p2)(int) = f; // same as &f
  L7 @4 s8 D2 b9 m- ?9 G; O return 0;, H& F0 U3 B5 y, C8 T7 }: d4 h
}; @7 A6 o( E" V! }: f1 G/ i
翻译成汇编代码， p1和p2的赋值是一样的。
, N: G* C% e) y" N9 ]& r. s6 ~
$ I0 J, n- K# O5 x" ?! }# O4 r# b" B4 S* E8 _
/ L. r- @' U8 x1 e2 Q
函数指针的声明7 @, z0 C0 ^7 ^
单个函数指针变量定义步骤
  ]1 A- N0 u" S6 c! Q定义一个函数。void fun1(int a, int b); int fun2(double a);5 \/ N; R3 [% g7 `  o& L& p
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
- f% l: ?, P1 T- ?9 [. V如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);  X( D3 Y' x/ M! T4 Z9 C
typedef定义函数指针
7 U' K6 t: A9 @可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
; ^/ h; [- b( L2 A9 V4 ~& i" }5 k7 V- Q: S
typedef定义函数指针的语法; y; E# z  A0 a- N3 n
typedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。% @" N5 v( M8 j( C( b* r6 p

5 n" m9 t1 K8 A9 w' h1 ytypedef int FuncObject(int a, int b); // FuncObject类型是函数对象
. ^7 c+ `1 J. w) l. ltypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针; V5 r! O1 [3 B, z9 r
FuncObject* f1 = &Add;% q0 U) P' L8 Q! [1 R& ]. ^# B& b
FuncPointer f2;5 _$ v# g. J( a+ W. c9 K
f2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。5 W) E2 t/ |6 S! F7 p1 s
FuncObject f3 = Add; // 报错！函数对象不支持拷贝
- I' Z( j/ G2 S, W3 {FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配. X) I( Y1 R9 Q7 ^, ?
FuncObject& f5 = Add; // 正确
7 G( K5 X7 d5 ^$ V) nint ret = f5(2, 3); // 正确1 b" F# L( _1 c) m/ g& Y
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配4 m$ z2 h. b' x3 D- y
如何记住typedef定义函数指针的步骤
# B  T2 }9 m! Q$ f5 q; `# ^( t5 S# N像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);
& e7 a7 ~$ C0 h% E在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);( J& ^+ M7 U! ?( u* j
完整例子
: P( b. T9 {$ ^- W5 [typedef int(*CalFun)(int a, int b);7 A7 Z, y0 z9 D( y; K

- u3 y5 P: T& R- c, L# L7 Q1 N2 Vint Add(int a, int b)9 H5 q% v$ ^; C7 }* N# _' K. g
{
8 X8 _3 r6 n2 V" e( L return (a + b);
0 R8 A4 |8 T8 K4 I+ Z( q6 n5 p}0 a9 _. U8 u& u8 t
9 Z+ R/ x2 f" d; G6 i
int Sub(int a, int b)/ l5 y# J8 q) c& K) v: A5 ?
{
3 A* g! m$ G9 {& H7 m- z return (a - b);
) _, l2 l- ^7 ?+ F}5 F7 E* }5 L8 m2 i! ~
$ s$ |% A: e% P1 \" k3 T+ A" a! O+ ?' K* y
int main(int argc, char** argv)
  q! n: q* H, f0 t. V{
: a: Q- G* }5 B/ w CalFun f1 = Add;
# k; s; I  h' R* B CalFun f2 = Sub;
" ?2 q# }4 q" t int a = f1(2, 3);0 r3 r5 e& N0 k" r3 A
int b = f2(10, 5);
3 R* {$ O2 m. V2 S
5 ^. r+ d( [( a+ U& y5 K8 x# f // typedef定义的函数指针数组。  O. d& w% B6 G1 u4 S. Z1 C
CalFun f_ary[2];
. @& @; s8 c5 a4 R! \" x9 t f_ary[0] = Add;
+ A: o6 z% i0 y- y f_ary[1] = Sub;, P8 _$ e. p' Y0 e
. l1 r1 f* {1 i- ^2 e" i, D7 D0 Z
// 单个定义的函数指针数组。
% m$ ]0 l; N3 B9 ^) r: ] int(*f_ary2[2])(int a, int b);
$ I' \$ a8 {' F! ^8 j. q% ] f_ary2[0] = Add;8 }7 M0 q8 p) r: Z
f_ary2[1] = Sub;
  K* I" b' }: C0 x" j
# B' E, ~. x& M- W0 O3 g# |7 N return 0;/ M, m0 H$ Y4 L: f
}( O  J+ S; a1 b) l4 E. ~
- t  |% H- H1 g9 ]
using别名定义函数指针
) x/ ]; i0 ^, t" V0 Qc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
$ I5 E8 t4 L# h# [( @$ i; z# d
+ `2 S" v0 P& T- ^+ btypedef int FuncObject(int a, int b); // FuncObject类型是函数对象, x6 X! ]9 L+ a: P4 q
using FuncObject = int(int a, int b);
& ^, X$ q* o! c. U7 j- \( Z: Xtypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针* s2 x. |5 W9 e3 e+ {' b
using FuncPointer = int(*)(int a, int b);2 i- ]% @8 j! [! N! u. P4 _6 v
函数指针的调用
9 o) K9 S6 {" x: K( {# ]8 h函数指针和函数对象都可以直接后加括号调用
6 d9 ?! y6 r( u+ u3 aint f();, y) B( A0 r0 m. b, [( h; V! v# O& A
int (*p)() = f;  // pointer p is pointing to f
9 l# G% c' I; i: [int (&r)() = *p; // the lvalue that identifies f is bound to a reference1 _4 P0 a, b/ x7 t) l' |
r();          // function f invoked through lvalue reference5 U! @. I) |- K' B! {
(*p)();       // function f invoked through the function lvalue
. f7 L- d; Y( V% tp();          // function f invoked directly through the pointer4 U. B( a7 H/ s& V  }2 N
如果函数有重载，函数指针会指向匹配的那个版本。
  ~$ E7 d8 ~+ _, Y8 s( Xtemplate<typename T>
3 p  f3 q. p, i8 vT f(T n) { return n; }! Q4 d" @% [9 S" p

6 z3 u  T7 z# V& Jdouble f(double n) { return n; }
. v1 D0 ~3 F% h- h7 F$ z
6 r# S: ~9 N0 v( I! Qint main()
0 c) j: G2 k; p8 S{
$ T( h1 T- k4 |+ w/ } int (*p)(int) = f; // instantiates and selects f<int>9 H( g, H8 G8 l1 @. K- W3 j3 u
}9 J+ i* x- ]7 L) @$ _# `
成员函数指针
0 {5 E1 A. H$ W% Y# ?静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。& B" k  T) t4 F5 _) y0 I

0 v2 C* }5 a- X$ F3 c成员函数指针定义。
8 b$ j4 p/ O' k/ P$ b& ~; T/ F3 H像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
7 i1 J+ e3 J% V0 [' N4 N% a$ s# V, d/ T括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
8 E# O$ O1 M) \& r在名称的前面加个*号void (ClassName::*func)(int);3 @" b% g! H; a* f/ N
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);7 T& n' B7 `+ Q( L  B
成员函数指针如何调用。
( h- i) v+ W# V3 d+ O假设成员函数指针名字为func. |8 J' i6 }3 o, A
. @; r2 D  c9 a( o, Z. ]
void (ClassName::*func)(int);
6 Y/ O7 A1 x) b! n4 y对象式调用。
( L4 B4 Q' H$ z" L4 B$ n  AClassName c; // 被调用的对象/ C8 U1 [' I& R. ]* p- ^
成员函数指针名字当作正常函数那样写。1 e0 X/ ^$ p& ~( g1 H# k( |: M$ c
c.func(3);
: q  \6 W, ^5 D- [/ i  x: D# i成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
/ N% @3 J. k/ Q, M$ Q& sc.*func(3);1 l- S' b3 l" ~2 h1 `" z
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。0 \! D& S0 M4 R
(c.*func)(3);
+ ?: _3 E" z5 d$ t) E0 O! d( L为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外8 L' U' I6 K( q  n. I
(c.(*func))(3);) ^: n$ K+ g# R+ N/ c8 n/ \
这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
" d# j- i/ \: Q9 B5 f) s. ]7 \* H指针式调用) G+ J9 Z% B/ X) X
ClassName* p; // 被调用的对象的指针. J# l( M/ F/ s' V
成员函数指针名字当作正常函数那样写。
) H0 r/ d3 P% Tp->func(3);! W+ r% j6 E, L% S3 J
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
' I4 M# i  u* s2 ?: A5 c5 ~p->*func(3);
  T" Z) Z5 |. B7 m: m. x最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
6 `% r/ X8 ~$ j(p->*func)(3);
: |' r6 {' s% q' D' z6 s5 h) O* S函数指针使用完整例子3 l: A  }' y5 {* w
struct Cal / O. F# l+ k, V8 ~
{
. H4 S5 ]+ i1 h: n int add(int a, int b);
8 C* l' d$ y5 Y. P' T int sub(int a, int b);! r3 M- w9 C# B/ k$ Z  I
};
  d9 g7 w: A) ?1 p5 z! P1 c% \2 s, S# d2 u- M
int main()" ]8 z0 k  ~" Y7 i2 t# W1 |/ e
{
5 f  U2 I7 k0 Q1 g& t& W8 y int (Cal::*fun)(int, int) = &Cal::add;
' R: n# b2 r4 d fun = &Cal::sub;
% V5 t  Q6 I; f" A
) O2 J3 m; E* W Cal* p_cal = new Cal();$ ]7 V) `+ y+ j; m
int r1 = (p_cal->*fun)(2, 3);
2 v/ ?( L8 {0 R3 r delete p_cal;5 {* [; R9 m' K  M7 _

& j% B9 U: N  A, j9 |  [3 n Cal local_cal;: t. C! h  N3 K
int r2 = (local_cal.*fun)(8, 6);; k2 a1 Q) w2 Y) H, k+ A
}' G, W) b8 b; Y+ u

, ^" G$ g# C: U% c) g5 h成员变量指针8 a$ P- Z5 A+ X/ u; G6 R4 {1 y
成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。" j: I1 Q) k( V; z# G$ @

4 v  d" X7 ]( L" m成员变量指针的定义3 q& _' F% E/ m8 `
假如以下结构体C。4 U# U' P+ ]5 Q) Z8 u$ U
6 b1 D+ Q5 p: {8 s! B
struct C   a. J3 R6 l0 ]3 z! B) P4 s
{ 1 Y3 i$ j4 ~" k; D
int m;
% N  r( q# |2 t' p+ n, j};
% b5 t6 ~8 P! r2 m7 x单个成员变量指针定义
' L# _$ \: j7 c假设名称为p, 类似静态成员变量定义那样声明( ?0 o6 u5 k! u* U8 p6 Y
int C::p;: Y( R& |0 h( V* C6 O3 D) Q  w
在名称前面加上指针标识号*
7 r/ T" a7 w& }8 cint C::*p;
0 N  l1 o% Q: r& H6 x7 Jtypedef或using方式定义
9 e( T! ~% ^8 W- c/ _typedef int C::*MemberPointer;( X# E5 `* Q, M. }+ E4 w- J
using MemberPointer = int C::*;3 X8 l% t" m- M$ r
成员变量指针的使用。
/ H/ t7 ?, J! C" Q9 {类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。# @8 J% I: y- P$ A* p
成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。
* y- s" S, S0 y7 y! F5 @% K( E% i3 o# n
完整例子
2 _1 {- T1 C5 O* pstruct C { int m; };
. u  m' I0 y7 ^4 nint main()2 }/ D' F" J  g: ~
{  [3 ]0 R0 D- \5 i7 J
int C::* p = &C::m;       // pointer to data member m of class C
0 _- A& S4 Z. s0 z4 I C c = {7};
7 D- k9 ?1 g' \ std::cout << c.*p << '\n'; // prints 73 o9 W5 [/ s8 [3 Z- p
C* cp = &c;! b* E* Y9 [2 x5 k5 U" \/ f/ T9 Q
cp->m = 10;) s: z2 ]; w* I3 ~$ D  r% n
std::cout << cp->*p << '\n'; // prints 10/ y7 N5 |7 B8 K: z, y* j5 [: X+ j
: \& b8 N, m+ ]1 d6 j
————————————————
2 l; H; e9 I8 v4 \版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
5 L3 K0 P+ J1 D5 `5 W- d! T原文链接：https://blog.csdn.net/m0_64407685/article/details/1267881156 _( c4 b6 t% V0 J2 v- k, g
7 @; g' Y0 X! R( P& E
0 {! s- ?7 u4 Q1 r. L& J7 k* ~