查看: 2464|回复: 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)取得数组对象
// 再通过下标操作访问元素。
, B- ]" w" P. [4 n5 [! {( _( h (*p_ary) = i;   }. @6 b8 ~+ M
}
# v* w' ?4 E1 X% \* ?
+ Q  B8 f4 X3 t" t* t* nint b[10];: L$ S/ W% v; h
int c[20];2 c. _$ u# h5 k7 D
p_ary = &b; // 合法; N4 x% F& ~; Q5 X' ~/ w" T
p_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
3 g: `8 y7 }9 w( R数组指针指向多维数组的子数组8 A( B, B2 V3 \7 U
int a[10];
0 V0 a- _0 M' g0 m, b. kint b[4][10];
5 V  @# u7 z/ q3 C! [# }# A) I6 Aint(*p_ary)[10] = &a;
% Z* m7 G" N* {for (int i = 0; i < 10; i++) {8 n$ K* e0 k3 }# @
(*p_ary) = 1; 0 W. M0 q) q$ O9 X/ G+ y) e
}
( @' v+ o, v: }9 X5 a6 M0 T9 F- x$ F: L
p_ary = &b[2]; // 多维数组，可以看作数组的数组，0 u; p( c3 r1 `
// b[2][0] ~ b[2][9]的值都被改成2了: v6 {8 w. ]) @& ^5 d
for (int i = 0; i < 10; i++) {
6 B2 U  d: V0 f- S: c5 L (*p_ary) = 2;
  t1 O0 `1 p/ L$ O}
多维数组指针
2 k' W: r' ^+ v6 k多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。2 Z# y* ?" i1 E, a

+ O) _. X3 g  z7 ^' xint a[2][5][10];! p. C& c$ R& W
int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
8 n2 a) \: I$ _) P. {& Nint(*p_ary2)[5][10] = &a[1]; // 2维数组指针
! f0 r3 b4 W5 E* e  Q% xfor (int row = 0; row < 5; row++) {
8 m7 X; D, Z4 t6 g for (int col = 0; col < 10; col++) {
1 V' q1 a1 a7 Z4 ~       (*p_ary2)[row][col] = row * col;5 i8 I4 X' d" \8 `7 ~  e
}
4 \, B( l% g4 h/ @* T  e: \$ r}
# Y2 k. r# A2 l0 Y/ A0 P数组指针和指针数组对比实例
2 s' U  F* r9 w, [, v数组指针还是记住两步法即可& u! n5 E$ z; z+ [) f2 r

8 o! y# z" m& b! K4 n定义一个数组/ v+ |4 Q0 c4 E! F- {+ R0 z% P
括号包围1中定义的名称，再在名称前加个*号。
; q7 f7 V' b% T" v1 uint a[10];  y+ J2 S" m  I: u* k5 c
int(*ary_pointer1)[10] = &a; // 数组指针9 w+ a1 }7 e9 y/ ^. Z0 R
int* pointer_ary1[10]; // 指针数组。元素类型是int*
& {+ w/ F+ p% @int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。2 o  {0 x1 E, U! G
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。& e% I- A) W( h" Z
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
1 t7 O  ^& `; y, ]; ^5 P! m# R4 @3 o$ w! Q
// 指针数组可以把每个元素指向数组对应位置的地址。
% b/ |" r) D* @+ r0 S% X4 ]// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，
% Q) }; W0 w: U! H: [  D+ h// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。
* s4 k1 r6 L# Q3 F! F% ^- nint* pointer_ary[10];
8 c2 f/ e; G  G, Ofor (int i = 0; i < 10; i++) {' `6 \9 w, a8 E7 F  ?  v) u! b
pointer_ary = &a;$ w9 t2 R  l$ n3 W1 G  ?
}0 [: b0 ~3 l7 j( t/ p
// 类似遍历原数组效果。
$ h+ J# m! D3 @/ m% S( e+ _6 Qfor (int i = 0; i < 10; i++) {1 a$ z1 L+ u# N6 r. g; t% s
*pointer_ary = i; // 修改原数组。8 p4 }  Z) i% S" r$ v
}
/ A  o* t% F  m6 J: k
6 h8 j/ u% a9 a函数指针
( z5 F/ b) X: ]取得函数地址) S5 a! e$ u/ @5 A# C
函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。' h  Y" e$ j5 I9 ]9 ?1 j6 `# {( d# z

2 U5 j/ d0 H0 F; K' R3 n& qvoid f(int);
- S2 u* F1 f0 x1 @" |* l& Iint main()
4 N6 g& P1 m0 h& R9 b7 d- [# N{+ x2 ]8 }# D) X( `7 ^0 b7 Q! e
void (*p1)(int) = &f;
) X8 r5 e5 R, q) D3 A+ ^+ ]" V& u void (*p2)(int) = f; // same as &f
( ]7 k* {, j( b' |! m return 0;
# f6 h* X7 q4 d3 N# S: V}" j7 q5 f( P: Y/ [
翻译成汇编代码， p1和p2的赋值是一样的。% t. {$ u2 a  H! x1 p

& z% Z2 j# T, ^+ w7 q
. r2 z! ~. S7 m9 [3 u7 [; _- i  P' N8 x% K) d8 E9 {
函数指针的声明+ f6 W: l! S$ ]
单个函数指针变量定义步骤! q  s2 g9 B  j1 v) n
定义一个函数。void fun1(int a, int b); int fun2(double a);* A$ Z/ P. F7 R+ G* G, s; C5 k) w
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);: x& ]) a4 |* u0 _- X) d5 g# M
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
, ^2 D: N8 r# V! z. Stypedef定义函数指针8 j/ \1 Z& B) E1 \/ T
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
0 ?7 J' {% N# s+ d3 N. Z4 c0 f- ?% M* T$ K3 l
typedef定义函数指针的语法
. t# m, n. k& V, L7 w. V( otypedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。
  w" K3 W0 f" P8 t  L) F
( ?# ~$ a; U) X8 j$ b) xtypedef int FuncObject(int a, int b); // FuncObject类型是函数对象- @' h( _2 N7 v9 l% ?& h
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
& w, t* N- }- Q% e1 q: cFuncObject* f1 = &Add;
! Y$ A4 ]" ~! VFuncPointer f2;
2 R3 B! Y/ K4 z3 ?, E# g: ff2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。
5 ]/ e4 z8 q: V8 L) B* P3 t2 AFuncObject f3 = Add; // 报错！函数对象不支持拷贝
/ \/ B9 ?7 y0 XFuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配! h7 J% s4 y7 Z" i1 Z2 v
FuncObject& f5 = Add; // 正确3 k+ L5 X) j- O& F) }
int ret = f5(2, 3); // 正确
; }+ _0 @) b* O5 d7 S* x6 U" t0 \( wFuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配& J+ X6 `; B4 e) I( V
如何记住typedef定义函数指针的步骤) E1 z$ T: o  ^
像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);0 H+ [9 ^8 i0 j6 j# I! D  E
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
. N' O* Y9 D; Q/ V2 `# Y完整例子
$ S4 _3 j$ V+ Gtypedef int(*CalFun)(int a, int b);
  H5 z  J! q! q" n! z2 ]3 H
) E, m6 y. X( Iint Add(int a, int b)
& d0 e% o; I. R6 R; o{% x  @# y  }9 }) _, D! y
return (a + b);
* e$ i+ L; y* s3 I}; I- N3 \0 l: f* }% J1 Z

7 A1 }0 A# s6 tint Sub(int a, int b)% W& ~9 ]( t- Q6 q9 r. Q+ H0 q9 M( t
{2 t8 w8 g$ o( P* V* W( h8 K
return (a - b);
6 q' U8 i% ^9 X& N) _% ?1 _}  T4 T. O$ m0 v: f, b( g
3 b4 \" ^5 T$ a: E5 C$ O' ]1 m
int main(int argc, char** argv)
4 z$ Q9 @- D+ P0 N& q+ y/ |+ M/ ?{- L" H  ?3 X1 C6 E+ @
CalFun f1 = Add;
/ I4 C8 S$ p* o# I! |+ C CalFun f2 = Sub;- o& _) H9 R" C0 l7 b
int a = f1(2, 3);
2 ^) r2 p- F$ |; o$ R; I' c9 w" G int b = f2(10, 5);6 ^( K( u. ^( q1 V, R4 t

5 E/ E- `  e/ y, a( O6 k // typedef定义的函数指针数组。
* ~& z1 }* q1 u; C+ P/ m CalFun f_ary[2];# P3 i1 `- B8 R- y' I5 ]
f_ary[0] = Add;
6 B# }$ e3 F% ~* V9 e# y( n f_ary[1] = Sub;; ]2 X/ @  t. J& {* W' _) S& Z

7 T7 p4 M! w/ e7 d/ W // 单个定义的函数指针数组。
2 Q" `; O/ h( L int(*f_ary2[2])(int a, int b);% @) {! y, I, S8 l: s
f_ary2[0] = Add;
; ?9 a% [; B, X3 ]/ P f_ary2[1] = Sub;8 c  _6 `, {1 m; F
4 e" r2 y1 h3 w7 H* E
return 0;
. g0 x0 ?. p9 Y}& D. C3 l5 X- q" N" y* v) e3 `

# s4 R/ ]0 y, X" i8 qusing别名定义函数指针2 t2 ]7 ?/ [  j2 K) \1 _
c++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
- q* u- Z- A$ z6 o8 L* Q9 S" C; c! f$ |% S; y
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象, Q4 ~" G: T5 k1 q3 u
using FuncObject = int(int a, int b);
$ y# n: m' C4 i! Z: j8 F6 Dtypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针& F0 V$ I( y: @, O
using FuncPointer = int(*)(int a, int b);
: ]5 L3 l* K& U; Y9 O+ Z  W4 E% {函数指针的调用
" J8 \2 w  w4 P函数指针和函数对象都可以直接后加括号调用! I; o; c3 M1 j5 q0 z0 ?
int f();
- K; n6 A& d# q  U& J' V: O( qint (*p)() = f;  // pointer p is pointing to f# t9 |4 ?- B( l4 F" Z2 F
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
& a; p! r" _& l+ R/ f0 [: |3 @r();          // function f invoked through lvalue reference/ f" Q3 G: V6 S+ [$ Q
(*p)();       // function f invoked through the function lvalue
6 s8 }" g* y- A9 sp();          // function f invoked directly through the pointer
+ f5 T! H1 F, D  q+ F0 S4 J如果函数有重载，函数指针会指向匹配的那个版本。
9 I+ u: ]! F  V5 v/ K5 o& Itemplate<typename T>
3 E+ }# |/ w  d8 R% dT f(T n) { return n; }
" ]+ K. W4 P$ ~) T! s! ]8 `# o$ g6 ?& N3 T+ N, T& H( Q" P5 O
double f(double n) { return n; }" i: ]. P. z8 W5 \  T/ E

+ i0 G5 [, n  k: s* t' xint main()
5 {# E- k5 s; h- _  Q- O4 C( `{. z, `2 |, {- R" b/ g; l) f; m. A
int (*p)(int) = f; // instantiates and selects f<int>
- O9 F. C  c, U; d7 E}) z7 s0 v0 Q+ f: Y( q2 j6 `
成员函数指针
  F) T3 j1 W1 c, G! M静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。% t4 }: T$ k9 S; g4 g8 N/ G

" ^) M% I) D+ R成员函数指针定义。
: E/ m( a8 X7 x  M, S* _像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);) g' r' y" B* ?: s/ D
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);- W. u1 g2 D: z, k$ [5 z$ O5 G8 N( d
在名称的前面加个*号void (ClassName::*func)(int);0 q" t/ A6 y1 ~- ?* e& b
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
$ D& }! L/ f0 \' U6 b* y6 T成员函数指针如何调用。
. j7 z; g6 C$ |2 l假设成员函数指针名字为func- G) r% l0 V" T2 N

# E7 R( U) O+ G' J7 lvoid (ClassName::*func)(int);5 A) m1 I- u$ Z- n$ k
对象式调用。" e2 L0 `( W3 B; R- E
ClassName c; // 被调用的对象! ?9 I4 I! W' g  y' r" I3 E
成员函数指针名字当作正常函数那样写。! }- y: E9 v8 S- r; V: Z# o/ h/ R3 J
c.func(3);& ^0 B( _% v3 o! J2 _4 m
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。* o0 P% A. e. i! D/ N- J
c.*func(3);
7 ~/ W7 u1 C+ D4 Y$ j- [) Z最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
9 `+ r" x8 m. Y  q- ], P, m9 z4 R) [(c.*func)(3);
7 Y9 P4 `6 B( h3 B6 [为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外* }- d$ d1 H5 v! C: t
(c.(*func))(3);
# _) G8 y; t9 H0 x- @这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。! {' {+ ?; y0 ?) `% A- D3 v* Z7 B
指针式调用$ r7 b  K7 r, e5 d4 }
ClassName* p; // 被调用的对象的指针
8 R0 ~% `+ x3 d( k7 X成员函数指针名字当作正常函数那样写。
/ M1 A3 ]: ?* a* O1 @3 s. mp->func(3);
+ e1 \* W" [4 z1 ?5 B( u( _成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。, l; G, W6 D( |! H! {$ E+ C
p->*func(3);; g3 p! R7 U6 y4 K" {' j! ~* z
最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
( P9 R4 C: @8 U+ \# |0 x# w(p->*func)(3);
& z1 P$ h% ^% D0 F1 ]0 j8 ]  I函数指针使用完整例子
: A4 A7 ]; G) c! M8 R9 `* jstruct Cal + b5 U5 ]' [3 y' Y9 Y8 h
{
7 u  \* i! f/ b( y int add(int a, int b);
8 t, t' q+ S; F/ M: c5 K int sub(int a, int b);) E; ^$ H) q8 V) F# g( r, j! a& A
};: o- S7 `7 S- b" s; \7 h5 |, }8 o

9 V' V4 m- x+ e$ r( bint main()
) k+ l1 o1 ~# O{
9 _* W3 P3 M/ A6 |+ _0 i' z int (Cal::*fun)(int, int) = &Cal::add;+ a7 }) f0 Q6 g, q0 W9 j; W
fun = &Cal::sub;; [" D; w. N* u2 v
- F  Z- m: H. `" o) g' L
Cal* p_cal = new Cal();
! ~& D2 d- ^- q4 ~. h" c int r1 = (p_cal->*fun)(2, 3);) B, q9 a/ R6 |, q2 u
delete p_cal;  H7 C) R0 Y8 k, e3 s

. i- x$ U  ]- M* J2 Y Cal local_cal;) h6 D* T7 _" [$ E
int r2 = (local_cal.*fun)(8, 6);& J) w5 h9 E" }; M
}
0 n' p( I4 Q% T9 g* p% P1 w8 N# a0 w- ]1 q" l% L  ~. T
成员变量指针
0 @3 U8 ]2 x1 r: J7 K成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。" V$ F- [% \1 e2 K, y7 ^' d

( B6 w; U& ~# ~成员变量指针的定义9 L& s; _1 D9 ~8 E- R+ M3 ]8 V
假如以下结构体C。
  j  s& B  Q1 L" R; c5 L2 L4 q  u, |8 u+ a4 z* E
struct C
3 C6 V9 Y% L. [{ 0 Y- {0 F1 d( M; R8 G; J, x4 L
int m;
8 J' f2 O0 _. p4 m: j};$ E3 y0 ]. h% Q) M  h6 o+ P& ?( Q
单个成员变量指针定义 8 C4 C* q0 M( H
假设名称为p, 类似静态成员变量定义那样声明2 ~( D! G8 E/ ^
int C::p;
: }. R9 h( G! w& b! u+ d! R在名称前面加上指针标识号*
, F( O" @7 I, M5 l3 P. xint C::*p;8 A/ Z. y' }) e' s- J) F- A, ?
typedef或using方式定义7 n# L+ n* _) o" @3 _
typedef int C::*MemberPointer;
7 c- _7 D) p& |: d+ q$ g9 husing MemberPointer = int C::*;& p4 f) t1 U' v& C
成员变量指针的使用。
+ }% E1 x# ?. x9 n; |$ [类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
7 h* T; |8 B) t3 w4 B* S# z成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。) t/ U3 `/ a9 L( j* x( w  {3 c
% W( V8 |6 ~6 y& _9 Y- t
完整例子9 x( W7 @4 R* H! x
struct C { int m; };/ `# \$ l0 J8 p; H3 z
int main()+ C5 W  m8 K" ?/ B' f9 \! r1 t* ^
{# d( |, y* ?3 k+ Y& X0 o% i3 W
int C::* p = &C::m;       // pointer to data member m of class C: y0 }" V, b  B8 o6 ~
C c = {7};. u1 s6 o0 ~5 D& @* ^1 b1 M7 ]9 e* d
std::cout << c.*p << '\n'; // prints 7
( X2 B4 i7 e5 G% ^  b9 Y8 n* R C* cp = &c;% V/ Y( k" A8 T  d- o% j
cp->m = 10;, U  m$ P0 W$ Q3 e
std::cout << cp->*p << '\n'; // prints 10
% B; Z/ x2 g+ X0 \
6 ~0 ~" |2 D1 t' v1 u; g3 I————————————————+ I& ]* K' @; c( `% E
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
( n, [, M) f2 q4 U; j0 q原文链接：https://blog.csdn.net/m0_64407685/article/details/1267881154 g) T* T4 p, c( a- I' S

2 \. o% u- `6 p' ]" w; G3 R- Y3 v3 I. }; r9 g8 o' ^: A, j, T9 V