STL без копирования оболочки вокруг существующего массива?
Вопрос
Можно ли создать STL-подобный контейнер или даже просто итератор в стиле STL для существующего массива элементов типа POD?
Например, предположим, у меня есть массив целых. Было бы удобно иметь возможность вызывать некоторые функции STL, такие как find_if, count_if или сортировать непосредственно в этом массиве.
Не решение: копирование всего массива или даже просто ссылки на элементы. Цель состоит в том, чтобы очень сэкономить память и время, при этом, надеясь, использовать другие алгоритмы STL.
Решение
Многие алгоритмы STL можно вызывать непосредственно в обычном массиве в стиле C - они были разработаны для того, чтобы это работало. . Например,
int ary[100];
// init ...
std::sort(ary, ary+100); // sorts the array
std::find(ary, ary+100, pred); find some element
Я думаю, вы обнаружите, что большинство вещей работает так, как вы ожидаете.
Другие советы
Вы можете использовать шаблон встроенной функции, чтобы вам не приходилось дублировать индекс массива
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);
}
Все алгоритмы STL используют итераторы.
Указатель является допустимым итератором в массив объектов.
N.B. Конечный итератор должен находиться на один элемент за концом массива. Отсюда данные + 5 в следующем коде.
#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"));
}
Вы можете использовать Boost.Array , чтобы создать тип массива C ++ с семантикой STL.
используя массивы:
int a[100];
for (int i = 0; i < 100; ++i)
a[i] = 0;
используя boost.arrays:
boost::array<int,100> a;
for (boost::array<int,100>::iterator i = a.begin(); i != a.end(); ++i)
*i = 0;
Обновление: . В C ++ 11 теперь вы можете использовать std :: array
.
Указатель является допустимой моделью итератора:
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;
}