查看: 2389|回复: 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)取得数组对象
// 再通过下标操作访问元素。& N9 `; ?0 f+ W1 j3 Y8 g
(*p_ary) = i; ' {7 O* h. m4 Z! v* X
}6 }8 x" q3 h, i3 I0 {& H
1 Y  n5 I; N! {- ~: d
int b[10];
  M, V- i" l/ rint c[20];6 o" k$ E- d4 t+ U8 H/ Y: P
p_ary = &b; // 合法* J/ f- c; e& }
p_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体9 q+ d- D$ n: T4 O! n4 g  `# p6 l
数组指针指向多维数组的子数组. W; d% c9 e6 Z, [4 t: ^
int a[10];: L: l3 I9 H& a) V0 b# m! X
int b[4][10];
6 D( {9 g5 \; z8 Cint(*p_ary)[10] = &a;
8 t" L/ Y7 L* X: Mfor (int i = 0; i < 10; i++) {
$ R( U6 r- f; t9 ?7 Y (*p_ary) = 1;
' a$ v: m5 j( O; Q( W+ l}
9 P+ e& j, T( [0 x. k
6 `  A! I9 }- a& I' u8 \3 cp_ary = &b[2]; // 多维数组，可以看作数组的数组，3 Y4 F$ ~& O. \, r
// b[2][0] ~ b[2][9]的值都被改成2了0 M0 `) h, E- E/ C5 x
for (int i = 0; i < 10; i++) {
& ]( _" H' Z# D0 I (*p_ary) = 2;
. V5 V# k& J( z* j1 w}
7 k" b" a: p' A, |) j1 X多维数组指针
9 z9 G9 F. I* z多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。- Y  t* d9 w4 e/ T5 ]0 J
- t2 b' {7 `* Y. s8 k2 X6 x+ `: K
int a[2][5][10];
  I- G) Y* w0 }5 x6 g9 m, Tint(*p_ary1)[10] = &a[1][2]; // 1维数组指针+ F' H. c6 O/ k6 P7 s% P
int(*p_ary2)[5][10] = &a[1]; // 2维数组指针) n! O$ V" {# N% w6 W! P% p) F% f
for (int row = 0; row < 5; row++) {0 D) I- W" F' E( D  ]3 w' u
for (int col = 0; col < 10; col++) {& t, s: P8 L: F0 b7 ~; e1 I1 l- \
      (*p_ary2)[row][col] = row * col;( X( G8 F' ]7 A0 w3 |) L
}
! j# }1 D  P; H7 l}! c" i7 k4 V/ s
数组指针和指针数组对比实例. `7 Y% S+ {9 A$ t! m2 b" e, C
数组指针还是记住两步法即可7 x3 C' y7 j2 m9 y* M

1 o4 X" ~' l( m. r0 [定义一个数组
1 t" a  o) z6 P/ \4 X1 g括号包围1中定义的名称，再在名称前加个*号。
; u3 l  s1 D% d  s% c- P" E7 oint a[10];7 `$ M; L- w4 x8 p/ w, }
int(*ary_pointer1)[10] = &a; // 数组指针, j% b& ]: ^6 G
int* pointer_ary1[10]; // 指针数组。元素类型是int*' B$ O7 ~& |2 K! D# q8 b1 ^
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。* ]5 {. `1 D0 [8 o& b6 b4 F( o# @
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
+ {2 l& `+ g0 Nint c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
4 }% i' p7 u* J2 N- q% F9 ^
! c) j! T" R% ~" H+ y& j4 |3 o; o// 指针数组可以把每个元素指向数组对应位置的地址。, E1 H5 d; g7 R5 {
// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，
5 R+ O3 A2 N4 i: s1 @* [# J/ v// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。' J8 k4 L1 Z# C3 ^+ \) m+ F  |
int* pointer_ary[10];
& T3 v/ y* H0 W# O/ U' lfor (int i = 0; i < 10; i++) {
1 o1 `1 z7 ^- Z4 q: C) Y) A pointer_ary = &a;
( ~$ ]% n8 F8 W/ v3 y/ H4 n: s}
) U. P" k6 I% A$ Q1 `6 l// 类似遍历原数组效果。: Z8 O5 j2 L6 u8 d- B$ N
for (int i = 0; i < 10; i++) {' S$ j3 z& Q$ _  e
*pointer_ary = i; // 修改原数组。/ r5 A# `$ P* {$ f
}) l0 `, F6 ]9 I% j0 |9 w
$ b' E/ Y$ a$ |5 K, I
函数指针4 N: J; C2 A3 G% Z. g- f
取得函数地址
4 \  a/ N$ G  ^- ~+ a6 ~- [函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。! v) a8 P; V/ z* t" }5 z
+ L1 {9 M: k# y5 i
void f(int);! Q" p+ C' F4 z! w+ ]0 a
int main()
5 X5 ^) h9 |+ `( S# f{
, U: O1 u: R" E8 z1 M void (*p1)(int) = &f;" W7 k+ B) q. z
void (*p2)(int) = f; // same as &f
. _$ _7 h% X6 C' u return 0;6 J: R: a  D( _0 f0 w% \
}! X+ p! d3 m) X! ]/ z! e
翻译成汇编代码， p1和p2的赋值是一样的。
9 h5 Y# g% l0 F* a+ I% P, v* z7 @5 }$ n- V5 O0 W0 d; v
3 y6 v0 E6 E, I. R& T
' M/ ?+ P4 x6 L2 z# g
函数指针的声明+ `" x$ a+ [# ^
单个函数指针变量定义步骤: @, W5 y) O* J4 S0 L3 e) B& n3 O
定义一个函数。void fun1(int a, int b); int fun2(double a);
# Q  M: a' h; _  z( Z7 s用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);! g; N+ X% p0 u5 d: P* z% t
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
$ n% A% S* |& W+ i4 I2 j  atypedef定义函数指针0 X* ?) Y& f6 Q1 S4 W) a
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
- }: K3 t6 Q9 V: C2 H5 F
  U% H' x. ~* M# O% b) \9 I7 w: @' Ytypedef定义函数指针的语法0 o* G$ k6 b* r2 n( F* {
typedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。
$ g: ^1 |% O; q5 ~3 y/ v, P) h# Q; L# E; W
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象4 M6 s; |  F1 a  {3 E& b* u
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针+ k! N. A- ]5 X6 u6 r
FuncObject* f1 = &Add;
6 k& V# i1 B1 `* GFuncPointer f2;
" _* Z4 o1 D+ A' o1 Af2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。! P! l2 U& _, e5 F
FuncObject f3 = Add; // 报错！函数对象不支持拷贝
5 O' G& [( @7 A9 EFuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配/ G$ O2 |! ]! ~- e! a! Q1 j
FuncObject& f5 = Add; // 正确
! |0 x3 Y, \0 `$ yint ret = f5(2, 3); // 正确) d3 z7 ?% G4 k6 M& ~& k
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配9 G9 u% {) v* l/ s7 N; ?9 }
如何记住typedef定义函数指针的步骤
- g; |3 v. `- A6 V. P3 {9 b6 \6 f) g像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);
' o5 c' [+ L' @% J8 R在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);! s" i! Z) z; H6 ~
完整例子
; [" C& j5 @7 qtypedef int(*CalFun)(int a, int b);' q' w$ n9 e" g6 D% l! @  v
$ A1 F: {2 K  E# W
int Add(int a, int b)
; A) B5 P0 N! V9 `- Q{
  F( N$ B& b5 M$ ]7 H& q; s return (a + b);3 \; |: q; l4 k! P
}- L9 _% u) \, F7 \: Q
- w& C$ O) ~* o2 h9 u
int Sub(int a, int b)
9 d: ~2 z3 F/ o* v{7 O) L3 N- l2 L- T
return (a - b);
/ L: x% F' M: N: J}
: ]7 x2 }& e! L0 u, G
0 a, B/ Y. `6 `& X% ?8 nint main(int argc, char** argv)
& Q! t( y2 d) B3 b; U) h# i{" D# }$ N0 B6 `8 e" F' y
CalFun f1 = Add;3 F$ M. \9 `, i* v) l* M
CalFun f2 = Sub;
. O3 g( h" p2 @$ A$ k int a = f1(2, 3);! N. c% |' c; [6 I
int b = f2(10, 5);4 R; I8 ^; m4 k7 I- j# i& X  Z
& L4 _: K8 H6 K6 I- p/ K$ ?! Y+ [
// typedef定义的函数指针数组。
5 J, W0 T) e9 z CalFun f_ary[2];4 X) G2 o7 j' C; ^6 g
f_ary[0] = Add;& m- Q3 c! e: K
f_ary[1] = Sub;' ~1 n% V0 {) u7 X6 K

/ A. V6 n* R8 }) ^5 o$ C // 单个定义的函数指针数组。
) V, o7 V+ n7 m* b% j1 U int(*f_ary2[2])(int a, int b);
  i4 I. v$ S# ^$ ^6 q8 X+ t3 e: B f_ary2[0] = Add;
) ~3 H0 j0 [* J- M, D f_ary2[1] = Sub;
- w* F3 \, m+ q
# T' G/ p5 b7 W0 i: A2 l" ` return 0;' a1 T% }4 ]* h. [, q
}% [& H2 a3 A# r- e2 c! h

& n2 J0 ?! b4 T! A( q% m' x$ o, |using别名定义函数指针
$ o7 O1 k6 ?0 a8 d% pc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。, f4 E, i9 i: e! Z' H
  \5 C# f& V) m" H8 ]+ r
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象  d$ H! U3 l) Y4 @& U7 u
using FuncObject = int(int a, int b);
& O6 {' u1 f4 t* Dtypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
1 O, l0 ^, r' d2 `2 T1 @' S4 Busing FuncPointer = int(*)(int a, int b);
- ?0 N4 m4 _' W7 H, o+ ^4 I函数指针的调用' k4 r9 ]: d6 R6 b$ ~7 h
函数指针和函数对象都可以直接后加括号调用# U, O" p& x/ P. D( V# d
int f();
9 P: v* m) I$ F3 e, [3 xint (*p)() = f;  // pointer p is pointing to f
# Y0 s# |. \% Y, e9 yint (&r)() = *p; // the lvalue that identifies f is bound to a reference
: E; t2 L9 W: d, pr();          // function f invoked through lvalue reference
+ y8 R& B7 K& L) S(*p)();       // function f invoked through the function lvalue
0 f- V) [( z! v( qp();          // function f invoked directly through the pointer
- v& N* S0 d8 V) _# i0 h& M: {如果函数有重载，函数指针会指向匹配的那个版本。& g) X8 c: i: \/ Z) O# T0 R
template<typename T>
  Y. U* ?# Z& k9 L( ^! H, K( Z6 |+ ^T f(T n) { return n; }7 `  R! D, S) T( D6 ?5 t9 E

2 I) j& d0 u1 pdouble f(double n) { return n; }
4 `# C+ L0 t/ P- e0 y1 h* u, g+ a% m% V2 ^" ]3 D6 X, J' g  q
int main()
5 v5 m5 m# e! C( d3 ]{; {% O9 L6 j- ^5 Q
int (*p)(int) = f; // instantiates and selects f<int>; M, z0 k* c2 e' B9 _
}
: L# ?: }0 d' o# I8 ]. C! E$ u成员函数指针* k) ^+ T/ t5 }& \. s& p- G
静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。0 H% ?  {( [6 D, k
1 X2 L1 I8 F, S  B
成员函数指针定义。
0 `1 v  H2 e- j4 O9 r$ t像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);+ j" g2 d+ Q5 }7 t/ Z
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);0 S9 H5 R2 D* o) c- r  \& Q
在名称的前面加个*号void (ClassName::*func)(int);
' j- |% F6 H& `5 B) I成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
$ F& A. P0 Z2 L$ z4 u成员函数指针如何调用。
' g4 p" W2 ]( w9 K假设成员函数指针名字为func: o2 d7 e0 W0 j1 _

  j5 M5 U" |' c5 t' ?  r: B3 |void (ClassName::*func)(int);: z6 \6 e$ e9 p7 L
对象式调用。- x  F, k' C/ ?$ Y4 q3 }
ClassName c; // 被调用的对象
2 e' W( G' \. ^/ E成员函数指针名字当作正常函数那样写。; `* [/ D% h* V0 k/ Y
c.func(3);
* o  n- Q3 s+ O5 a6 W成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。' D& d1 E7 @- d/ F) b4 U
c.*func(3);+ ^: a3 F# i- R0 l( R- F
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。; n. z, Q2 C" |7 T9 l+ p
(c.*func)(3);
$ Z+ j2 c! {# l- @2 B为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外3 Y  a7 k, ]5 y/ G$ \
(c.(*func))(3);
; E) C( c: L; B: f- f5 W4 f' H这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
5 b! J9 e$ G3 }: U7 G, m指针式调用# n( L/ @, {+ I; h' t% p9 [
ClassName* p; // 被调用的对象的指针) V7 h% J' m- K' {$ g: x! x$ w# j
成员函数指针名字当作正常函数那样写。2 I# M6 N3 o8 ~1 @/ g
p->func(3);
( U7 V7 I  w, N! }; N成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
" p9 Q8 k$ q  `: C6 {p->*func(3);
/ s+ R9 `1 q. q- |' A5 T  R最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
) c$ @6 s! v2 i3 l3 [(p->*func)(3);
7 h0 o# I  |( e7 C函数指针使用完整例子# z0 J) v5 v! J* U! d* G: Z' v
struct Cal 5 C: E$ p+ |4 h, X7 r8 a
{ 2 M( {% Q5 \, O- D0 u
int add(int a, int b);
& I; L  H) g) o" I" |7 {. X# c int sub(int a, int b);+ d7 k0 M( R' e. M& B6 |% Q
};
5 o0 t# H. @1 p1 w: ^
4 C1 |# S. d1 d; J! q/ M: O% t  \int main()
, Q- x* p7 [% N/ i0 C) c{7 k/ i1 _8 H; l: H8 N% S) W
int (Cal::*fun)(int, int) = &Cal::add;
: n; O) n$ G5 _/ U) Z fun = &Cal::sub;# w' Z+ `* r. ~7 J) s3 x& b
7 x! g. m0 Z$ H5 @# ]2 b; U
Cal* p_cal = new Cal();% T  {9 Y1 u1 F  ]
int r1 = (p_cal->*fun)(2, 3);
, v7 d- l: w# T) Z+ z# s  s6 p delete p_cal;( X2 |8 Y% }, g$ f2 h7 W) X
+ a, O$ W2 Y( G7 Z
Cal local_cal;
; {: B$ F8 s. ~, V) x int r2 = (local_cal.*fun)(8, 6);$ v2 o; @/ s3 B5 ?  d
}) ?; R" R6 Q+ z/ ^5 W6 l

0 E: x1 ~/ M2 t3 g# n3 w成员变量指针
2 Y6 U' X2 W1 Q1 z* Z. G6 d7 a, H成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。
3 E6 t, H3 K) x
7 p: X' g* a! u! {3 w9 i: K成员变量指针的定义
3 j& Z/ Q$ c% \& k* v假如以下结构体C。+ A9 J# K) R5 T: @

( ?6 l4 x. ^# R5 L) bstruct C
1 ?8 B4 r& G2 ~7 Y{ " a4 `7 y2 [8 h9 @
int m; / U9 P* H. V  e1 H7 o, Y
};+ y+ }) |3 Z* J' K+ _& I
单个成员变量指针定义 5 w9 K7 }2 }8 R* G, v0 w% n" f# Y
假设名称为p, 类似静态成员变量定义那样声明
/ X0 N( o0 @: d  Wint C::p;3 K, g  ^. H0 T" ~( e1 x  ^
在名称前面加上指针标识号* 9 H; ^$ c/ l! u. C3 n/ z: e
int C::*p;
' r! H& Q; h" a) E: `typedef或using方式定义6 ?, H& X+ M0 s) M
typedef int C::*MemberPointer;5 R7 a' r1 x5 e4 Z2 W+ R, J# H" [' [
using MemberPointer = int C::*;
: H: G% E& K$ J: X1 C$ x成员变量指针的使用。
( y3 Q3 c7 S" T1 y1 w& j2 [类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
& {; m2 I: t* [8 @1 H5 _成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。) ~/ q. N) x: Y7 o& H
: K8 O+ R" a* {) ~
完整例子1 I1 N5 y$ Y* i8 ^: o/ w9 @8 ^
struct C { int m; };
! s/ F* s! h. l/ `, z5 Vint main()% n3 d/ u" ~6 A; H8 }
{
3 ]; L5 t) ?* M* G int C::* p = &C::m;       // pointer to data member m of class C& A6 E  R: S. q6 _
C c = {7};
% }* M. u; o* g9 x5 o0 Q4 x. e std::cout << c.*p << '\n'; // prints 7
( m2 [2 e+ ~5 P5 q2 |! s5 @ C* cp = &c;8 Y- d' \9 E6 S7 q4 y( ^
cp->m = 10;
2 f7 y+ S7 s( w9 I. `4 w# o5 _ std::cout << cp->*p << '\n'; // prints 10
; B7 Y1 n: W; v8 h
- e2 l  ?+ N& u0 S- z7 {6 y————————————————3 v: J/ L) I: Z  t) E6 a, \
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。# a4 z4 P$ r* g* N  }
原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115  _: i5 f6 l: {8 n2 w# b" o
* Q5 f  M5 R: F. Z, v
  Q  x5 X- h% [