查看: 2442|回复: 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)取得数组对象
// 再通过下标操作访问元素。, I* t) ?) ^) {( d4 C9 K
(*p_ary) = i;
}9 K5 \9 \1 H5 ]
- p, e) l$ h0 ^2 `9 U
int b[10];. ~8 y& c' A& |' e( C! V
int c[20];
+ z+ _! C1 R- u: F$ Tp_ary = &b; // 合法7 ~7 d* X5 [1 W" C+ G/ f
p_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体1 A! K2 m! Z( Y9 I4 O% d, L8 r0 j
数组指针指向多维数组的子数组3 ~7 R( s. }8 r( Y9 R
int a[10];
5 u- x! Q( ~, B) g- pint b[4][10];
: |! {# }: z- tint(*p_ary)[10] = &a;
% ^- S% V: O; \for (int i = 0; i < 10; i++) {  o7 \! X% A+ u* @1 \' g
(*p_ary) = 1; ( G/ B3 h6 W8 ~
}) e1 x  }7 w2 g$ t4 d3 f. r1 B
) e: F1 j) U+ y9 _, b' L% ^: {+ ~# M
p_ary = &b[2]; // 多维数组，可以看作数组的数组，# g( \1 `. P, U' ?7 I
// b[2][0] ~ b[2][9]的值都被改成2了
/ e$ l: [5 c1 `' Vfor (int i = 0; i < 10; i++) {% w& A5 v( L$ i- j8 \* C
(*p_ary) = 2;* G( Q! j2 T6 O
}
4 x: m# [3 L6 |. a, x多维数组指针# M+ J# G- \  r; C
多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。
6 e6 A2 h  T% m8 P2 e% y' `! {9 y0 V1 @( N; ^8 F
int a[2][5][10];+ e& s% D$ u, g8 |. Q
int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
' Q) N, ]% `3 \5 [/ L4 V/ eint(*p_ary2)[5][10] = &a[1]; // 2维数组指针
" q7 G# z0 G1 I% ufor (int row = 0; row < 5; row++) {* _! q5 ~  K8 ^3 Q4 w8 x
for (int col = 0; col < 10; col++) {: [  _! H9 F0 B1 j
      (*p_ary2)[row][col] = row * col;. M8 ]8 {& n1 C: u
}
6 \& l2 M2 v, t0 M; g  P; E5 s" ^}
+ B, o& M- H; ~数组指针和指针数组对比实例7 Z( z' q: L: e. @3 \- O. \; x' W
数组指针还是记住两步法即可9 F1 f4 E, e8 s( e& K2 Z4 y% ], f
5 y/ [/ w) M, E! D" O) q
定义一个数组- i% H* }9 R1 \& w- ~
括号包围1中定义的名称，再在名称前加个*号。
6 `9 ~7 k- K0 Hint a[10];
+ t4 I6 \2 g- W2 \2 b, g( Oint(*ary_pointer1)[10] = &a; // 数组指针
: D$ {! t# I& n; zint* pointer_ary1[10]; // 指针数组。元素类型是int*
! u3 e  a2 F& Rint *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
3 W3 h5 F$ E* m+ \2 m9 Z: m, z2 O" @int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。4 s0 ?) ^: U, N& @% ?+ X; j$ `$ M
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。% ~* ?1 k) o. ?0 {& I6 z

3 h+ G" W, O7 z" k! X// 指针数组可以把每个元素指向数组对应位置的地址。2 u6 F  ^5 b; m* H2 E/ ^& F
// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，
# Q" m+ y, \' E// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。
; d& U: o! t& p4 _( l7 Bint* pointer_ary[10];
) j" P$ V3 d! Z9 l) A. Nfor (int i = 0; i < 10; i++) {. ]' {" b7 m# l; c/ g
pointer_ary = &a;  J9 }  C+ z5 D# Y
}, s0 Z" \- L$ c2 S1 [( N) }
// 类似遍历原数组效果。7 y$ n* s/ S  X- \. A# Z
for (int i = 0; i < 10; i++) {/ u3 \9 V, {3 \$ g' U0 Y( `
*pointer_ary = i; // 修改原数组。' H3 G6 H" A% U* L" Y. m( ^
}, o* r9 M& A& V- F% }" i. Q

; X  E4 Y+ f5 s8 ]7 F/ y函数指针
1 O# R, s! s8 H/ d7 L9 L/ e) N取得函数地址
1 J- _! N) b/ I+ b5 M) g5 M5 X函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。4 g6 t& ~0 I' Z1 \

3 k/ F8 c" D6 K$ ?& U) svoid f(int);
2 b6 v& j' q9 _3 d4 ]* _int main()# F( H$ g7 r5 |) @( U) ^8 D
{
' P5 `: Z- @: S4 D7 H void (*p1)(int) = &f;
$ [" y, t/ q; L( h) R2 H  J void (*p2)(int) = f; // same as &f
/ _# f$ f% g5 ~4 U- L# {$ d return 0;# {5 S% k4 n0 I; }; h4 ]
}6 v: a$ Q, C) B1 j) W
翻译成汇编代码， p1和p2的赋值是一样的。3 Q1 L. b' h- f8 {6 I

# G1 Z; f; i! N7 t3 P# Q( I3 X) T- t+ W3 c  D% q' C7 C
8 ^! b; Z( {: z# J: |8 T4 U
函数指针的声明
' A1 O- o9 L0 E4 B2 D' M单个函数指针变量定义步骤
3 Q" v- [# g0 D8 L: j- c定义一个函数。void fun1(int a, int b); int fun2(double a);/ U9 |) ]# n& p) d& u( k
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
4 n7 ^% j& h6 \. {. p0 ~% T如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);9 @# Z7 G0 r0 r$ F' G7 H
typedef定义函数指针
" }, @! a' P2 p5 D/ m, `5 o可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。9 b; W" t5 A3 v# f1 p' X* s

' O( |* k8 v0 \4 y2 e, Gtypedef定义函数指针的语法
) I* T) q% M! n7 J' {  S4 Z; C3 utypedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。0 P5 j* `, Y& q: r
8 w0 X9 [; x* P- H% K7 s" R2 p' J
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象/ c6 O' S2 h% T% A- v1 E
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针# ~0 W, ~7 I# p) G5 Y. G- E. b; @
FuncObject* f1 = &Add;
7 r  K( p7 M0 x! _$ R1 gFuncPointer f2;
. y" W  E# i- v: R) \  pf2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。
. u) f1 {( |* R0 G$ V+ vFuncObject f3 = Add; // 报错！函数对象不支持拷贝
9 {2 ?! R6 d9 e* s- v2 x  c1 AFuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
5 d" s  V' |+ N2 |, X5 h6 iFuncObject& f5 = Add; // 正确/ W4 I; ]5 e2 H9 n$ U
int ret = f5(2, 3); // 正确! i& \" m: F' m( y3 N9 I9 @
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配! G2 [  A9 ?( Y1 A4 W* ~8 Z' G0 {. m
如何记住typedef定义函数指针的步骤
1 p: C+ V! N* v% W  v" U像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);5 r0 s' V( j) W  F: f$ |
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);' Q$ ?( E' R5 F$ p8 x
完整例子
& `/ n7 a) f2 z" b& qtypedef int(*CalFun)(int a, int b);
/ m! \, M- z0 [6 O, w4 i8 t9 ~4 b$ S4 E4 B. C
int Add(int a, int b)
5 ~( p' T# P  a4 I# Z% s{/ O; W6 m5 C: J/ }
return (a + b);) c! W* E9 V9 i  I  c. K+ \1 r
}  N# \! ?3 [  b, v  k# p

, ?' A) U: X' ~int Sub(int a, int b)
" Y+ v1 `' f) r2 ^3 X) J1 D{6 Q$ V# m) ?$ t1 ^6 f3 |
return (a - b);" V! Z9 Z6 F0 M
}
2 ~/ m8 p% V1 L8 O6 U; p
) [& m' k* P' Sint main(int argc, char** argv)2 b/ K9 T; [3 k6 N9 p  o2 `9 b/ G' j
{
! K, j- W3 ~1 z! S CalFun f1 = Add;$ o3 J  {, t: M% ^+ E+ O
CalFun f2 = Sub;
8 ?' Q9 A( _% i3 {8 c0 ^; W int a = f1(2, 3);. g- x3 B* O+ d9 v5 W9 ~1 X
int b = f2(10, 5);) x* w0 W% p; L# U2 u

9 |# B/ m. N7 W& O& W/ f- n; t // typedef定义的函数指针数组。5 ?0 t5 I  p8 e9 Z* E
CalFun f_ary[2];
! e# o3 `. V3 y5 L1 j! E f_ary[0] = Add;; h: ?( P1 T0 |9 W
f_ary[1] = Sub;: |* W& {- X- k

0 ^5 b) c4 a6 A: q( N // 单个定义的函数指针数组。
+ Q3 |0 }6 X! R3 o& D/ ^+ H int(*f_ary2[2])(int a, int b);
0 i) u; A0 J3 w' E) W, G f_ary2[0] = Add;: \' }! d0 V; P6 o
f_ary2[1] = Sub;
  Z7 V4 s1 m" W4 k7 [. A5 g' r! b' z
return 0;8 f* r& w# f. N) Z/ b+ W9 ~
}+ y9 D: B9 a' `' A. @

' x1 $ L+ i; J0 eusing别名定义函数指针
3 m. b2 z( d2 s( ~$ l6 F, ec++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
+ H! H: b. `. G; d. ?! ~  [
; j2 t/ V9 k2 E8 otypedef int FuncObject(int a, int b); // FuncObject类型是函数对象1 R# J% T8 U$ D8 f6 C4 v
using FuncObject = int(int a, int b);
# f5 i0 N2 Q6 R  _+ R5 J- ytypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针1 m, Z! c$ M- M3 m0 s# f4 ?( }
using FuncPointer = int(*)(int a, int b);1 l+ X: W$ O8 T3 j, I' E' N* {
函数指针的调用  y3 $ m7 Y1 Z% @. B
函数指针和函数对象都可以直接后加括号调用
5 T% w" v) Z+ E5 T2 S# Fint f();
+ I. _$ u4 k. i5 Nint (*p)() = f;  // pointer p is pointing to f
' `9 }- Q( I. e1 yint (&r)() = *p; // the lvalue that identifies f is bound to a reference
5 B* ]3 F0 B; P5 Wr();          // function f invoked through lvalue reference: y+ Y8 n; W+ i, ?
(*p)();       // function f invoked through the function lvalue; D# F- W+ J( O1 y/ b6 ~
p();          // function f invoked directly through the pointer5 [4 A5 ]% O6 u6 e* R, m
如果函数有重载，函数指针会指向匹配的那个版本。
+ k; ~2 @; o2 j% E4 g; k6 atemplate<typename T>8 f$ u* K: r  B  x( H: m
T f(T n) { return n; }
: b0 x1 ^: `6 h0 f
2 ]0 $ Z& d. ^7 i- \* edouble f(double n) { return n; }
6 \" Z1 u5 P7 a+ m! $ }& l- s
  ^+ K4 r+ m4 @) H, Z: O  bint main()
# Y7 X0 D+ }( r{1 Y& i) y2 G% B% W
int (*p)(int) = f; // instantiates and selects f<int>
! z! a; j* B! y* G2 _}
7 e4 W! V) t  M成员函数指针9 D% `$ L# u6 p4 P
静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。% v* |; u+ i) p. g) k

0 d# B2 c" u: q. V3 h成员函数指针定义。0 Y  }# A! Q! U6 Y
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);& i3 G: H! ^% |1 }" S. j7 \
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
% t6 |% q- L- V; ~- r4 o1 J在名称的前面加个*号void (ClassName::*func)(int);
0 s$ I1 L) A' L( A成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
6 a5 M  ~2 T( L( d成员函数指针如何调用。) ?# I0 y; O/ a# {0 [  @& C
假设成员函数指针名字为func
: X% D) k5 r& `  o2 ]( |" @. q/ u* ^
void (ClassName::*func)(int);4 T/ G* v, G8 `9 ~! ]
对象式调用。' J! Q+ m" q( W; ?; A5 {
ClassName c; // 被调用的对象" A& e7 {2 }' P0 m1 a; G; l: y5 w( E
成员函数指针名字当作正常函数那样写。6 c7 `; v! @: B  I" _1 |
c.func(3);
! a% f# l( W1 b$ [+ Z: q2 d成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。/ Y  j' i6 M. N3 E7 i2 d
c.*func(3);2 W8 a0 {5 Q0 n: g5 Y+ k& X
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
" L0 @7 ^4 }) }. d(c.*func)(3);. U1 ~7 F  E# J7 ]
为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外" J0 m5 s/ U1 C3 T& x
(c.(*func))(3);
  v) H) R! c' i这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。, }0 Y8 A  U0 u0 W6 N
指针式调用% P4 F1 A- \) Q" c  j
ClassName* p; // 被调用的对象的指针9 H! m1 {9 P% @0 O3 ~. p8 I
成员函数指针名字当作正常函数那样写。
6 H1 [" G- t3 j3 F9 E+ ~4 kp->func(3);: D+ }7 I# o; Q7 q1 W$ ~* e* f
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
- j" O) q! y/ j' Lp->*func(3);. Y6 P( A- s7 r
最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。' B) ~! r: e; W* ?6 ]; e
(p->*func)(3);
* x# G; \2 ~9 B4 Z: D& F, a. U函数指针使用完整例子0 Z' H" l6 W6 r& W3 `
struct Cal
9 U" p, ^7 h. W: y{
" g$ r1 a8 ]$ e3 h) E int add(int a, int b); 7 Z, j7 r, I2 p2 j# k- k
int sub(int a, int b);/ b. t4 n- p5 H9 n& L. E7 V
};
: G; E) w1 U- u6 R  S2 r3 N' N. Z
int main(), @% q+ B# m* a6 i
{
) J+ M3 I9 ?+ c+ N" I int (Cal::*fun)(int, int) = &Cal::add;
4 ^; G+ U; @) C. ]$ v5 \* D fun = &Cal::sub;+ {6 p; P3 D8 T0 {9 P/ b# |
0 c6 e; U# P. I- t& b7 s( `  e+ m8 H
Cal* p_cal = new Cal();
: ~/ ]" H, F! U) K0 _9 Q int r1 = (p_cal->*fun)(2, 3);) L6 y' |( V+ w' h- d+ F4 p. T
delete p_cal;( I" u$ f$ B2 D6 u+ i. c# Y
; C( l" M% V2 \" {
Cal local_cal;" h" R/ n0 n* b/ [
int r2 = (local_cal.*fun)(8, 6);
9 Q( l2 _1 ^6 c& G9 c}: s3 C; g7 S6 g/ a
" d4 B) l: B! e( k8 d% |
成员变量指针- Z  v  {) k0 r) I: r
成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。
1 u, V+ C/ ?# ^6 `/ r2 M" M( ]3 M3 N2 S( N
成员变量指针的定义' e7 C4 u, {* F4 `3 A" ~" X
假如以下结构体C。
5 I! G0 L0 \4 s) @' y; U, v7 B! X7 V
struct C 2 A- r5 ~$ [* _7 n# {+ p/ }
{
% Y- D' E+ N) B4 h, v+ C int m; 4 N9 r! ], x7 z+ J; G3 i) [9 V
};9 }, z. M  Y, i% B! s
单个成员变量指针定义 5 n6 a9 g6 A! N- X. v; P" D( b# H
假设名称为p, 类似静态成员变量定义那样声明
+ \; R4 B; ^6 b1 G/ nint C::p;  f& f5 ]7 A8 c+ y, N/ u
在名称前面加上指针标识号* ' H5 a' O: c& c' w, w( x$ ^2 \' @8 s
int C::*p;
6 V- N' e  ^6 H0 Vtypedef或using方式定义7 C, [4 u9 E( t2 [2 p/ c  L( m( H7 R
typedef int C::*MemberPointer;
* H, p' J' ~4 L! M& iusing MemberPointer = int C::*;! g4 Z' |% ]: O9 x( l3 y
成员变量指针的使用。
: S6 W6 s; P7 [" e! T$ l类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。8 S3 [/ n# p# \: r: H' X8 l* I- G4 z/ _
成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。# K! A0 C, e8 W( p" @% h/ I1 M
$ r2 S& T; a  Q$ E
完整例子  S, w3 d* B! b! z6 L  ~+ u
struct C { int m; };
; q  ~, o9 B, P8 H6 Jint main()# P0 `5 Y) j! w$ O  G6 g
{/ s/ W3 G+ l) e5 g* i( T
int C::* p = &C::m;       // pointer to data member m of class C
% O4 ?" H. O8 L- a) Q& z C c = {7};
9 L' G6 |. e  U' k7 G3 I, D4 N std::cout << c.*p << '\n'; // prints 7! t- S! F! L% _' ]
C* cp = &c;
9 K% H+ z+ S: y& |& ^ cp->m = 10;% y; X+ c& t  G7 ^6 E) }
std::cout << cp->*p << '\n'; // prints 10
% n4 F4 d" g. B$ z% r- G- H! n5 X9 W, [% J2 O, C
————————————————+ S9 M" z4 Z& d& W5 H
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。. s/ \9 ]# v8 w6 N& b( V
原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
; Y5 v3 _3 u) s+ G/ n+ M* o
, [  |7 {% X6 S, Y3 x
2 u. _7 a: q( A: Y, {+ u( a& r9 Q