我正在使用一个外部库，该库有时会给我一个指向整数和大小数组的原始指针。

现在，我想std::vector用来访问和修改这些值，而不是使用原始指针访问它们。

这是一个解释这一点的人工示例：

size_t size = 0;
int * data = get_data_from_library(size);   // raw data from library {5,3,2,1,4}, size gets filled in

std::vector<int> v = ????;                  // pseudo vector to be used to access the raw data

std::sort(v.begin(), v.end());              // sort raw data in place

for (int i = 0; i < 5; i++)
{
  std::cout << data[i] << "\n";             // display sorted raw data 
}

预期产量：

1
2
3
4
5

原因是我需要<algorithm>对该数据应用（排序，交换元素等）算法。

在另一方面改变这种载体的大小将永远不会改变，因此push_back，erase，insert不要求工作在该载体。

我可以根据库中的数据构造一个向量，使用修改该向量并将数据复制回库中，但这将是两个完整的副本，由于数据集可能很大，因此我要避免。

问题在于，std::vector必须对其进行初始化的数组中的元素进行复制，因为它拥有所包含对象的所有权。

为了避免这种情况，你可以用一个切片对象的数组（即类似于std::string_view是std::string）。您可以编写自己的array_view类模板实现，该类模板的实现是通过使用原始指针指向数组的第一个元素和数组长度来构造的：

#include <cstdint>

template<typename T>
class array_view {
   T* ptr_;
   std::size_t len_;
public:
   array_view(T* ptr, std::size_t len) noexcept: ptr_{ptr}, len_{len} {}

   T& operator[](int i) noexcept { return ptr_[i]; }
   T const& operator[](int i) const noexcept { return ptr_[i]; }
   auto size() const noexcept { return len_; }

   auto begin() noexcept { return ptr_; }
   auto end() noexcept { return ptr_ + len_; }
};

array_view不存储数组；它只是持有一个指向数组开头和该数组长度的指针。因此，array_view对象的构造和复制便宜。

由于array_view提供了begin()与end()部件的功能，可以使用标准库算法（例如，std::sort，std::find，std::lower_bound，等等）就可以了：

#define LEN 5

auto main() -> int {
   int arr[LEN] = {4, 5, 1, 2, 3};

   array_view<int> av(arr, LEN);

   std::sort(av.begin(), av.end());

   for (auto const& val: av)
      std::cout << val << ' ';
   std::cout << '\n';
}

输出：

1 2 3 4 5

使用std::span（或gsl::span）代替

上面的实现公开了切片对象背后的概念。但是，由于C ++ 20，您可以直接使用std::span。无论如何，您都可以使用gsl::spanC ++ 14以后的版本。

C ++ 20年代 std::span

如果能够使用C ++ 20，则可以使用“ std::span指针-长度对”，它使用户可以查看连续的元素序列。它是一种std::string_view，虽然std::span和和std::string_view均为非所有者视图，但std::string_view它是只读视图。

从文档：

类模板范围描述了一个对象，该对象可以引用对象的连续序列，序列的第一个元素位于位置0。跨度既可以具有静态范围，也可以具有动态范围，在这种情况下，序列中的元素数量是已知的并且已按类型进行编码。

因此，以下方法将起作用：

#include <span>
#include <iostream>
#include <algorithm>

int main() {
    int data[] = { 5, 3, 2, 1, 4 };
    std::span<int> s{data, 5};

    std::sort(s.begin(), s.end());

    for (auto const i : s) {
        std::cout << i << "\n";
    }

    return 0;
}

现场查看

由于std::span基本上是指针-长度对，因此您也可以按以下方式使用：

size_t size = 0;
int *data = get_data_from_library(size);
std::span<int> s{data, size};

注意：并非所有编译器都支持std::span。在此处检查编译器支持。

更新

如果您不能使用C ++ 20，则可以使用C ++ 20 gsl::span的基本版本std::span。

C ++ 11解决方案

如果限于C ++ 11标准，则可以尝试实现自己的简单span类：

template<typename T>
class span {
   T* ptr_;
   std::size_t len_;

public:
    span(T* ptr, std::size_t len) noexcept
        : ptr_{ptr}, len_{len}
    {}

    T& operator[](int i) noexcept {
        return *ptr_[i];
    }

    T const& operator[](int i) const noexcept {
        return *ptr_[i];
    }

    std::size_t size() const noexcept {
        return len_;
    }

    T* begin() noexcept {
        return ptr_;
    }

    T* end() noexcept {
        return ptr_ + len_;
    }
};

现场查看C ++ 11版本

由于算法库与迭代器一起使用，因此您可以保留数组。

对于指针和已知的数组长度

在这里，您可以使用原始指针作为迭代器。它们支持迭代器支持的所有操作（递增，相等性比较，value的值等）：

#include <iostream>
#include <algorithm>

int *get_data_from_library(int &size) {
    static int data[] = {5,3,2,1,4}; 

    size = 5;

    return data;
}


int main()
{
    int size;
    int *data = get_data_from_library(size);

    std::sort(data, data + size);

    for (int i = 0; i < size; i++)
    {
        std::cout << data[i] << "\n";
    }
}

data指向最脏的数组成员（如，返回的迭代器），begin()并data + size指向数组最后一个元素之后的元素（如，返回的迭代器）end()。

对于数组

在这里您可以使用std::begin()和std::end()

#include <iostream>
#include <algorithm>

int main()
{
    int data[] = {5,3,2,1,4};         // raw data from library

    std::sort(std::begin(data), std::end(data));    // sort raw data in place

    for (int i = 0; i < 5; i++)
    {
        std::cout << data[i] << "\n";   // display sorted raw data 
    }
}

但是请记住，这只有data在不衰减到指针的情况下才有效，因为这样会丢失长度信息。

您可以在原始数组上获得迭代器，并在算法中使用它们：

    int data[] = {5,3,2,1,4};
    std::sort(std::begin(data), std::end(data));
    for (auto i : data) {
        std::cout << i << std::endl;
    }

如果使用原始指针（ptr +大小），则可以使用以下技术：

    size_t size = 0;
    int * data = get_data_from_library(size);
    auto b = data;
    auto e = b + size;
    std::sort(b, e);
    for (auto it = b; it != e; ++it) {
        cout << *it << endl;
    }

UPD： 但是，上面的示例设计不好。该库返回给我们一个原始指针，我们不知道底层缓冲区分配在哪里以及谁应该释放它。

通常，调用者为函数填充数据提供缓冲。在这种情况下，我们可以预分配向量并使用其底层缓冲区：

    std::vector<int> v;
    v.resize(256); // allocate a buffer for 256 integers
    size_t size = get_data_from_library(v.data(), v.size());
    // shrink down to actual data. Note that no memory realocations or copy is done here.
    v.resize(size);
    std::sort(v.begin(), v.end());
    for (auto i : v) {
        cout << i << endl;
    }

使用C ++ 11或更高版本时，我们甚至可以使get_data_from_library（）返回向量。由于进行了移动操作，因此不会有内存副本。

如果std::vector没有进行复制，您将无法使用。 std::vector拥有其幕后的指针，并通过提供的分配器分配空间。

如果您需要支持C ++ 20的编译器，则可以使用为此目的而构建的std :: span。它将指针和大小包装到具有C ++容器接口的“容器”中。

如果没有，您可以使用gsl :: span，它是标准版本的基础。

如果您不想导入其他库，则可以根据需要具备的所有功能来自己简单地实现此功能。

现在，我想使用std :: vector来访问和修改这些值

你不能。那不是std::vector为了什么 std::vector管理自己的缓冲区，该缓冲区始终从分配器获取。它永远不会拥有另一个缓冲区的所有权（从相同类型的另一个向量中除外）。

另一方面，您也不需要因为...

原因是我需要对该数据应用（排序，交换元素等）算法。

这些算法适用于迭代器。指针是数组的迭代器。您不需要向量：

std::sort(data, data + size);

与中的功能模板不同<algorithm>，某些工具（例如range-for，std::begin/ std::end和C ++ 20范围）不能仅与一对迭代器一起使用，而可以与向量（vector）等容器一起使用。可以为迭代器+ size创建一个包装器类，该包装器的行为类似于范围，并可以与这些工具一起使用。C ++ 20会将这样的包装器引入标准库：中std::span。

除了关于std::span使用c ++ 20和的其他好建议之外，到那时为止还gsl:span包括您自己的（轻量级）span类已经很容易了（可以随意复制）：

template<class T>
struct span {
    T* first;
    size_t length;
    span(T* first_, size_t length_) : first(first_), length(length_) {};
    using value_type = std::remove_cv_t<T>;//primarily needed if used with templates
    bool empty() const { return length == 0; }
    auto begin() const { return first; }
    auto end() const { return first + length; }
};

static_assert(_MSVC_LANG <= 201703L, "remember to switch to std::span");

如果您对更通用的范围概念感兴趣，还要特别注意一下升程范围库boost-range：https : //www.boost.org/doc/libs/1_60_0/libs/range/doc/html/range/reference /utilities/iterator_range.html。

范围概念也将在c ++ 20中出现

实际上，通过滥用自定义分配器功能将指针返回到要查看的内存，您几乎可以使用std::vector它。标准无法保证这会正常工作（填充，对齐，返回值的初始化；在分配初始大小时，您将需要付出很多努力；对于非基本类型，您还需要修改构造函数），但实际上，我希望它能进行足够的调整。

永远不会那样做。这是丑陋的，令人惊讶的，hacky和不必要的。标准库的算法已被设计为与原始数组以及矢量均能正常工作。有关详细信息，请参见其他答案。

正如其他人指出的那样，std::vector必须拥有底层内存（不要与自定义分配器混淆），因此无法使用。

其他人也推荐了c ++ 20的跨度，但是显然需要c ++ 20。

我建议使用span-lite span。引用它的字幕：

span lite-单文件标头库中的C ++ 98，C ++ 11和更高版本的类似于C ++ 20的span

它提供了一个无所有权和可变的视图（因为您可以更改元素及其顺序，但不能插入它们），并且正如引号所说的那样，它没有依赖关系，并且可以在大多数编译器上使用。

你的例子：

#include <algorithm>
#include <cstddef>
#include <iostream>

#include <nonstd/span.hpp>

static int data[] = {5, 1, 2, 4, 3};

// For example
int* get_data_from_library()
{
  return data;
}

int main ()
{
  const std::size_t size = 5;

  nonstd::span<int> v{get_data_from_library(), size};

  std::sort(v.begin(), v.end());

  for (auto i = 0UL; i < v.size(); ++i)
  {
    std::cout << v[i] << "\n";
  }
}

版画

1
2
3
4
5

如果有一天你做切换到C ++ 20这也有增加的上攻，你就应该能够取代这一nonstd::span带std::span。

您可以使用std::reference_wrapperC ++ 11以后的版本：

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>

int main()
{
    int src_table[] = {5, 4, 3, 2, 1, 0};

    std::vector< std::reference_wrapper< int > > dest_vector;

    std::copy(std::begin(src_table), std::end(src_table), std::back_inserter(dest_vector));
    // if you don't have the array defined just a pointer and size then:
    // std::copy(src_table_ptr, src_table_ptr + size, std::back_inserter(dest_vector));

    std::sort(std::begin(dest_vector), std::end(dest_vector));

    std::for_each(std::begin(src_table), std::end(src_table), [](int x) { std::cout << x << '\n'; });
    std::for_each(std::begin(dest_vector), std::end(dest_vector), [](int x) { std::cout << x << '\n'; });
}