C++ 将对象数组转换为指向唯一对象的指针数组

我试图将一个对象数组转换为一个对象指针数组，其中指针指向一个数组的元素，该数组包含第一个数组的所有唯一对象

我使用的对象复制起来并不便宜，因为它们涉及缓冲区分配和缓冲区复制。然而，它们的移动成本很低

例如： 阵列

[G，F，E，G，E，G]

应转换为唯一的对象数组
U=[E，F，G]和指针数组
P=[&U[2]、&U[1]、&U[0]、&U[2]、&U[0]、&U[2]]

我目前正在使用以下代码来实现此目的：

int N; // 50 Millions and more
std::vector<MyObj> objarray; // N elements
std::vector<MyObj*> ptrarray; // N elements
...
std::vector<MyObj> tmp(objarray.begin(), objarray.end());

std::sort(objarray.begin(), objarray.end());
auto unique_end = std::unique(objarray.begin(), objarray.end());

// now, [objarray.begin(), unique_end) contains all unique objects

std::map<MyObj, int> indexmap;

// save index for each unique object
int index = 0;
for(auto it = objarray.begin(); it != uniqueend; it++){
    indexmap[*it] = index;
    index++;
}

//for each object in original array, look up index in unique object array and save the pointer
for(int i = 0; i < N; i++)
    ptrarray[i] = &objarray[indexmap[tmp[i]]];

int N；//五千多万
std:：vector objarray；//N元素
std:：vector ptrarray；//N元素
...
向量tmp（objarray.begin（），objarray.end（））；
排序（objarray.begin（），objarray.end（））；
auto unique_end=std:：unique（objarray.begin（），objarray.end（））；
//现在，[objarray.begin（），unique_end）包含所有唯一的对象
std：：map indexmap；
//保存每个唯一对象的索引
int指数=0；
for（auto-it=objarray.begin（）；it！=uniquend；it++）{
indexmap[*it]=索引；
索引++；
}
//对于原始数组中的每个对象，在唯一对象数组中查找索引并保存指针
对于（int i=0；i

有没有更有效的方法来实现这一点，因为对象副本很昂贵，可能不需要创建原始数组的副本？

struct r{
struct r {
  std::vector<MyObj> objects;
  std::vector<MyObj*> ptrs;
};

r func( std::vector<MyObj> objarray ) {

  // makes a vector containing {0, 1, 2, 3, ..., N-1}
  auto make_index_buffer = [&]{
    std::vector<std::size_t> r;
    r.reserve(objarray.size());
    for (std::size_t i = 0; i < objarray.size(); ++i)
      r.push_back( i );
    return r;
  };

  // build a buffer of unique element indexes:
  auto uniques = make_index_buffer();

  // compares indexes by their object: 
  auto index_less = [&](auto lhs, auto rhs) { return objarray[lhs]<objarray[rhs]; };
  auto index_equal = [&](auto lhs, auto rhs) { return objarray[lhs]==objarray[rhs]; };

  std::sort( uniques.begin(), uniques.end(), index_less );
  uniques.erase( std::unique( uniques.begin(), uniques.end(), index_equal ), uniques.end() );

  // build table of index to unique index:
  std::map<std::size_t, std::size_t, index_less> table;
  for (std::size_t& i : uniques)
    table[i] = &i-uniques.data();

  // list of index to unique index for each element:
  auto indexes = make_index_buffer();

  // make indexes unique:
  for (std::size_t& i:indexes)
    i = table[i];

  // after this, table will be invalidated.  Clear it first:
  table = {};

  // build unique object list:
  std::vector<MyObj> objects;
  objects.reserve( uniques.size() );
  for (std::size_t i : uniques)
    objects.push_back( std::move(objarray[i]) );

  // build pointer objects:
  std::vector<MyObj*> ptrarray; // N elements
  ptrarray.reserve( indexes.size() );
  for (std::size_t i : indexes)
    ptrarray.push_back( std::addressof( objects[i] ) );

  return {std::move(objects), std::move(ptrarray)};
}

向量对象；
std：：载体ptrs；
};
r func（标准：：矢量对象）{
//生成一个包含{0，1，2，3，…，N-1}的向量
自动生成索引缓冲区=[&]{
std：：向量r；
r、 保留（objarray.size（））；
对于（std:：size_t i=0；i自动索引_-less=[&]（自动左侧，自动右侧）{返回objarray[lhs]移动它们便宜吗？代码看起来是错误的，因为它在跟踪它们来自何处之前进行了排序和消除。此外，在消除重复项之后，它无法修剪数组的末尾。是的，移动它们便宜。我在文章中添加了此信息。修剪没有显示在代码中。它发生在填充ptraray之前。另一个是sue表示您正在存储指向向量中元素的指针。如果以任何方式调整该向量的大小，则这些指针可能会无效。例如：
ptrarray[i]=&objarray[indexmap[tmp[i]]；
@Abator-Abator-Abator，使用向量索引（位置）每个对象的标识符都是我担心的问题。@PaulMcKenzie我知道这一点。设置指针后，objarray不会改变。Ptraray和objarray的生存期也是相同的。我猜您仍然在指针向量上构建代码，以尽量减少更改以保持清晰。引入结构不是更合适吗！

用和int表示对象绝对位置及其对象指针？代码中还有一个小错误。std:：unique的lambda应该测试等价性，不少于。尽管如此，做得很好。谢谢。@AbatorAbetor修复了。我为不编译和运行而付出的代价。@MohammadKanan可能。这将取决于使用和寿命测量的仔细程度。指向向量和偏移量的指针与指向元素的指针具有不同的失效问题。您甚至可以使用共享指针的别名向量，并将元素向量存储在共享ptr中。