如何在std::map中存储永不失效的Maya API对象？C++

针对Maya场景中缓存对象（含重复引用实例）的需求，以下是几种高效且安全的实现方案：

方案1：使用MObjectHandle作为std::map键（推荐） #

MObjectHandle是Maya提供的安全对象引用，能区分同一源文件多次导入的实例（即使UUID重复），且自带有效性检查。只需自定义比较器让它能作为std::map的键：

#include <maya/MObjectHandle.h>
#include <map>

// 自定义比较器，用于std::map排序
struct MObjectHandleCompare {
    bool operator()(const MObjectHandle& lhs, const MObjectHandle& rhs) const {
        // 无效句柄排在前面
        if (!lhs.isValid() && !rhs.isValid()) return false;
        if (!lhs.isValid()) return true;
        if (!rhs.isValid()) return false;
        // 通过MObject的哈希值比较，确保唯一实例区分
        return lhs.object().hashCode() < rhs.object().hashCode();
    }
};

// 定义缓存容器
std::map<MObjectHandle, YourCachedDataType, MObjectHandleCompare> objectCache;

优势： #

• 自动处理对象删除/失效场景，可通过isValid()快速校验缓存条目有效性
• 每个引用实例对应唯一MObject，避免UUID重复问题
• std::map查找复杂度为O(logn)，性能满足大部分场景

方案2：使用MDagPath作为std::map键 #

如果需要基于完整路径标识对象，可自定义MDagPath的比较逻辑，利用其包含的层级和引用节点信息区分实例：

#include <maya/MDagPath.h>
#include <map>

struct MDagPathCompare {
    bool operator()(const MDagPath& lhs, const MDagPath& rhs) const {
        // 先比较路径层级长度
        if (lhs.length() != rhs.length()) return lhs.length() < rhs.length();
        // 逐个比较路径上的节点哈希值
        for (unsigned int i = 0; i < lhs.length(); ++i) {
            const MObject lhsNode = lhs.node(i);
            const MObject rhsNode = rhs.node(i);
            const auto lhsHash = lhsNode.hashCode();
            const auto rhsHash = rhsNode.hashCode();
            if (lhsHash != rhsHash) return lhsHash < rhsHash;
        }
        // 路径完全相同
        return false;
    }
};

std::map<MDagPath, YourCachedDataType, MDagPathCompare> dagPathCache;

优势： #

• 直接关联对象的层级路径，方便后续路径相关操作
• 天然区分不同引用实例下的同名节点（引用节点的MObject不同）

方案3：使用MUniqueID作为std::map键（最快访问） #

MUniqueID是Maya为每个节点实例分配的全局唯一整数ID，无需自定义比较器，整数键的std::map查找效率最高：

#include <maya/MUniqueID.h>
#include <map>

// 直接定义缓存，MUniqueID默认支持operator<
std::map<MUniqueID, YourCachedDataType> uniqueIdCache;

使用方式： #

通过MObject的getUniqueID()方法获取ID：

MObject targetObj;
MUniqueID objId;
targetObj.getUniqueID(objId);
// 存入缓存
uniqueIdCache[objId] = yourData;

进阶：用std::unordered_map实现O(1)平均查找 #

如果追求极致访问速度，可改用std::unordered_map，需自定义哈希函数和相等判断（以MObjectHandle为例）：

#include <maya/MObjectHandle.h>
#include <unordered_map>

struct MObjectHandleHash {
    size_t operator()(const MObjectHandle& handle) const {
        if (!handle.isValid()) return 0;
        // 基于MObject的哈希值生成哈希码
        return std::hash<size_t>()(handle.object().hashCode());
    }
};

struct MObjectHandleEqual {
    bool operator()(const MObjectHandle& lhs, const MObjectHandle& rhs) const {
        if (!lhs.isValid() && !rhs.isValid()) return true;
        if (!lhs.isValid() || !rhs.isValid()) return false;
        return lhs.object().hashCode() == rhs.object().hashCode();
    }
};

std::unordered_map<MObjectHandle, YourCachedDataType, MObjectHandleHash, MObjectHandleEqual> fastObjectCache;

注意事项 #

• 定期清理缓存中无效的条目（比如通过isValid()检查MObjectHandle，或验证MDagPath是否存在），避免内存泄漏
• 避免使用对象名称/UUID作为键：名称可被修改，UUID在重复引用场景下不唯一

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