C++ 当我使用+；=若要将数字添加到数组中，无论该数字是什么，它最终总是为0

我试图为我的机器人编写代码，跟踪它的行驶位置，这样它就可以知道它在笛卡尔网格上的位置（我是根据本文：）

在开始时，

绝对位置[0]（x坐标）

和

绝对位置[1]（y坐标）

都

设置为2

，这意味着机器人

从网格上的（2,2）

开始在第一个循环中，在机器人移动之前（表示左、右和后

变量都设置为0

），

绝对位置[0]和绝对位置[1]都设置为0

---

据我所知，varCos和varSin都应该是0，所以

absolute_position[0] += varCos;
absolute_position[1] += varSin;

应评估为

2 += 0;
2 += 0;

但正如我所说，他们最终都是0。 如果我尝试用0替换varCos和varSin，或者如果我将它们都设置为0（而不是offset_global[0]*cos（offset_global[1]），则绝对位置最终会像我预期的那样为[2,2]

完整代码：

double absolute_position[2] = {2,2};
double theta0;
double left = 0;
double right = 0;
double back = 0;
double prevLeft = 0;
double prevRight = 0;
double prevBack = 0;
double deltaLr = 0;
double deltaRr = 0;
double deltaBr = 0;
double deltaL = 0;
double deltaR = 0;
double deltaB = 0;
double thetar = 0;
double theta1 = 0;
double deltaTheta = 0;
double thetaM = 0;
double offset_local[2];
double offset_global[2];
double varCos = 0;
double varSin = 0;

///////////////////////////////////////////////////

void positionTracking(){
    float sL = 10.5;
    float sR = 10.5;
    float sB = 6.5;
    while(true){
        //stores current encoder values
        left = -leftEncoder;
        right = rightEncoder;                                                   
        back = backEncoder;

        //finds the distance traveled for each wheel in inches
        deltaL = (left - prevLeft) * 3.25 * M_PI / 360;
        deltaR = (right - prevRight) * 3.25 * M_PI / 360;
        deltaB = (back - prevBack) * 3.25 * M_PI / 360;

        //updates the last values of the encoders to be used next cycle
        prevLeft = left;
        prevRight = right;
        prevBack = back;

        //calculates total accumulated encoder values
        deltaLr += deltaL;
        deltaRr += deltaR;
        deltaBr += deltaB;

        //calculates new absolute orientation
        theta1 = thetar + (deltaLr - deltaRr) / (sL + sR);
        if(theta1 < 0){
            theta1 += 2 * M_PI;
        }
        else if(theta1 >= 2 * M_PI){
            theta1 -= 2 * M_PI;
        }

        //find the change in orientation
        deltaTheta = theta1 - theta0;

        //find local offset vector
        if(deltaTheta == 0){
            offset_local[0] = deltaB;
            offset_local[1] = deltaR;
        }
        else{
            offset_local[0] = 2 * sin(deltaTheta / 2) * (deltaB / deltaTheta + sB);
            offset_local[1] = 2 * sin(deltaTheta / 2) * (deltaR / deltaTheta + sR);
        }

        //calculate the average orientation
        thetaM = theta0 + deltaTheta / 2;

        //converts cartesian to polar and changes the angle
        offset_global[0] = sqrt(pow(offset_local[0], 2) + pow(offset_local[1], 2));
        offset_global[1] = atan(offset_local[1] / offset_local[0]) - thetaM;

        //converts polar offset back to cartesian and adds it to the absolute_position
        varCos = offset_global[0] * cos(offset_global[1]);
        varSin = offset_global[0] * sin(offset_global[1]);

        absolute_position[0] += varCos;
        absolute_position[1] += varSin;

        //updates the old orientation to be used next cycle
        theta0 = theta1;
    }
}

双绝对位置[2]={2,2}；
双θ0；
左双=0；
右双=0；
双回=0；
双左=0；
双右=0；
双前驱回=0；
双deltaLr=0；
双deltaRr=0；
双deltaBr=0；
双三角=0；
双德尔塔=0；
双deltaB=0；
双θ=0；
双θ=0；
双德尔塔塔=0；
双θ=0；
双偏移_本地[2]；
双偏置_全局[2]；
双变量=0；
双varSin=0；
///////////////////////////////////////////////////
void positionTracking（）{
浮动sL=10.5；
浮点数sR=10.5；
浮动sB=6.5；
while（true）{
//存储当前编码器值
左=-左编码器；
右=右编码器；
后退=后退编码器；
//查找每个车轮的行驶距离（以英寸为单位）
deltaL=（左-左）*3.25*M_PI/360；
德尔塔=（右-右）*3.25*M_PI/360；
deltaB=（背面-背面）*3.25*M_PI/360；
//更新下一周期使用的编码器的最后值
左=左；
右=右；
prevBack=back；
//计算编码器总累积值
deltaLr+=deltaL；
deltaRr+=deltaR；
deltaBr+=deltaB；
//计算新的绝对方向
θ1=θ+（deltaLr-deltaRr）/（sL+sR）；
if（θ1<0）{
θ1+=2*M_π；
}
否则如果（θ1>=2*M_π）{
θ1-=2*M_π；
}
//找到方向上的变化
德尔塔塔=θ1-θ0；
//查找局部偏移向量
如果（deltaTheta==0）{
偏移量_local[0]=deltaB；
偏移量_local[1]=增量；
}
否则{
偏移量_local[0]=2*sin（deltaTheta/2）*（deltaB/deltaTheta+sB）；
偏移量_local[1]=2*sin（deltaTheta/2）*（deltaR/deltaTheta+sR）；
}
//计算平均方向
θ=θ0+deltaTheta/2；
//将笛卡尔坐标转换为极坐标并更改角度
偏移量_全局[0]=sqrt（pow（偏移量_局部[0]，2）+pow（偏移量_局部[1]，2））；
偏移量全局[1]=atan（偏移量局部[1]/偏移量局部[0]）-θ；
//将极轴偏移转换回笛卡尔坐标并将其添加到绝对位置
varCos=偏移量_全局[0]*cos（偏移量_全局[1]）；
varSin=offset_global[0]*sin（offset_global[1]）；
绝对位置[0]+=varCos；
绝对位置[1]+=varSin；
//更新下一个周期使用的旧方向
θ0=θ1；
}
}

---

谢谢你的帮助

我想出来了：机器人的屏幕上显示varCos和varSin为0，但当我在计算机（不是机器人）上运行程序时，屏幕上显示它们为NaN。我把它改成了

varCos = offset_global[0] == 0 ? 0 : offset_global[0] * cos(offset_global[1]);
varSin = offset_global[0] == 0 ? 0 : offset_global[0] * sin(offset_global[1]);

---

确保它们是数字。

您说过它们“应该”有某些值，但您是否进行过任何调试以验证这些值的真实性？“据我所知，varCos和varSin都应为0”我将首先验证该值。据我所知，varCos和varSin都应该是0——使用编译器附带的调试器。现有的每个程序员都编写过程序，在程序运行之前，他们对事情“肯定”，然后他们发现自己的假设是错误的。当他们调试程序时，他们会发现错误并进行适当的更改。为什么不将所有这些变量嵌入

结构

或

类

？这样你可以很容易地初始化它们，跟踪它们的值…当我看varCos和varSIn的值时，它们是0。我说它们“应该”为0的唯一原因是，我希望绝对位置的值为2，而不是0。