C++ 关于C+中函数调用和求值的一个问题+；

嘿，那里， 关于以下问题，我可能有一个直截了当的问题：

我有一个函数

double afunction(double *myarray)
{   
    double ret = 1.0;
    for(int i = 0; i < 4; i++)
        ret *= myarray[i]*myarray[i];
    return ret;
}

问题是：我不想修改数组

myrray

，我也不想为此创建一个新数组，因为内存问题（这将稍后在GPU上计算，在那里我无论如何都无法在内核函数中分配一个全新的数组）。 简单的解决方法？ 谢谢

编辑 对不起，我打错了什么。我想说的是

myarray[index]+=*add；

EDIT2 一个更大的函数示例，稍后可以很容易地扩展到大约50个不同的返回案例。因此，在每个返回案例中使用if语句修改特定值

myarray[index]

，并添加

*add

，这是非常难看的：(

double a函数（double*myarray、int-funcIndex、int-indexAdd、double*add）
{   
myarray[indexAdd]+=*add；
如果（funcIndex>=1&&funcIndex
在完成其余的计算之后。同样不能保证
myarray[indexAdd]
会精确返回到原来的值

或者更好的做法是，将旧值保存在函数顶部，然后还原：

float old = myarray[ indexAdd ];
myarray[ indexAdd ] += *add;
//do work
myarray[ indexAdd ] = old;

在完成其余的计算之后。同样不能保证
myarray[indexAdd]
会精确返回到原来的值

或者更好的做法是，将旧值保存在函数顶部，然后还原：

float old = myarray[ indexAdd ];
myarray[ indexAdd ] += *add;
//do work
myarray[ indexAdd ] = old;

double-a函数（double*myarray，int-index，double*add）
{   
双ret=（*加）*（*加）；
对于（int i=0；i<4；i++）
如果（i！=索引）
ret*=myarray[i]*myarray[i]；
返回ret；
}
double-a函数（double*myarray，int-index，double*add）
{   
双ret=（*加）*（*加）；
对于（int i=0；i<4；i++）
如果（i！=索引）
ret*=myarray[i]*myarray[i]；
返回ret；
}
有几种可能的解决方案：

显而易见的是：

double
aFunction( double* array, int index, double add )
{
    double result = 1.0;
    for ( int i = 0; i != 4; ++ i ) {
        double tmp = array[i];
        if ( i == index ) {
            tmp += add;
        }
        result *= tmp * tmp;
    }
    return result;
}

可能更快（如果在循环中则否），但可能不同
结果:

我怀疑这件事是否值得花上一段时间
四元素数组：四个
if
s可能不会比
最后的附加计算。但是，对于较长的数组，它可能是
值得考虑

最后，更多的参考，因为它真的很难看，而且只在
单线程环境：

double
aFunction( double* array, int index, double add )
{
    array[index] += add;
    double result = 1.0;
    for ( int i = 0; i != 4; ++ i ) {
        result *= array[i] * array[i];
    }
    array[index] -= add;
    return result;
}

根据实际的硬件和编译器优化，这可能会
要最快。（但同样，对于四个元素来说，这远远不够
当然可以。）

关于代码的另外两条注释：如果您不打算修改
数组
，您可能应该将其作为
双常量*
传递（其中
消除了上面最后一种可能性），因为你所做的就是阅读
一个值，作为指针传递
add
实际上没有意义；
在上面的代码中，我按值传递了它。
有几种可能的解决方案：

显而易见的是：

double
aFunction( double* array, int index, double add )
{
    double result = 1.0;
    for ( int i = 0; i != 4; ++ i ) {
        double tmp = array[i];
        if ( i == index ) {
            tmp += add;
        }
        result *= tmp * tmp;
    }
    return result;
}

可能更快（如果在循环中则否），但可能不同
结果:

我怀疑这件事是否值得花上一段时间
四元素数组：四个
if
s可能不会比
最后的附加计算。但是，对于较长的数组，它可能是
值得考虑

最后，更多的参考，因为它真的很难看，而且只在
单线程环境：

double
aFunction( double* array, int index, double add )
{
    array[index] += add;
    double result = 1.0;
    for ( int i = 0; i != 4; ++ i ) {
        result *= array[i] * array[i];
    }
    array[index] -= add;
    return result;
}

根据实际的硬件和编译器优化，这可能会
要最快。（但同样，对于四个元素来说，这远远不够
当然可以。）

关于代码的另外两条注释：如果您不打算修改
数组
，您可能应该将其作为
双常量*
传递（其中
消除了上面最后一种可能性），因为你所做的就是阅读
一个值，作为指针传递
add
实际上没有意义；
在我上面的代码中，我是按值传递的。
它可能工作正常，也可能不正常，这完全取决于函数的输入。确切地说。这“取决于”是让我害怕的。尽管所有浮点函数都对输入敏感，即使是原始函数（没有
*add
的东西）如果在
myarray
中无序排列元素的顺序，将返回不同的值。好的，谢谢你们。你们说得对，我明白了重点。问题是：函数可能非常简单，看起来臃肿，不像上面所说的那么简单（我插入了一个示例）。当然，我可以在每种情况下插入语句，但这看起来真的很难看。因此，我打赌可能没有办法不复制数组并修改值，除非在每种情况下都使用if语句来修改一个值：（好的，再次感谢。我觉得最后一个解决方案是“最酷的”，因为它很容易实现，但由于我想稍后在多线程环境中使用它，这也是不可能的：（它可能工作正常，也可能不正常，这完全取决于函数的输入。确切地说。这“取决于”是什么让我害怕。所有浮点函数都对输入敏感，即使是原始函数（没有
*add
的东西）如果在
myarray
中无序排列元素的顺序，将返回不同的值。好的，谢谢你们。你们说得对，我明白了重点。问题是：函数可能非常简单，看起来臃肿，不像上面所说的那么简单（我插入了一个示例）。当然，我可以在每种情况下插入语句，但这看起来真的很难看。因此，我打赌可能没有办法不复制数组并修改值，除非在每种情况下都使用if语句来修改一个值：（好的，再次感谢。我觉得最后一个解决方案是“最酷的”，因为它很容易实现，但因为我想晚一点使用它
double afunction(double *myarray, int index, double *add)
{   
    double ret = (*add) * (*add);
    for(int i = 0; i < 4; i++)
        if( i != index )
            ret *= myarray[i]*myarray[i];
    return ret;
}

double
aFunction( double* array, int index, double add )
{
    double result = 1.0;
    for ( int i = 0; i != 4; ++ i ) {
        double tmp = array[i];
        if ( i == index ) {
            tmp += add;
        }
        result *= tmp * tmp;
    }
    return result;
}

double
aFunction( double* array, int index, double add )
{
    double result = 1.0;
    for ( int = 0; i != 4; ++ i ) {
        result *= array[i] * array[i];
    }
    //  Since we multiplied by array[i]^2, when we should
    //  have multipied by (array[i] + add)^2...
    result *= 2 * array[index] * add + add * add;
    return result;
}

double
aFunction( double* array, int index, double add )
{
    array[index] += add;
    double result = 1.0;
    for ( int i = 0; i != 4; ++ i ) {
        result *= array[i] * array[i];
    }
    array[index] -= add;
    return result;
}