¿STL que no copia el contenedor alrededor de una matriz existente?

Question

¿Es posible crear un contenedor similar a STL, o incluso un iterador de estilo STL, para una matriz existente de elementos de tipo POD?

Por ejemplo, supongamos que tengo una matriz de entradas. Sería conveniente poder llamar a algunas de las funciones STL, como find_if, count_if, u ordenar directamente en esta matriz.

No solución: copiando la matriz completa, o incluso solo referencias a los elementos. El objetivo es ahorrar mucho tiempo y memoria y, con suerte, permitir el uso de otros algoritmos STL.

Answer 1

Puede llamar a muchos de los algoritmos STL directamente en una matriz de estilo C normal, ya que fueron diseñados para que esto funcione. por ejemplo,:

int ary[100];
// init ...

std::sort(ary, ary+100); // sorts the array
std::find(ary, ary+100, pred); find some element

Creo que encontrarás que la mayoría de las cosas funcionan como esperabas.

Answer 2

Puede usar una plantilla de función en línea para no tener que duplicar el índice de matriz

template <typename T, int I>
inline T * array_begin (T (&t)[I])
{
  return t;
}

template <typename T, int I>
inline T * array_end (T (&t)[I])
{
  return t + I;
}

void foo ()
{
  int array[100];
  std::find (array_begin (array)
      , array_end (array)
      , 10);
}

Answer 3

Todos los algoritmos STL usan iteradores.
Un puntero es un iterador válido en una matriz de objetos.

N.B. El iterador final debe ser un elemento más allá del final de la matriz. De ahí los datos + 5 en el siguiente código.

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

int main()
{
    int   data[] = {4,3,7,5,8};
    std::sort(data,data+5);

    std::copy(data,data+5,std::ostream_iterator<int>(std::cout,"\t"));
}

Answer 4

Puede usar Boost.Array para cree un tipo de matriz C ++ con semántica STL.

utilizando matrices:

int a[100];
for (int i = 0; i < 100; ++i)
    a[i] = 0;

utilizando boost.arrays:

boost::array<int,100> a;
for (boost::array<int,100>::iterator i = a.begin(); i != a.end(); ++i)
    *i = 0;

Actualización: Con C ++ 11, ahora puedes usar std :: array .

Answer 5

Un puntero es un modelo válido de un iterador:

struct Bob
{ int val; };

bool operator<(const Bob& lhs, const Bob& rhs)
{ return lhs.val < rhs.val; }

// let's do a reverse sort
bool pred(const Bob& lhs, const Bob& rhs)
{ return lhs.val > rhs.val; }

bool isBobNumberTwo(const Bob& bob) { return bob.val == 2; }

int main()
{
    Bob bobs[4]; // ok, so we have 4 bobs!
    const size_t size = sizeof(bobs)/sizeof(Bob);
    bobs[0].val = 1; bobs[1].val = 4; bobs[2].val = 2; bobs[3].val = 3;

    // sort using std::less<Bob> wich uses operator <
    std::sort(bobs, bobs + size);
    std::cout << bobs[0].val << std::endl;
    std::cout << bobs[1].val << std::endl;
    std::cout << bobs[2].val << std::endl;
    std::cout << bobs[3].val << std::endl;

    // sort using pred
    std::sort(bobs, bobs + size, pred);
    std::cout << bobs[0].val << std::endl;
    std::cout << bobs[1].val << std::endl;
    std::cout << bobs[2].val << std::endl;
    std::cout << bobs[3].val << std::endl;

    //Let's find Bob number 2
    Bob* bob = std::find_if(bobs, bobs + size, isBobNumberTwo);
    if (bob->val == 2)
        std::cout << "Ok, found the right one!\n";
    else 
        std::cout << "Whoops!\n";

    return 0;
}