C++ 存储大型相似对象的更好方法

因此，我有一个“大”类

a

，另一个类

B

，它将容纳至少100个

a

对象的向量。将类

B

中的所有对象作为

向量存储似乎不是一个好主意，因为很多信息都可以重用

我正在考虑在类
B
中使用一个模板，它保存
a
的所有类似属性，然后为它创建一个
向量。但这让他们都一样

那么，有没有一种方法可以存储一个类的相似变量，以便只需多次存储少数差异

最小工作示例
#包括
//假设int很大：
struct A{//创建一个包含3个整数的结构
A（）：A（0），b（0），c（0）{}
void print（）{//打印所有变量
不能换一种方式：

std::vector <std::reference_wrapper<A>> vector_ref_A;

std:：vector vector\u ref\u A；

例如：

A a, b, c;

std::vector < std::reference_wrapper < A >> vector_ref_A = {a, b, c};

for (int i = 0; i < vector_ref_A.size(); ++i) {
    vector_ref_A[i].get().randomize();
}

for (int i = 0; i < vector_ref_A.size(); ++i) {
    vector_ref_A[i].get().print();
}

A、b、c；
std：：vector>vector_ref_A={A，b，c}；
对于（int i=0；i
需要一些澄清，但我会同意我对你问题的理解

struct Common_A_Members
{
  int x;
  double y;
};

struct Uncommon_A_Members
{
  unsigned int this_member_changes;
};

struct A : public Common_A_Members, public Uncommon_A_Members
{
  A(const Common_A_Members& c, const Uncommon_A_Members& d)
  : Common_A_Members(c), Uncommon_A_Members(d)
  { ; }
};


struct B
{
  Common_A_Members a_common;
  std::vector<Uncommon_A_Members> a_uncommon;
};

struct Common\u\u成员
{
int x；
双y；
};
结构成员
{
unsigned int此成员更改；
};
结构A：公共公共成员、公共非公共成员
{
A（常数普通A_成员和c，常数不寻常A_成员和d）
：普通成员（c）、不常见成员（d）
{ ; }
};
结构B
{
普通会员普通会员；
std：：向量a_不常见；
};

在上面的示例中，concept类分为两部分，一部分包含不变的值（普通成员）和不变的值（不常见成员）。这允许
B
具有一个常量数据成员和一个
更改的
数据向量。
a
概念类具有一个组合常量数据和更改数据的构造函数

B
中的两个成员是一个集合。对于具有不同常量值的概念类，需要复制或重复该集合

理论是从不断变化的数据中分离出常数数据。
如果变量b、c对于A的所有实例都是相同的，则将它们设为A中的静态变量

如果变量B、C对于存储在B的一个实例中的实例集是相同的，则考虑将B、C替换为B。
如果变量B、C仅对于某一组A是相同的，考虑因子B、C到它自己的“配置”类C，并将智能指针存储到C中。A假设B、C足够大，或者由足够的实例共享，以便额外的管理是值得的。
顺便问一下，您确定print2（）函数应该使用vector_ptr_A[0]而不是vector_ptr_A[i]吗？
（如果可以的话，我会在评论中问这个问题……）
编辑：第三个选项的参考版本：

class A_Config // stores common parts of A
{
public:
  A_Config(int a, int b) : m_a(a), m_b(b) {}
private:
  int m_a;
  int m_b;
};

class A // store parts changing for each instance and a reference to the common parts
{
public:
  A(int changing, A_Config& shared) : m_changing(changing), m_shared(shared) {}
private:
  int m_changing;
  A_Config& m_shared;
};

class B
{
public:
  B(int a, int b) : conf(a,b) {} // the common parts of A initialized 
                                 // only once when B is created

  void add_A(int changing) // add the changing parts when A is added
  {
    v.push_back( A(changing, conf) );
  }

private:
  A_Config conf;
  vector<A> v;
};

class A\u Config//存储
{
公众：
A_-Config（inta，intb）：m_-A（A），m_-b（b）{}
私人：
国际货币基金组织；
国际货币基金组织；
};
class A//存储每个实例的零件更改和对公共零件的引用
{
公众：
A（int-changing，A_-Config&shared）：m_-changing（changing），m_-shared（shared）{}
私人：
国际货币单位变化；
A_配置&m_共享；
};
B类
{
公众：
B（inta，intb）：conf（a，B）{}//初始化的
//仅在创建B时使用一次
void add_A（int changing）//添加A时添加更改部分
{
v、 推回（A（改变，形态））；
}
私人：
A_Config conf；
向量v；
};
拥有一个对象向量实际上比拥有一个指向对象的指针向量占用的空间要少。原因是，有了指针向量，除了对象的空间之外，还有指针的空间。这两个向量之间的主要区别是对象存储的位置，仅此而已。如果你想要一个di向量不同的对象，查看或库。我不确定我是否理解：如果
b
和
c
对于每个
A
都应该是相同的，为什么它们不是
A
的
static
数据成员？如果它们对于同一
b
所包含的所有
A
都必须是相同的，那么这些值为什么不是相同呢根据
b
以任何方式分配给
b
和
c
，但请注意，此模运算不会在范围内生成均匀分布的随机数（除非机器上的RAND_MAX是100的倍数）.你应该使用这个RAND_MAX，但是…它没那么重要-你只会稍微倾斜distribution@AndyProwl
b
和
c
应该由类
b
设置，并且可以由其他人赋予其他值。这样做只是为了简单。我喜欢你的想法，但我不希望更改
A
>仅适用于
B
。我可能可以在
B
中创建一个结构的向量，其中包含所有不常见的值和
a
的一个对象。你能解释第三种方法吗？比如在
a
中创建一个包含这些变量的结构吗？是的，这是一个打字错误，谢谢。@didii我编辑了答案以反映我的想法。添加了示例代码。我不知道这是什么：p
class A_Config // stores common parts of A
{
public:
  A_Config(int a, int b) : m_a(a), m_b(b) {}
private:
  int m_a;
  int m_b;
};

class A // store parts changing for each instance and a reference to the common parts
{
public:
  A(int changing, A_Config& shared) : m_changing(changing), m_shared(shared) {}
private:
  int m_changing;
  A_Config& m_shared;
};

class B
{
public:
  B(int a, int b) : conf(a,b) {} // the common parts of A initialized 
                                 // only once when B is created

  void add_A(int changing) // add the changing parts when A is added
  {
    v.push_back( A(changing, conf) );
  }

private:
  A_Config conf;
  vector<A> v;
};