c++ - 在方法中返回静态变量是个坏主意吗？

Question

我四处搜索，似乎无法找到我的问题的答案。我正在做一个项目，我必须为 vector 和多项式之间的运算重新定义一些运算符(+、-、* 等)。据我所知，如果我们只是调用运算符(即 vect1+vect2; 而不是 vect1 += vect2;) 而不是将结果放在任何地方。

现在，我已经看到使用静态变量是一种不好的做法，但是当方法需要返回结果的拷贝而不是修改对象时，我该如何避免这样做呢？

问题here和 here并没有真正帮助，因为他们没有解决我的特定问题。

这是我的意思的一个例子:

template <class elem>
Vect_variable<elem>& Vect_variable<elem>::operator+(const Vect_variable& operand)
{
    if (taille >= operand.taille)
        {
        static Vect_variable<elem> temp_v;
        temp_v = *this;
        for (std::size_t i = 0; i<operand.taille; i++)   
            {
            temp_v[i] += operand.vecteur[i];
            }
        return temp_v;
        }
    else
        {
        static Vect_variable<elem> temp_v;
        temp_v = operand;
        for(std::size_t i = 0; i<taille; i++)
            {
            temp_v[i] += vecteur[i];
            }
        return temp_v;
        }
}

在这种情况下，您可以看到我正在为使用的临时变量创建静态 Vect_variable。有什么办法可以做到这一点吗？

Answer 1

是的。不要使变量 static。这样每次调用该函数都会得到它自己的新变量，然后您返回它。

此外，它是自动的(在堆栈上)而不是静态的，您可以一次性声明变量并初始化它。

...而且我没有注意到您正在向 vector 返回一个引用。不要那样做。按值返回。

template <class elem>
Vect_variable<elem> Vect_variable<elem>::operator+(const Vect_variable& operand)
{
    if (taille >= operand.taille)
        {
        Vect_variable<elem> temp_v = *this;
        for (std::size_t i = 0; i<operand.taille; i++)   
            {
            temp_v[i] += operand.vecteur[i];
            }
        return temp_v;
        }
    else
        {
        Vect_variable<elem> temp_v = operand;
        for(std::size_t i = 0; i<taille; i++)
            {
            temp_v[i] += vecteur[i];
            }
        return temp_v;
        }
}

接下来要做的是注意您在两个分支中都在做几乎相同的事情。这仅取决于哪个尾部较短。所以使用一对指针:

{
    decltype(this) one, two;
    if (taille >= operand.taille)
        {
        one = this;
        two = &operand;
        }
    else
        {
        one = &operand;
        two = this;
    }

    Vect_variable<elem> temp_v = *one;
    for (std::size_t i = 0; i<two->taille; i++)   
        {
        temp_v[i] += two->vecteur[i];
        }
    return temp_v;
}

最后的评论是，通常最好先编写 operator +=，然后将 operator + 编写为带有签名的非成员二元函数:

TYPE operator +(TYPE lhs, const TYPE& rhs)
{
    lhs += rhs;
    return lhs;
}

请注意 lhs 由 value 获取(因此您已经拥有自己的拷贝)。非成员函数的优点是，如果您有任何到 TYPE 的转换函数，它们将在左右两侧对称地运行。