C++ 在方法中返回静态变量是个坏主意吗？_C++_Variables_Static_Return

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

c++ variables

C++ 在方法中返回静态变量是个坏主意吗？,c++,variables,static,return,C++,Variables,Static,Return,我四处寻找，似乎找不到我问题的答案。我正在做一个项目，我必须为向量和多项式之间的运算重新定义一些运算符（+，-，*，等等）。据我所知，如果我们只是调用操作符（即vect1+vect2；而不是vect1+=vect2；），并且不将结果放在任何地方，那么这些操作符应该返回对象的副本，以便不直接修改它们现在，我已经看到了使用静态变量是一种不好的做法，但是当一个方法需要返回结果的副本而不是修改对象时，如何避免这样做呢这些问题并没有真正起到帮助作用，因为它们没有解决我的特定问题以下是我的意思的一个例

我四处寻找，似乎找不到我问题的答案。我正在做一个项目，我必须为向量和多项式之间的运算重新定义一些运算符（

，

，等等）。据我所知，如果我们只是调用操作符（即

vect1+vect2；

而不是

vect1+=vect2；

），并且不将结果放在任何地方，那么这些操作符应该返回对象的副本，以便不直接修改它们

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

这些问题并没有真正起到帮助作用，因为它们没有解决我的特定问题

以下是我的意思的一个例子：

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;
        }
}

模板
向量变量和向量变量：：运算符+（常量向量变量和操作数）
{
if（taille>=操作数taille）
{
静态向量变量温度；
temp_v=*此；
对于（std:：size_t i=0；iYes）。不要使变量为静态的
。这样，对函数的每次调用都会得到自己的新变量，然后返回该变量
此外，它是自动的（在堆栈上），而不是静态的，您可以声明变量并一次性初始化它
…我没有注意到您正在返回对向量的引用。不要这样做。按值返回它
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;
        }
}

请注意，lhs
是按值计算的（因此您已经有了自己的副本）。非成员函数的优点是，如果您有任何到类型的转换函数，它们将在左侧和右侧对称运行。
是。不要将变量设置为静态的。这样，对函数的每次调用都将获得自己的新变量，然后返回该变量
此外，它是自动的（在堆栈上），而不是静态的，您可以声明变量并一次性初始化它
…我没有注意到您正在返回对向量的引用。不要这样做。按值返回它
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;
        }
}

请注意，lhs
是按值计算的（因此您已经有了自己的副本）。非成员函数的优点是，如果您有任何到类型的转换函数，它们将在左侧和右侧对称运行。
稳健而简单的方法是返回a（非静态）局部变量按值计算。在某些情况下，这也是有效的方法
如果您非常关心效率，那么对于两个输入之一是右值的情况，您需要一个备用执行路径。在这种情况下，您根本不需要局部变量。相反，您希望通过右值引用获取输入，修改它并通过右值引用返回它
为了避免重复代码过多，您可能需要定义一个操作符+=
，并将实际工作放在该方法中，让所有版本的操作符+
将工作委托给操作符+=

在某些情况下，通过引用返回静态
变量比上述所有情况更有效。但这种情况并不多，而且它们充满了足够多的危险，您不应该做出这样的选择
您在前面的答案中看到过这样的注释：您正确地引用了一个引用的“<代码>静态< /代码>”，避免了从虚拟函数的重写中获得多态返回的大问题。但是它是以牺牲自身的问题为代价的。对于一个简单的例子，考虑使用“<代码> +<代码>的人”。计算
A+（B+C）
。不要问他们为什么把那些不合适的（）
。只要意识到他们没有办法知道他们不应该这样做。因此，您的操作员将B
复制到一个静态文件中，并将C
添加到该静态文件中，然后将a
复制到同一静态文件中，并将该静态文件添加到该静态文件中，并返回2A
。虽然该示例是精心设计的，但这只是您可以使用+/code>执行的许多操作之一>如果它返回一个对静态变量的引用，那就大错特错了。
稳健而简单的方法是按值返回一个（非静态）局部变量。在某些情况下，这也是有效的方法
如果您非常关心效率，那么对于两个输入之一是右值的情况，您需要一个备用执行路径。在这种情况下，您根本不需要局部变量。相反，您希望通过右值引用获取输入，修改它并通过右值引用返回它
为了避免重复代码过多，您可能需要定义一个操作符+=
，并将实际工作放在该方法中，让所有版本的操作符+
将工作委托给操作符+=

在某些情况下，通过引用返回静态
变量比上述所有情况更有效。但这种情况并不多，而且它们充满了足够多的危险，您不应该做出这样的选择
您在前面的答案中看到过这样的注释：您正确地引用了一个引用的“<代码>静态< /代码>”，避免了从虚拟函数的重写中获得多态返回的大问题。但是它是以牺牲自身的问题为代价的。对于一个简单的例子，考虑使用“<代码> +<代码>的人”。计算
A+（B+C）
。不要问他们为什么把那些不合适的（）
。只要意识到他们没有办法知道他们不应该这样做。因此，您的操作员将B
复制到一个静态文件中，并将C
添加到该静态文件中，然后将a
复制到同一静态文件中，并将该静态文件添加到该静态文件中，并返回2A
。虽然该示例是精心设计的，但这只是您可以使用+/code>执行的许多操作之一>如果它返回一个对静态
TYPE operator +(TYPE lhs, const TYPE& rhs)
{
    lhs += rhs;
    return lhs;
}