数学建模社区-数学中国

标题: 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)取得数组对象
// 再通过下标操作访问元素。6 B8 d9 K( l7 S5 M* [( M) D
(*p_ary) = i;
8 k  F, m& u1 r$ u. G8 x7 y}
, f2 ]! [8 x" T$ j, `7 X
8 X: G% S( l; K5 nint b[10];1 o3 t  P5 w7 d/ R
int c[20];
1 L% ^8 I8 m& U; q! l# Ip_ary = &b; // 合法, T. q. w5 C6 e6 _# O/ ?6 C" l8 o
p_ary = &c; // 报错！不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体; Y1 R  ]6 h$ }% Z
数组指针指向多维数组的子数组- U# ~8 j: M: `: i8 L/ b/ S. f4 |
int a[10];
, j, {6 r% U, C0 Vint b[4][10];& V  P' t* H. ]% C/ s
int(*p_ary)[10] = &a;0 P- s! P# A, q
for (int i = 0; i < 10; i++) {
" k5 `  R9 K5 E* ]6 c. J (*p_ary) = 1;
% |, L8 @  s+ a" B9 M  i}0 m% Z) X5 w- ^/ M( a
. G3 A: e0 a9 H* O- ^
p_ary = &b[2]; // 多维数组，可以看作数组的数组，; ~1 u+ S& k; }# A/ S- Q; Q% M
// b[2][0] ~ b[2][9]的值都被改成2了0 P. X) J; _- i: k& O
for (int i = 0; i < 10; i++) {8 _1 ?5 O, c* m3 k
(*p_ary) = 2;$ s' |& }% f( T8 o% h9 k: c4 f
}
1 W0 y4 h6 T8 A5 W; Z多维数组指针
8 z& Y# r& t: G2 J  {多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。+ ]/ J/ `+ K0 c  \
4 E/ Q, ]$ c% I8 Y" L5 c# Y( T
int a[2][5][10];
/ j% ^: E: {+ {* W2 qint(*p_ary1)[10] = &a[1][2]; // 1维数组指针
' n* p% I! N/ |# `+ c" K. C" Fint(*p_ary2)[5][10] = &a[1]; // 2维数组指针7 @& Q3 ^5 r( n$ u, h9 j
for (int row = 0; row < 5; row++) {
, u/ r  v# k0 a8 P; I for (int col = 0; col < 10; col++) {
- b# [/ \" W$ ^- m8 ^  o, D       (*p_ary2)[row][col] = row * col;
: J, c9 j' u5 m/ @( D8 A8 { }
" I# B5 K/ ~& t( J* a$ S( N$ a  c}  O% O4 T. Z  j: A/ M3 R$ W
数组指针和指针数组对比实例
5 L$ ]& K% S0 w9 T. F3 r' r3 G数组指针还是记住两步法即可, l& t/ w9 m8 ~0 H
- W; I4 K) Y/ B7 U0 L
定义一个数组, H5 z1 M' f' m5 i# z6 m2 d$ |
括号包围1中定义的名称，再在名称前加个*号。
4 g+ T( W; G8 t( N) z" Hint a[10];
$ \( l6 q4 q3 t/ Yint(*ary_pointer1)[10] = &a; // 数组指针1 f, l( f! [) h7 `: w* Z+ m8 ~; @1 }8 \
int* pointer_ary1[10]; // 指针数组。元素类型是int*& A# [* f' m' y7 x$ E- M9 P; e
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
0 W$ P0 \! T  j6 i" wint (*ponter_ary3[10]); // 指针数组。另外一种定义方式。  `- ^) K* p. {; G  s9 f
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。+ r8 l9 T, |& D

2 y# j+ t' s6 i$ X/ u! i$ b% I// 指针数组可以把每个元素指向数组对应位置的地址。2 H5 U  \7 l/ b8 e. Y/ i
// 这样遍历指针数组，可以达到遍历数组元素的效果，但是注意每个元素都是指针，
) `/ |  Q5 V% m5 W" w$ G  c# @// 需要访问原数组的值的话，需要对指针用*间接寻址运算符。
. H1 T" S) f4 n) N; L1 U- y. Xint* pointer_ary[10];   D; N, n! x% d1 Q% }$ |$ ]
for (int i = 0; i < 10; i++) {
2 [1 G/ O" t  s% U pointer_ary = &a;; s% s6 V8 E. _. q4 H6 p& L
}3 l4 u9 p1 V* T' e) L
// 类似遍历原数组效果。% @6 a& p0 P5 w9 t% x; u
for (int i = 0; i < 10; i++) {
3 h8 r( U- t" s' o1 J& k *pointer_ary = i; // 修改原数组。+ N% B9 f" m: ^  n
}
- ^* K" y( x5 G* m+ Z+ b
5 ~" E1 w* w3 K7 S- T9 r! P1 n) S3 h函数指针
- q  [7 q. u$ Y5 ?7 {/ q取得函数地址
) ^0 V7 B+ G  W9 E$ C函数的名称作为参数被传递时，会隐式转换成函数指针，和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
6 ?" m% L: W# y: M8 y2 i6 o( d5 i. @- [1 V% C6 a0 S
void f(int);  l, M' {& G9 t* |0 R3 Q5 g. P: g1 o
int main()1 p( b" F8 L: _1 A
{
8 z% n4 `/ I; G; L( H void (*p1)(int) = &f;
- k- n( x. E( r* ~/ |  K void (*p2)(int) = f; // same as &f
; b( w5 t5 g  A2 s return 0;
! `7 h5 |9 ^6 T4 Y/ v}9 j; ^. _; }" b9 o( ?
翻译成汇编代码， p1和p2的赋值是一样的。4 e" r, E! ?) p) {9 ~( j: M

! @+ U+ o3 l+ _5 \! t& F' {
4 _8 w2 h3 u5 W. D
2 T% d3 [, ^4 B5 v* o# \) f. y函数指针的声明1 [1 n6 R6 M% s
单个函数指针变量定义步骤: A$ u2 m9 g/ n' @3 O" z4 @/ h
定义一个函数。void fun1(int a, int b); int fun2(double a);
* O) Z, L/ c, s6 t, ^. P用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);/ q8 [+ K* m" E0 P2 I' [
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);2 L" A0 i" b/ c
typedef定义函数指针" o2 Z/ `; L4 E2 c$ `$ J
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。$ s* i+ C3 b( a& T$ s2 A' v3 Q. b8 k3 X) l

) I% N/ ^  o/ j$ J. x" k/ Wtypedef定义函数指针的语法% Q8 c2 l* y/ p- p' w. e6 @
typedef有两种做法，一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值，但是支持引用。/ |$ C# _9 {8 ~/ g# f! y' Z

' Y0 ^+ @# n" W! x: p6 u( gtypedef int FuncObject(int a, int b); // FuncObject类型是函数对象
! E" t2 o( l# R) ltypedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
( k' _2 N2 D& y. b1 i6 IFuncObject* f1 = &Add;
0 e- y0 x: V/ O" `! O3 r. ]FuncPointer f2;$ _( z: |3 i8 r4 Y9 N  u* S: P4 ]
f2 = f1; // f1, f2类型一样，都是形式为int(int, int)的函数的指针。+ I% s9 W* q+ S, R
FuncObject f3 = Add; // 报错！函数对象不支持拷贝. W% t2 I" [. w$ Q6 r
FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
. Q  {9 y) \, KFuncObject& f5 = Add; // 正确) l8 Q$ w/ t8 B4 L
int ret = f5(2, 3); // 正确
- J+ ~" s1 }6 z* mFuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
" o) b( X+ t& ^6 {1 |如何记住typedef定义函数指针的步骤
0 m. i! U0 q2 i$ A3 R' `6 ?. q像定义一个函数指针那样，指定一个名称。int (*CalFun)(int a, int b);7 j( ]$ ~- J0 N1 @+ e! O
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);7 e  ^0 U- i/ M! a
完整例子
7 g; J+ j: i$ L+ Mtypedef int(*CalFun)(int a, int b);
7 k7 j6 `$ ?3 W; B) y- v' \% d
. c& R+ ^) q7 K- O7 _int Add(int a, int b)
7 B9 i7 W  |# i{7 E' s  R) }' T! Z5 v
return (a + b);
}
* ^8 c" `8 X4 c3 y
' b7 V, Y+ L/ F, Tint Sub(int a, int b)# z& S7 |4 q  E3 {1 A9 j* R
{
# o5 d) W9 u# Z) Y1 M7 x return (a - b);  M  _, ?" W8 B& {1 @' f' {" V/ z  M
}
7 [% n  e  ~: M$ r& s. Z4 F( F2 [6 F3 O* \, S, @# w. ^
int main(int argc, char** argv)
$ \: t6 S$ R9 z6 f3 t; B{9 R6 C2 y9 z7 B# y$ c1 }! j
CalFun f1 = Add;
1 [- J3 ]( L7 p3 t  J$ } CalFun f2 = Sub;
) s1 i  }* O6 T int a = f1(2, 3);
0 f3 `+ S' E* q% w+ }+ }: | int b = f2(10, 5);! J" U% S" g8 ?4 ?

2 _# P/ x* r7 T  `8 m // typedef定义的函数指针数组。4 J9 Q$ O% i# ]5 h+ h$ G$ j, |
CalFun f_ary[2];
, a! j' $ a& m( F$ E: i2 B f_ary[0] = Add;  @% n8 e! t1 a1 y0 d3 |: \
f_ary[1] = Sub;
" z! J3 |3 ?) V& {1 K: _
* R# B* }0 f% x* v9 f! B // 单个定义的函数指针数组。
) l# i9 g3 C) p int(*f_ary2[2])(int a, int b);
+ ^6 X, M: U% ~3 W4 m- g f_ary2[0] = Add;
1 G7 J% W0 s/ x6 k9 ~3 O f_ary2[1] = Sub;
; d, G- O) v4 w$ o: U# F: p# K+ R0 g) $ W  P1 _3 u
return 0;
% I, j9 O% m1 |% R4 |# s  U}
7 M* o7 r) U3 `8 N2 E5 f1 G8 a9 D* N* L! m$ }
using别名定义函数指针) p- y, _; S) y& s# X( i
c++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。
1 O! H; p7 `6 m7 q' W# C6 Q' p- g
- c) @" R" L5 Y6 r! `" utypedef int FuncObject(int a, int b); // FuncObject类型是函数对象
0 Y8 \7 K& `' b' Gusing FuncObject = int(int a, int b);+ Y0 o( t5 J3 O4 \
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针# x. z# j9 Z/ d" S) A
using FuncPointer = int(*)(int a, int b);# t9 R9 r, ^% \/ l' H) n# @
函数指针的调用$ J2 d5 O5 ^  T8 ^* a
函数指针和函数对象都可以直接后加括号调用9 K$ @! q( D0 ]& L$ N$ F
int f();/ I+ O7 E0 t! r# E% W0 g1 h; i- l, y
int (*p)() = f;  // pointer p is pointing to f
7 m7 M. Y4 L2 e9 [int (&r)() = *p; // the lvalue that identifies f is bound to a reference
0 A) N/ |, `7 A0 U6 C" w0 Fr();          // function f invoked through lvalue reference6 D& l$ o* d1 s8 H$ S) Q' w* x) E* U
(*p)();       // function f invoked through the function lvalue
- Q0 N; L( O6 x; ?1 z  i" Rp();          // function f invoked directly through the pointer
1 V- t" V* X9 l/ p7 r: t如果函数有重载，函数指针会指向匹配的那个版本。
+ U1 [, e' r0 V  k: |. u6 J/ f9 ytemplate<typename T>* J( N9 a4 }" Q7 q' o, g, @  K8 E
T f(T n) { return n; }/ _" G% `3 x+ d$ i
: ]8 d9 W5 K7 m) M9 L
double f(double n) { return n; }
3 g0 P- [* L6 b! Q$ L
" Y4 ~- G$ A+ g3 b- jint main()' w8 C- C$ X2 C. j' o! I
{4 |$ `; e" l3 g3 ]+ q: R) A: r! V
int (*p)(int) = f; // instantiates and selects f<int>
# y4 R! }1 P6 a3 B  d8 j}3 }7 Y8 H7 Y0 K( W4 P7 ^
成员函数指针
, R. V: T' ^8 M9 b% b1 B5 O" d) R静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。
! B$ `1 T5 i# ^0 k( R0 u
: `& T4 ]) ?' q& g( S, |9 @8 ]成员函数指针定义。
: t( a: [* t3 L  K0 r% h2 y像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
; @) \) B0 r) u! w2 V括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
0 h; @' M+ N# {5 u在名称的前面加个*号void (ClassName::*func)(int);
; z7 n# n# z6 T7 O9 ]( v9 i7 D! V  o成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
, b  P5 m1 V$ I  D) G2 w6 B/ v成员函数指针如何调用。9 `$ q& F% a8 E0 }1 y
假设成员函数指针名字为func
1 ~, ^  H0 R4 a0 I1 Z6 P. O# e8 C* Z3 ^9 k- V5 K1 T$ {4 E. I1 F
void (ClassName::*func)(int);
+ T7 w/ @% N$ y% \5 I+ P8 y  s对象式调用。( O' ?% S; C. u8 A, ?7 D2 i
ClassName c; // 被调用的对象5 D, P! M1 `& j0 V5 y5 |6 q. Z
成员函数指针名字当作正常函数那样写。
, k( L; r! M9 mc.func(3);
: i4 t- I2 n6 c; |* k! U+ _  ?成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
: q5 u; `& }$ [9 n3 q# [c.*func(3);
5 B' W5 a0 n: C' b' n, M) l最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。( ~/ Z+ l1 \' {8 R( _
(c.*func)(3);
7 z* l6 B& X+ S6 n为何要加上括号？根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低，成员函数指针还没取得对象就被调用了，自然报错。另外
9 e0 |7 h. l5 u% L& L; o(c.(*func))(3);
, ?$ x# m- g: m! k- Z: `1 k" b7 T$ J这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。! `# k% n6 U* S& G
指针式调用; M- \, S* l+ \: @& g9 o  Y
ClassName* p; // 被调用的对象的指针" _" b. m( b& W' A
成员函数指针名字当作正常函数那样写。
! o4 N( d7 w0 s7 F8 _( A% Zp->func(3);
7 r3 P$ U* r% w8 r9 j成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。; M: y0 \9 i0 E. p+ w1 T; `. q) b, N
p->*func(3);
" \. B* e/ x% K7 \# j8 l最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。; b0 ~/ m' J/ ]. ?* ~% e* k
(p->*func)(3);: m: z/ L9 n# D
函数指针使用完整例子
- r+ P, i. d! tstruct Cal 8 ^$ j7 Q0 T8 Y) s
{
+ R. R  n6 }4 O9 V int add(int a, int b); 0 q7 g- }/ X( P- }" H1 W8 a
int sub(int a, int b);
8 a- {9 m. m. L  ]0 P};
! i5 F5 _! H+ w* Z  H( b, d
4 G, H2 v, M8 v$ mint main()
% e0 n" u; P& k+ r) C4 U7 V1 @{
9 Y9 T+ P% i% x0 x int (Cal::*fun)(int, int) = &Cal::add;0 s5 d( n% r! |2 W9 d
fun = &Cal::sub;, ~+ X' H  }! @: p/ c0 y$ F$ [
2 |* a& ~2 T2 _# @
Cal* p_cal = new Cal();  `2 n1 q& O7 x! S' O4 o
int r1 = (p_cal->*fun)(2, 3);
" N' \. m* Y. X9 k+ a% k' f0 | delete p_cal;
! b" Y* |/ H) v, k3 Z! c& T: T# f' `; d  [
Cal local_cal;
2 Z) x: y+ V7 _1 j6 e. W+ j int r2 = (local_cal.*fun)(8, 6);" t9 M4 z3 `2 X! z8 M
}
+ k+ W- g# _) ~/ [7 u8 `+ M4 v3 n" |0 P2 I3 O
成员变量指针
9 Y+ Y* m6 k$ o( `成员变量指针比成员函数指针还要简单些，没有函数调用，无需考虑函数调用和间接引用符*的优先级问题。
# k! G5 ~% W% L1 G4 L! `  T$ }  A2 `
成员变量指针的定义3 ^& N2 |7 W( V; v) V. k
假如以下结构体C。9 y5 a( e: p( g: l9 l- T

' g# q5 I8 f6 o2 Zstruct C
, d8 S+ u1 R. O; h' d4 w8 u8 a{ / T( K. q7 _" h2 x; ]/ T
int m;
* l8 \* N! F6 W9 i. M};2 m, l2 N$ F' Y- q7 F- N/ T5 C
单个成员变量指针定义
5 J# k0 M+ B" W' P2 Y假设名称为p, 类似静态成员变量定义那样声明$ R7 m: D0 h4 e. v$ R
int C::p;0 v) }* o! m; I9 O/ E
在名称前面加上指针标识号* # y* M4 ?2 g0 M5 @0 c* l9 I3 E
int C::*p;
; j/ C- r3 c+ m1 d4 A  U' T- K5 ?% stypedef或using方式定义9 G$ m( l3 f# B7 x7 U- H" O
typedef int C::*MemberPointer;3 p2 w, n$ T7 J$ D4 {8 ?
using MemberPointer = int C::*;
1 l' R; d/ s  h  D: z+ d成员变量指针的使用。6 H$ r5 J2 r) Z* [9 {4 A! a; a6 [: T
类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
8 I) T2 U% t& U; H7 x& K1 M  T& e成员变量指针，能让我们实现一些遍历成员的动态功能。例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。
% ?* R8 j& y; i1 ?" k! e: a) u! a
% Q' C  _. [  K, ?; z. U 完整例子
5 {: }- U! t- `& w7 o8 Mstruct C { int m; };: W5 [2 R& c* R
int main()
% r% y! w& f6 {5 l5 E{' L: v: J4 q7 r( X" e. r3 h: q' {
int C::* p = &C::m;       // pointer to data member m of class C. l# G/ L! S- M: U& k4 t9 W
C c = {7};
) c; p% [/ x" C5 V% J4 O1 s% ]0 t std::cout << c.*p << '\n'; // prints 7
1 a0 _  Y1 O! ^! ]! Z6 k C* cp = &c;
- H+ _- ~/ {6 i cp->m = 10;
1 {( S4 D5 x- | std::cout << cp->*p << '\n'; // prints 10
4 B9 Y) x' a- B: q6 S1 ^
9 Q  [' A( u/ b8 x: Q7 q————————————————1 Q  {8 _" u; m7 r! W
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。1 P, ^4 W4 J+ W# u) a0 C
原文链接：https://blog.csdn.net/m0_64407685/article/details/1267881150 I5 e" \5 t0 b, c! a( C
6 q9 r, b. f6 I2 [3 i. S
' J# m4 {' q! d, ]  \' D7 |

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