<think>我们注意到用户的问题是关于C++中"
handler类"的
使用。根据提供的引用，我们发现"
handler"在C++中有多种不同的上下文含义：
1
. **Android C++层的
Handler**（引用[1]）：用于消息循环和处理，类似于Java层的
Handler机制。
2
. **new-
handler**（引用[2]）：用于处理内存分配
失败时的回调函数。
3
. **事件处理回调接口
**（引用[3]）：定义了一组回调函数，用于处理特定事件（如引擎事件）。
4
. **消息处理类
**（引用[4]）：用于消息传递和处理的类设计。
由于用户没有明确具体场景，我们将分别介绍几种常见的
handler使用场景，并提供示例代码。
### 1
. Android C++层的
Handler（消息循环）
在Android NDK开发中，C++层提供了`Looper`和`Message
Handler`用于处理线程消息。
```cpp
#include <android/looper
.h>
#include <android/native_activity
.h>
class My
Handler : public android
::Message
Handler {
public
:
virtual void
handleMessage
(const android
::Message& message
) {
// 处理消息
switch
(message
.what
) {
case 1
:
// 执行任务1
break;
case 2
:
// 执行任务2
break;
}
}
};
//
使用示例
void example
() {
// 获取当前线程的Looper
ALooper
* looper = ALooper_prepare
(0);
// 创建
Handler
sp<My
Handler>
handler =
new My
Handler();
// 发送消息
android
::Message msg;
msg
.what = 1;
handler->sendMessage
(msg
);
}
```
### 2
. new-
handler（内存分配
失败处理）
当`
new`操作符无法分配足够内存
时，会调用
new-
handler函数。
```cpp
#include <iostream>
#include <
new>
void my
NewHandler() {
std
::cerr << "Memory allocation failed
. Exiting
...\n";
std
::set_
new_
handler(nullptr
); // 移除自身，避免循环
throw std
::bad_alloc
();
}
int main
() {
std
::set_
new_
handler(my
NewHandler); // 设置自定义
new-
handler
try {
while
(true
) {
new int[1
000000000]; // 尝试分配巨大内存块
}
} catch
(const std
::bad_alloc& e
) {
std
::cerr << "Caught exception
: " << e
.what
() << '\n';
}
return
0;
}
```
### 3
. 事件处理回调接口（
Handler Interface）
定义事件处理接口，由具体类实现。
```cpp
// EngineEvent
HandlerInterface
.h
class EngineEvent
HandlerInterface {
public
:
virtual ~EngineEvent
HandlerInterface
() = default;
virtual void onJoinSuccess
(unsigned int uid
) =
0;
virtual void onLeave
() =
0;
virtual void onDestroy
() =
0;
};
// EngineEvent
HandlerImpl
.h
#include "EngineEvent
HandlerInterface
.h"
class EngineEvent
HandlerImpl
: public EngineEvent
HandlerInterface {
public
:
void onJoinSuccess
(unsigned int uid
) override {
std
::cout << "User " << uid << " joined successfully
.\n";
}
void onLeave
() override {
std
::cout << "User left
.\n";
}
void onDestroy
() override {
std
::cout << "Engine destroyed
.\n";
}
};
//
使用示例
int main
() {
EngineEvent
HandlerImpl
handler;
// 模拟事件发生
handler.onJoinSuccess
(12345
);
handler.onLeave
();
return
0;
}
```
### 4
. 消息处理类（自定义消息系统）
设计一个简单的消息处理系统，包含消息类和处理器类。
```cpp
#include <iostream>
#include <vector>
#include <string>
class Message {
public
:
explicit Message
(const std
::string& content
) : content_
(content
) {}
std
::string getContent
() const { return content_; }
private
:
std
::string content_;
};
class Message
Handler {
public
:
virtual void
handleMessage
(const Message& msg
) =
0;
};
class ConsoleMessage
Handler : public Message
Handler {
public
:
void
handleMessage
(const Message& msg
) override {
std
::cout << "Console
: " << msg
.getContent
() << std
::endl;
}
};
class LogMessage
Handler : public Message
Handler {
public
:
void
handleMessage
(const Message& msg
) override {
// 这里可以添加日志记录逻辑
std
::cout << "Log
: " << msg
.getContent
() << std
::endl;
}
};
int main
() {
Message msg
("Hello,
Handlers!"
);
ConsoleMessage
Handler console
Handler;
LogMessage
Handler log
Handler;
console
Handler.handleMessage
(msg
);
log
Handler.handleMessage
(msg
);
return
0;
}
```
### 总结
-
**Android消息
Handler**：用于线程间通信，结合`Looper`
使用[^1]。
-
**new-
handler**：处理内存分配
失败，通过`std
::set_
new_
handler`设置[^2]。
-
**事件回调
Handler**：定义接口并实现，用于事件驱动编程[^3]。
-
**消息处理类
**：自定义消息系统，实现多种消息处理方式[^4]。
根据实际需求选择合适的
handler实现方式。注意不同上下文中的
handler具有完全不同的用途。
§§相关问题§§
1
. 如何在Android NDK中实现跨线程消息传递？
2
. C++中如何自定义内存分配
失败的处理逻辑？
3
. 如何设计一个可扩展的事件处理系统？
4
. 在C++中实现观察者模式有哪些方法？</think>### C++
Handler 类
使用详解
在 C++ 中，"
Handler" 通常指代三种不同概念，我将分别说明其
使用方法和提供示例：
---
#### 1
. **事件回调处理器（最常见）
**
用于实现事件驱动架构，定义回调接口处理特定事件（如网络事件、用户操作等）。
**使用步骤：
**
1
. 定义抽象接口类
2
. 实现具体处理类
3
. 注册处理器
4
. 触发事件
**示例代码：
**
```cpp
// 1
. 定义处理器接口
class EngineEvent
Handler {
public
:
virtual ~EngineEvent
Handler() = default;
virtual void onJoinSuccess
(unsigned int uid
) =
0;
virtual void onLeave
() =
0;
};
// 2
. 实现具体处理器
class GameEngine
Handler : public EngineEvent
Handler {
public
:
void onJoinSuccess
(unsigned int uid
) override {
std
::cout << "玩家 " << uid << " 加入游戏成功\n";
// 实际游戏逻辑
}
void onLeave
() override {
std
::cout << "玩家离开游戏\n";
// 清理资源
}
};
// 3
. 使用处理器
int main
() {
GameEngine
Handler handler; // 创建处理器实例
// 模拟事件触发
unsigned int playerId = 1
001;
handler.onJoinSuccess
(playerId
); // 输出：玩家 1
001 加入游戏成功
handler.onLeave
(); // 输出：玩家离开游戏
return
0;
}
```
---
#### 2
. **Android NDK 消息处理器
**
用于 Android 底层 C++ 代码的消息循环（类似 Java 的
Handler 机制）。
**核心组件：
**
- `Looper`：消息循环
- `Message
Handler`：消息处理接口
- `Message`：消息对象
**示例代码：
**
```cpp
#include <android/looper
.h>
#include <android/log
.h>
// 自定义消息处理器
class My
Handler : public android
::Message
Handler {
public
:
void
handleMessage
(const android
::Message& message
) override {
switch
(message
.what
) {
case 1
:
__android_log_print
(ANDROID_LOG_INFO, "MyApp", "收到消息1"
);
break;
case 2
:
__android_log_print
(ANDROID_LOG_INFO, "MyApp", "收到消息2"
);
break;
}
}
};
//
使用示例
void startMessageLoop
() {
ALooper
* looper = ALooper_prepare
(0); // 准备Looper
My
Handler handler;
android
::sp<android
::Message
Handler> msg
Handler(&
handler);
// 发送消息（通常在另一个线程）
android
::Message msg;
msg
.what = 1; // 消息ID
msg
Handler->sendMessage
(msg
);
}
```
---
#### 3
. **内存分配处理器
(new-
handler)**
处理内存分配
失败时的回调机制。
**使用步骤：
**
1
. 定义处理函数
2
. 设置全局处理器
3
. 处理分配
失败
**示例代码：
**
```cpp
#include <iostream>
#include <
new>
// 自定义内存分配
失败处理器
void my
NewHandler() {
std
::cerr << "内存分配
失败！尝试释放资源
...\n";
// 1
. 释放备用内存
// 2
. 抛出异常或终止程序
throw std
::bad_alloc
(); // 或 std
::abort
()
}
int main
() {
std
::set_
new_
handler(my
NewHandler); // 注册处理器
try {
// 尝试分配超大内存（触发
失败）
int
* hugeArray =
new int[1
000000000000];
} catch
(const std
::bad_alloc& e
) {
std
::cerr << "捕获异常
: " << e
.what
() << "\n";
}
return
0;
}
```
---
### 关键区别总结
| 类型 | 主要用途 | 典型场景 | 重要组件 |
|------------------|---------------------------|---------------------|------------------|
| 事件回调处理器 | 事件驱动编程 | 游戏引擎、网络框架 | 抽象接口+实现类 |
| Android 消息处理器| 线程间通信 | Android NDK 开发 | Looper+Message |
| 内存分配处理器 | 处理内存分配
失败 | 资源敏感型应用 | set_
new_
handler |
>
**最佳实践
**：
使用 `std
::unique_ptr` 管理处理器生命周期，避免内存泄漏[^2]。对于事件处理器，推荐基于接口编程提高扩展性[^3]。
本文探讨了在界面初始化过程中如何正确使用Handler。为了避免因界面未完全渲染导致的问题，文章建议利用onWindowFocusChanged事件来确保在界面完全加载后再使用Handler。
扫一扫
6958
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
