C++ 使常数对常数向量唯一

我想创建一个整数向量。一旦创建，我想洗牌 整数的随机顺序。这将用于测试排序功能

现在，不允许任何排序算法对向量进行就地排序，因此我们需要使向量为常量。另外-我不希望任何人能够更改

唯一的\u ptr

并将其指向其他内容

问题1。我们如何做到这一点

当前解决方案：

在阅读和其他参考资料后，我做了以下工作

我正在创建一个向量，将其分配给唯一指针，以确保它受到内存泄漏的保护，并且在超出范围时自动删除。我们洗牌该向量，然后将该向量移动到一个新的向量，该向量的类型为（

const std:：vector

）。然后，我们将指针移动到一个常量唯一指针

在下面的代码中，我对当前解决方案进行了编码。如果有更好的方法，请告诉我

我正在使用c++17编译程序

#include <random>
#include <memory>
#include <algorithm>
#include <iostream>
#include <vector>

std::unique_ptr<const std::vector <int>>
createConstVector(int numberOfElements, int increments) {
    auto v = std::make_unique <std::vector<int>> (numberOfElements);
    std::random_device rd;
    std::mt19937 g(rd());
    std::generate(v->begin(), v->end(),
                  [n=0, increments] () mutable { n = n + increments; return n;});
    std::shuffle(v->begin(), v->end(), g);
    std::unique_ptr<const std::vector<int>> v2 = std::move(v);
    return std::move(v2);
}

auto sortUsingStdSort(std::unique_ptr<const std::vector<int>> const &vectorToSort) {
  auto v = std::make_unique<std::vector<int>> (*vectorToSort);

  std::sort(v->begin(), v->end());
  return std::move(v);
}

int main () {
  const std::unique_ptr<const std::vector <int>> u3 = createConstVector(10, 5);
  auto sortedVector = sortUsingStdSort(u3);
  for(auto v : *sortedVector) {
    std::cout << " " << v;
  }
}

#包括
#包括
#包括
#包括
#包括
std:：unique\u ptr
createConstVector（int numberOfElements，int增量）{
自动v=标准：：使_唯一（numberOfElements）；
std：：随机_装置rd；
标准：MT19937G（rd（））；
std:：generate（v->begin（），v->end（），
[n=0，增量]（）可变的{n=n+增量；返回n；}）；
std:：shuffle（v->begin（），v->end（），g）；
std:：unique_ptr v2=std:：move（v）；
返回std：：move（v2）；
}
自动排序TDsort（标准：：唯一的\u ptr const和vectorToSort）{
自动v=std:：使_唯一（*vectorToSort）；
排序（v->begin（），v->end（））；
返回std：：move（v）；
}
int main（）{
const std:：unique_ptr u3=createConstVector（10,5）；
auto-sortedVector=sortUsingStdSort（u3）；
用于（自动v:*分拣机）{
std：：cout以下是如何编写它，而不使用原始指针，不使用不必要的
独特的\u ptr
用法，也不使用
std：：move
：

#include <iostream>
#include <random>
#include <algorithm>
#include <vector>

std::vector<int>
createVector(int numberOfElements, int increments) {
    auto v = std::vector<int>(numberOfElements);
    std::random_device rd;
    std::mt19937 g(rd());
    std::generate(v.begin(), v.end(),
                  [n=0, increments] () mutable { n = n + increments; return n;});
    std::shuffle(v.begin(), v.end(), g);
    return v;
}

auto sortUsingStdSort(std::vector<int> v) {
  std::sort(v.begin(), v.end());
  return v;
}

int main() {
  const std::vector<int> u3 = createVector(10, 5);
  auto sortedVector = sortUsingStdSort(u3);
  for(auto v : sortedVector) {
    std::cout << " " << v;
  }
}

#包括
#包括
#包括以避免在此处复制

唯一可以复制的地方是
sortUsingStdSort
函数的参数，我们在这里显式地请求它。
为什么不简单地使用
const vector
而不是
std:：unique\u ptr
？我想你想得太多了。我认为没有必要使用
unique\u ptr
。我们说：
auto sortUsingStdSort（const std：：vector&vectorToSort）{std：：vector v=vectorToSort；std：：sort（v.begin（），v.end（））；return v；}
`@SaileshD我很确定第二个链接中规则的要点是，无论在哪里，只要接受
const unique\u ptr&
你最好接受
T*
（或
T&
）因为两种方式都没有所有权转移，后者更灵活。@RishiAgrawal是的，只需将向量作为一个自动变量。向量基本上已经是其托管数组的唯一ptr（使用一些额外的方法来做向量的事情）.在这种情况下，没有理由动态分配向量本身。非常感谢。这使我能够理解整个“常量”而我认为，代码> > const 是C++的一个最优秀的特性。理解它，你就不能开始喜欢它。<代码> SotutsIsStdStuts也可以接受值，而不是在正文中复制。然后避免从R-值争论中复制到 CeaVeVeCue<代码>。ode>rd
和
g
static

@RobertAndrzejuk我不想做太多的更改来回答这个问题。这里不是codereview.stackexchange.com。