数学建模社区-数学中国

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

---

作者: 杨利霞    时间: 2022-9-12 18:49
标题: C++数组指针、函数指针、成员函数指针
C++数组指针、函数指针、成员函数指针
C++数组指针、函数指针、成员函数指针

% c+ L3 h4 a& S5 M2 t/ n
操作符名称
+ E" C/ _# n# y" E0 M) p# C& 取地址符(Address-Of operator)
* 间接寻址运算符(Indirection operator)
  G- w, B" \- Z1 x+ c.和-> 成员访问运算符(Member-Access operators)，用于取对象的成员。
.*和->* 指向成员的指针运算符(Pointer-To-Member operators), 用于成员函数指针和成员变量指针的取对象。
() 函数调用运算符(Function-Call operator)
:: 范围解析运算符(Scope-Resolution operator)
- Y/ i, A) L4 L3 {: g, w如何定义一个指针变量
) h. p+ W& j  a  G假设类型T， 变量名称name, 指针的定义如下:

T* name;
, z5 K' `3 y# b5 n4 t( G1 L  b标识变量名字name, 它是T类型的指针。例如

/ r7 V# t+ c; T) ~/ b+ E1 q$ Fint n = 0;
* T/ b$ B; B7 v3 b4 c# g- n  ]+ fint* p_n = &n;
% o3 }( M$ k' e) cp_n是int指针类型， 指向某个int型的对象。

指针变量的修饰
7 M4 l& h; q0 G7 x. e指针实际上也是一种变量类型， 只是它保存的内容有些特别， 是指定类型的地址值，通过间接寻址运算符(indirection operator)*, 可以访问到指针指向地址上的指定类型。

! \1 h, @& a$ Q! r& j指针也可以用const, volatile修饰。 const int或int const均表示一个变量类型是int， 且该变量不能修改。以下两种写法都可以:
8 z9 X/ y$ H" D7 M2 [
const int a = 1;
0 W9 l/ J$ a  Dint const b = 2;
既然指针是也一种变量类型，同样支持被const修饰， 表示指针的值/指针的指向不允许修改， 指针所指向的那个变量是否允许修改， 那是另外修饰。写法如下:

; w! j9 l% t( }& v0 j2 G3 E# G' Hint a = 1;
int b = 2;
( `/ G+ P2 l4 ^. {/ c1 g. ^int* const cp_a = &a; // 指针的修饰词，放在*号后面。
*cp_a = 10; // 指针指向的值可以修改
cp_a = &b; // 指针不能被修改，报错！
总结带修饰的指针的格式:
只要记住修饰词总是放在被修饰的内容后面。
2 u8 @5 ?- H+ p; |9 W/ X
cv表示const / volatile修饰词。指针定义形式如下:

7 h; U4 J. g- y! `9 y3 Z- h' {7 g9 o( BT [cv for T] * [cv for pointer] name
, s9 h- G2 V8 G* Q/ e0 N8 ?+ q注意对T的修饰放在T的前面也是合法的写法。
. t7 m' J0 G/ |5 G; p4 e0 y
const int const c = 2;
在mscv编译器下也不会报错。

! ~$ ^7 E' t0 i" b2 t完整的格式:
[cv for T] T [cv for T] * [cv for pointer] name
; \1 x6 c5 z: n/ a3 E! O
) w' y) W$ H2 k  M8 B8 l& x" e4 SSyntax        meaning
7 U3 o. M6 g' W, f# Uconst T*       
pointer to constant object
. m: o* J5 D% B4 F! R* M
T const*        pointer to constant object
T* const        constant pointer to object
7 r) E6 ?. e: v1 E% sconst T* const        constant pointer to constant object
5 Z3 Z) n% f7 i8 QT const* const        constant pointer to constant object
上面格式中T还可以是一种指针， 指针的指针仍然是按照修饰词总是修饰前面的标识(T或者*)来确定修饰的意图。

int a = 1;
int b = 2;

int* p_a = &a;
*p_a = 10; // 合法
5 O  e+ }1 b' K" j* B0 J+ Y7 Hp_a = &b; //合法
- ?8 ?. c2 a* I: o% p/ ]6 D
const int* cp_a = &a; // const修饰int类型， 并非修饰指针
7 A2 o( b, W: H7 k2 {* W*cp_a = 11; //报错! const int类型不能修改
( |% w+ Y9 h. z# D0 G+ jcp_a = &b; // 合法， 指针没有const修饰，指针可以修改。

2 V; N3 `) o. qint* const pc_a = &a; // const修饰指针。类型没有const修饰
+ x3 K5 R- _. a2 T, x8 o*pc_a = 12; // 合法， 因为类型没有const修饰，可以修改。
5 X  ~9 f: r3 t5 r" \pc_a = &b; //报错！ 指针被const修饰， 不能修改指针。
0 a7 c1 b9 R$ y+ c& d9 u  C
int const* const cpc_a = &a; // int类型被它后面的const修饰， 指针符号*后面也有const修饰
/ G' \/ G- I/ x/ m*cpc_a = 13; // 报错！ 类型被const修饰，不能修改。
7 Y3 `  j* W5 ^0 Icpc_a = &b; // 报错！ 指针被const修饰，不能修改。
, e" L$ V. a2 M# D4 s+ n
8 l1 m; X: K5 W2 X: P! p  w1 t 更复杂的指针的指针
$ f' }  N3 O4 ?6 i/ n! \
int a = 1;
! _/ E( C, @4 ]" s' D! w8 |: iint b = 2;
int* p1 = &a;
) g0 J8 X  ^# o. a2 t; Wint* p2 = &b;
const int* ct_p1 = &a; // ct for const type
5 v# e' a. l. y3 e9 ?) E6 `' Rconst int* ct_p2 = &b; // ct for const type

// int * * pp1; 指向(int*)类型的指针
4 m" i% l0 h- F; t2 B  ^; |8 Mint** pp1 = &p1;  
4 q. l2 ?7 M3 n5 Z: Jpp1 = &p2; // 合法,
pp1 = &ct_p1; // 报错! 类型不匹配。 (int*)不能指向(const int*)
; H1 {' S) G0 q. V% _- L
! v8 b8 U8 d, a1 m3 ]7 Y- d: u/ k// (const int) * * pp1; 指向((const int) *)类型的指针
, G3 H& a1 q+ C- `# Wconst int** ct_pp1 = &ct_p1;  
ct_pp1 = &ct_p2; // 合法
ct_pp1 = &p1; // 合法！(const int*) 可以指向(int*)类型。

// (const int) (*const)
2 A. C: W: `/ S, }# Wconst int * const ct_cp1 = &a; // 指针也不能修改
const int * const ct_cp2 = &b; // 指针也不能修改
ct_cp1 = &b; // 报错！指针有const修饰
1 y+ ?3 ^- i) r8 I0 r
4 I/ c/ m# T3 q! {// (const int) (* const) *  指向((const int) (*const))的指针
) z0 B/ P8 P$ X' R% Dconst int* const * ct_cp_p1 = &ct_p1;  
ct_cp_p1 = &ct_cp2; // 合法， 指针的指针并没有const修饰， 指向的指针有const修饰
7 @$ ^& ~% q- r*ct_cp_p1 = &a; // 报错！等价于操作ct_cp2,  指向的指针是带const修饰的不能修改

// (const int) (* const) (*const)  
// 指向((const int) (*const))的指针,且该指针被const修饰
- p# _0 \6 e3 R# G: Qconst int* const * const ct_cp_cp1 = &ct_cp1;
ct_cp_cp1 = &ct_cp2; // 报错！ 指针的指针被const修饰， 不能修改指针指向。
" R+ }( j  b( B
& [2 E* P& v0 U/ S# D3 T0 k7 M4 ]一行声明多个变量
类型 + 名称定义一个变量。
变量的前面可以加*号修饰， 表示指针， 一个星号代表一层间接。**表示指针的指针。
7 w! D5 g$ \! Z+ I. P' E& a
& [# {* {# ]& H! u' L. V# |9 [int a, *b, *c, d, **e;
a = 0;
& z3 S- P/ V6 ?) gd = 1;
/ n! _5 L) }9 o8 d: ib = &a;
& X" d: Z0 Y- \& ]c = &d;
5 w* }! Z" ~. {9 h- t! E7 ?e = &b; // e为int**类型 指针的指针
e = &c; // e为int**类型 指针的指针
( c$ e3 c( A, R  E也可以用括号包围变量和*号。

int (a), (*b), (*c), (d), (**e); // 合法定义。
2 u6 E; ]& y2 L8 p: j; \括号可以省略，某些情况， 个人感觉加上括号更清晰一些。例如

int (a), (const *b), (*const c) = &a, (const d), (const* const* const e) = &c;
写成
1 k0 b2 T, d$ Z5 p4 m
4 N% r/ u" L1 E4 w( Hint a, const *b, *const c = &a, const d, const* const* const e = &c;
1 v% @3 e! S# r+ T( n更重要的是， 后面我们表达数组指针，以及函数指针时，括号是不可缺少的， 带括号的表达更加统一。
8 z4 l! u, e/ F2 E0 o* @2 l
数组指针
数组基本表达
int a[10];  // 定义了类型是int, 元素个数是10的一个数组。
由于c++要支持一行定义一个类型的多个变量。 所以数组的[]时放在名称后面的。虽然我觉得

* s& b- ]) G6 U  H& q( Qint[10] a;
这样的写法更符合类型 名称的思维， 但是如果类型都这么写的话， 没法兼容以下的写法:

int a = 0, *b = nullptr, c[20], **d = nullptr;
c++标准规定如此，但我们可以通过每一行只定义一个变量的写法， 类型会更加清晰。
1 J6 B8 c! h) x; M
int a = 0;
int* b = nullptr; // 指针int*
int c[20];
int** d = nullptr; // 指针的指针int**
数组的名称是什么类型
* c6 Q% A* n* b+ i数组元素类型的指针，可以直接指向数组。 并且数组跟指针一样，可以通过下标去访问元素。

8 D5 ?/ `5 a! e7 c  bint a[10];
% X3 h: d: o# o) L" _int* p = a; // 指向a数组的第一个元素
8 i: O, \8 z& Y' p  W! Q1 O4 \a[1] = 1;
: g( o: [1 Z7 M) r0 Np[1] = 1; // 效果与a[1] = 1一样。
: I8 d# J+ @7 r# V; o数组可以当作T* const来使用， 但是又与T* const有些不同。sizeof()的结果不一样。

int a[10];
int b[10];
int* const p_a = a;
; Y2 Y% x. G' P) s: ta[0] = 1; // 合法。 数组的元素可以修改。
p_a[0] = 1; // 效果与a[0] = 1一样。

1 h/ Z% l! Q) Ha = b; // 报错！ 数组本身的指向不能修改。
3 B  Z5 P4 Z8 i2 x' F7 {
// 所以数组a可以当作int* const来使用
& M7 G2 _% C+ d$ `& D! U: _int *const& ref1 = a; //正确。
% R; b7 Y4 F4 U9 ~int *& ref2 = a; // 报错!
. _8 i& e% I1 g, H! `
// 但是又跟int* const有些区别。
assert(sizeof(p_a) == 4); // 32bit程序。
2 B: t. R0 W" d% ], ^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()才有获取数组占用空间大小的效果。
& E6 F0 K2 z& N, c; [6 Z, l/ j0 x
以下3个函数翻译成汇编以后，汇编代码是一样的。

void Func1(int* p_ary)
* b/ t7 U! L) Z5 X2 I4 @& H{
/ k5 G4 `0 ^& S3 g0 [    assert(sizeof(p_ary) == 4); // 32-bit
    p_ary[1] = 1;
2 g7 y' q; d% B1 `$ x9 `3 _8 o; l}

void Func2(int ary[])
4 ]6 |# r) y0 H% x5 R9 z{
    assert(sizeof(ary) == 4); // 32-bit
$ @6 K; _3 o4 Y4 d  r/ X    ary[1] = 1;
5 {3 w8 F# H8 U* Y( Q}

void Func3(int ary[10])
6 s4 j- e! t1 f# n0 @{
    assert(sizeof(ary) == 4); // 32-bit
    ary[1] = 1;
}
' b, h: I9 I! h3 I& ?' I; Y) L
int main(int argc, char** argv)
{
    int a[10];
    int b[20];
" J. U& O3 p' u    Func1(a);
3 U0 o  v& b) X4 S% B    Func2(a);
* C  p! W  @2 N% r4 b2 ]    Func3(a);
0 y4 ~+ O1 b  b    Func3(b); // 退化成int* const了， 即使数组长度不匹配也不会报错。
    return 0;
; d1 n; k9 N  O- N  W$ p+ f# Q}

0 E% ]2 S5 L. V  O& s
) i% t8 _$ _7 r) g. l* y& N
多维数组
一个3行，4列的数组， 结构如下:
3 h" n( n( B( \( |
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]
1 c0 d! r. }7 [% Arow 1        a[1][0]        a[1][1]        a[1][2]        a[1][3]
6 E% H+ ~  X  n- z' Urow 2        a[2][0]        a[2][1]        a[2][2]        a[2][3]
" [& f8 i) o: A& {  H- x; d3 ~数组初始化

! j  o# S: l4 l) l7 Mint a[3][4] = {
1 e2 R$ b" _& b6 N8 }    {0, 1, 2, 3},
    {4, 5, 6, 7},
! k# S4 z( i' w* k; C% u. i    {8, 9, 10, 11}
};
实际上多维数组和1维数组在开启速度优化后，翻译成汇编代码是一样的。
/ v3 Y# q# ]7 @* W0 j6 u
6 h% J/ j4 `4 j. xvoid Print(int* p_ary);
1 p' \# n/ i* V! G8 H
  v, j& u8 S/ zvoid Test1()
4 |6 w& a4 P8 h! J{
    int a[10];
& }2 b* i+ F; @" l9 E% M) t8 n    a[3] = 3;
    a[7] = 7;
5 G, \: N, X3 F    Print(&a[0]);
}
" A( E* a, d) D9 A
- v% z5 m2 `# v+ b$ f) jvoid Test2()
{
7 b% |9 m, m$ m" q; z2 }: Z    int a[2][5];
    a[0][3] = 3;
( I# K( k6 G* V. z2 b' w/ }    a[1][2] = 7;
9 [: Y! t' @$ N    Print(&a[0][0]);
9 B  H" W4 a! O}
+ U2 l8 _$ F4 v4 V: k# r* ~8 d* }, L6 N

4 S( t% J3 A& b- i
很自然地，多维数组也支持用1维数组的方式去初始化。

$ q0 w9 i0 x) eint a[3][4] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
既然多维数组与1维数组没什么区别， 为什么还需要多维数组？

4 y& l" E& l) ?& M2 ~- f; S, E0 g假设有一幅RGB图像720*576个像素，每个像素有RGB三个通道，每个通道的值是8bit大小。给出图像的首地址p_rgb_image， 我们要取第40行，第50个像素的R,G,B值。代码如下:

& e* M! \! X1 y2 f. a( _$ cunsigned char* p_rgb_image;
unsigned char r = p_rgb_image[40*720*3 + 50 + 0];
6 b2 l3 ?1 A6 T: ~0 p7 P! n) W3 u4 Lunsigned char g = p_rgb_image[40*720*3 + 50 + 1];
7 F9 F* t- o( u5 gunsigned char b = p_rgb_image[40*720*3 + 50 + 2];
% ^/ L5 ~' A2 Z  u7 I1 m类似这样的场景， 采用多维数组的写法， 有点类似以索引为参数，可读性更高。相当于程序员和编译器打了一个配合。
) u) t3 I2 D: |6 t; J
' S7 q& q/ U* D3 d$ s6 |' J6 Jenum
. f: W. b9 c: o. F{
Red = 0,
Green = 1,
Blue = 2
};
7 O, x2 ~7 W6 G) dunsigned char rgb_image[576][720][3];
" @/ Z" Y! Q2 k" i) j7 k/ u) mint row = 40;
: ~- F+ \; Z- n: M3 wint col = 50;
unsigned char r = rgb_image[row][col][Red];
7 s- V! m" q& c1 uunsigned char g = rgb_image[row][col][Green];
. r2 A8 N) |9 J8 [7 Munsigned char b = rgb_image[row][col][Blue];
数组指针以及与指针数组的区别
5 S% J- f8 [2 K9 F4 L9 @数组指针，是一个指针， 指向的对象是数组。 数组指针的赋值，要求数组的长度匹配，否则会报错。当指向1维数组时， 需用用*取得数组对象的引用，再用下标来访问数组元素。
) q; x8 [5 ~, w: \2 ?指针数组，是一个数组， 数组保存的元素的类型是指针。
: y2 S# t+ p. Z7 g( _数组指针的定义
+ Y6 s, [/ n- g4 w数组指针定义先定义一个数组。
int a[10];
然后对数组里的名称用括号括起来后再在变量名称前面加个*号
int (*a)[10];
后面你会发现函数指针定义类似。
2 P2 u9 v9 H! G; O3 G2 h) |// 各类定义对比
, t) l7 d6 R9 o' d: z5 Uint a, *b, **c, d[10], e[10][20], *f[10], (*g)[10], *(*h)[10];
% j$ N& J/ O+ S& a$ h% X  Q
% L5 H( w% h) B8 n) V+ G8 qint *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];
% v7 C8 M) B2 m$ C4 R% ^7 u! \g = &d;
6 K1 {; o* k1 g0 \
( D% B/ G7 ~% I+ h, f- ~; X  Fint* e[10];
h = &e;
- h% [8 X5 [% ]: g6 h$ ^数组指针的使用
数组指针一般先通过*号取得指针指向的数组对象， 然后再用下标操作访问元素。
$ h* Q  `" M8 J$ |+ q) x4 `0 p
int a[10];
: V2 R; ~0 @4 H, ?2 S$ P& i6 V7 G* Pint(*p_ary)[10] = &a; // p_ary是一个指针， 指向"int (*)[10]"类型的数组
for (int i = 0; i < 10; i++) {
// p_ary是一个指向数组的指针， 需要先通过间接寻址运算符*(indirection operator)取得数组对象
// 再通过下标操作访问元素。
$ Y5 |$ @. i4 @" j$ {9 Y7 Z$ N; b3 q (*p_ary) = i;
}
" _( m  m, X9 s8 }9 G& d7 q3 B; b
int b[10];
# Y; O- q0 h1 ]. h: t* hint c[20];
p_ary = &b; // 合法
p_ary = &c; // 报错！ 不能将 "int (*)[20]" 类型的值分配到 "int (*)[10]" 类型的实体
数组指针指向多维数组的子数组
" W4 i: X8 y6 d( e- [! S' Cint a[10];
int b[4][10];
2 `# n. d, U" s1 y2 Nint(*p_ary)[10] = &a;
4 m) D# X, `1 k$ N: i1 p: ~% ifor (int i = 0; i < 10; i++) {
8 ?7 C3 [4 ]. Y (*p_ary) = 1;
}
+ I8 x, O0 m8 @' Q* n- v
p_ary = &b[2]; // 多维数组，可以看作数组的数组，
// b[2][0] ~ b[2][9]的值都被改成2了
' K8 Q. B8 A$ X. T4 Q4 x+ [8 c8 nfor (int i = 0; i < 10; i++) {
(*p_ary) = 2;
}
多维数组指针
多维数组指针，是一种指针，指向的对象是个多维数组，支持多个下标操作。
! ~2 o. p6 u$ F6 j- _8 o
int a[2][5][10];
int(*p_ary1)[10] = &a[1][2]; // 1维数组指针
int(*p_ary2)[5][10] = &a[1]; // 2维数组指针
! _4 H, m& J! T% Ofor (int row = 0; row < 5; row++) {
    for (int col = 0; col < 10; col++) {
        (*p_ary2)[row][col] = row * col;
% o7 |, U" r! j; _7 \: B/ A    }
6 W1 v& c- G3 d! j8 s+ n$ L}
- {% N3 _, B, b$ |- n* Z8 Y/ b数组指针和指针数组对比实例
数组指针还是记住两步法即可

定义一个数组
括号包围1中定义的名称，再在名称前加个*号。
5 e- v( g8 z) D0 N9 ^. w2 dint a[10];
/ [3 O3 n# ?/ O$ A2 V/ L+ Q' z* Fint(*ary_pointer1)[10] = &a; // 数组指针
int* pointer_ary1[10]; // 指针数组。元素类型是int*
int *(ponter_ary2[10]); // 指针数组。另外一种定义方式。
int (*ponter_ary3[10]); // 指针数组。另外一种定义方式。
int c, *d, (*ary_pointer2)[10], *pointer_ary3[10]; // 排列定义比较。
6 |( g; O" F2 L' c  g2 F
// 指针数组可以把每个元素指向数组对应位置的地址。
" k1 `! M' N) F// 这样遍历指针数组， 可以达到遍历数组元素的效果，但是注意每个元素都是指针，
# n" H6 V9 p: q; ]0 T) M// 需要访问原数组的值的话， 需要对指针用*间接寻址运算符。
- J" P% f# J+ Q- r2 q1 Hint* pointer_ary[10];
4 @+ W* L' l' |5 a! q" e8 Lfor (int i = 0; i < 10; i++) {
    pointer_ary = &a;
/ G) a* X1 t9 Z& {}
// 类似遍历原数组效果。
for (int i = 0; i < 10; i++) {
    *pointer_ary = i; // 修改原数组。
7 r) j. F/ ^, @}

函数指针
取得函数地址
0 m. \% W6 A9 m) b& z! X% _. O8 F1 v函数的名称作为参数被传递时，会隐式转换成函数指针， 和在函数名称前加取地址符&等价。建议带上更加统一和清晰。
5 S0 d  ^" y" i7 u, E# |
void f(int);
int main()
2 z0 u  F$ Y& h{
    void (*p1)(int) = &f;
    void (*p2)(int) = f; // same as &f
    return 0;
}
1 }  D, H1 E5 h翻译成汇编代码， p1和p2的赋值是一样的。
- T4 w0 F  J) S4 V$ E

2 r6 y1 S% c5 E1 ?6 C* i/ V
' K, y1 G+ L" X函数指针的声明
7 s+ P7 ~6 E2 o4 e单个函数指针变量定义步骤
4 M& b1 O5 a- F/ N" r) v1 n( R定义一个函数。void fun1(int a, int b); int fun2(double a);
1 {) k  @% p( G0 u  {' \5 N用括号把函数名称包围起来，然后在名称前面加*号。void (*fun1)(int a, int b); int (*fun2)(double a);
如果要定义函数指针数组，在定义单个函数指针的基础上，在名称后面加上[数组长度]void (*fun1[2])(int a, int b); int (*fun2[10])(double a);
typedef定义函数指针
可读性高比单个定义要高，特别是声明多个同类型的函数指针，或者函数指针数组。

0 |) c2 t* |  L1 \# c9 ]2 h! jtypedef定义函数指针的语法
( j3 y" F5 Y& l1 Z* ]8 v7 }% j3 vtypedef有两种做法， 一种就是定义一种函数对象，另外一种就是定义函数指针。用法稍稍不同，效果是一样。其中函数对象不支持赋值， 但是支持引用。
% I9 f$ R1 H- [( R3 ?
$ u* B' K/ o" `2 L9 I2 {& ktypedef int FuncObject(int a, int b); // FuncObject类型是函数对象
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
FuncObject* f1 = &Add;
FuncPointer f2;
5 D; S* V5 y1 w4 W, if2 = f1; // f1, f2类型一样， 都是形式为int(int, int)的函数的指针。
FuncObject f3 = Add; // 报错！ 函数对象不支持拷贝
FuncObject f4 = &Add; // 报错！&Add是函数指针，与函数对象类型不匹配
! t, ^8 Z9 T1 vFuncObject& f5 = Add; // 正确
int ret = f5(2, 3); // 正确
FuncObject& f6 = &Add; // 报错！&Add是函数指针，与函数对象引用类型不匹配
如何记住typedef定义函数指针的步骤
像定义一个函数指针那样， 指定一个名称。int (*CalFun)(int a, int b);
在这个函数指针变量声明前面加上typedef。typedef int (*CalFun)(int a, int b);
! q; e; H/ E, D! [. z+ I" g! x* P完整例子
typedef int(*CalFun)(int a, int b);

int Add(int a, int b)
{
    return (a + b);
% ?& h$ r  X7 ^4 c}

2 I$ X5 r. L6 ^9 ~5 s' mint Sub(int a, int b)
8 d) n: X9 q! {{
- i! w( {) c" m9 [( R) a    return (a - b);
}
( w8 E6 D7 x6 o* d! B! u5 R0 W
int main(int argc, char** argv)
/ `: W2 c* a  ~2 q8 c8 }{
: o5 r# l; c2 E% }  Q, Q    CalFun f1 = Add;
    CalFun f2 = Sub;
+ \$ {  k' A: N; |, N. t  L0 L3 C% D    int a = f1(2, 3);
    int b = f2(10, 5);

/ s5 k1 ]9 h) }4 ^1 [    // typedef定义的函数指针数组。
. x7 n: e2 K; U/ r# F& `    CalFun f_ary[2];
    f_ary[0] = Add;
. Y0 z! e5 X2 U8 W    f_ary[1] = Sub;
5 L- x6 m7 d  O: I' L( Z0 g, `
    // 单个定义的函数指针数组。
( y8 @8 C$ S, \1 x    int(*f_ary2[2])(int a, int b);
    f_ary2[0] = Add;
) E7 p2 M' k( A5 Z8 N) f    f_ary2[1] = Sub;

2 E* F# `3 U/ O+ |$ ^    return 0;
}
/ A9 h* Z. W! E/ e
using别名定义函数指针
- o% {) Y. T- u" X7 Y8 Kc++11以后的类型别名定义--using也可以用于定义函数指针， typedef的好处它都有，个人感觉比typedef更直观。using类型别名同样分函数对象和函数指针两种方式。

typedef int FuncObject(int a, int b); // FuncObject类型是函数对象
- y/ m0 P. Q$ j# \1 L7 x0 Husing FuncObject = int(int a, int b);
typedef int (*FuncPointer)(int a, int b); // FuncPointer类型是函数指针
using FuncPointer = int(*)(int a, int b);
+ g) i2 r. d0 Z7 W* Y6 l& A函数指针的调用
/ x/ k9 a% X  [0 g8 L函数指针和函数对象都可以直接后加括号调用
int f();
( H( H, @* _0 F* F' v$ g( ^* vint (*p)() = f;  // pointer p is pointing to f
int (&r)() = *p; // the lvalue that identifies f is bound to a reference
r();             // function f invoked through lvalue reference
) {0 r# }/ j3 ]9 q5 Q(*p)();          // function f invoked through the function lvalue
p();             // function f invoked directly through the pointer
如果函数有重载， 函数指针会指向匹配的那个版本。
template<typename T>
T f(T n) { return n; }
% }$ v; ?" ]7 d; d# J- Z
7 A) E2 L2 O4 y0 k" p1 ?double f(double n) { return n; }

' c4 U- h( w" r. fint main()
" ^( T2 h/ h2 t1 h* d! e) U0 s8 P- L{
    int (*p)(int) = f; // instantiates and selects f<int>
}
) b. N( e+ r6 n* M成员函数指针
! `! h, q' u, p! Z$ i* ?9 M静态成员函数，除了增加了访问控制以外，跟普通的函数指针没什么区别，所以普通函数指针可以直接指向类的静态成员函数。但非静态的成员函数与普通函数指针不太一样，声明时需要指定函数归属的类名，并且调用需要指定对象实例。
' F4 n6 ^' ]% @8 M$ v$ E7 r
成员函数指针定义。
像定义类成员函数实现那样写, 并任意指定名称，这里作func。void ClassName::func(int);
" i& Q! \  y# d* ]& W  q' i括号把类名、范围解析运算符::、名称包围起来。void (ClassName::func)(int);
在名称的前面加个*号void (ClassName::*func)(int);
成员函数也支持typedef和using的定义方式。typedef void(C::* MemberFunc)(int); using MemberFunc = void(C::*)(int);
成员函数指针如何调用。
' ^0 ?3 ^7 H4 r! Z; d- v8 L假设成员函数指针名字为func
; G# M) c# t9 \7 R- n
void (ClassName::*func)(int);
对象式调用。
; U1 _+ U( K+ J' I- t5 }# AClassName c; // 被调用的对象
2 \: {& f8 V' P成员函数指针名字当作正常函数那样写。
3 {" C2 Q5 X1 i! mc.func(3);
成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
c.*func(3);
最后用括号把调用对象、成员访问运算符.、间接寻址运算符*、和成员函数指针的名称包围起来。
(c.*func)(3);
  @; c6 }* G8 \! ]$ u5 j* p为何要加上括号？ 根据c++的优先级标准，取成员运算符. > 函数调用() > 间接引用符*。 *号优先级比函数调用要低， 成员函数指针还没取得对象就被调用了，自然报错。 另外
(c.(*func))(3);
这样的写法也不行。 .*和->*是整体作为一个运算符的，中间不能用括号隔开。
指针式调用
: N8 V! J2 T+ L! X9 M2 R& k6 t  z+ dClassName* p; // 被调用的对象的指针
成员函数指针名字当作正常函数那样写。
p->func(3);
2 w& X# X2 z& K) r4 ~1 [4 O成员函数指针是指针， func名称前面需加上间接寻址运算符*，变成函数对象。
! I3 K0 s; ~' w, P. Pp->*func(3);
$ J# A: A& Y9 u! o2 ?最后用括号把调用对象、成员访问运算符->、间接寻址运算符*、和成员函数指针的名称包围起来。
(p->*func)(3);
函数指针使用完整例子
. |! s  M+ D) _% N2 T9 e( W4 T. }* ]- \) Hstruct Cal
{
    int add(int a, int b);
    int sub(int a, int b);
& M) O3 {8 P5 Q0 J' {1 s};

! h$ b0 U. x" I) n9 t9 P) Tint main()
{
4 E4 ^# {0 e7 R( w    int (Cal::*fun)(int, int) = &Cal::add;
1 J+ r. O: b1 l  ?0 c- u; t; y    fun = &Cal::sub;

    Cal* p_cal = new Cal();
    int r1 = (p_cal->*fun)(2, 3);
    delete p_cal;
* S2 j. b# I, ?' `+ ?. X
: H/ _, w9 Y$ m5 \    Cal local_cal;
' P1 i$ D' X- s, O    int r2 = (local_cal.*fun)(8, 6);
}

成员变量指针
# }  z0 R5 R) C  l: v1 y* I成员变量指针比成员函数指针还要简单些，没有函数调用， 无需考虑函数调用和间接引用符*的优先级问题。
& V  _; ^; I- d& D
( J% V! y) U5 i' U, k* N成员变量指针的定义
假如以下结构体C。
0 D8 K7 L  _0 k" O% o
struct C
7 j' s  K" c! V3 j1 X" y{
    int m;
0 p/ W# S* n. a2 ~};
单个成员变量指针定义
1 f! x! W, b" Q. a2 _/ G7 _8 E假设名称为p, 类似静态成员变量定义那样声明
1 v: V' I: g7 t1 Qint C::p;
# L' K) G3 b( c" X# y在名称前面加上指针标识号*
int C::*p;
0 T8 v1 o& ^2 W+ Utypedef或using方式定义
typedef int C::*MemberPointer;
' X" @' C4 S: t2 c) r2 w* ]1 Gusing MemberPointer = int C::*;
成员变量指针的使用。
8 b) M7 }6 V/ |. b% c类似成员函数指针那样，直接使用指向成员的指针运算符：.* 和->*即可。
成员变量指针， 能让我们实现一些遍历成员的动态功能。 例如把一个类/结构体的多个同类型的成员变量放进一个容器里，然后遍历访问这些成员变量。
# v, Y& j' g; h( h
完整例子
struct C { int m; };
$ w; z. Z! Q* Rint main()
8 _; e# n+ F: t3 {0 f! Z& G) c{
. _" u$ s5 Z% w9 l    int C::* p = &C::m;          // pointer to data member m of class C
" F5 U7 j3 s! l' s    C c = {7};
3 H) q/ t$ P8 I    std::cout << c.*p << '\n';   // prints 7
, V5 h, D$ f" v+ h    C* cp = &c;
    cp->m = 10;
) L: W! c! J) {    std::cout << cp->*p << '\n'; // prints 10

————————————————
版权声明：本文为CSDN博主「南风fahaxiki」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_64407685/article/details/126788115
$ H) F" C/ `# B) X. Z# W4 Q

---

欢迎光临 数学建模社区-数学中国 (http://www.madio.net/)

Powered by Discuz! X2.5