数学建模社区-数学中国

标题: C++数组指针、函数指针、成员函数指针 [打印本页]

作者: 杨利霞 时间: 2022-9-12 18:49
标题: C++数组指针、函数指针、成员函数指针
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)取得数组对象
// 再通过下标操作访问元素。7 {' n& B+ \6 @% c1 G
(*p_ary) = i;
# N% m8 k5 b- G7 f5 Z& J6 [2 L: a}- z" x& G% T+ z0 {3 l3 w( C

# K  S- ?9 T$ m6 ^/ j' nint b[10];
+ n" p' k0 m& s2 yint c[20];& Z* b% `8 V2 n! |5 b* ^
p_ary = &b; // 合法
3 t, x8 `, h9 G4 s  Lp_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
; i. j9 ~9 a( `% v! F: n数组指针指向多维数组的子数组2 q) Y% E# I4 X
int a[10];
8 A# H" [; G- a6 n/ F' pint b[4][10];0 s; k0 |3 W" x: R, S6 p7 S' ]6 a0 E9 n
int(*p_ary)[10] = &a;2 s9 [/ D6 l1 N2 A  k  c
for (int i = 0; i < 10; i++) {6 T$ S6 i' G: b/ X$ w8 n: W5 |
(*p_ary) = 1; ! h* Z0 F4 p" @+ }: l
}! G! e4 a! y, N6 ], q
) R" P! v' T$ Q+ N8 I; `
p_ary = &b[2]; // 多维数组，可以看作数组的数组，
; T" C6 @% Q2 E: Y, [, e) n// b[2][0] ~ b[2][9]的值都被改成2了
: M3 i+ q  G) Dfor (int i = 0; i < 10; i++) {
  l  w1 b- f5 ]0 b (*p_ary) = 2;$ S7 B4 S* c- ~' A4 n( G2 I
}3 O. F; ^0 j  t/ p2 H, c% o
多维数组指针8 p3 I( X# K  W
多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。) `, I$ c; _. Y9 R2 X- \
8 T! }5 W) j3 i% k
int a[2][5][10];
3 d' t# t$ c* X* p4 S! U' @int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
8 d7 b9 [; {- v" T# f  F' lint(*p_ary2)[5][10] = &a[1]; // 2维数组指针
( X/ M' Q2 G9 A1 dfor (int row = 0; row < 5; row++) {5 c4 r& e5 N  h8 j+ |8 L! D
for (int col = 0; col < 10; col++) {3 s. G6 C0 |) d% }, z* w" V
      (*p_ary2)[row][col] = row * col;
3 T6 K" @, @6 R9 H }% n5 W1 ]2 o) g  |
}
5 l# \8 f0 p+ Z: e4 i! J& t数组指针和指针数组对比实例
. |; q$ D$ M/ G; @% ~' G数组指针还是记住两步法即可
/ e, ^3 ?% @( ~+ h3 q1 Q3 x7 G9 q2 n9 z
定义一个数组1 g+ K1 e* }5 ]
括号包围1中定义的名称，再在名称前加个*号。
, W' |( b$ h+ K, Pint a[10];
6 d) ]) }6 ]' yint(*ary_pointer1)[10] = &a; // 数组指针5 |! ]6 q2 P" P  \5 y% Y% I
int* pointer_ary1[10]; // 指针数组。元素类型是int*
  e: b& |3 a& wint *(ponter_ary2[10]); // 指针数组。另外一种定义方式。- r/ X% d7 Q5 ]% t5 }1 c; V" B
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。3 b/ F1 U: k* i8 ?* X, e$ `
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。7 }, O: M& g# W; V& u" B  _8 N4 J) D1 l

& m* E5 Q+ d/ L// 指针数组可以把每个元素指向数组对应位置的地址。6 q9 i. H' W1 E. a& U- g
// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，: d, T. |2 I6 o
// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。
( G8 E( N+ X- aint* pointer_ary[10]; 0 s$ @" n* Z/ G
for (int i = 0; i < 10; i++) {! ]4 j6 r+ E' k2 B2 B
pointer_ary = &a;
}
% @+ v5 s+ }: q/ T// 类似遍历原数组效果。
" E" S1 G7 E! @% V: Y, L) g3 C1 zfor (int i = 0; i < 10; i++) {
, k& R4 l7 l& C2 w# Z( o *pointer_ary = i; // 修改原数组。0 t3 o( Z7 |) l2 @9 ]1 Z
}
' m5 A3 f  E6 ^1 Y% i
, A2 S2 r' U* A  Z' v函数指针; t: a2 P5 M+ S! }/ S
取得函数地址* K$ J# ?. h3 z# E5 t
函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
6 b1 b% e5 Y* e; A( v! E7 h
- w6 D7 u. M4 b; T( y% Svoid f(int);& f; I+ q2 I$ f) @% N
int main()
: t) j7 ]( I2 F! `$ ]4 |3 Y. l{6 `2 z1 [, ~4 K" R" y6 L$ m! J
void (*p1)(int) = &f;
9 k7 r( _" G- b void (*p2)(int) = f; // same as &f8 u8 b$ [) x3 b  U4 t+ n
return 0;$ Q7 i5 V, s6 E# d! A
}4 H$ U3 T7 j2 i2 p
翻译成汇编代码， p1和p2的赋值是一样的。8 E/ P  Q7 R+ W% H4 B1 K2 z% T

& r+ L# F) D9 n% V' R) `5 T+ V/ b( p# Y' ^* P2 P7 U  N
" `7 R# x# H0 R; `, Z2 d& @! t4 \
函数指针的声明
8 O# q3 X; q1 k% X单个函数指针变量定义步骤9 M; D  o/ o+ v" U
定义一个函数。void fun1(int a, int b); int fun2(double a);1 K) }/ W: x8 C
用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);) G- B1 t7 x6 F# R4 W1 p
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
: l3 y7 O' G7 Otypedef定义函数指针& h+ K1 D  J2 H. G: d' i
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。
' E9 P5 k7 P- k" k9 J7 K! M' u5 a' ]4 r6 _
typedef定义函数指针的语法6 J" ^3 W4 D+ o5 M! ?* R
typedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。
) F3 L# |; w% c! ^% R' ]8 \3 e, A7 r5 O1 B. U- z
typedef int FuncObject(int a, int b); // FuncObject类型是函数对象7 O* C7 b9 Z2 H+ j! A
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
" R4 s6 j6 G% R: D8 UFuncObject* f1 = &Add;/ @6 [) x" j% P
FuncPointer f2;
( r& [# R$ y8 S5 cf2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。+ z* S; q' ^+ q: n
FuncObject f3 = Add; // 报错！函数对象不支持拷贝
/ q1 N9 h' }3 a% E2 E: g  w. PFuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配% x& e9 q. u/ o" f0 q: S
FuncObject& f5 = Add; // 正确
" @+ u+ g7 z- A3 G( ]% sint ret = f5(2, 3); // 正确
. d" j" p; m3 }  Q8 P* wFuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配: O9 s' ^: S2 @$ Y6 q: W
如何记住typedef定义函数指针的步骤. C( z- N. s9 T, q; A" e
像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);
7 b* h# y; w1 N/ I0 K在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);5 I& X5 L, a' j! ^: B2 U* D
完整例子' `9 X+ M: ?5 }- h- M( ~7 H
typedef int(*CalFun)(int a, int b);
% ~9 N' ^3 g! @
9 F/ R& P9 I8 ]. \$ B& T; A; {int Add(int a, int b)
( q- }( C' S7 O, Q7 h{
6 Y: X% ?$ `) ~. V return (a + b);
! e; k( ^# U! A+ c+ L  d}* D* I* V) ]3 }$ w" O4 J
7 C1 w8 {& P; h$ H. j
int Sub(int a, int b)4 @( Q4 O9 O0 h; `1 t
{
" x  f+ g' s1 ~& v- ]5 [, u- R8 A return (a - b);
, D3 X. i+ S9 q) Y) P}
# c8 t9 [% z+ O9 K8 Y+ C! ^; `. h
4 @$ Y* E* G. n5 Z4 ]int main(int argc, char** argv)
5 `( H) Z5 G1 \  T{
9 L) P9 E; v! p2 y3 { CalFun f1 = Add;4 W  c6 D; E" q2 Z
CalFun f2 = Sub;/ t' p) S6 B1 w6 F
int a = f1(2, 3);  G$ u" X- z" {5 D7 L
int b = f2(10, 5);
& s" E" C! {: h# }) T; c) E# w
( g6 W6 a6 H9 u // typedef定义的函数指针数组。
' W0 s  y/ A- O% x  l. Q" h3 T, Z CalFun f_ary[2];
% \" S* N8 i! G/ k& H f_ary[0] = Add;' W5 w' K2 O2 T# u7 m8 B& b
f_ary[1] = Sub;
" G& G, |) i$ s' ~- N: }1 c8 p4 L5 z2 [) P
// 单个定义的函数指针数组。( I! v9 z6 N# V8 {8 W, @
int(*f_ary2[2])(int a, int b);
, K* F  q; l- W/ Q f_ary2[0] = Add;
: u1 i* g' u2 u f_ary2[1] = Sub;
  D* c" a4 z( U# u
1 m. z" m6 m4 \# W4 z return 0;
/ I1 P) v) N* p}
0 p7 t, N/ I2 c- y; s8 N
4 F5 S* A7 b" Q# N  U0 l3 Susing别名定义函数指针9 [/ [6 _$ G2 j, c1 B" ~
c++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
$ I7 p4 |+ a% `1 h! M) x7 E' W* X
- Y1 ~, p. f; g2 p, Ntypedef int FuncObject(int a, int b); // FuncObject类型是函数对象5 C  `: |- u0 w7 u
using FuncObject = int(int a, int b);! G( ^1 Z, G" {# k
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
7 d1 C5 [2 x  d1 Cusing FuncPointer = int(*)(int a, int b);1 X. j. d, C, }5 \
函数指针的调用
4 [* ?1 m& E5 r* I" l! T: q5 K函数指针和函数对象都可以直接后加括号调用
- B5 u7 s& u4 t3 C+ ?) T$ o' G( dint f();+ f( i; u3 U( X$ N& @
int (*p)() = f;  // pointer p is pointing to f* ~- x$ p0 L0 w" \4 b7 }3 r
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
5 {4 c7 c$ G- |' g5 _r();          // function f invoked through lvalue reference
# b: r2 x% ]" a5 G/ S(*p)();       // function f invoked through the function lvalue
) s9 ^2 F8 G% B1 |" [p();          // function f invoked directly through the pointer# _5 p. c) X, I
如果函数有重载，函数指针会指向匹配的那个版本。
0 `2 r6 J3 G5 l& [+ z; Etemplate<typename T>) I# [7 q: C3 u; J6 J( H
T f(T n) { return n; }
$ i1 [$ [9 q$ t, d* Q6 i: p4 z5 |$ W7 g, R
double f(double n) { return n; }
+ b  Q% L( ~( q
: m* C# H' O9 r3 y+ q: mint main()& H- s- `4 \4 y0 p
{
  }5 Y3 I8 O+ T# f. u* E1 { int (*p)(int) = f; // instantiates and selects f<int># n) f$ v2 c& W, v9 v6 ~2 f
}+ j) P+ u8 f4 ?
成员函数指针
5 t, c$ `' ^: D9 f静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。4 j* U( W% x& a6 o
1 v) [% n3 m  L! h7 H( S
成员函数指针定义。2 ~" p/ e" V; p% Y
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);* a2 x, G! _/ \4 Z0 f' y
括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
: T- }# Y. D$ l! t4 [2 v在名称的前面加个*号void (ClassName::*func)(int);6 O4 x5 g0 E, i
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
8 m$ S+ d) _' \: x* ~成员函数指针如何调用。( c; _3 T8 m: }3 _" |& ?6 w8 P1 V
假设成员函数指针名字为func
8 S0 t: t! T4 @! l* k5 K
/ H( }& f5 \1 W' fvoid (ClassName::*func)(int);
0 y2 ~/ H' f. h/ B对象式调用。
; h, ~8 s. r) r- h* U" [ClassName c; // 被调用的对象
1 F* z% m% G. s) c. ?8 U7 q+ j2 ^成员函数指针名字当作正常函数那样写。
+ n! i: |& L4 G, ?c.func(3);! C4 n. C+ y  P2 G7 k
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。1 Z; w& b) ]. J6 s1 A- l& w
c.*func(3);
2 E! t$ J! F6 P最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
( I; k$ t# J" r4 @(c.*func)(3);/ V& O+ B/ @" D6 ?8 {* K( y
为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外
. M6 F' V( d5 y: W0 u. h(c.(*func))(3);* ^% C, v; H- v0 g, ?6 N2 ~
这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。: g8 D" a0 k' {8 v/ c  f
指针式调用
8 h' u1 ~. D, j8 t  QClassName* p; // 被调用的对象的指针
) q' R6 R/ M1 m成员函数指针名字当作正常函数那样写。  j$ I! |: d5 d& B/ i
p->func(3);
! k3 j  T5 R& d; Y9 g2 N* W成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。4 X/ f' |2 U) `% H5 V7 a$ v) f# A
p->*func(3);
$ |$ g0 K: h5 j; A最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
6 ?& ^: s8 J0 Q4 |. D8 X(p->*func)(3);& r* L% b+ B" c
函数指针使用完整例子5 Z9 L' @* E7 z8 ^/ U  B) R
struct Cal
' R9 A) J. ^; S' w0 t- O{
2 f' {9 t3 g/ D- S5 X' K int add(int a, int b); : z7 |- f: e! P. }' Z, S9 u& Z( [
int sub(int a, int b);
0 k! L  }. F9 I3 m, r8 |};# ^: t, P- Z7 L" T0 v9 s
- x* O4 s- D  i) F: P: [7 p
int main()
' o- k- S3 [* L7 y, g5 G: e" p3 j{/ Q) _2 r( E  P
int (Cal::*fun)(int, int) = &Cal::add;: W& ]# N* W( `9 D, v
fun = &Cal::sub;
8 ?+ a2 O: T6 V. o, T& m
$ ^! I0 O8 U; ~  B Cal* p_cal = new Cal();; L% T- q3 ]5 y5 ]+ K8 [, p
int r1 = (p_cal->*fun)(2, 3);4 I2 O8 f# h% z7 H# r( `" J
delete p_cal;
: o+ [' L, c( P& N6 g6 `2 K% i
4 P( p# Y* Q' z& h, _ Cal local_cal;! K3 J1 |5 `3 x& w4 O1 T$ s' V
int r2 = (local_cal.*fun)(8, 6);  `& ]% s) }6 A
}1 c2 P% K. H6 m+ }3 Z* ?( ]- A

! t, l. v2 a# X4 n; N成员变量指针
3 B8 E5 ~8 B% B8 z成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。
8 e5 ]# n5 a% _, k6 @0 ~; Q
; i" P. U, g9 q成员变量指针的定义
' @0 M$ {  E0 h  U- H8 A* X假如以下结构体C。! i, g0 L: Z1 f5 R$ u5 v; G
) k" M( x" Z1 A: N
struct C
7 Z6 B8 b, r* }3 h; u4 z, x, l{
% ~& o3 \  f' F- g int m; / v) A) U7 `1 Q9 W' v2 L0 g  k2 J
};
3 g" P) c6 z3 g7 v: g* A2 i% c, J单个成员变量指针定义 3 d4 T: v, o! t
假设名称为p, 类似静态成员变量定义那样声明! Z' G( U) v  M/ Q5 G* ~4 R5 h$ G
int C::p;
4 W; Q  g" p) g# h) v$ v) a在名称前面加上指针标识号*
1 v+ \& J5 q8 N! w' J1 Hint C::*p;& P0 O  A) q0 Y2 P
typedef或using方式定义
. p5 D2 f: W. S5 \7 d6 R! Otypedef int C::*MemberPointer;
0 v. {; l4 Z8 a4 H5 q. yusing MemberPointer = int C::*;" I7 @4 a6 h" i
成员变量指针的使用。
/ _9 k8 {9 h, _% D2 y类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。& Q; d% S, C) R
成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。
2 V" p) R1 w- I7 @0 K% H* S6 ~; h: x- E
完整例子
( o- G" c6 V( M8 Gstruct C { int m; };
5 v$ ]4 x8 u# s  r5 F) Fint main()
  y/ U) N$ f7 z* I( C- T& m% j{# F  n  l' k/ N( a
int C::* p = &C::m;       // pointer to data member m of class C
$ j, G' l$ ~- d. ^+ X3 V& Y C c = {7};
, u: V* P5 s; f( q9 @! W1 _  r9 t std::cout << c.*p << '\n'; // prints 7  L( i8 M: m5 Y; Y+ k* o+ U) x
C* cp = &c;& Z, A( w9 n; O' G+ a$ J
cp->m = 10;
8 l; |( n5 d: }3 f# |# U std::cout << cp->*p << '\n'; // prints 10" W# v- T, p* c3 ?
& G* v0 o& q# n7 [* m& G
————————————————- S  h; ?6 v$ |0 B2 W9 \6 r' Q# d
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。+ U2 F. i1 L# ]: z. v) W
原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115' U: A: K: z8 h8 V' w) x- T  v

2 F& f8 y: ~1 `1 J$ `/ h

欢迎光临数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5