查看: 2467|回复: 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)取得数组对象
// 再通过下标操作访问元素。9 M, J: H: K% ?( o8 r' M8 i5 S
(*p_ary) = i; 4 i  [8 \3 o+ T+ r4 k5 j* I7 f
}& A5 M: D  S0 c' @
2 X9 v" j) F  G( S5 S2 |) B! ~
int b[10];
! S4 @" E* k0 A# {: }0 l6 hint c[20];8 q" `7 j- M0 X: i3 \3 }: u. y
p_ary = &b; // 合法
7 G: t' o9 F5 C  h! f  Y5 h( J, \p_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
3 r$ K( m9 ?; W4 H数组指针指向多维数组的子数组
1 F' Y7 _6 u& ]8 @5 }9 Bint a[10];2 t5 n) W1 M/ F6 n: q" g
int b[4][10];, c; E7 {* ~* F4 g
int(*p_ary)[10] = &a;% ^& {5 H  ^& @% V9 X' E7 j- r. ]
for (int i = 0; i < 10; i++) {
) {( W0 d) N; {2 p  `! O (*p_ary) = 1;
1 Z2 L2 X: S+ t" p9 w5 b8 x}! u0 Z* ~, e# e1 N) X9 ^; k

. b: \  c1 B& Qp_ary = &b[2]; // 多维数组，可以看作数组的数组，; n, T* W  w. _2 B9 E  X. {
// b[2][0] ~ b[2][9]的值都被改成2了0 u3 _- O& D+ F+ |/ r  S9 ^
for (int i = 0; i < 10; i++) {' O: `) U9 H2 O5 D
(*p_ary) = 2;
/ |* o% p9 a2 r- b' d2 }}
8 Z2 [6 T; N: C, L# B: z多维数组指针
3 t1 t9 K4 ^8 z( e多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。0 U) M+ I  a; U" z

, Y- A3 y9 [0 l" Gint a[2][5][10];
, H6 r( f, L) ]* r/ f2 @$ h# qint(*p_ary1)[10] = &a[1][2]; // 1维数组指针
, I  O* q3 C+ E. mint(*p_ary2)[5][10] = &a[1]; // 2维数组指针7 l$ w% U$ X, G
for (int row = 0; row < 5; row++) {
4 |5 i, ^3 O$ B for (int col = 0; col < 10; col++) {5 i- Y; ?. _; }
      (*p_ary2)[row][col] = row * col;0 M: X7 r( s! a* P1 c+ }
}% R3 I0 S) I5 J
}% I0 a  l. u7 r# I( a/ p$ e, K$ e
数组指针和指针数组对比实例! K- [! h" M7 a2 Z0 ~3 L& W+ i; s
数组指针还是记住两步法即可
! ^. }0 d5 x4 b; W, f% N
# D4 q8 k; r3 z$ [' o0 ?  a( O定义一个数组7 m8 y! U. v; X" F( F- s  {/ @. f
括号包围1中定义的名称，再在名称前加个*号。  c; C6 `( r6 w/ o- J) q' Z
int a[10];
0 F  {! D  k5 q& s7 h& r8 ]& kint(*ary_pointer1)[10] = &a; // 数组指针+ |% g' f0 D; N. `4 G: P: \
int* pointer_ary1[10]; // 指针数组。元素类型是int*
/ z1 A1 F+ G" _7 X, a: m& Zint *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
3 u9 A# d0 A- b8 K# D3 ?int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。; _, x6 _  M$ _) _; O7 J
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。* V; s/ z- T/ K2 A
! E( X. M* G* w/ P% v1 _
// 指针数组可以把每个元素指向数组对应位置的地址。
' U8 \5 L0 ^2 e2 w! {7 Z// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，
- b; m0 W: s  M. M6 N2 w) v/ ?// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。
" d3 J+ J, m+ [! sint* pointer_ary[10];
  Q  _3 O* P4 F& X5 B/ efor (int i = 0; i < 10; i++) {
' {0 z/ f4 k, n1 x" p$ }% U pointer_ary = &a;
, j4 I4 f8 g1 d1 a1 ^0 ]" i}) I% k% _; s6 O; U$ F
// 类似遍历原数组效果。
, O" z. T) S' t8 t$ ?8 \/ f- Vfor (int i = 0; i < 10; i++) {  N) F: I/ P7 O, w2 q( f5 Z
*pointer_ary = i; // 修改原数组。3 B, j5 o7 A. F' W
}
4 S7 [, l# m$ `4 ]- Z7 O3 s4 C1 W! C, y, J8 {
函数指针0 v) t7 g1 y8 p
取得函数地址
+ C2 U$ c4 H  e4 B4 \7 {8 U函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。6 R+ Y* |2 J% W5 N, ?8 g: h

1 I; f8 i, \+ O$ j2 L1 ivoid f(int);
" t; ~9 t" y: W% q5 {% @6 C3 C& Pint main()) ~1 e7 r3 Z2 [) p
{
  H) ]5 S3 N. [/ q  ? void (*p1)(int) = &f;( t& o( v( z! V9 g# W# ?2 @& ^
void (*p2)(int) = f; // same as &f
7 V* V' y6 i" z9 U, b return 0;
/ N+ H: x# z# x}
2 ?: k) T  [" y# |翻译成汇编代码， p1和p2的赋值是一样的。: ~: _$ q' x6 I1 k% k' X
" D3 O" ]/ a, f
$ A9 Y+ `) ^4 t+ z4 y5 Z

" V% h/ W8 V4 u: z函数指针的声明
( K7 V  ?3 ?2 O6 f( u* r0 G+ j单个函数指针变量定义步骤
  \) T+ m* U; f; D: u' n3 Z定义一个函数。void fun1(int a, int b); int fun2(double a);
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);, O; P: C3 S5 N2 k% T0 K  L1 h
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);5 h. P. ]/ ~4 f* A
typedef定义函数指针
' t8 {$ f+ p$ c7 Y2 j- }可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。8 u* X+ E8 r+ f) ?6 M8 E
; Q# _% r9 ?- [$ G3 t/ P$ f
typedef定义函数指针的语法
) h; e' D+ D) v3 ]  f7 _typedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。
  W5 C" V0 p$ N& Y9 k8 }$ N: \* X5 Q( O, N3 W
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
+ I. z4 X' B$ z; B+ \typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针9 @: q/ a6 o2 `. t
FuncObject* f1 = &Add;
& o" x. M) p& P8 t& x5 \/ Z$ M" vFuncPointer f2;. w: M0 G: F9 S1 H
f2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。
" w9 c7 T! n) |$ Q  ?% `' j5 JFuncObject f3 = Add; // 报错！函数对象不支持拷贝' x5 Q8 X, ~' a
FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配0 `7 W' ]! [2 y& @
FuncObject& f5 = Add; // 正确
5 }  Z2 Q  P  G/ ~int ret = f5(2, 3); // 正确5 E& s9 R  a; ~# w2 e
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
; E& A3 q0 v# l  i7 |% O4 M如何记住typedef定义函数指针的步骤* l; G: f) }% @: f, {. T
像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);
$ U$ C; T( E) E3 ]% @, x' p. K2 n2 j在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);# a1 D9 M7 s4 N% N
完整例子
8 S# b! L! q7 Z# q* q4 H, X, Rtypedef int(*CalFun)(int a, int b);) o& W9 i. P* G' }+ e3 w* P$ {
/ ]% v0 F8 g% z9 [, O
int Add(int a, int b)" R& X6 m6 u; l0 T4 e9 ~- M
{
5 ?" X! G9 c! n, W return (a + b);/ F9 ~- r. `% V8 S
}  s! [# l. }: w7 z' }/ `" ?
: h1 l" V) H& {: r5 G4 V
int Sub(int a, int b)
/ V1 g  V# n* N5 l- @6 z# {{$ E8 B0 i; r' L& t
return (a - b);
" W6 P6 z7 X6 V7 t' s}/ R* d7 y+ `  ?

, ]5 E- v& F$ n7 M3 N" N4 [! q% r7 D2 Oint main(int argc, char** argv)- ?+ h6 ]6 X4 ?6 q; }) n5 z) ^, \
{8 `  h7 P2 D9 {' M; ?5 X" L. r
CalFun f1 = Add;2 |6 U  G+ }% f( s7 @
CalFun f2 = Sub;% P$ @# e4 j# F+ i1 c
int a = f1(2, 3);
/ S! o/ x/ d, D int b = f2(10, 5);  n; ?. ^0 I% K7 }7 r

3 s' e0 N% m( o& d // typedef定义的函数指针数组。. m& u2 e1 l. o
CalFun f_ary[2];8 o4 ?* ]2 [+ g
f_ary[0] = Add;4 M1 J; d' W+ w* a% a
f_ary[1] = Sub;
. v! q3 C* g' d8 e8 `0 c2 f# R! d# S4 M9 q6 d- q
// 单个定义的函数指针数组。
/ @* s; m8 F& [5 n int(*f_ary2[2])(int a, int b);3 G5 n+ J* R3 x. C% n6 Z4 u
f_ary2[0] = Add;
; N. s8 Y0 o( ^ f_ary2[1] = Sub;
- ]. L( F, D# e: u1 {
2 {5 m5 ~1 Y; Z( M1 P return 0;
  s9 {9 W' t/ L) }}
( A( s2 e7 X; G0 O; x/ o+ e! T5 ~" `$ E- d& l1 L$ E4 j: e
using别名定义函数指针
3 G7 ^0 R0 E4 V' [8 m3 M# Sc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
* G4 {% Z. Y& C. g' w7 O+ U5 O& G7 M  q
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象0 c" F' d, b3 n; @/ L9 Z2 j
using FuncObject = int(int a, int b);
( n4 E2 Z0 o5 K5 z2 {  ~3 I0 ptypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
5 @. b/ N. @2 ?' H" |* R% Lusing FuncPointer = int(*)(int a, int b);
9 d$ V0 ~4 s# z5 Y, S, Z函数指针的调用% P2 k$ _! Z' q" a; Z1 i
函数指针和函数对象都可以直接后加括号调用- `5 |7 y/ s2 S
int f();3 }& D! K  K' K- d
int (*p)() = f;  // pointer p is pointing to f* p+ |) `, \6 C7 P0 c
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
( l' l0 @6 s1 t* kr();          // function f invoked through lvalue reference2 F6 k' `: E7 Z+ e
(*p)();       // function f invoked through the function lvalue( g! H+ b6 ]: {5 V2 p+ l1 Z
p();          // function f invoked directly through the pointer
" _. r+ c' {" D0 N* w: h0 P9 E如果函数有重载，函数指针会指向匹配的那个版本。
1 H9 l! L) p& L" \- _template<typename T>+ G, L& i  r8 ?5 F
T f(T n) { return n; }& I6 |7 a! R3 @1 d" _/ q( W
+ P* M0 K$ x; M0 X( |3 G  R8 P
double f(double n) { return n; }; Z7 a$ Y$ q0 O
; V9 l0 n" _0 h7 f6 D1 l7 Q  T! C
int main()
2 B2 n( U* ^3 m  D{, y& I% J5 l8 h
int (*p)(int) = f; // instantiates and selects f<int># Z3 r  M* ^. }4 t% Z( f; _- \6 f( ?# N
}
4 S: w9 _# e  i: }. s成员函数指针
8 m) E  w, ^0 N8 e静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。8 s* m5 ]( Q( L5 y) r

8 p  O3 X1 [# g, s) P2 b8 w  }成员函数指针定义。
" h: p2 m0 m, n像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);5 l1 l* H6 x! N1 l6 K4 F; h$ B
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);+ t: j6 _: O2 _+ i( v. l; K2 c
在名称的前面加个*号void (ClassName::*func)(int);
6 p! j: \0 s# E; f6 r: T成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
" H* O6 d5 E/ o2 g成员函数指针如何调用。
1 e, k: f2 y) S8 S  ~, ]1 t假设成员函数指针名字为func
. F0 ?' q0 t  m7 A
, }- D! m6 {2 n+ l% l* `void (ClassName::*func)(int);
( q* t* w! \, ]% n: ?对象式调用。  z3 C9 ~/ ~2 O7 x' V9 f
ClassName c; // 被调用的对象
9 V& p; o5 W1 A. g成员函数指针名字当作正常函数那样写。
! m3 c5 S0 m9 ac.func(3);- }3 K+ W$ t6 r3 B# W$ i
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
- |8 F% m; d0 c4 o% F9 ac.*func(3);" d# m1 J4 D" @, e
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
% \# m) a$ K3 O2 R# Q# a9 D" V6 w(c.*func)(3);
4 z9 g+ d7 [- p' L' X为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外
0 |) u; N5 j; }) {/ Q(c.(*func))(3);
2 l" ^6 u+ c: z- @7 y/ x$ W这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
+ Q( L- @$ _% P3 K. t) I指针式调用, X. x2 J) S* P, H2 G+ k: A
ClassName* p; // 被调用的对象的指针
  R7 l3 w' `% H. [+ H! }0 Y+ g成员函数指针名字当作正常函数那样写。
& Q( Z6 \$ Z; e+ @! n4 ~p->func(3);2 T! ^! j. f. Y3 ~2 P/ p2 h
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
3 L* K! ^4 ?! \% xp->*func(3);
( n! Y# d$ r! p- X" m最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
7 t! J% a: O. q2 k" o$ J4 _  ~(p->*func)(3);
" @  ?; M9 R% R! A; ?2 l函数指针使用完整例子
: t* G4 F, V& E8 J# H$ b! tstruct Cal
; r1 X0 Y; f, q5 T2 X, P1 @{ ; n. x0 b5 b0 x( L2 d% x' {
int add(int a, int b);
/ P& ^* W9 T) C3 N( @/ k( g int sub(int a, int b);
4 \% G8 }/ e; l, R  X' m0 Z};5 |& d/ s; g# x( W3 }5 Q

$ Y! y+ g+ [2 ~int main()! ^( i( Z, L6 f  @) P
{+ S0 \9 p- j0 f6 M% k9 J+ }
int (Cal::*fun)(int, int) = &Cal::add;& R" ~" _6 E0 q0 _( I5 ?
fun = &Cal::sub;0 L) Z0 D% q/ }" p

% e; g1 K# `# a' f' q Cal* p_cal = new Cal();' ~0 I& Y. Y7 b4 ]
int r1 = (p_cal->*fun)(2, 3);
) u% @. B. z! A0 X/ x" D& R delete p_cal;* ?: p/ g) r; Q) }5 i) t) S
1 @- X+ t& |0 b* `+ D
Cal local_cal;( G; g6 e2 a+ H. n" u. x( b
int r2 = (local_cal.*fun)(8, 6);
" p' N* B/ ^1 h7 a" r4 W0 m$ E, ]$ A}
3 h( h- T# H0 P6 F' `7 `) w& V' t
成员变量指针# \3 \# Q" F" e" p. k
成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。  f- r" H7 Y$ w/ ]3 Z* S5 ?
  `9 x* _$ e/ {7 i6 m, N# ~+ k
成员变量指针的定义  \% |5 T5 d) \  }0 A, `. M
假如以下结构体C。! U9 }6 J  v" |6 [  j3 h6 b

7 L4 ^7 G! J/ o$ W8 ~( V+ Wstruct C * y  W" d  C, y' B/ v" e
{
2 Y; _; q5 W0 O+ x int m; , S. F; `2 h% l$ s
};+ N4 e: W2 t4 _, I& H; H, v% v  h5 ]
单个成员变量指针定义 5 v7 M  a- Q6 y* w( ~% j* U" |
假设名称为p, 类似静态成员变量定义那样声明+ ]0 C- h0 g) J% k0 L  W
int C::p;0 o* o8 G% u$ }% B3 J, l8 l# w
在名称前面加上指针标识号* ( V4 _+ e9 R# e3 ]  s, b4 b5 R+ h1 q
int C::*p;
+ Y' ?0 d9 S6 x7 m4 Utypedef或using方式定义8 u2 Z( x8 K: a. v  D. V
typedef int C::*MemberPointer;+ m3 l/ w0 t- s1 M
using MemberPointer = int C::*;- Z. a/ o  M1 n
成员变量指针的使用。
$ d6 d4 `# h: ]' h# K1 q7 F类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
6 A3 g9 T7 i% V  p, @% l成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。/ v' d1 S; q+ |* m% w
! |4 O: ^: @/ w4 M, J5 C+ S
完整例子3 W6 n: k0 a' a2 O
struct C { int m; };
2 v) w5 c) C' Wint main()" W( g0 H6 D! ^# T. z9 c  @" F
{
int C::* p = &C::m;       // pointer to data member m of class C
/ A1 q: o* I( b: r C c = {7};/ `5 _' S- p" [8 Z/ q  }( u  [
std::cout << c.*p << '\n'; // prints 7
0 u4 ]' y+ n, F* F" d7 Y3 ] C* cp = &c;
# Z- V. G5 d! k: r. [% W cp->m = 10;
- R2 i) O& a- C2 ~ std::cout << cp->*p << '\n'; // prints 10
% f# l5 ^  @* g  H) v, }7 b2 l) I
————————————————
" V6 t/ R9 ?, y; K  j: Z版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
4 U$ U3 V3 m- z* p1 ^; }原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
6 {3 B; g3 B: D/ K
% v5 [! P  o5 I% t. K. g3 o1 \1 y( e3 }$ w+ Y! K- W! B8 S. u4 D