C++ 向已定义数组写入值时，该数组的大小正在更改

好的，我正试图从gy521传感器读取arduino的数据。我正处于从FIFO寄存器读取数据的阶段，但当我尝试将数据分配给数组以便计算位置时，数组写入20个值，而不是我在开始时定义的10个值。这是我正在进行的工作代码：

#include <Wire.h>

  #define MPU_6050 0x68
  #define PWR_MGMT_1 0x6B 
  #define FIFO_EN 0x23
  #define FIFO_COUNTH 0x72
  #define FIFO_COUNTL 0x73
  #define FIFO_R_W 0x74
  #define SMPLRT_DIV 0x19
  #define USER_CTRL 0x6A
  #define GY_CONFIG 0x1B
  #define SELF_TEST_X 0x0D
  #define SELF_TEST_Y 0x0E
  #define SELF_TEST_Z 0x0F
  #define INT_EN 0x38
  #define INT_STAT 0x3A
  #define ARRAY_SIZE 10

  int FIFO_OVERFLOW_STAT;
  int FIFO_DATA_X;
  int FIFO_DATA_Y;
  int FIFO_DATA_Z;
  int x0;
  int y0;
  int z0;
  int FIFO_COUNT;
  int x_val[ARRAY_SIZE];
  int y_val[ARRAY_SIZE];
  int z_val[ARRAY_SIZE];

  void setup() {
   Serial.begin(115200); //Start a serial interface
   Wire.begin(); //set up i2c
   Wire.beginTransmission(MPU_6050); //start transmission to slave
   Wire.write(PWR_MGMT_1); 
   Wire.write(0); //Wake up
   Wire.endTransmission(true); // Send byte in buffer
   Wire.beginTransmission(MPU_6050);
   Wire.write(SMPLRT_DIV);
   Wire.write(5); //set the sample rate to 250hz (because 8000/1+31=250)
   Wire.endTransmission(true);
   disable_FIFO();
   Wire.beginTransmission(MPU_6050);
   Wire.write(USER_CTRL); 
   Wire.write(68); //enable the FIFO Line and Clear it
   Wire.endTransmission(true);
   check_FIFO_size();
   Wire.beginTransmission(MPU_6050);
   Wire.write(SELF_TEST_X); 
   Wire.write(7); //set up self tests
   Wire.endTransmission(true);
   Wire.beginTransmission(MPU_6050);
   Wire.write(SELF_TEST_Y); 
   Wire.write(7); //set up self tests
   Wire.endTransmission(true);
   Wire.beginTransmission(MPU_6050);
   Wire.write(SELF_TEST_Z); 
   Wire.write(7); //set up self tests
   Wire.endTransmission(true);
   Wire.beginTransmission(MPU_6050);
   Wire.write(GY_CONFIG); 
   Wire.write(224); //Self test gyro and set Full Scale range to 250*/s 
   Wire.endTransmission(true);
   Wire.beginTransmission(MPU_6050);
   Wire.write(INT_EN); 
   Wire.write(16); //set up interrupt overflow of FIFO to prevent loss of data
   Wire.endTransmission(true);
   enable_FIFO();
   get_0_vals();
  }

  void enable_FIFO(){
    Wire.beginTransmission(MPU_6050);
    Wire.write(FIFO_EN);
    Wire.write(112); //enable the FIFO line for GY x,y and z
    Wire.endTransmission(true);
  }

  void disable_FIFO(){
    Wire.beginTransmission(MPU_6050);
    Wire.write(FIFO_EN);
    Wire.write(0); //enable the FIFO line for GY x,y and z
    Wire.endTransmission(true);
  }

  void check_FIFO_overflow_stat(){
    Wire.beginTransmission(MPU_6050);
    Wire.write(INT_STAT);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_6050, 1, true);
    if(Wire.available() >= 1){
      FIFO_OVERFLOW_STAT = Wire.read() >> 4;
    }
    Serial.println(FIFO_OVERFLOW_STAT);
  }

  void check_FIFO_size(){
    Wire.beginTransmission(MPU_6050);
    Wire.write(FIFO_COUNTH);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_6050, 2, true);
    if(Wire.available() >=2){  
      FIFO_COUNT = Wire.read() << 8;
      FIFO_COUNT |= Wire.read();
    }
    Wire.endTransmission();
    Serial.print("FIFO count: ");
    Serial.println(FIFO_COUNT);
  }
  void get_0_vals(){
    Wire.beginTransmission(MPU_6050);
    Wire.write(FIFO_R_W);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_6050, 6, true);
    if(Wire.available() >= 6){  
      x0 = Wire.read() << 8;
      x0 |= Wire.read();
      y0 = Wire.read() << 8;
      y0 |= Wire.read();
      z0 = Wire.read() << 8;
      z0 |= Wire.read();
    }
    Wire.endTransmission();
  }
  void read_FIFO_xyz(){
    Wire.beginTransmission(MPU_6050);
    Wire.write(FIFO_R_W);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU_6050, 6, true);
    if(Wire.available() >=6){  
       FIFO_DATA_X = Wire.read() << 8;
       FIFO_DATA_X |= Wire.read();
       FIFO_DATA_Y = Wire.read() << 8;
       FIFO_DATA_Y |= Wire.read();
       FIFO_DATA_Z = Wire.read() << 8;
       FIFO_DATA_Z |= Wire.read();
    }
    Wire.endTransmission(true);
  }

  void zero_FIFO_data(){
    FIFO_DATA_X = FIFO_DATA_X - x0;
    FIFO_DATA_Y = FIFO_DATA_Y - y0;
    FIFO_DATA_Z = FIFO_DATA_Z - z0;
  }

  void fill_arrays(){
    for(int i = 0; i<10; i++){   
      should_FIFO_be_on();
      if(FIFO_COUNT > 6){
        read_FIFO_xyz();
        zero_FIFO_data();
        x_val[i] = FIFO_DATA_X;
        y_val[i] = FIFO_DATA_Y;
        z_val[i] = FIFO_DATA_Z;
      }
    }
  }

  void should_FIFO_be_on(){
    check_FIFO_size();
    if(FIFO_COUNT > 900){
      disable_FIFO();
    }
    else{
      enable_FIFO();
     }
  }

  void loop() {
    Serial.print("Size of x_val: ");
    Serial.println(sizeof(x_val));
    Serial.println("Start of Main");
    check_FIFO_size();
    should_FIFO_be_on();
    if(FIFO_COUNT > 60){
      fill_arrays();
    }
    Serial.print("Size of x_val: ");
    Serial.println(sizeof(x_val));
    for(int i = 0; i<10; i++){
      Serial.print("Element ");
      Serial.print(i);
      Serial.print(" of x_val: ");
      Serial.println(x_val[i]);  
    }
  }

#包括
#定义MPU_6050 0x68
#定义压水堆管理0x6B
#定义FIFO_EN 0x23
#定义先进先出计数0x72
#定义先进先出计数0x73
#定义FIFO\u R\u W 0x74
#定义SMPLRT_DIV 0x19
#定义用户\u CTRL 0x6A
#定义GY_配置0x1B
#定义自测试0x0D
#定义自测试0x0E
#定义自测试0x0F
#定义INT_EN 0x38
#定义INT_STAT 0x3A
#定义数组大小为10
int FIFO_溢出_统计；
int FIFO_数据_X；
int FIFO_数据_Y；
int FIFO_数据_Z；
int x0；
int-y0；
int z0；
国际先进先出计数；
int x_val[数组大小]；
int y_val[数组大小]；
int z_val[数组大小]；
无效设置（）{
Serial.begin（115200）；//启动串行接口
Wire.begin（）；//设置i2c
Wire.beginTransmission（MPU_6050）；//开始传输到从机
电线写入（压水堆管理1）；
Wire.write（0）；//唤醒
Wire.endTransmission（true）；//在缓冲区中发送字节
电线开始传输（MPU_6050）；
导线写入（SMPLRT_DIV）；
Wire.write（5）；//将采样率设置为250hz（因为8000/1+31=250）
线端传输（真）；
禁用_FIFO（）；
电线开始传输（MPU_6050）；
Wire.write（用户\u CTRL）；
Wire.write（68）；//启用FIFO行并清除它
线端传输（真）；
检查_FIFO_size（）；
电线开始传输（MPU_6050）；
Wire.write（自测试）；
Wire.write（7）；//设置自检
线端传输（真）；
电线开始传输（MPU_6050）；
线写（自测试）；
Wire.write（7）；//设置自检
线端传输（真）；
电线开始传输（MPU_6050）；
Wire.write（自测试）；
Wire.write（7）；//设置自检
线端传输（真）；
电线开始传输（MPU_6050）；
Wire.write（GY_配置）；
Wire.write（224）；//自检陀螺仪并将满标度范围设置为250*/s
线端传输（真）；
电线开始传输（MPU_6050）；
导线写入（INT_EN）；
Wire.write（16）；//设置FIFO的中断溢出以防止数据丢失
线端传输（真）；
启用_FIFO（）；
获取0个VAL（）；
}
void enable_FIFO（）{
电线开始传输（MPU_6050）；
线写入（FIFO_EN）；
Wire.write（112）；//为GY x、y和z启用FIFO行
线端传输（真）；
}
void disable_FIFO（）{
电线开始传输（MPU_6050）；
线写入（FIFO_EN）；
Wire.write（0）；//为GY x、y和z启用FIFO行
线端传输（真）；
}
无效检查\u先进先出\u溢出\u统计（）{
电线开始传输（MPU_6050）；
导线写入（INT_STAT）；
线端传输（假）；
请求自（MPU_6050，1，真）；
如果（Wire.available（）>=1）{
FIFO_OVERFLOW_STAT=Wire.read（）>>4；
}
Serial.println（先进先出溢出统计）；
}
无效检查\u FIFO\u大小（）{
电线开始传输（MPU_6050）；
线写入（先进先出计数）；
线端传输（假）；
请求自（MPU_6050，2，真）；
如果（Wire.available（）>=2）{
FIFO_COUNT=Wire.read（）=6{
x0=您正在使用的Wire.read（），它不会返回数组中的元素数

返回类型的对象表示形式的大小（以字节为单位）

这里有一个解决方案：

sizeof(x_val) / sizeof(x_val[0])

这将返回数组中的元素数。更多信息。
您正在使用的，它不会返回数组中的元素数

返回类型的对象表示形式的大小（以字节为单位）

这里有一个解决方案：

sizeof(x_val) / sizeof(x_val[0])

这将返回数组中的元素数。更多信息。
sizeof（x_val）
是20，因为它是
sizeof（int）*10
（
int
在Arduino上是16位）。这与
sizeof（x_val）
是20，因为它是
sizeof（int）*.10
（
int
在Arduino上是16位）这距离@AlexBanton还有很长的路要走，请务必接受答案以供进一步参考。是的，我马上就试过了，只是告诉我必须等待5分钟。记住，如果
x\u val
是指针，这不起作用（如果数组作为参数传递给函数，函数将接收指针而不是数组，因此有必要以其他方式传递大小）.@AlexBanton请确保接受答案以供进一步参考。是的，我马上就试过了，但它告诉我必须等待5分钟。记住，如果
x\u val
是指针，则此操作无效（如果将数组作为参数传递给函数，则函数将接收指针而不是数组，因此有必要以其他方式传递大小）。