STL vs Массив(замер скорости)
От: WolfHound  
Дата: 07.05.03 07:09
Оценка:
Тесты проводились на VC++7.0 конфигурация Release /Ob2. Celeron 1000 256M WinXP.
Следовательно сделаные выводы касаются только его и его родного STL.
for_all vec             0.114540
for_all_ref vec         0.133207
for_all lst             0.395151
for_all_ref lst         0.395573
vec[i].Hi()             0.115812
arr[i].Hi()             0.025971

for_all vecp            0.672557
for_all_ptr vecp        0.671437
for_all lstp            0.661827
for_all_ptr lstp        0.660183
vecp[i]->Hi()           0.668313
arrp[i]->Hi()           0.684243

Выводы:
Контейнеры обьектов проигрывают обычным массивам причем сильно по сему использование их в критичных по скорости местах не рекомендую.(На не полиморфных обьектах отставание меньше.)
Но при использовании полиморфных контейнеров скорость примерно одинаковая. Особенно меня порадовал std::list который какимто чудом всех сделал(не сильно но сделал). А если учесть что вставка/удаление происходят за константное время то ИМХО для полиморфных контейнеров без альтернатив.

Если изменить параметры так(только не забудте сказать линкеру что метр под стек это мало)
    enum
    {
        ArrSize=1000000,
        IterCount=10,
    };

то
for_all vec             0.132461
for_all_ref vec         0.133806
for_all lst             0.388159
for_all_ref lst         0.385950
vec[i].Hi()             0.131733
arr[i].Hi()             0.128936

for_all vecp            0.672520
for_all_ptr vecp        0.671783
for_all lstp            0.650277
for_all_ptr lstp        0.649454
vecp[i]->Hi()           0.673344
arrp[i]->Hi()           0.672832

На длинных дистанциях у массивов начинаются проблемы... А на полиморфных обьектах std::list сделал всех еще сильнее.

    enum
    {
        ArrSize=100,
        IterCount=100000,
    };

for_all vec             0.113320
for_all_ref vec         0.115010
for_all lst             0.139346
for_all_ref lst         0.124963
vec[i].Hi()             0.110228
arr[i].Hi()             0.026199

for_all vecp            0.131513
for_all_ptr vecp        0.127315
for_all lstp            0.129233
for_all_ptr lstp        0.132465
vecp[i]->Hi()           0.127523
arrp[i]->Hi()           0.129062

А на коротких дистанциях полиморфные контейнеры почти не отстают.

Код:
#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <tchar.h>
#include <windows.h>
#include <vector>
#include <list>
#include <functional>
#include <memory>
unsigned int s;
struct TestBase
{
    virtual void Hi()=0;
    virtual ~TestBase(){}
};
struct Test:TestBase
{
    int g;//Начинка для того чтобы компилятор не соптимизировал циклы в ничто.
    void Hi()
    {
        static int x;
        x+=x+325;
        s+=x;
        g+=s;
    }
};
template<class T, class F>//Просто болие удобная замена for_each если надо перебрать ВСЕ элементы
inline F for_all(T& t, F f)
{
    for(T::iterator i=t.begin(), e=t.end();i!=e;++i)
        (f)(*i);
    return f;
}
template<class T, class F>
inline F for_all_ref(T& t, F f)
{
    for(T::iterator i=t.begin(), e=t.end();i!=e;++i)
        ((*i).*f)();
    return f;
}
template<class T, class F>
inline F for_all_ptr(T& t, F f)
{
    for(T::iterator i=t.begin(), e=t.end();i!=e;++i)
        ((**i).*f)();
    return f;
}
template<class T>//Эмуляция умного указателя
struct SmartPtr//В реальных проектах рекомендую boost::shared_ptr.(boost'а под рукой не было)
{
    T* p_;
    SmartPtr()
        :p_(0)
    {}
    SmartPtr(T* p)
        :p_(p)
    {}
    operator T*()
    {
        return p_;
    }
    T* operator ->()
    {
        return p_;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    enum
    {
        ArrSize=10000,
        IterCount=1000,
    };
    Test arr[ArrSize];
    std::auto_ptr<TestBase> arrp[ArrSize];
    unsigned __int64 freq, begin, end;
    QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
    s=0;
    std::vector<Test> vec;
    vec.resize(ArrSize);
    std::list<Test> lst;
    lst.resize(ArrSize);
    std::vector<SmartPtr<TestBase> > vecp;
    std::list<SmartPtr<TestBase> > lstp;
    for(int i=0;i<ArrSize;++i)
    {
        std::auto_ptr<Test> p(new Test());
        arrp[i]=p;
        vecp.push_back(&*arrp[i]);
        lstp.push_back(&*arrp[i]);
    }
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all(vec, std::mem_fun_ref(&Test::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all vec \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all_ref(vec, &Test::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ref vec \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all(lst, std::mem_fun_ref(&Test::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all lst \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all_ref(lst, &Test::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ref lst \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            vec[i].Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("vec[i].Hi() \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            arr[i].Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("arr[i].Hi() \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
    printf("\n");
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all(vecp, std::mem_fun(&TestBase::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all vecp \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all_ptr(vecp, &TestBase::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ptr vecp \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all(lstp, std::mem_fun(&TestBase::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all lstp \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all_ptr(lstp, &TestBase::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ptr lstp \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            vecp[i]->Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("vecp[i]->Hi() \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            arrp[i]->Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("arrp[i]->Hi() \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
    return s;
}
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re: STL vs Массив(замер скорости)
От: MaximE Великобритания  
Дата: 07.05.03 07:21
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Тесты проводились на VC++7.0 конфигурация Release /Ob2. Celeron 1000 256M WinXP.
WH>Следовательно сделаные выводы касаются только его и его родного STL.

[]

На мой взгляд, ты тут наизмерял издержки виртуальных вызовов — больше ничего.
Re[2]: STL vs Массив(замер скорости)
От: WolfHound  
Дата: 07.05.03 08:40
Оценка:
Здравствуйте, MaximE, Вы писали:

ME>На мой взгляд, ты тут наизмерял издержки виртуальных вызовов — больше ничего.
Ты уверен? А если посмотреть внимательно? Особенно на короткую дистанцию... которая показывает что эти задержки ничтожны.
К томуже если во второй части сделать не полиморфный обьект (но по указателю) то результаты практически не изменятся.
... << RSDN@Home 1.0 beta 6a >>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re: STL vs Массив(замер скорости)
От: Bell Россия  
Дата: 07.05.03 10:21
Оценка:
Здравствуйте, WolfHound, Вы писали:

Я немного модифицировал код, чтобы он компилился под VC6, и попробовал динамические массивы (а то как-то несправедливо получается — все STL контейнеры динамические, а массив — стековый...):

unsigned int s;
struct TestBase
{
    virtual bool Hi()=0;
    virtual ~TestBase(){}
};
struct Test:TestBase
{
    int g;//??????? ??? ???? ????? ?????????? ?? ?????????????? ????? ? ?????.
    bool Hi()
    {
        static int x;
        x+=x+325;
        s+=x;
        g+=s;

        return true;
    }
};
template<class T, class F>//?????? ????? ??????? ?????? for_each ???? ???? ????????? ??? ????????
inline F for_all(T& t, F f)
{
    for(T::iterator i=t.begin(), e=t.end();i!=e;++i)
        (f)(*i);
    return f;
}
template<class T, class F>
inline F for_all_ref(T& t, F f)
{
    for(T::iterator i=t.begin(), e=t.end();i!=e;++i)
        ((*i).*f)();
    return f;
}
template<class T, class F>
inline F for_all_ptr(T& t, F f)
{
    for(T::iterator i=t.begin(), e=t.end();i!=e;++i)
        ((**i).*f)();
    return f;
}
template<class T>//???????? ?????? ?????????
struct SmartPtr//? ???????? ???????? ?????????? boost::shared_ptr.(boost'? ??? ????? ?? ????)
{
    T* p_;
    SmartPtr()
        :p_(0)
    {}
    SmartPtr(T* p)
        :p_(p)
    {}
    operator T*()
    {
        return p_;
    }
    T* operator ->()
    {
        return p_;
    }
};




int main(int argc, char** argv)
{
   enum
    {
        ArrSize=10000,
        IterCount=1000,
    };
    Test* arr = new Test[ArrSize];
    TestBase** arrp = new TestBase*[ArrSize];
    __int64 freq, begin, end;
    QueryPerformanceFrequency((LARGE_INTEGER*)&freq);
    s=0;
    std::vector<Test> vec;
    vec.resize(ArrSize);
    std::list<Test> lst;
    lst.resize(ArrSize);
    std::vector<SmartPtr<TestBase> > vecp;
    std::list<SmartPtr<TestBase> > lstp;
    for(int i=0;i<ArrSize;++i)
    {
        std::auto_ptr<Test> p(new Test());
        arrp[i]=p.release();
        vecp.push_back(&*arrp[i]);
        lstp.push_back(&*arrp[i]);
    }
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(int c=0;c<IterCount;++c)
        for_all(vec, std::mem_fun_ref(&Test::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all vec \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for_all_ref(vec, &Test::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ref vec \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for_all(lst, std::mem_fun_ref(&Test::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all lst \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for_all_ref(lst, &Test::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ref lst \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            vec[i].Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("vec[i].Hi() \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            arr[i].Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("arr[i].Hi() \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
    printf("\n");
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for_all(vecp, std::mem_fun(&TestBase::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all vecp \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for_all_ptr(vecp, &TestBase::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ptr vecp \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for_all(lstp, std::mem_fun(&TestBase::Hi));
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all lstp \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for_all_ptr(lstp, &TestBase::Hi);
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("for_all_ptr lstp \t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            vecp[i]->Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("vecp[i]->Hi() \t\t%f\n", (float(end-begin))/freq);
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
    QueryPerformanceCounter((LARGE_INTEGER*)&begin);
    for(c=0;c<IterCount;++c)
        for(int i=0;i<ArrSize;++i)
            arrp[i]->Hi();
    QueryPerformanceCounter((LARGE_INTEGER*)&end);
    printf("arrp[i]->Hi() \t\t%f\n", (float(end-begin))/freq);

    delete [] arr;
    for(i=0;i<ArrSize;++i)
       delete arrp[i];
    delete [] arrp;

    return 0;
}


VC6SP5 конфигурация Release /Ob2. P3-500 256M WinNT4SP6.
Результаты:


ArrSize=10000
IterCount=1000

for_all vec             0.305155
for_all_ref vec         0.313379
for_all lst             0.788412
for_all_ref lst         0.787564
vec[i].Hi()             0.344568
arr[i].Hi()             0.306783

for_all vecp            1.188012
for_all_ptr vecp        1.192888
for_all lstp            1.396116
for_all_ptr lstp        1.406102
vecp[i]->Hi()           1.247560
arrp[i]->Hi()           1.215618



ArrSize=1000000
IterCount=10

for_all vec             0.743408
for_all_ref vec         0.739664
for_all lst             1.768272
for_all_ref lst         1.766327
vec[i].Hi()             0.773530
arr[i].Hi()             0.741022

for_all vecp            1.685743
for_all_ptr vecp        1.715588
for_all lstp            2.215562
for_all_ptr lstp        2.215071
vecp[i]->Hi()           1.695664
arrp[i]->Hi()           1.708686
Любите книгу — источник знаний (с) М.Горький
Re: STL vs Массив(замер скорости)
От: Павел Кузнецов  
Дата: 07.05.03 10:23
Оценка:
Здравствуйте, WolfHound, Вы писали:

W> Тесты

Чтобы результаты были хоть сколько-то достоверными, тесты необходимо
разносить по разным функциям, обеспечивая невозможность для компилятора
их подставить. Иначе присутствует взаимное влияние тестов. Также следует
проводить замеры каждого случая несколько раз, отбрасывая несколько
крайних результатов. Кроме того, сравнивать с std::vector следует массив,
выделяемый на куче, а не на стеке.
Posted via RSDN NNTP Server 1.5 beta
Легче одурачить людей, чем убедить их в том, что они одурачены. — Марк Твен
Re: STL vs Массив(замер скорости)
От: gfif  
Дата: 07.05.03 10:39
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Выводы:
WH>Контейнеры обьектов проигрывают обычным массивам причем сильно по сему использование их в критичных по скорости местах не рекомендую.(На не полиморфных обьектах отставание меньше.)

vector проигрывает обычным массивам не более нескольких процентов — я это многократно промерял.

А в какой конфигурации компилировали ваш тест.
Если в Debug, то результат объясним
Re: STL vs Массив(замер скорости)
От: gbush  
Дата: 07.05.03 19:08
Оценка:
Здравствуйте, WolfHound, Вы писали:


WH>template<class T>//Эмуляция умного указателя
WH>struct SmartPtr//В реальных проектах рекомендую boost::shared_ptr.(boost'а под рукой не было)
WH>{
WH>    T* p_;
WH>    SmartPtr()
WH>        :p_(0)
WH>    {}
WH>    SmartPtr(T* p)
WH>        :p_(p)
WH>    {}
WH>    operator T*()
WH>    {
WH>        return p_;
WH>    }
        М.б здесь надо так:
           operator T*()
    {
        return (T*)p_;
    }
WH>    T* operator ->()
WH>    {
WH>        return p_;
WH>    }
WH>};
WH>
Все хорошо кончается, что кончается ещё лучше...
Re[3]: STL vs Массив(замер скорости)
От: VladD2 Российская Империя www.nemerle.org
Дата: 07.05.03 19:12
Оценка: +1 -1
Здравствуйте, WolfHound, Вы писали:

Ты кстати оптимизацию включал?

Если, да то не факт, что твои безсмысленные (с точки зрения компилятора) циклы остались.

А если, нет, то ты меряеш вчерашний день. По своему опыту скажу, измерять скорость кода созданного оптимизирующим компилятором очень не просто. Нужно убедить его, что код нужен.

Кстати, включи автоинлайнинг (/Ob2 — Any Suitable). При этом все вызовы методов исчезнут и скорость значительно возрастет. Думаю при этом скорость обычных массивов будет не сильно выше вектора.

Кстати, померяй еще и массивы из ATL7.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[2]: STL vs Массив(замер скорости)
От: VladD2 Российская Империя www.nemerle.org
Дата: 07.05.03 20:53
Оценка:
Здравствуйте, Павел Кузнецов, Вы писали:

ПК>Здравствуйте, WolfHound, Вы писали:

W> Тесты

ПК>Чтобы результаты были хоть сколько-то достоверными, тесты необходимо
ПК>разносить по разным функциям, обеспечивая невозможность для компилятора
ПК>их подставить. Иначе присутствует взаимное влияние тестов. Также следует
ПК>проводить замеры каждого случая несколько раз, отбрасывая несколько
ПК>крайних результатов.

Более того еще об оптимизации нужно подумать. И аглоритмы осмысленные использовать иначе все это будет фикцией.

ПК>Кроме того, сравнивать с std::vector следует массив,
ПК>выделяемый на куче, а не на стеке.

Ну, тут ты не прав. Все же интересно и то, и то. Согласись часто бывает, что вектор используется для облекчения жизни, а размер массива маленький.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: STL vs Массив(замер скорости)
От: WolfHound  
Дата: 07.05.03 20:57
Оценка:
Здравствуйте, VladD2, Вы писали:

VD>Ты кстати оптимизацию включал?
Еще один ты вобще пост читал? См первая строчка.
VD>Если, да то не факт, что твои безсмысленные (с точки зрения компилятора) циклы остались.
А это я по твоему чем занимался?
unsigned int s;
struct TestBase
{
    virtual void Hi()=0;
    virtual ~TestBase(){}
};
struct Test:TestBase
{
    int g;//Начинка для того чтобы компилятор не соптимизировал циклы в ничто.
    void Hi()
    {
        static int x;
        x+=x+325;
        s+=x;
        g+=s;
    }
};


VD>Кстати, померяй еще и массивы из ATL7.
А звать их как?
... << RSDN@Home 1.0 beta 6a >>
Пусть это будет просто:
просто, как только можно,
но не проще.
(C) А. Эйнштейн
Re[2]: STL vs Массив(замер скорости)
От: UgN  
Дата: 08.05.03 06:52
Оценка:
Здравствуйте, gbush, Вы писали:

WH>template<class T>//Эмуляция умного указателя
WH>struct SmartPtr//В реальных проектах рекомендую boost::shared_ptr.(boost'а под рукой не было)
WH>{
WH>    T* p_;
WH>    operator T*()
WH>    {
WH>        return p_;
WH>    }
G>        М.б здесь надо так:
G>           operator T*()
G>    {
G>        return (T*)p_;
G>    }
WH>};
WH>


А зачем? Оно и так типа T*
Re[3]: STL vs Массив(замер скорости)
От: gbush  
Дата: 08.05.03 08:14
Оценка:
Здравствуйте, UgN, Вы писали:

UgN>Здравствуйте, gbush, Вы писали:

UgN>
WH>template<class T>//Эмуляция умного указателя
WH>struct SmartPtr//В реальных проектах рекомендую boost::shared_ptr.(boost'а под рукой не было)
WH>{
WH>    T* p_;
WH>    operator T*()
WH>    {
WH>        return p_;
WH>    }
G>        М.б здесь надо так:
G>           operator T*()
G>    {
G>        return (T*)p_;
G>    }
WH>};
WH>
UgN>


UgN>А зачем? Оно и так типа T*

Некоторые компиляторы обрабатывают такую ситуацию не правильно(у меня VC6.0),например в
CComPtr operator T*() реализован {return (T*)p;}
Все хорошо кончается, что кончается ещё лучше...
Re[4]: STL vs Массив(замер скорости)
От: UgN  
Дата: 08.05.03 08:22
Оценка:
Здравствуйте, gbush, Вы писали:

UgN>А зачем? Оно и так типа T*

G>Некоторые компиляторы обрабатывают такую ситуацию не правильно(у меня VC6.0),например в
G>CComPtr operator T*() реализован {return (T*)p;}

Ну, не знаю... У меня на VC6.0 все ОК.

Хотелось бы услышать мнение остальных.
Re[3]: STL vs Массив(замер скорости)
От: Павел Кузнецов  
Дата: 08.05.03 09:26
Оценка:
Здравствуйте, VladD2, Вы писали:

V> Ну, тут ты не прав. Все же интересно и то, и то. Согласись часто бывает,
V> что вектор используется для облекчения жизни, а размер массива маленький.

Скажем, так: сравнивать следует не только стековый массив, но и выделяемый динамически.
Agreement?
Posted via RSDN NNTP Server 1.5 beta
Легче одурачить людей, чем убедить их в том, что они одурачены. — Марк Твен
Re[5]: STL vs Массив(замер скорости)
От: VladD2 Российская Империя www.nemerle.org
Дата: 09.05.03 01:09
Оценка:
Здравствуйте, WolfHound, Вы писали:

WH>Еще один ты вобще пост читал? См первая строчка.

Извени слоника не заметил.

Да он зараз хитрый. Если функцию подставит, то может скорее всего и на обращение к члену наплевать.

VD>Кстати, померяй еще и массивы из ATL7.
WH>А звать их как?

CAtlArray<>, CSimpleArray<>

Он вроде писался как раз в расчете на инлайн-подстановку.
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[4]: STL vs Массив(замер скорости)
От: VladD2 Российская Империя www.nemerle.org
Дата: 09.05.03 01:10
Оценка:
Здравствуйте, Павел Кузнецов, Вы писали:

ПК>Скажем, так: сравнивать следует не только стековый массив, но и выделяемый динамически.
ПК>Agreement?

Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
 
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.