Эффективные последствия & p [0] против p.get() в boost :: scoped_array

Тема в целом говорит все. В основном в такой ситуации:Эффективные последствия & p [0] против p.get() в boost :: scoped_array

boost::scoped_array<int> p(new int[10]);

есть ли заметная разница в производительности между выполнением: &p[0] и p.get()?

Я спрашиваю, потому что я предпочитаю первый, он имеет более естественный указатель, такой как синтаксис. Фактически, это делает так, чтобы вы могли заменить p на собственный указатель или массив и не должны ничего менять.

Я предполагаю, так как получите это один лайнер «return ptr;», что компилятор будет встраивать, и я надеюсь, что он достаточно умен, чтобы встраивать operator[] таким образом, что он способен не разыменования, а затем сразу же ссылки ,

Кто-нибудь знает?

источник

2008-11-07 Evan Teran

ОК, я сделал некоторые базовые тесты в соответствии с предложениями Мартина Йорка.

Кажется, что g ++ (4.3.2) на самом деле довольно хорош. На обоих уровнях оптимизации -O2 и -O3 он выводит немного другую, но функционально эквивалентную сборку как для &p[0], так и для p.get().

В OOs, как и ожидалось, он прошел по наименьшей сложности и выбрал вызов operator[]. Единственное, что следует отметить, что версия &p[0] действительно вызывает г ++ испускать копию operator[] тела, но она никогда не используется, так что есть небольшой код навороты, если вы никогда не использовать operator[] иначе:

Тестируемый код был этим (с #if как 0 и 1):

#include <boost/scoped_array.hpp> 
#include <cstdio> 

int main() { 
    boost::scoped_array<int> p(new int[10]); 
#if 1 
    printf("%p\n", &p[0]); 
#else 
    printf("%p\n", p.get()); 
#endif 
}

источник

2008-11-07 23:07:29

Единственный способ узнать, действительно ли это измерить!

Но если у вас есть источник повышения: scoped_array, вы можете использовать код и посмотреть, что он делает. Я уверен, что это очень похоже.

T * scoped_array::get() const // never throws 
{ 
    return ptr; 
} 

T & scoped_array::operator[](std::ptrdiff_t i) const // never throws 
{ 
    BOOST_ASSERT(ptr != 0); 
    BOOST_ASSERT(i >= 0); 
    return ptr[i]; 
}

Напишите две версии кода (один использует get() другой, используя оператор []). Скомпилируйте сборку с включенными оптимизациями. Посмотрите, действительно ли ваш компилятор оптимизирует команду ptr + 0.

источник

2008-11-07 22:48:25

Я посмотрел на источник, оператор [] в основном просто выполняет «return ptr [i];» (есть некоторые утверждения, но это важный код). Мой вопрос заключается в том, что компилятор достаточно умен, чтобы знать, что & ptr [0] == ptr в этом случае используется функция operator []. – 2008-11-07 22:50:03

Вы спрашиваете, достаточно ли укомплектован компилятор для оптимизации «ptr + 0». Проверьте выходные данные вашего компилятора. – 2008-11-07 22:53:25

Хе-х, вы могли бы просто сказать «я не знаю» :-P. Во всяком случае, я знаю, может ли p быть родным указателем. Я полагаю, что если параметр оператора [] известен во время компиляции, он * должен * иметь возможность учитывать все это. Интересно, не так ли. – 2008-11-07 22:58:27

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

В общем, люди рекомендуют, чтобы четкость кода была более важной, чем скорость, поэтому, если вы не уверены, что это будет иметь значение, вы должны выбрать тот вариант, который лучше и соответствует вашей базе кода. FWIW, я лично считаю, что get() понятнее.

источник

2008-11-08 02:24:37

Эффективные последствия & p [0] против p.get() в boost :: scoped_array

ответ

Смежные вопросы