如何在多次实例化的C++类中复用大型数据映射表？

问题场景 #

你定义的A类包含大型的map<A,B>和map<A,C>成员，每次实例化A都会复制一份这些映射表，当创建大量A对象时会造成严重的内存冗余：

#include <map>
using namespace std;

class A {
    const map<A, B> AToB = ;//... 大型数据块
    const map<A, C> AToC = ;//... 大型数据块
    
    B AsBType() {
        return AToB.at(data);
    }
    //... AsCType等方法类似
    
    Data data;
};

你尝试的方案及顾虑 #

1. 全局映射表方案
   将映射表设为全局变量，让A类引用：

   const map<A,B> AToB = ; //...
   
   class A {
       Data data;
   public:
       B AsBType() {
           return AToB.at(data);
       }
       //...
   };
   

   顾虑：映射表全局可见，不想暴露给其他代码。

2. ATranslator单例方案
   把转换逻辑放到单例类中：

   class A {
       Data data;
   public:
       Data GetData() {
           return data;
       }
   };
   class ATranslator {
       const map<A,B> AToB = ; //...
       
       B AsBType(A a) {
           return AToB.at(a.GetData());
       }
   };
   

   顾虑：单例需要在各处传递，全局单例的可行性不确定。

推荐解决方案 #

方案1：使用A类的私有静态成员（最简洁）

把映射表声明为A类的private静态const成员，这样所有A对象共享一份实例，且仅A类内部可访问，完美解决全局暴露的问题：

#include <map>
using namespace std;

class A {
private:
    // 静态成员：所有A实例共享，仅类内部可见
    static const map<A, B> AToB;
    static const map<A, C> AToC;
    
    Data data;
    
public:
    B AsBType() {
        return AToB.at(data);
    }
    // ... AsCType等方法类似
};

// 必须在类外部初始化静态成员（否则会触发链接错误）
const map<A, B> A::AToB = /* 填入大型数据块初始化逻辑 */;
const map<A, C> A::AToC = /* 填入大型数据块初始化逻辑 */;

• 优势：内存仅占用一份，无全局暴露问题，代码改动最小；
• 注意：C++中类的静态成员必须在类外初始化（除非是constexpr类型）。

方案2：优化后的ATranslator单例（适合逻辑分离场景）

如果想把转换逻辑独立出来，可以将ATranslator设计为私有构造的单例，并让A类成为其友元，这样既不需要传递单例对象，也能保证映射表仅被授权类访问：

#include <map>
using namespace std;

class A; // 前向声明

class ATranslator {
private:
    const map<A, B> AToB;
    const map<A, C> AToC;
    
    // 私有构造：禁止外部创建实例
    ATranslator() : AToB(/* 初始化数据 */), AToC(/* 初始化数据 */) {}
    
    // 友元声明：允许A类直接访问内部映射表
    friend class A;
    
public:
    // 线程安全的单例获取方式（C++11及以上标准保证）
    static ATranslator& GetInstance() {
        static ATranslator instance;
        return instance;
    }
};

class A {
private:
    Data data;
    
public:
    B AsBType() {
        // 直接通过单例访问映射表，无需暴露Data的getter
        return ATranslator::GetInstance().AToB.at(data);
    }
    // ... AsCType等方法类似
};

• 优势：转换逻辑与A类解耦，单例全局可访问但内部数据仅对A开放，线程安全；
• 注意：局部静态变量实现的单例在C++11之前不保证线程安全，若使用旧标准需加锁。

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