C++中的向量i没有返回任何内容。它应该返回5个元素 我在使用代码拦截器开发他的C++代码时遇到了麻烦。它实现了机器人的感知和移动，有一个概率向量p，它将随着我应用感知和移动而改变，这是我的主要功能

下面有一个感觉函数和一个移动函数，基本上改变了概率向量p

我在我的主要功能中调用它们，但它似乎不起作用，因为它返回5个nan值

#include <iostream>
#include <vector>
#include <string>

using namespace std;

vector<float> p (5);
vector<string> world (5);
vector<string> measurements (2);
vector<int> motions (2);
float pHit;
float pMiss;
float pExact;
float pOvershoot;
float pUndershoot;
vector<float> sense(vector<float> p, string Z);
vector<float> move(vector<float> p, int U);


int main(){
    vector<float> p = {0.2, 0.2, 0.2, 0.2, 0.2};
    vector<string> world = {"green", "red", "red", "green", "green"};
    vector<string> measurements = {"red", "green"};
    //string measurements = "red";
    vector<int> motions = {1,1};
    float pHit = 0.6;
    float pMiss = 0.2;
    float pExact = 0.8;
    float p0vershoot = 0.1;
    float pUndershoot = 0.1;

    vector<float> sense(vector<float> p, string Z);
    vector<float> moves(vector<float> p, int U);


    for(int i=0; i<measurements.size(); i++){
        p = sense(p, measurements[i]);
        p = moves(p, motions[i]);
    }

    for(int i=0; i<p.size(); i++){
        cout << p[i] << " ";
    }

    return 0;
}

vector<float> sense(vector<float> p, string Z){
    vector<float> q;
   // q.reserve(p.size());
    for(int i=0; i<p.size(); i++){
        bool hit = (Z == world[i]);
        q.push_back(p[i] * (hit * pHit + (1-hit) * pMiss));
    }

    float s = 0.0;
    for(int i=0; i<q.size(); i++){
        s += q[i];
    }

    for(int i=0; i<q.size(); i++){
        q[i] /= s;
    }

    return q;
}

vector<float> moves(vector<float> p, int U){
    vector<float> q;
   // q.reserve(p.size());
    for(int i=0; i<p.size(); i++){
        float s = pExact * p[(i-U) % p.size()];
        s = s + pOvershoot * p[(i-U-1) % p.size()];
        s = s + pUndershoot * p[(i-U+1) % p.size()];
        q.push_back(s);
    }
    return q;
}

---

你的代码不会像你在这里展示的那样编译。首先，您试图在其他函数中引用main中定义的局部变量。其次，您有一系列隐式的双精度浮点转换。如果以这种或那种方式解决了这些问题，您的代码似乎可以正常工作，请参见下面的代码

#include <vector>
#include <iostream>

using namespace std;

vector<double> p = { 0.2, 0.2, 0.2, 0.2, 0.2 };
vector<string> world = { "green", "red", "red", "green", "green" };
vector<string> measurements = { "red", "green" };

float pHit = 0.6;
float pMiss = 0.2;
float pExact = 0.8;
float pOvershoot = 0.1;
float pUndershoot = 0.1;

int main() {
    //string measurements = "red";
    vector<int> motions = { 1,1 };

    vector<double> sense(vector<double> p, string Z);
    vector<double> moves(vector<double> p, int U);


    for (int i = 0; i<measurements.size(); i++) {
        p = sense(p, measurements[i]);
        p = moves(p, motions[i]);
    }

    for (int i = 0; i<p.size(); i++) {
        cout << p[i] << " ";
    }

    return 0;
}

vector<double> sense(vector<double> p, string Z) {
    vector<double> q;
    // q.reserve(p.size());
    for (int i = 0; i<p.size(); i++) {
        bool hit = (Z == world[i]);
        q.push_back(p[i] * (hit * pHit + (1 - hit) * pMiss));
    }

    float s = 0.0;
    for (int i = 0; i<q.size(); i++) {
        s += q[i];
    }

    for (int i = 0; i<q.size(); i++) {
        q[i] /= s;
    }

    return q;
}

vector<double> moves(vector<double> p, int U) {
    vector<double> q;
    // q.reserve(p.size());
    for (int i = 0; i<p.size(); i++) {
        float s = pExact * p[(i - U) % p.size()];
        s = s + pOvershoot * p[(i - U - 1) % p.size()];
        s = s + pUndershoot * p[(i - U + 1) % p.size()];
        q.push_back(s);
    }
    return q;
}

---

在main中声明一组局部变量，float pHit=0.6；等等，但在其他函数中使用类似名称的未初始化全局变量，因此i-U%p.size给出一个负数，如果U>i，则读取的值将超出p的界限。使用p.atx而不是p[x]来帮助检测此乘以布尔值的情况？真奇怪。。。false time 4.2…堆栈溢出不是免费的调试服务，您应该显示您尝试使用调试器或其他更简单的方法（如调试打印语句）调试代码的情况。这并不是你唯一一次在代码中遇到bug，学习调试程序比让别人帮你找到bug更有帮助。你能不能精简一下代码，让我们只关注那些编译并表现出错误行为的部分？特别是那些声明块——你真的需要多少变量来复制坏结果？这仍然存在p[i-U%p.size]的问题；访问越界扫描你能更具体一点吗？这是我得到的输出：0.161053 0.148421 0.0810526 0.168421 0.387368按任意键继续。你得到了什么输出？如何编译和运行此代码？在什么平台上？我没有运行它，我通过查看代码发现了一个错误。代码不包含p[-1%5u]。这实际上不是一个越界访问，但是，假设OP意味着它要解析为p[4]，它做得不好，我确实运行了它-输出在上面。看看代码，我不太理解这部分中的索引，也没有太多的注释。指数计算似乎确实被打破了。也许作者可以解释他在这里想要达到什么目的？@VictorHavin正确答案应该是0.211 0151 0.810526 0.168421 0.387368