Qt iOS应用在MLKit人脸检测回调中偶现EXC_BAD_ACCESS崩溃

你的核心问题是异步回调与C++对象生命周期不匹配导致的竞态条件——用m_Initialized标记的方式无法原子性地完成「检查对象存活+访问对象」的操作，因此仍会出现极端场景下的崩溃。以下是几种更可靠的解决方案：

方案1：用C++ std::weak_ptr 管理对象生命周期 #

利用C++智能指针的弱引用特性，确保回调执行时能安全判断对象是否存活，且操作是原子性的：

#include <memory>
#include <QObject>

class FaceDetector : public QObject, public std::enable_shared_from_this<FaceDetector> {
    Q_OBJECT
public:
    FaceDetector(QObject* parent = nullptr) : QObject(parent) {
        // 初始化MLKit FaceDetector
        faceDetector = [MLKFaceDetector detectorWithOptions:options];
    }

    ~FaceDetector() {
        // 释放MLKit资源
        [faceDetector release];
    }

    void runFaceDetection(const QImage& image) {
        // 捕获弱引用，避免强引用延长对象生命周期
        std::weak_ptr<FaceDetector> weakSelf = shared_from_this();
        
        // 转换QImage为MLKit兼容的UIImage
        UIImage* mlImage = convertQImageToUIImage(image);
        
        // 调用MLKit异步检测接口
        [faceDetector processImage:mlImage completionHandler:^(NSArray<MLKFace *> *faces, NSError *error) {
            // 尝试获取强引用，原子性判断对象是否存活
            std::shared_ptr<FaceDetector> self = weakSelf.lock();
            if (!self) {
                [mlImage release];
                return; // 对象已销毁，直接终止回调
            }
            
            // 安全处理检测结果
            self->handleDetectionResult(faces, error);
            [mlImage release];
        }];
    }

private:
    MLKFaceDetector* faceDetector;

    void handleDetectionResult(NSArray<MLKFace*> *faces, NSError *error) {
        // 业务逻辑处理，比如发送Qt信号更新UI等
    }

    UIImage* convertQImageToUIImage(const QImage& qImg) {
        // 实现QImage到UIImage的转换逻辑
    }
};

// 使用时必须用shared_ptr持有对象
std::shared_ptr<FaceDetector> detector = std::make_shared<FaceDetector>();

关键优势：weak_ptr::lock()是原子操作，彻底避免了「检查存活状态后对象立即被销毁」的竞态问题。

方案2：Objective-C弱引用+__block修饰符 #

通过OC辅助对象持有C++对象的弱引用，在回调中先验证引用有效性：

// FaceDetector辅助OC类（在.mm文件中实现）
@interface FaceDetectorHelper : NSObject
@property (nonatomic, weak) FaceDetector* cppDetector;
@end

@implementation FaceDetectorHelper
@end

// C++ FaceDetector类
#include <QObject>

class FaceDetector : public QObject {
    Q_OBJECT
public:
    FaceDetector(QObject* parent = nullptr) : QObject(parent) {
        ocHelper = [[FaceDetectorHelper alloc] init];
        ocHelper.cppDetector = this;
        faceDetector = [MLKFaceDetector detector];
    }

    ~FaceDetector() {
        ocHelper.cppDetector = nullptr; // 析构时主动置空弱引用
        [ocHelper release];
        [faceDetector release];
    }

    void runFaceDetection(const QImage& image) {
        UIImage* mlImage = convertQImageToUIImage(image);
        __block FaceDetectorHelper* weakHelper = ocHelper;

        [faceDetector processImage:mlImage completionHandler:^(NSArray<MLKFace *> *faces, NSError *error) {
            FaceDetector* detector = weakHelper.cppDetector;
            if (!detector) {
                [mlImage release];
                return;
            }
            detector->handleDetectionResult(faces, error);
            [mlImage release];
        }];
    }

private:
    FaceDetectorHelper* ocHelper;
    MLKFaceDetector* faceDetector;

    void handleDetectionResult(NSArray<MLKFace*> *faces, NSError *error) {
        // 业务逻辑处理
    }

    UIImage* convertQImageToUIImage(const QImage& qImg) {
        // 转换实现
    }
};

关键优势：OC弱引用会自动在对象销毁后变为nil，回调中判断nil即可安全终止操作，适配OC与C++混合编程场景。

方案3：主动取消未完成检测任务 #

如果MLKit提供了检测任务的取消接口（部分版本支持），可以在FaceDetector析构时主动终止所有未完成的异步任务：

~FaceDetector() {
    // 若MLKit支持取消任务，调用对应API
    if (faceDetector && [faceDetector respondsToSelector:@selector(cancelAllTasks)]) {
        [faceDetector cancelAllTasks];
    }
    [faceDetector release];
}

如果MLKit没有取消接口，可以自行维护一个任务状态标记：

class FaceDetector : public QObject {
    Q_OBJECT
public:
    ~FaceDetector() {
        QMutexLocker locker(&m_mutex);
        m_isDestroyed = true;
    }

    void runFaceDetection(const QImage& image) {
        UIImage* mlImage = convertQImageToUIImage(image);
        [faceDetector processImage:mlImage completionHandler:^(NSArray<MLKFace *> *faces, NSError *error) {
            QMutexLocker locker(&m_mutex);
            if (m_isDestroyed) {
                [mlImage release];
                return;
            }
            handleDetectionResult(faces, error);
            [mlImage release];
        }];
    }

private:
    QMutex m_mutex;
    bool m_isDestroyed = false;
    MLKFaceDetector* faceDetector;
};

关键优势：从根源上阻止回调触发，避免后续的无效操作。

方案4：绑定Qt信号槽机制 #

将MLKit回调转换为Qt信号，利用Qt的对象销毁自动断开信号特性：

class FaceDetector : public QObject {
    Q_OBJECT
signals:
    void detectionFinished(NSArray<MLKFace*> *faces, NSError *error);

public:
    void runFaceDetection(const QImage& image) {
        UIImage* mlImage = convertQImageToUIImage(image);
        [faceDetector processImage:mlImage completionHandler:^(NSArray<MLKFace *> *faces, NSError *error) {
            // 切换到Qt主线程发送信号
            QMetaObject::invokeMethod(this, [this, faces, error]() {
                emit detectionFinished(faces, error);
            }, Qt::QueuedConnection);
            [mlImage release];
        }];
    }
};

// 使用时连接信号
connect(detector, &FaceDetector::detectionFinished, [](NSArray<MLKFace*> *faces, NSError *error) {
    // 处理结果
});

关键优势：当FaceDetector对象被销毁时，Qt会自动断开所有已连接的信号槽，不会触发后续回调。

内容的提问来源于stack exchange，提问作者Teee