Передать ссылку массива!С++

> counter.Clear();
> for( std::vector<int>::iterator it = STLA.begin() ; it != STLA.end() ; ++it ) sum += *it;
> size_t time4 = counter.GetInterval(); // 23642 ms

Это что за хренотень? Вы, верно, издеваетесь? Естественно, она три года работать будет (потому что функции begin и end вызываются на каждой итерации цикла). Просто признайте, что вы не знаете C++. Вот так надо:


int main()
{
  IntArray a(50000000);
  Timer t;
  t.restart();
  int sum = std::accumulate(a.begin(), a.end(), 0);
  std::cout << t.elapsed() << std::endl; //0.887347
  return 0;
}

> какое же дерьмо этот STL и С++

Толсто же.

Насчет лишнего копирования согласен, но вектор можно передать по ссылке в процедуру:

void func(const std::vector<int> & inVec, std::vector<int> outVec)
{
     
}

Вопрос не в том, на сколько более читабельнее и компактнее, а в том насколько правильнее.
Никто же не программирует на C в функциональной парадигме, так вот и на плюсах не рекомендуется прогать сишными методами.

>> copy(a->begin(), a->end(), ostream_iterator<int>(cout, " "));

> кстати на этой строке ваш пример собранный под оффтопиком вываливается с ошибкой ostream_iterator is not dereferenaceable

ну это уже личная интимная проблема вас и вашей студии. У меня печатает ряд нулей, разделенных пробелами. Пруфпик выложу по реквесту, а то лениво.

>Толсто же.

Судя по этому топику не так уж и толсто..

>Судя по этому топику не так уж и толсто..

попкорн будешь?

>как ни странно delete, "потом вот из-за таких вот борющихся за >"производительность" месяцами ловят утечки и сегфолты." - расскажи это >сишникам( а также авторам КДЕ - "плазма не падает" ), при наличии >головы на плечах, сразу при написании кода для выделения памяти >пишется код для ее очистки

Ну сколько раз уже жевали ...

void foo{
a = new MyObject();
a->bla_bla(); // получаем исключение
delete a;
}

Кто будет память чистить ?

>попкорн будешь?

уже жую. ждем, когда вернется lester...

ой да ладно

пусть мучаются

я у себя взрослых людей не могу приучить к этому (вообще к возможности исключений)

А ты детям рассказываешь

> Ну сколько раз уже жевали ...
> void foo{
> a = new MyObject();
> a->bla_bla(); // получаем исключение
> delete a;
> }
> Кто будет память чистить ?

я в полной мере сторонник ООП - когда весь код разложен по классам, а не функциям, и ваш пример выглядит так:

MyClass::~MyClass( void )
{
delete mpObject ;
}

void MyClass::DoSomething( void )
{
mpObject = new MyObject();
mpObject->bla_bla(); // получаем исключение
}

> ну это уже личная интимная проблема вас и вашей студии

хороший подход к написанию программ

> Это что за хренотень? Вы, верно, издеваетесь? Естественно, она три года работать будет (потому что функции begin и end вызываются на каждой итерации цикла). Просто признайте, что вы не знаете C++. Вот так надо:

выдернули частный случай( я случайно выбрал сумму ) и умничаете

>я в полной мере сторонник ООП - когда весь код разложен по классам, а не функциям, и ваш пример выглядит так

а которым местом это кореллирует? будет та же фигня, только в профиль - между созданием и разрушением объекта MyClass тоже может случится исключение, и все созданные им объекты весело повиснут в воздухе. даже хуже - память будет утекать на всяком вызове DoSomething кроме первого

есть мнение, что ты - тонкий тролль, призванный дискредитировать плюсовое ООП

>выдернули частный случай

всё программирование - одни сплошные частные случаи :)

> есть мнение, что ты - тонкий тролль, призванный дискредитировать плюсовое ООП

почти рядом :), на самом я не против stl( и auto_ptr в частности ) и сам часто пользуюсь шаблонами, что заставило нести чушь в топике( особенно в конце ) - хз, видно недосыпание сказывается

> хороший подход к написанию программ

а как вы хотели? Вывод в cout с помощью интервального копирования элементов коллекции по итератору cout'а - это хрестоматийный пример (как printf("Hello world\n") в случае языка C), который _работает везде_, где имеется имеется нормальная реализация библиотеки C++.

> выдернули частный случай( я случайно выбрал сумму ) и умничаете

Какой же это частный случай? Это общая закономерность. Очень часто на конкретную задачу есть готовое решение в библиотеке C++, которое позволяет 1) унифицировать код, отказавшись от разработки своего кривого велосипеда (даже если это банальный цикл, который складывает целые числа или выводит их в cout) 2) избежать кучи ошибок при разработке своего велосипеда. Доказательства этих двух положений в топике -> налицо.

Сам редиска

>какое же дерьмо этот STL и С++

Вот наконец мысль по существу.

>я в полной мере сторонник ООП - когда весь код разложен по классам, а не функциям

Курить Мейерса(*) и Саттера+Александреску(**).

(*)статья о икапсуляции (**)стандарты кодирования С++

>Курить Мейерса(*) и Саттера+Александреску(**).

отдаю свой голос за Коплиена

>а вы юморист, ничего так, что у вас лишнее копирование всего вектора?

там нет лишнего копирования всего вектора. гугли NRVO

>std::auto_ptr использовать надо хотя бы

ну не для сишных массивов же?)

>ну не каждом шагу же

в хорошей цпп-программе не должно быть ни одного оператора delete (К. О.)

>и что я буду делать с вектором, который зарезервировал себе память, а по сути не содержит ни одного элемента?

а чем это отличается от аналогичной работы с динамически созданным массивом? (ну кроме того, что все это надо будет делать вручную, а память при эксепшенах не будет освобождаться)

>в хорошей цпп-программе не должно быть ни одного оператора delete (К. О.)

и ни одного оператора new. будет идеальный C++ в вакууме

>Вообще откуда такое время взялось?

мне кажется, товарищ юзает богомерзкую студию с ее STL'ем, который ЕМНИП делает какие-то лишние проверки даже в release-конфигурации

это, кстати, еще один повод юзать STLPort

>и ни одного оператора new

тогда уж и ни одной строчки кода на C++)

легковесная, безглючная и geek'оугодная программа получится

>Никто же не программирует на C в функциональной парадигме

Ну разница еще и в том, что на С в функциональной парадигме не очень как-то и поработаешь, а вот на плюсах в процедурном стиле, к сожалению, очень даже можно (

>>ну не каждом шагу же

>в хорошей цпп-программе не должно быть ни одного оператора delete (К. О.)

А что в STL используется вместо него?

>А что в STL используется вместо него?

а ты проверь, это несложно

> а вы юморист, ничего так, что у вас лишнее копирование всего вектора? не считая того, чтоб работа с массивом по определению более быстрая( а код компактнее и читабельнее ), вектор хорош там, где надо динамически менять размер структуры, если этого делать не надо - в большинстве случаев можно обойтись и без него

а вы юморист, ничего так, что в STL давно все COW? И ничего, что работа с вектором в C++ в большинстве случаев заметно быстрее чем с C-массивом? (почитай Майерса школьник).

> Насчет лишнего копирования согласен, но вектор можно передать по ссылке в процедуру:

А вот и зря согласился. Ничего там не будет копироватся. Хотя православно делать так:

void func(...., std::vector<int> &outVec)
{
           .....
           std::vector<int>result;
          .....
          .....
          if (все хорошо)
          {
                     result.swap(outVect); // всегда выполняется за O(1) !
          }     
}

> работа с вектором в C++ в большинстве случаев заметно быстрее

выше товарищ уже писал - бенчмарки, или пшел нахуй

Вот паттерн того, как сливает C-массив плюсам на векторе. 
Не бенчмар, но обьяснение для тупого быдла. 
Описывает в принципе реальную ситуацию, толко в гипертрафированной форме.

#include <sys/time.h>
#include <stdio.h>
        
#include <vector>
                
class some_object_with_a_HEAVY_constructor
{       
        char *my_internal_heavy_data;
public: 
        some_object_with_a_HEAVY_constructor() : my_internal_heavy_data(NULL)
        {
                my_internal_heavy_data = new char[10000];
        }
        some_object_with_a_HEAVY_constructor(const some_object_with_a_HEAVY_constructor &obj)
        {
                my_internal_heavy_data = new char[10000];
                memcpy( my_internal_heavy_data, obj.my_internal_heavy_data, 10000);
        }
        ~some_object_with_a_HEAVY_constructor()
        {
                delete my_internal_heavy_data;
        }
};

        
int main()
{       
        enum {MAX = 10000, SIZE=3000 };
        
        time_t s1 = time(NULL);
                
        for (int i=0; i<MAX; i++)
        {
                std::vector<some_object_with_a_HEAVY_constructor> abc;
                abc.reserve(SIZE);
        }

        time_t s2 = time(NULL);

        for (int i=0; i<MAX; i++)
        {
                some_object_with_a_HEAVY_constructor abc[SIZE];
        }

        time_t s3 = time(NULL);

        printf("STL-vector time: %d sec, C-array time: %d sec\n", s2-s1, s3-s2);
}


запущаем (компилялось без оптимизаций): 

STL-vector time: 0 sec, C-array time: 13 sec

> abc.reserve(SIZE);

не впечатлило

>> abc.reserve(SIZE);

> не впечатлило

Ну убейся тогда об стену. В том и речь, что vector позволяет захавать место под массив, но не инициализировать элементы до тех пор, пока это не понадобится. Как сие сделать с C-Array? А че если к тому-же конструктор обьекта хранимого в массиве - жутко неадекватный и любыт кидать эксепшены?

P.S. Речь идет об превосходстве std::vector-а над c-array-ем в контексте его использования в C++, если ты еще не понял, быдло. Конечно, если сделать "чиста на це", то оно в подобных случаях может и пошустрей выйдет (а может и не выйдет).

>а вы юморист, ничего так, что в STL давно все COW?

Ты читал не последние книжки и не в курсе плюсовых мод и трендов. Теперь модно всегда копировать - это проще и надежнее как оказалось.

> Ты читал не последние книжки и не в курсе плюсовых мод и трендов. Теперь модно всегда копировать - это проще и надежнее как оказалось.

Для тупых повторюсь: православно делать swap, который всегда O(1)

> В том и речь, что vector позволяет захавать место под массив, но не инициализировать элементы до тех пор, пока это не понадобится. Как сие сделать с C-Array?

ты полный 0, кто ж в конструктор ложит выделение памяти, для этого делается отдельный метод

> если ты еще не понял, быдло

просто пшел нахуй - разговор окончен

> ты полный 0, кто ж в конструктор ложит выделение памяти, для этого делается отдельный метод

И как он называется? О просвяти меня святоч программирования! А зачем тогда конструктор? Что-бы была заглушка, так, для галочки "типа обьектно"? Или это вы так для себя решили, в силу того, что не освоили плюсы в полной мере? Попиши на них лет 5, минимум, может снизойдет на тебя великое дао.

>> если ты еще не понял, быдло

> просто пшел нахуй - разговор окончен

О как наша деточка заговорила. Ну-ну, сопляк, я тебя до этого не материл, а теперь буду пидрило. (быдло - не мат, и не ругательство, по отношению к тебе это вежливое обращение).

>Ну убейся тогда об стену. В том и речь, что vector позволяет захавать место под массив, но не инициализировать элементы до тех пор, пока это не понадобится. Как сие сделать с C-Array?

Говорят realloc() весьма быстр, т.к свежеаллокированный чанк обычно лежит на вершине кучи и для увеличения его объема достаточно только поменять верхний баунд за O(1). Тесты это вродебы подтверждают. Кстати, у Вас в коде ошибочка - аллокированное через new[] надо удалять через delete[].

> И как он называется? О просвяти меня святоч программирования! А зачем тогда конструктор? 

char* MyClass::GetData( void )
{
    return mpData ?
        mpData :
        mpData = new char[10000];
}

> А зачем тогда конструктор? 

ну уж точно не для того, чтоб не делать кучу движений сразу при создании объекта

> теперь буду пидрило

да вы им и были

> Кстати, у Вас в коде ошибочка - аллокированное через new[] надо удалять через delete[].

Это я торопился быдло покарать.

>> Ты читал не последние книжки и не в курсе плюсовых мод и трендов. Теперь модно всегда копировать - это проще и надежнее как оказалось.

>Для тупых повторюсь: православно делать swap, который всегда O(1)

А как же COW-ность STL?

> ну уж точно не для того, чтоб не делать кучу движений сразу при создании объекта

Если тебе не нужно кучи телодвижений -- не создавай обьект, разве это трудно понять? Держи пустой shared_ptr вместо него, и все, делов то.

> А как же COW-ность STL?

А вот так. Модные тенденции - тенденциями. А реализации текущие все равно COW делают.

Ладно, ХУИ, вы мне надоели, я свалил.

> Ладно, ХУИ, вы мне надоели, я свалил.

слив засчитан