查看: 2452|回复: 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)取得数组对象
// 再通过下标操作访问元素。
: v3 L4 `- {6 v2 k9 X* K3 a (*p_ary) = i;
. }% v: u" W- x8 X/ N}5 O" Z6 o  F+ L3 z) M/ k3 {0 {
5 `+ l/ s" S, h5 m/ b: o* a/ |
int b[10];
4 ?  T; a1 d& gint c[20];
& x" `+ X5 `* ~p_ary = &b; // 合法
/ z, d, u/ ^% L& b, p' Vp_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体* p1 f- E: C3 f+ `1 g' A2 f: m
数组指针指向多维数组的子数组% }% A4 y' E; X% B7 N
int a[10];
% y# {: m8 n& ?. j; f4 yint b[4][10];
# _( I; C, E8 f% r7 X+ A! ^. r1 h- fint(*p_ary)[10] = &a;
' A( o- s4 ~6 ?* _) _for (int i = 0; i < 10; i++) {
9 ]8 B! X  u. G: F: q (*p_ary) = 1; - M9 Z0 ?" Y, r; L
}; x2 H$ j; M; w/ u% g
5 M1 a1 G/ p  c" n
p_ary = &b[2]; // 多维数组，可以看作数组的数组，8 u4 X: H, L# P
// b[2][0] ~ b[2][9]的值都被改成2了
) Y' o" Q- u5 Qfor (int i = 0; i < 10; i++) {
8 V/ k6 k( j; [; X6 ]0 W (*p_ary) = 2;
/ e1 p* v3 b6 I}
: f  e$ p" O' e* F  T4 s/ h多维数组指针( R* b3 `+ p+ f1 L  K& L
多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。- O6 L; g5 p6 k$ n; k/ E

% c" U# w3 U( Gint a[2][5][10];1 o" C# e# |+ {7 s" T
int(*p_ary1)[10] = &a[1][2]; // 1维数组指针5 a5 N' a2 D7 \; A8 e% K+ V' B
int(*p_ary2)[5][10] = &a[1]; // 2维数组指针( r+ D/ P3 s6 ^& H& S1 ]) Z& Y5 g% W
for (int row = 0; row < 5; row++) {
0 a/ m6 I8 n- p4 Q8 k* F for (int col = 0; col < 10; col++) {9 @  W- a  n6 W" p! C* i
      (*p_ary2)[row][col] = row * col;% w! |  J: w) _4 J
}
* ?. V0 ?. Q' O  o& y9 v}0 p  J( [# h8 ?0 d$ |
数组指针和指针数组对比实例  z, @4 C  h: M# N4 c% M1 m3 w
数组指针还是记住两步法即可+ H5 I( I! a/ f6 P4 z
* p5 T; t0 r2 q! g% X+ ^
定义一个数组
" P, x/ R, h* f/ U4 q括号包围1中定义的名称，再在名称前加个*号。% k6 B" Q+ R1 a+ S0 v
int a[10];
2 w6 E' F/ t! yint(*ary_pointer1)[10] = &a; // 数组指针
2 M) }0 c/ M3 ]; o% wint* pointer_ary1[10]; // 指针数组。元素类型是int*; r+ w! L2 S1 I0 g& b
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。3 m' s$ w2 h0 Z- `* Q# [3 d
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。! V4 V6 R3 a- u( P
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。: J) ?0 i' g9 v2 Z, u# C  B
6 d5 ^, T2 B. _% N
// 指针数组可以把每个元素指向数组对应位置的地址。2 W* V6 B7 U# G) l8 E& @4 I
// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，+ n. K% J% w  u' D
// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。0 u- G0 A0 l" Q( o' V
int* pointer_ary[10];
% w: L6 N; d/ F: \for (int i = 0; i < 10; i++) {. s! k$ O5 U4 n! S6 W$ v1 \
pointer_ary = &a;) u% P; k$ H3 s4 E
}% O& e8 D+ \0 p6 M
// 类似遍历原数组效果。& `5 Y- v: S% s0 B, x8 c
for (int i = 0; i < 10; i++) {0 P  g& A: J# s/ P& z
*pointer_ary = i; // 修改原数组。
. D! [$ v' r6 \# z}6 |" L2 g1 C! A) b  P
/ A! t/ |: e+ x' Z1 m
函数指针
1 M# i) U6 d2 v- k" ]/ W取得函数地址% O$ e* m6 ?) S8 i
函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。9 H* D) _7 p* q% y: r
' u$ C# Z, p" s; F1 N
void f(int);9 t% p* Q' _, o+ e" I5 ^
int main()6 Z6 n8 ?1 t  T7 S( T
{: O0 A, v: d4 V7 z6 _
void (*p1)(int) = &f;
9 B" ~) I2 v8 |# q. D/ ?; h void (*p2)(int) = f; // same as &f5 g8 D$ F' c1 a6 `" S7 n
return 0;2 _* c$ P* |) D; B; `+ L2 q) F  s1 @2 s
}
5 n1 K" x* M- X# w8 ~! W翻译成汇编代码， p1和p2的赋值是一样的。! P( b% |$ Y3 W6 _1 l
( O6 B- \* U' J7 E! d8 I" \

3 x$ ^6 V5 n5 H3 M7 g" G: G6 @: A6 v$ S  {( u6 E' e3 `
函数指针的声明* ^+ t4 z: m1 M* L% ^* C
单个函数指针变量定义步骤
$ B" o1 e- K3 K6 t& g, F" K! k定义一个函数。void fun1(int a, int b); int fun2(double a);2 ?; f$ Y) ?4 @+ c; H: u
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);1 |7 c9 a! @  C7 o8 P$ W; T7 F1 }
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
2 H$ Z  ~8 U7 j+ r6 Atypedef定义函数指针
6 x$ U4 |9 a+ |9 o可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
/ E8 N7 s( u: B- S! b
$ P3 e% k% o4 p8 n' m$ Xtypedef定义函数指针的语法+ R8 R, H# d7 [1 q
typedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。
$ P) o( I2 n# H0 H( M0 x) G/ ]- N4 |/ H9 _" @  a7 I0 @
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象' K. k; z$ I/ z0 d# l8 q
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针  @. \0 R9 b8 {  [9 y# }3 ~
FuncObject* f1 = &Add;
8 i# F  v  t( r9 J! IFuncPointer f2;; X4 D% a. {$ H7 h
f2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。8 L1 x& B2 d- G( I3 `5 C# y2 ~- k
FuncObject f3 = Add; // 报错！函数对象不支持拷贝2 Y: @: i  e+ r$ m
FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
7 Q9 @( e6 _: \0 D: z6 e) ^FuncObject& f5 = Add; // 正确
9 M; B9 ]1 j, {) `% |4 f# Rint ret = f5(2, 3); // 正确' J: H: r- M& X% [+ n" T1 B+ D& K+ O
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
& V* f) a* h7 P5 g- _; @8 f如何记住typedef定义函数指针的步骤
& A) U- R( Z- z6 w$ o  c1 V, y像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);) {2 l  w1 Z- {3 ^: ~
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
- E0 W3 y$ ?: r: i: r完整例子
; M& P- |1 @5 m7 Otypedef int(*CalFun)(int a, int b);
- b6 m9 J6 E- l' z, n
- @8 X- A  I( n% s  X/ [9 l2 qint Add(int a, int b)
( U- g' @& t; u8 Z% ^{
' t' {5 |+ a, F return (a + b);7 _2 g2 x( k; M, X
}
& B  x3 X3 p- V1 u& E6 E
3 Z$ T8 q; r% h! ^7 G# Nint Sub(int a, int b)4 T$ q+ {% I" A
{
" k& I! b2 U* D7 h5 ]6 X- H0 | return (a - b);
2 J6 v- n- Z3 [, j! B! P1 f}
4 P4 D+ M% k  x' X/ W
% b/ m% P; ^! q$ ^* t# oint main(int argc, char** argv)
" D# o- M0 i6 x3 Q{: a/ X/ q7 ~# F" o1 _
CalFun f1 = Add;4 J& l4 K7 v. i- }
CalFun f2 = Sub;9 c, C( k0 I4 \- T, A5 B; Q
int a = f1(2, 3);8 L$ }: Q$ X" P+ A4 H; N% C$ @% N
int b = f2(10, 5);0 B1 |9 @$ M& a6 d# d; r2 o* ]4 K
* g# c* h2 r" U/ x2 {
// typedef定义的函数指针数组。. y' Z; o# |* V2 X8 ^) |
CalFun f_ary[2];  B, v  V$ `; Z
f_ary[0] = Add;* r; ^* D9 Q0 k+ S
f_ary[1] = Sub;  q( A0 D2 x2 L- I3 F( Z

7 R) i+ {$ s' j4 J! C" n. g // 单个定义的函数指针数组。
' ?, V# l  }: ?6 {+ t int(*f_ary2[2])(int a, int b);- O* g8 V! a+ W
f_ary2[0] = Add;) O% j5 y* w9 c# Y* z
f_ary2[1] = Sub;: ]. T, p8 `" S6 C& g) f

, \) S, Y4 t2 Q  v1 E return 0;" `1 `- M' j; [* j, N2 v. w
}: E0 z# _. n8 J. [
8 o* Z! Z8 ~8 M; u( ^% n
using别名定义函数指针7 i/ _' f! M6 A* ]; m
c++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。( A& }! Y1 w  {; c9 y- R; T

2 y7 V9 J( G6 \9 d( N4 u) f% O. Ktypedef int FuncObject(int a, int b); // FuncObject类型是函数对象2 N; W9 |: |- w& K. s
using FuncObject = int(int a, int b);: C( U! V; H2 ?( j% k# C# Z: M
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
+ q9 p6 L7 I$ d  rusing FuncPointer = int(*)(int a, int b);8 ?" e+ t( T1 {( ~% _) _' a& b
函数指针的调用0 v5 J) c7 i$ R2 }
函数指针和函数对象都可以直接后加括号调用
3 s; c# {, ]' C( U: Iint f();
- e2 E- f# p1 G) Pint (*p)() = f;  // pointer p is pointing to f
# _7 K, I( D7 R( Nint (&r)() = *p; // the lvalue that identifies f is bound to a reference
- d2 O, q- ]7 u+ k- Jr();          // function f invoked through lvalue reference
" j4 B3 w& @1 h) V. c1 W$ X5 Z- d(*p)();       // function f invoked through the function lvalue1 w4 F* a3 v$ \) v' Q: ^' m# V
p();          // function f invoked directly through the pointer
  w" `$ q* R: T2 p! D如果函数有重载，函数指针会指向匹配的那个版本。
$ {2 J$ {: ?  H0 C% ctemplate<typename T>
; i! d- y. Q9 g. d, k0 ZT f(T n) { return n; }
* f3 W( E4 J5 c; a( K; V) I( s( c, Y
double f(double n) { return n; }
# h' i6 `- |# B2 `: b
+ J& i; V. [+ F1 C7 R  oint main()
/ b0 d: K, d* K' }8 p" D{$ R5 a8 d2 p: P2 f4 Z( N4 j
int (*p)(int) = f; // instantiates and selects f<int>4 u5 c" b. b# a
}
/ o, t. m! g& H! g9 N成员函数指针
8 U" {" \3 D1 F- i静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。" Y5 m+ f- S8 g3 w8 U. |5 L2 ~. `

2 V1 p; X$ d, b: g2 J/ D成员函数指针定义。
( t  ^& [6 z6 c像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);6 \- `! G+ `2 }/ @3 n
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
3 n" m$ ?: y$ [$ M在名称的前面加个*号void (ClassName::*func)(int);" \( T7 {3 `; g/ ]# C- g
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
, }3 H2 s9 s0 Y+ j; x6 R$ l成员函数指针如何调用。! h* y' e8 k! K" a* T8 d
假设成员函数指针名字为func2 n1 o5 B) C( F

( f$ y3 e& H+ ^# m6 A( B; i0 nvoid (ClassName::*func)(int);, x/ M1 N; G# _/ Q* l0 Q5 ?# L- l
对象式调用。
: L3 \8 o! z- E1 AClassName c; // 被调用的对象$ U3 A- s# j6 W! \
成员函数指针名字当作正常函数那样写。
9 q* `9 ?& Q/ hc.func(3);
! J$ {# Q4 b  g( [& h( K6 Y( i成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
/ _& x1 w1 n9 O+ ~$ \/ a5 P3 R. Rc.*func(3);
+ H5 L3 O8 l0 M7 A最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
( j; T1 X8 F5 ^* x/ d  g8 a(c.*func)(3);
  x6 B/ L  }( G- @# E9 C为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外
9 _% Z0 C+ u( S% c. Z1 s(c.(*func))(3);
5 U2 G; n+ A3 T6 X, \; {这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。% s5 e+ _5 @: B7 j! y
指针式调用
0 W1 J+ S7 L+ o2 eClassName* p; // 被调用的对象的指针/ J1 g2 `8 O4 X$ S2 ~
成员函数指针名字当作正常函数那样写。
; e  e) _/ j! t$ c* _2 Fp->func(3);0 g. U/ F: E' ]2 w7 z5 E4 B
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
% C- E0 ]9 t4 c; Ap->*func(3);2 q4 [$ ^  e; `* x9 N) c% w6 U$ D
最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。: o& \" U. c1 G$ Q; ?& N
(p->*func)(3);: w5 f) E% ~8 [, R
函数指针使用完整例子
0 }: C0 v/ U/ D. o. N1 p/ gstruct Cal
. q7 D  d+ n. G; K{ / Y7 }6 Y! s7 B. K3 A* |7 |
int add(int a, int b); ; R9 K/ C/ i+ H7 c
int sub(int a, int b);% j' I* `3 s: `# m- {* ^* s: i( _$ K
};' ]/ x% N! N. k3 [+ b, M3 g$ Y0 O
- d1 F, c7 z5 L0 z- q
int main()) j9 g2 R5 [0 ?  b3 n7 ~! H
{
5 d: |. V+ S0 U! a6 D, u int (Cal::*fun)(int, int) = &Cal::add;3 _2 o1 k; R) o; I
fun = &Cal::sub;* f; p9 C) b6 B$ w
- O, M) E- ^( |" I, v
Cal* p_cal = new Cal();
2 }& p! }2 d' M2 R4 P+ {" ~ int r1 = (p_cal->*fun)(2, 3);
% C7 a4 r+ D& y0 p9 E- j delete p_cal;
3 m0 V9 u. y7 g  \! X6 f$ {' ~7 v$ Q- }2 c9 O) x/ V2 B. h
Cal local_cal;' i! K6 z( @# L
int r2 = (local_cal.*fun)(8, 6);' ]6 M6 z3 h( `& Q6 V
}
5 a9 d* c4 L2 m( b7 i0 P+ s
  f; F# M9 n+ Q成员变量指针1 [  j; ~4 f4 T8 L' ]& X6 S0 p
成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。
6 o; H/ n7 }1 Q, M. Q
5 ]% s9 x' t4 X2 x成员变量指针的定义5 F9 ~0 j' T% n+ i  D7 ^
假如以下结构体C。7 B" }4 h8 ^$ U- k' F- Q0 o
1 c7 Q" P6 _6 I/ \% C6 v
struct C ' c2 f# c5 `( {( B2 }0 s
{
+ {, {% H7 R8 H5 x4 V0 B int m;
  I: O. M$ s2 U% A" T$ A- g};
2 I( B1 ^  r) X3 m% g单个成员变量指针定义
* U! g' k7 P; T+ C/ B$ H$ H假设名称为p, 类似静态成员变量定义那样声明. ~' {; n' A( l2 P
int C::p;
5 d; U7 g6 Z' O在名称前面加上指针标识号*
% m5 h/ i% M9 T. `% ^int C::*p;( b0 b6 z. }1 B9 J& Z# p
typedef或using方式定义4 P6 Y; e) a/ I0 |" o
typedef int C::*MemberPointer;
7 D" I  p: i% U" _$ Susing MemberPointer = int C::*;" o( \7 [$ |* n7 A% Z& o+ D
成员变量指针的使用。
0 y( q) Y# |+ i5 t5 d: R类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
: @0 h; e7 y0 ^# D6 H成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。5 ~$ q1 B2 M, _4 a
" H& X' B. F0 m' {& |& W; S; w6 @
完整例子
: J5 Y9 N/ k$ X; F8 wstruct C { int m; };7 W+ D5 Y. L5 v
int main()) G) v8 Q5 H* q  O% ~; R
{
6 \6 k3 }8 F8 c4 n$ h int C::* p = &C::m;       // pointer to data member m of class C6 P# ]! N* b- J/ F: ]& F, Y
C c = {7};. h5 Q% a5 C! [0 [4 r7 v
std::cout << c.*p << '\n'; // prints 7# j6 k" j6 M8 i- d, E
C* cp = &c;
% @+ q! W: |, U+ j! y cp->m = 10;% U. J% n# A+ g
std::cout << cp->*p << '\n'; // prints 10
6 K: A) B. Z- e: f( c
% P5 `7 e4 S8 }2 M+ g: G————————————————
8 F5 t: \/ f& G$ e) O9 p* L: v版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
7 @- T6 x* P" T, r  \原文链接：https://blog.csdn.net/m0_64407685/article/details/1267881155 l3 `+ }' B$ E6 S; u* B
1 V' q! t  i  E/ G

' R7 D5 e% F# i2 A+ f