غلاف STL غير للنسخ حول مصفوفة موجودة؟

Question

هل من الممكن إنشاء حاوية تشبه STL، أو حتى مجرد مكرر بنمط STL، لمجموعة موجودة من العناصر من نوع POD؟

على سبيل المثال، لنفترض أن لدي مجموعة من ints.سيكون من المناسب أن تكون قادرًا على استدعاء بعض وظائف STL، مثل find_if أو count_if أو الفرز مباشرة على هذه المصفوفة.

عدم الحل:نسخ المصفوفة بأكملها، أو حتى مجرد مراجع للعناصر.الهدف هو توفير الذاكرة والوقت بشكل كبير مع السماح باستخدام خوارزميات STL الأخرى.

Answer 1

ويمكنك استدعاء العديد من الخوارزميات STL مباشرة على العادية مجموعة C أسلوب - أنها صممت لهذا العمل. . منها مثلا،:

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

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

وأعتقد أنك سوف تجد أن معظم الاشياء يعمل تماما كما كنت تتوقع.

Answer 2

ويمكنك استخدام قالب دالة مضمنة بحيث لم يكن لديك لتكرار مؤشر مجموعة

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

تستخدم جميع خوارزميات STL التكرارات.
المؤشر هو مكرر صالح في مجموعة من الكائنات.

ملحوظة:يجب أن يكون مكرر النهاية عنصرًا واحدًا بعد نهاية المصفوفة.ومن هنا جاءت البيانات+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"));
}

Answer 4

يمكنك استخدام 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.

Answer 5

ومؤشر هو نموذج صالح مكرر:

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