Вставка перегруженного оператора c ++

Question

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

Я хочу перегрузить оператор '+', чтобы очень часто добавлять большие векторы в мой код.Отсюда и вопрос.

Answer 1

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

Answer 2

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

Answer 3

Позвольте компилятору принять решение об оптимизации.

Ключевое слово inline вводит в заблуждение: компилятор может - фактически - всегда делать то, что ему нужно, как с old auto (вы помните те дни?) И register.

Это современное значение: " определено в заголовке: отбросить, если не используется, объединить, если видели больше раз ".

Answer 4

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

template <class left, class right>
struct AddExpr { 
    const left& _left;
    const right& _right;

    AddExpr(const left& Left, const right& Right)
    :_left(Left), _right(Right)
    {assert(left.count() == right.count());}
    int count() const {return _left.count();}
    int operator[](int index) const {return _left[i]+_right[i];}
};
class Array {
    int* data;
    int size;

    int count() const {return size;}
    Array& operator=(AddExpr expr) {
        for(int i=0; i<expr.count(); ++i)
           data[i] = expr[i];
};
AddExpr operator+(const Array& lhs, const Array& rhs) 
{return AddExpr<Array, Array>(lhs, rhs);}
AddExpr operator+(const Array& lhs, const Expr& rhs) 
{return AddExpr<Array, Expr>(lhs, rhs);}
AddExpr operator+(const Expr& lhs, const Array& rhs) 
{return AddExpr<Expr, Array>(lhs, rhs);}
AddExpr operator+(const Expr& lhs, const Expr& rhs) 
{return AddExpr<Expr, Expr>(lhs, rhs);}

int main() {
    Array a, b, c, d;
    Array c = (a+b) + (c+d);  //awesome on lines like this
}

Это удаляет все временные объекты и значительно повышает эффективность кэширования. Но я полностью забыл, как называется эта техника.