824 字

2 分钟

cpp(八)——指针全解

2026-10-30

CPP

cpp

CPP—指针全解#

又回到这里了啊，指针。

CPP—指针全解

一、指针基础#

1
int a = 10;
2
int *p = &a;

可以把内存想象成一排带编号的储物柜：

a 是一个柜子，里面放着整数 10。
&a 是这个柜子的编号，也就是地址。
p 是另一个变量，里面保存着 a 的地址。
*p 表示按照 p 保存的地址，找到那个柜子并读取里面的值。

*的含义有两种

1
int *p;  // 声明：p 是一个 int 指针
2
*p = 20; // 解引用：修改 p 指向的内存

指针本身也是个变量，能够改变指向

1
int a = 10;
2
int b = 20;
3

4
int *p = &a;
5
p = &b;

空指针与野指针#

1
void *c=nullptr;//野指针。
2

3
int *p;
4

5
{
6
    int a = 10;
7
    p = &a;
8
}
9

10
// a 的生命周期已经结束，p 不能再安全使用，这时候就是个野指针。

二、指针与数组#

数组名在表达式中通常会退化为首元素地址

1
int arr[4] = {10, 20, 30, 40};
2

3
int *p = arr;

在大多数表达式中，arr 会转换为 &arr[0]。所以下面两种写法等价

1
int *p = arr;
2
int *q = &arr[0];

指针为何可以通过加法访问数组

1
//p = &arr[0]，p + 1 = &arr[1]
2
int arr[4] = {10, 20, 30, 40};
3

4
int *p = arr;
5

6
printf("%d\n", *p);       // 10
7
printf("%d\n", *(p + 1)); // 20
8
printf("%d\n", *(p + 2)); // 30
9
printf("%d\n", p[3]);     // 40

核心的原因就是：

p+n=p的地址+n*sizeof(*p)

如果 p 是 int*，而 sizeof(int) == 4，那么 p + 1 就向后移动 4 字节。

所以对于数组来说*(p+2)等价于p[2]

数组与指针并不相同#

1
int arr[4] = {10, 20, 30, 40};
2
int *p = arr;
3

4
printf("%zu\n", sizeof(arr));
5
printf("%zu\n", sizeof(p));

假设是 ARM64：

sizeof(arr) 通常是 4 * 4 = 16 字节。
sizeof(p) 通常是 8 字节。

数组是连续存放元素的一整块存储空间；指针只是一个保存地址的变量。

还有个区别

1
arr = p; // 错误，数组不能整体赋值
2
p = arr; // 可以，指针可以保存数组首元素地址

数组作为函数的参数#

1
void printArray(int arr[], int size) {
2
    for (int i = 0; i < size; i++) {
3
        printf("%d\n", arr[i]);
4
    }
5
}
6

7
等价于void printArray(int *arr, int size);

这里的 int arr[] 作为函数参数时，会被调整为 int *arr。

数组本身不携带长度信息，所以需要附带长度。

三、多级指针#

二级指针#

1
int a = 10;
2

3
int *p = &a;
4
int **pp = &p;
5

6
printf("%d\n", a);    // 10
7
printf("%d\n", *p);   // 10
8
printf("%d\n", **pp); // 10

拆解一下pp：

1
pp=p的地址`，`*pp=指针p本身`，`**pp=p指的那块地址存的值

二级指针常见用处#

最常见的用途之一：让函数修改调用者的指针变量。

1
void allocateMemory(int **p) {
2
    *p = new int(100);
3
}
4

5
int main() {
6
    int *ptr = nullptr;
7

8
    allocateMemory(&ptr);
9

10
    printf("%d\n", *ptr); // 100
11

12
    delete ptr;
13
}

为什么这里需要 int **？

因为我们希望函数修改的是 main() 中的 ptr，而不是仅仅修改一个指针副本。

调用过程：

&ptr：把 ptr 自己的地址传进去。
int **p：函数用二级指针接收这个地址。
*p = new int(100)：修改调用者的 ptr，让它指向新分配的内存。

三级指针#

多了一层间接访问而已。

1
int a = 10;
2

3
int *p = &a;
4
int **pp = &p;
5
int ***ppp = &pp;
6

7
printf("%d\n", ***ppp); // 10

四、函数指针#

保存函数入口地址的指针。

1
int add(int a, int b) {
2
    return a + b;
3
}
4

5
int (*func)(int, int) = add;
6

7
int result = func(10, 20);
8
printf("%d\n", result); // 30

表示：

func 是一个指针。
它指向一个函数。
这个函数接收两个 int 参数。
返回值是 int。

和正常函数对比一下，发现括号很重要。

1
int *func(int, int);   // 函数，返回 int*
2
int (*func)(int, int); // 函数指针，指向返回 int 的函数

回调函数：函数指针作为参数#

1
int add(int a, int b) {
2
    return a + b;
3
}
4

5
int sub(int a, int b) {
6
    return a - b;
7
}
8

9
int calculate(int a, int b, int (*operation)(int, int)) {
10
    return operation(a, b);
11
}
12

13
int main() {
14
    printf("%d\n", calculate(10, 5, add)); // 15
15
    printf("%d\n", calculate(10, 5, sub)); // 5
16
}

calculate 不关心具体执行加法还是减法，它只负责调用传进来的函数。

这就是回调函数。

函数指针数组#

这样就形成了一个函数表。

1
int add(int a, int b) { return a + b; }
2
int sub(int a, int b) { return a - b; }
3
int mul(int a, int b) { return a * b; }
4

5
int (*operations[3])(int, int) = {
6
    add,
7
    sub,
8
    mul
9
};
10

11
printf("%d\n", operations[0](10, 5)); // 15
12
printf("%d\n", operations[1](10, 5)); // 5
13
printf("%d\n", operations[2](10, 5)); // 50

IDA 伪代码	可能的含义
`(_DWORD )a1`	读取地址 `a1` 处的 4 字节
`(_QWORD )a1`	读取地址 `a1` 处的 8 字节
`(_DWORD )(a1 + 8)`	读取偏移 8 处的 4 字节
`(_QWORD )(a1 + 0x10)`	读取偏移 0x10 处的 8 字节
`(_QWORD )a1`	多级间接访问，需结合类型判断
`(*(函数指针)...)`	可能是间接函数调用

举个例子

1
struct User {
2
    int id;
3
    int age;
4
    char *name;
5
};
6

7
int getAge(User *user) {
8
    return user->age;
9
}
10

11
user->age等价于
12
*(int *)((char *)user + 4)
13
也就是
14
return *(_DWORD *)(a1 + 4);
15
你应该能反推出：
16
1. a1 很可能是结构体指针。
17
2. a1 + 4 是结构体偏移 4。
18
3. 读取 4 字节，可能是一个 int 字段。
19
4. 如果结合其他字段访问，就能进一步还原结构体。

五、实战分析#

1
#include<iostream>
2
#include<string>
3
#include <cstring>
4
#include <cstdint>
5
//普通指针
6
int read_pointer(int* tmp){
7
    if(tmp==nullptr)return 0;
8
    return *tmp;
9
}
10

11
void write_pointer(int* tmp){
12
    *tmp=6767;
13
}
14

15
void swap_p(int* a,int* b){
16
    std::swap(a,b);
17
}
18

19

20
//数组与指针
21
int arr_sum(int* arr,int size){
22
    int sum=0;
23
    for(int i=0;i<size;i++){
24
        sum+=arr[i];
25
    }
26
    return sum;
27
}
28

29
int find_target(int* arr,int index,int length){
30
    if (arr == nullptr) return 0;
31
    if (index < 0 || index >= length) return 0;
32
    int* address=arr+index;
33
    return *address;
34
}
35

36
//结构体与结构体指针
37
struct User{
38
    int id;
39
    int age;
40
    int score;
41
    char name[16];
42
};
43

44
//修改用户信息
45
void change_user(User* user,int age,int score,std::string name){
46
    user->age=age;
47
    user->score=score;
48
    std::strncpy(user->name,name.c_str(),sizeof(user->name) - 1);
49
    user->name[sizeof(user->name) - 1] = '\0';
50
}
51

52
//结构体数组遍历与条件查找
53
const User* find_user(const User* users,int count,int id){
54
    if(count<=0||id<0)return nullptr;
55
    for(int i=0;i<count;i++){
56
        if(users[i].id==id){
57
            return &users[i];
58
        }
59
    }
60
    return nullptr;
61
}
62

63
//多级指针
64
int alloc_pointer(int** pp,int value){
65
    if (pp == nullptr) return false;
66
    int *p = new int(value);
67
    if(p==nullptr)return false;
68

69
    *pp=p;
70
    return true;
71
}
72

73

74
//函数指针
75
typedef int (*Option)(int a,int b);
76
int add(int a,int b){
77
    return a+b;
78
}
79
int sub(int a,int b){
80
    return a-b;
81
}
82
static Option option[2] = {
83
    add,
84
    sub
85
};
86
// 根据索引选择函数
87
int calculateByIndex(
88
    int a,
89
    int b,
90
    int index
91
) {
92
    if (index < 0 || index >= 2) return -1;
93

94
    Option operation = option[index];
95

96
    return operation(a, b);
97
}
98

99

100

101
// ============================================================
102
// 6. 综合结构体：Request + Union + 函数指针
103
// ============================================================
104

105
union Payload {
106
    int32_t number;
107
    float value;
108
    char name[16];
109
};
110

111
struct Request {
112
    uint32_t type;
113
    uint32_t length;
114
    Payload payload;
115
};
116

117
//三种操作函数表
118
// 处理整数请求
119
static int handleInteger(Request* req) {
120
    if (req == nullptr) return -1;
121

122
    return req->payload.number + 100;
123
}
124

125
// 处理浮点数请求
126
static int handleFloat(Request* req) {
127
    if (req == nullptr) return -1;
128

129
    if (req->payload.value > 10.0f) {
130
        return 200;
131
    }
132

133
    return 201;
134
}
135

136
// 处理字符串请求
137
static int handleString(Request* req) {
138
    if (req == nullptr) return -1;
139

140
    int length = 0;
141

142
    for (int i = 0; i < 16; i++) {
143
        if (req->payload.name[i] == '\0') break;
144
        length++;
145
    }
146

147
    return length;
148
}
149

150
typedef int (*RequestHandler)(Request*);
151

152
// 请求处理函数表
153
static RequestHandler handlers[4] = {
154
    nullptr,
155
    handleInteger,
156
    handleFloat,
157
    handleString
158
};
159

160
// 统一请求处理入口
161
int processRequest(Request* req) {
162
    if (req == nullptr) return -1;
163

164
    if (req->type >= 4) return -1;
165

166
    RequestHandler handler = handlers[req->type];
167

168
    if (handler == nullptr) return -1;
169

170
    return handler(req);
171
}
172

173
// 获取 Request 字段
174
uint32_t getRequestType(const Request* req) {
175
    if (req == nullptr) return 0;
176
    return req->type;
177
}
178

179
uint32_t getRequestLength(const Request* req) {
180
    if (req == nullptr) return 0;
181
    return req->length;
182
}
183

184
int32_t getRequestNumber(const Request* req) {
185
    if (req == nullptr) return 0;
186
    return req->payload.number;
187
}
188

189

190
int main() {
191
    std::cout << "========== 1. 普通指针 ==========\n";
192
    {
193
        int x = 42;
194
        std::cout << "read_pointer(&x)      = " << read_pointer(&x) << " (期望 42)\n";
195
        std::cout << "read_pointer(nullptr) = " << read_pointer(nullptr) << " (期望 0，你的实现返回空)\n";
196

197
        int y = 0;
198
        write_pointer(&y);
199
        std::cout << "write_pointer 后 y    = " << y << " (期望 6767)\n";
200

201

202
    }
203

204
    std::cout << "\n========== 2. 数组与指针 ==========\n";
205
    {
206
        int arr[] = {1, 2, 3, 4, 5};
207
        int len = sizeof(arr) / sizeof(arr[0]);
208
        std::cout << "arr_sum(arr,5)        = " << arr_sum(arr, len) << " (期望 15)\n";
209
        std::cout << "find_target(arr,2,5)  = " << find_target(arr, 2, len) << " (期望 3)\n";
210
        std::cout << "find_target(arr,9,5)  = " << find_target(arr, 9, len) << " (期望 0，越界返回空)\n";
211
        std::cout << "find_target(nullptr,0,5) = " << find_target(nullptr, 0, len) << " (期望 0)\n";
212
    }
213

214
    std::cout << "\n========== 3. 结构体与结构体指针 ==========\n";
215
    {
216
        User u{};
217
        u.id = 1;
218
        change_user(&u, 20, 90, "Alice");
219
        std::cout << "change_user 后: id=" << u.id
220
                  << " age=" << u.age
221
                  << " score=" << u.score
222
                  << " name=" << u.name << " (期望 20,90,Alice)\n";
223

224
        // 测试超长名字截断
225
        change_user(&u, 21, 91, "ThisNameIsWayTooLongFor16Bytes");
226
        std::cout << "超长名字截断后 name   = " << u.name
227
                  << " (长度 " << std::strlen(u.name) << "，期望 15)\n";
228

229
        User users[3] = {
230
            {1, 18, 80, "Tom"},
231
            {2, 19, 85, "Jerry"},
232
            {3, 20, 90, "Spike"},
233
        };
234
        const User* found = find_user(users, 3, 2);
235
        if (found)
236
            std::cout << "find_user(id=2)       = " << found->name << " (期望 Jerry)\n";
237
        else
238
            std::cout << "find_user(id=2)       = 未找到\n";
239

240
        const User* notFound = find_user(users, 3, 99);
241
        std::cout << "find_user(id=99)      = " << (notFound ? "找到" : "nullptr") << " (期望 nullptr)\n";
242
    }
243

244
    std::cout << "\n========== 4. 多级指针 ==========\n";
245
    {
246
        int* p = nullptr;
247
        bool ok = alloc_pointer(&p, 123);
248
        std::cout << "alloc_pointer 返回    = " << ok << " (期望 1)\n";
249
        if (p) {
250
            std::cout << "*p                    = " << *p << " (期望 123)\n";
251
            delete p;   // ⚠️ 你的函数里 new 了，必须由调用方 delete
252
        }
253

254
        bool bad = alloc_pointer(nullptr, 1);
255
        std::cout << "alloc_pointer(nullptr)= " << bad << " (期望 0)\n";
256
    }
257

258
    std::cout << "\n========== 5. 函数指针 ==========\n";
259
    {
260
        std::cout << "calculateByIndex(6,2,0) = " << calculateByIndex(6, 2, 0) << " (期望 8, add)\n";
261
        std::cout << "calculateByIndex(6,2,1) = " << calculateByIndex(6, 2, 1) << " (期望 4, sub)\n";
262
        // 注意：option 数组只有 2 个元素，但 calculateByIndex 检查的是 index >= 3，
263
        // 传 index=2 会越界读 option[2]，是 bug（见下方问题清单）
264
        std::cout << "calculateByIndex(6,2,3) = " << calculateByIndex(6, 2, 3) << " (期望 -1, 越界)\n";
265
    }
266

267
    std::cout << "\n========== 6. Request + Union + 函数指针 ==========\n";
268
    {
269
        // type=1：整数
270
        Request r1{};
271
        r1.type = 1;
272
        r1.payload.number = 5;
273
        std::cout << "processRequest(整数5)   = " << processRequest(&r1) << " (期望 105)\n";
274

275
        // type=2：浮点，>10
276
        Request r2{};
277
        r2.type = 2;
278
        r2.payload.value = 3.14f;
279
        std::cout << "processRequest(浮点3.14)= " << processRequest(&r2) << " (期望 201)\n";
280

281
        Request r2b{};
282
        r2b.type = 2;
283
        r2b.payload.value = 20.0f;
284
        std::cout << "processRequest(浮点20)  = " << processRequest(&r2b) << " (期望 200)\n";
285

286
        // type=3：字符串
287
        Request r3{};
288
        r3.type = 3;
289
        std::strncpy(r3.payload.name, "hello", sizeof(r3.payload.name) - 1);
290
        std::cout << "processRequest(字符串hello) = " << processRequest(&r3) << " (期望 5)\n";
291

292
        // type=0：handlers[0]=nullptr
293
        Request r0{};
294
        r0.type = 0;
295
        std::cout << "processRequest(type=0)  = " << processRequest(&r0) << " (期望 -1, nullptr handler)\n";
296

297
        // type=4：越界
298
        Request r4{};
299
        r4.type = 4;
300
        std::cout << "processRequest(type=4)  = " << processRequest(&r4) << " (期望 -1)\n";
301

302
        // nullptr
303
        std::cout << "processRequest(nullptr) = " << processRequest(nullptr) << " (期望 -1)\n";
304

305
        // getter
306
        std::cout << "getRequestType(&r1)     = " << getRequestType(&r1) << " (期望 1)\n";
307
        std::cout << "getRequestLength(&r1)   = " << getRequestLength(&r1) << " (期望 0，未设置)\n";
308
        std::cout << "getRequestNumber(&r1)   = " << getRequestNumber(&r1) << " (期望 5)\n";
309
        std::cout << "getRequestType(nullptr) = " << getRequestType(nullptr) << " (期望 0)\n";
310
    }
311

312
    std::cout << "\n========== 测试结束 ==========\n";
313
    return 0;
314
}

六、ida里的结构体数组#

1
  v32 = 0;
2
  v103 = 0;
3
  v100 = xmmword_2504;
4
  v101 = xmmword_2514;
5
  v102 = xmmword_2524;
6
  *(_OWORD *)v98 = xmmword_24E4;
7
  v99 = xmmword_24F4;
8
  上面都是在定义初始化结构体数组
9
      User users[3] = {
10
            {1, 18, 80, "Tom"},
11
            {2, 19, 85, "Jerry"},
12
            {3, 20, 90, "Spike"},
13
        };
14
  源代码如上
15
  while ( *(_DWORD *)((char *)v98 + v32) != 2 )//v98是结构体数组起点，每次移动28字节对应结构体的大小。
16
  {
17
    v32 += 28;
18
    if ( v32 == 84 )
19
    {
20
      v33 = nullptr;
21
      goto LABEL_6;
22
    }
23
  }
24
  v33 = (char *)v98 + v32;

cpp(八)——指针全解

https://fatdog.20060113.xyz/posts/cpp-again8/

作者

神秘大胖狗

发布于

2026-10-30

许可协议

CC BY-NC-SA 4.0

部分信息可能已经过时

cpp（十）——对象内存布局

CPP沉淀（七）