Question

如果必须频繁使用该运算符，是否可以/应该使用内联的运算符以获得更高的效率（wrt时间或其他）？

我想重载'+'运算符，以便在我的代码中经常添加大向量。因此问题。

Answer 1

理想情况下，您需要对代码进行分析，然后决定要内联的内容。当您决定内联常规运算符和超载运算符时，确实没有太大区别。

Answer 2

如果要添加大向量，那么相对于实际添加两个向量的时间，函数调用加号的开销会很小。因此，标记运算符+内联不太可能改善整体运行时间。

Answer 3

让编译器决定优化。

关键字inline具有误导性：编译器可以 - 实际上 - 总是做它所需要的，就像使用旧 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
}

这将删除所有临时对象，并大大提高缓存效率。但我完全忘记了这种技术的用途。

内联重载运算符c ++

4 个答案: