Estoy usando una biblioteca externa que en algún momento me da un puntero en bruto a una matriz de enteros y un tamaño.

Ahora me gustaría utilizar std::vectorpara acceder y modificar estos valores en su lugar, en lugar de acceder a ellos con punteros sin formato.

Aquí hay un ejemplo articular que explica el punto:

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 
}

Rendimiento esperado:

1
2
3
4
5

La razón es que necesito aplicar algoritmos de <algorithm>(clasificación, intercambio de elementos, etc.) en esos datos.

Por otro lado cambiar el tamaño de ese vector no sería cambiado, por lo que push_back, erase, insertno están obligados a trabajar en ese vector.

Podría construir un vector basado en los datos de la biblioteca, usar modificar ese vector y copiar los datos de nuevo a la biblioteca, pero serían dos copias completas que me gustaría evitar ya que el conjunto de datos podría ser realmente grande.

El problema es que std::vectortiene que hacer una copia de los elementos de la matriz con la que lo inicializa, ya que tiene la propiedad de los objetos que contiene.

Para evitar esto, puede usar un objeto de división para una matriz (es decir, similar a lo que std::string_viewes std::string). Puede escribir su propia array_viewimplementación de plantilla de clase cuyas instancias se construyen tomando un puntero sin procesar al primer elemento de una matriz y la longitud de la matriz:

#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_viewno almacena una matriz; solo tiene un puntero al comienzo de la matriz y la longitud de esa matriz. Por lo tanto, los array_viewobjetos son baratos de construir y copiar.

Dado que array_viewproporciona las begin()y end()miembros de funciones, se pueden utilizar los algoritmos de la biblioteca estándar (por ejemplo, std::sort, std::find, std::lower_bound, etc.) sobre el mismo:

#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';
}

Salida:

1 2 3 4 5

Use std::span(o gsl::span) en su lugar

La implementación anterior expone el concepto detrás de los objetos de corte . Sin embargo, desde C ++ 20 puede usar directamente en su std::spanlugar. En cualquier caso, puedes usarlo gsl::spandesde C ++ 14.

C ++ 20's std::span

Si puede usar C ++ 20, puede usar std::spanun par de longitud de puntero que le da al usuario una vista de una secuencia contigua de elementos. Es una especie de std::string_view, y mientras tanto std::spany std::string_viewson vistas no propietario, std::string_viewes una vista de sólo lectura.

De los documentos:

El intervalo de plantilla de clase describe un objeto que puede referirse a una secuencia contigua de objetos con el primer elemento de la secuencia en la posición cero. Un intervalo puede tener una extensión estática, en cuyo caso el número de elementos en la secuencia es conocido y codificado en el tipo, o una extensión dinámica.

Entonces lo siguiente funcionaría:

#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;
}

Compruébalo en vivo

Dado que std::spanes básicamente un par de puntero - longitud, también puede usarlo de la siguiente manera:

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

Nota: No todos los compiladores son compatibles std::span. Verifique el soporte del compilador aquí .

ACTUALIZAR

Si no puede usar C ++ 20, podría usar gsl::spanbásicamente la versión base de los estándares de C ++ std::span.

Solución C ++ 11

Si está limitado al estándar C ++ 11, puede intentar implementar su propia spanclase simple :

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_;
    }
};

Echa un vistazo a la versión C ++ 11 en vivo

Dado que la biblioteca de algoritmos funciona con iteradores, puede mantener la matriz.

Para punteros y longitud de matriz conocida

Aquí puede usar punteros sin formato como iteradores. Admiten todas las operaciones que admite un iterador (incremento, comparación para igualdad, valor de, etc.):

#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";
    }
}

dataseñala al miembro de la matriz dirst como un iterador devuelto por begin()y data + sizeapunta al elemento después del último elemento de la matriz como un iterador devuelto por end().

Para matrices

Aquí puedes usar std::begin()ystd::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 
    }
}

Pero tenga en cuenta que esto solo funciona, si datano se descompone en un puntero, porque la información de longitud se pierde.

Puede obtener iteradores en matrices sin procesar y usarlos en algoritmos:

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

Si está trabajando con punteros sin formato (ptr + tamaño), puede usar la siguiente técnica:

    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: Sin embargo, el ejemplo anterior es de mal diseño. La biblioteca nos devuelve un puntero sin procesar y no sabemos dónde está asignado el búfer subyacente y quién se supone que lo liberará.

Por lo general, la persona que llama proporciona un búfer para que la función complete los datos. En ese caso, podemos preasignar el vector y usar su búfer subyacente:

    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;
    }

Al usar C ++ 11 o superior, incluso podemos hacer que get_data_from_library () devuelva un vector. Gracias a las operaciones de movimiento, no habrá copia de memoria.

No puede hacer esto con un std::vectorsin hacer una copia. std::vectorposee el puntero que tiene debajo del capó y asigna espacio a través del asignador que se proporciona.

Si tiene acceso a un compilador que tiene soporte para C ++ 20, puede usar std :: span que fue construido exactamente para este propósito. Envuelve un puntero y un tamaño en un "contenedor" que tiene la interfaz de contenedor C ++.

Si no, puede usar gsl :: span, que es en lo que se basó la versión estándar.

Si no desea importar otra biblioteca, puede implementarla trivialmente usted mismo dependiendo de qué funcionalidad quiera tener.

Ahora me gustaría usar std :: vector para acceder y modificar estos valores en su lugar

No se puede. Eso no std::vectores para lo que sirve. std::vectorgestiona su propio búfer, que siempre se adquiere de un asignador. Nunca toma posesión de otro búfer (excepto de otro vector del mismo tipo).

Por otro lado, tampoco es necesario porque ...

La razón es que necesito aplicar algoritmos de (clasificación, intercambio de elementos, etc.) en esos datos.

Esos algoritmos funcionan en iteradores. Un puntero es un iterador de una matriz. No necesitas un vector:

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

A diferencia de las plantillas de función en <algorithm>, algunas herramientas como el rango para std::begin/ / std::endy los rangos C ++ 20 no funcionan con solo un par de iteradores, aunque sí funcionan con contenedores como los vectores. Es posible crear una clase de contenedor para iterador + tamaño que se comporte como un rango y funcione con estas herramientas. C ++ 20 introducirá tales envoltura en la biblioteca estándar: std::span.

Además de la otra buena sugerencia sobre std::spanvenir en c ++ 20 e gsl:spanincluir su propia spanclase (ligera) hasta entonces ya es bastante fácil (siéntase libre de copiar):

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");

De especial interés es también la biblioteca boost range boost-range si está interesado en el concepto de rango más genérico: https://www.boost.org/doc/libs/1_60_0/libs/range/doc/html/range/reference /utilities/iterator_range.html .

Los conceptos de rango también llegarán en c ++ 20

En realidad casi podrías usarstd::vector esto, abusando de la funcionalidad del asignador personalizado para devolver un puntero a la memoria que desea ver. Eso no estaría garantizado por el estándar para trabajar (relleno, alineación, inicialización de los valores devueltos; tendrías que esforzarte al asignar el tamaño inicial, y para los no primitivos también necesitarías hackear tus constructores ), pero en la práctica esperaría que le dieran suficientes ajustes.

Nunca jamás hagas eso. Es feo, sorprendente, hacky e innecesario. Los algoritmos de la biblioteca estándar ya están diseñados para funcionar tan bien con matrices sin procesar como con vectores. Vea las otras respuestas para detalles de eso.

Como otros han señalado, std::vector debe ser dueño de la memoria subyacente (menos que jugar con un asignador personalizado) para que no se pueda usar.

Otros también han recomendado la duración de c ++ 20, sin embargo, obviamente eso requiere c ++ 20.

Recomendaría el span-lite span. Para citar es subtítulo:

span lite: un intervalo similar a C ++ 20 para C ++ 98, C ++ 11 y posterior en una biblioteca de solo encabezado de archivo único

Proporciona una vista no propietaria y mutable (ya que puede mutar elementos y su orden pero no insertarlos) y, como dice la cita, no tiene dependencias y funciona en la mayoría de los compiladores.

Su ejemplo:

#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";
  }
}

Huellas dactilares

1
2
3
4
5

Esto también tiene la ventaja adicional si un día cambias a c ++ 20, solo deberías poder reemplazarlo nonstd::spanpor std::span.

Puede usar un std::reference_wrapperdisponible desde C ++ 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'; });
}