C++ 字符数组中的空字符和分段错误-c++；

我正在填充一个字符数组，但当我尝试添加字符串结尾（'\0'）时，有时会出现分段错误。这是我的密码

板.h

#ifndef Plate_h
#define Plate_h

#include <string.h>
#include <vector>
#include "OCRChar.h"

using namespace std;

class Plate{
    public:
        Plate();

        void setChars(vector< vector<OCRChar> > chars);
        vector<char*> getPlateNums();
   private:
        vector< vector<OCRChar> > chars;

        vector<char*> plateNums;

        void computePlateNumbers();
        int calculatePlateListSize();
};

#endif

OCRChar.cpp

#include "OCRChar.h"


OCRChar::OCRChar(char character, float confidence){
    this->character = character;
    this->confidence = confidence;
}

char OCRChar::getCharacter(){
     return character;  
}


float OCRChar::getConfidence(){
    return confidence;
}

main.cpp

#include "Plate.h"
#include "OCRChar.h"

#include <vector>
#include <iostream>

using namespace std;

int main(void){



    vector< vector<OCRChar> > chars;
    vector<OCRChar> char1;
    vector<OCRChar> char2;
    vector<OCRChar> char3;
    vector<OCRChar> char4;
    vector<OCRChar> char5;
    vector<OCRChar> char6;
    char1.push_back(OCRChar('A',90));
    chars.push_back(char1);

    char2.push_back(OCRChar('1',60));
    char2.push_back(OCRChar('2',50));
    char2.push_back(OCRChar('3',50));
    char2.push_back(OCRChar('4',50));
    chars.push_back(char2);

    char3.push_back(OCRChar('B',60));
    char3.push_back(OCRChar('C',50));
    char3.push_back(OCRChar('D',50));
    char3.push_back(OCRChar('E',50));
    chars.push_back(char3);

    char4.push_back(OCRChar('5',60));
    char4.push_back(OCRChar('6',50));
    char4.push_back(OCRChar('7',50));
    char4.push_back(OCRChar('8',50));
    chars.push_back(char4);

    char5.push_back(OCRChar('F',60));
    chars.push_back(char5);

    char6.push_back(OCRChar('9',60));
    char6.push_back(OCRChar('G',60));
    chars.push_back(char6);

    Plate p;
    p.setChars(chars);
    vector< char*> nums = p.getPlateNums();
    for(int i=0;i<nums.size();i++){
        cout<<"Plate num "<<i<<" :"<<nums[i]<<endl;
    }

}

#包括“Plate.h”
#包括“OCRChar.h”
#包括
#包括
使用名称空间std；
内部主（空）{
向量<向量>字符；
载体char1；
载体char2；
载体char3；
载体char4；
载体char5；
载体char6；
char1.向后推（OCRChar（'A'，90））；
chars.推回（char1）；
char2.向后推（OCRChar（'1'，60））；
char2.向后推（OCRChar（'2'，50））；
char2.向后推（OCRChar（'3'，50））；
char2.向后推（OCRChar（'4'，50））；
chars.向后推（char2）；
char3.向后推（OCRChar（'B'，60））；
char3.向后推（OCRChar（'C'，50））；
char3.向后推（OCRChar（'D'，50））；
char3.向后推（OCRChar（'E'，50））；
chars.推回（char3）；
char4.向后推（OCRChar（'5'，60））；
char4.向后推（OCRChar（'6'，50））；
char4.向后推（OCRChar（'7'，50））；
char4.向后推（OCRChar（'8'，50））；
chars.向后推_（char4）；
char5.向后推（OCRChar（'F'，60））；
chars.向后推（char5）；
char6.向后推（OCRChar（'9'，60））；
char6.向后推（OCRChar（'G'，60））；
chars.向后推（char6）；
板p；
p、 塞查斯（查斯）；
向量nums=p.getPlateNums（）；
对于（inti=0；i检查
platesSize%numCycles==0
。如果不是这样，您将不会在
plates[j*oChars.size（）*rep+k*rep+l]=new char[chars.size（）+1]；
中初始化
板材的最后成员

比方说

platesSize == 100
oChars.size() == 9
rep == 1
numCycles = oChars.size()*rep == 9
iterations = platesSize/numCycles == 11

j = iterations-1 == 10
k = oChars.size()-1 == 8
l = rep-1 == 0;

j*oChars.size()*rep+k*rep+l == 10*9*1+8*1+0 == 98

因此，您将不会初始化
plates[99]
我没有太多时间阅读代码

但是看看错误线，我可以给你一个建议

plates[i][chars.size()] = '\0';

每当数组元素访问产生问题时，首先必须确定索引是否在边界内

由于
plates
是一个向量，您应该在这里使用
std:：vector.at（index）
。因此，如果执行任何越界访问，它将抛出。我怀疑越界访问是问题所在。
我解决了将char*更改为string的问题：

#ifndef Plate_h
#define Plate_h

#include <string>
#include <vector>
#include "OCRChar.h"

using namespace std;

class Plate{
    public:
        Plate();

        void setChars(vector< vector<OCRChar> > chars);
        vector<string> getPlateNums();
   private:
        vector< vector<OCRChar> > chars;

        vector<string> plateNums;

        void computePlateNumbers();
        int calculatePlateListSize();
};

#endif

#如果NDEF板
#定义板
#包括
#包括
#包括“OCRChar.h”
使用名称空间std；
班牌{
公众：
板（）；
无效设置字符（向量<向量>字符）；
向量getPlateNums（）；
私人：
向量<向量>字符；
载体平台；
void computePlateNumber（）；
int calculatePlateListSize（）；
};
#恩迪夫

车牌号

#include "Plate.h"

Plate::Plate(){
}


void Plate::setChars(vector< vector<OCRChar> > chars){
     this->chars = chars;
}

vector<char*> Plate::getPlateNums(){
    if(plateNums.size()==0){
        computePlateNumbers();
    }
    return plateNums;
}

void Plate::computePlateNumbers(){
     if(chars.size()== 0)return;
     int platesSize = calculatePlateListSize();
     vector<char*> plates(platesSize);
     int rep = 1;
     for(int i = 0; i<chars.size();i++){
         vector<OCRChar> oChars = chars[i];
         int numCycles = oChars.size()*rep;
         int iterations = platesSize/numCycles;
         for(int j=0;j<iterations;j++){
             for(int k= 0; k<oChars.size();k++){
                 for(int l=0;l<rep;l++){
                     if(!plates[j*oChars.size()*rep+k*rep+l]){
                         plates[j*oChars.size()*rep+k*rep+l] = new char[chars.size()+1];
                     }
                     plates[j*oChars.size()*rep+k*rep+l][i] = oChars[k].getCharacter();
                 }
             }
         }
         rep = numCycles;
     }

     for(int i =0; i<platesSize; i++){
        plates[i][chars.size()] = '\0';
     }

     plateNums = plates;
}

int Plate::calculatePlateListSize(){
    int platesSize = 1;
    for(int i = 0; i<chars.size();i++){
        platesSize *= chars[i].size();
    }
    return platesSize;
}

#include "Plate.h"

Plate::Plate(){
}


void Plate::setChars(vector< vector<OCRChar> > chars){
     this->chars = chars;
}

vector<string> Plate::getPlateNums(){
    if(plateNums.size()==0){
        computePlateNumbers();
    }
    return plateNums;
}

void Plate::computePlateNumbers(){
     if(chars.size()== 0)return;
     int platesSize = calculatePlateListSize();
     vector<string> plates(platesSize);
     int rep = 1;
     for(int i = 0; i<chars.size();i++){
         vector<OCRChar> oChars = chars[i];
         int numCycles = oChars.size()*rep;
         int iterations = platesSize/numCycles;
         for(int j=0;j<iterations;j++){
             for(int k= 0; k<oChars.size();k++){
                 for(int l=0;l<rep;l++){
                     plates[j*oChars.size()*rep+k*rep+l] += oChars[k].getCharacter();
                 }
             }
         }
         rep = numCycles;
     }

     plateNums = plates;
}

int Plate::calculatePlateListSize(){
    int platesSize = 1;
    for(int i = 0; i<chars.size();i++){
        platesSize *= chars[i].size();
    }
    return platesSize;
}

#包括“Plate.h”
板：：板（）{
}
空心板：：设置字符（向量<向量>字符）{
这->字符=字符；
}
向量板：：getPlateNums（）{
if（plateNums.size（）=0）{
computePlateNumber（）；
}
返回平台；
}
空心板：：ComputePlateNumber（）{
if（chars.size（）==0）返回；
int platesSize=calculatePlateListSize（）；
矢量板（平板化）；
int rep=1；
对于（int i=0；我请阅读指南，并在提供样本时注意“最小值”。好的，我将创建我的测试并与您分享。另外，为什么不使用
vector
而不是
vector
？我在vector中思考，这将是我的下一个方法，初始化不是问题。问题在图版[i][chars.size（）]='\0'；它只是在Debian Jessie上失败了。失败是因为在
plates[j*oChars.size（）*rep+k*rep+l]=new char[chars.size（）+1]；
中没有为
j
、
k
和
l
分配内存*rep+k*rep+l
，因此
plates[i]
未初始化，因此无法访问
plates[i][chars.size（）]
。这不是真的。如果我用空字符打印所有数组，它会在正确的字符后打印垃圾。我将char*改为string，这很好用。正如我提到的，它在Mac OS X和Fedora中非常好用，但在Debian/Raspian Jessie中，我有一些问题。
#ifndef Plate_h
#define Plate_h

#include <string>
#include <vector>
#include "OCRChar.h"

using namespace std;

class Plate{
    public:
        Plate();

        void setChars(vector< vector<OCRChar> > chars);
        vector<string> getPlateNums();
   private:
        vector< vector<OCRChar> > chars;

        vector<string> plateNums;

        void computePlateNumbers();
        int calculatePlateListSize();
};

#endif

#include "Plate.h"

Plate::Plate(){
}


void Plate::setChars(vector< vector<OCRChar> > chars){
     this->chars = chars;
}

vector<string> Plate::getPlateNums(){
    if(plateNums.size()==0){
        computePlateNumbers();
    }
    return plateNums;
}

void Plate::computePlateNumbers(){
     if(chars.size()== 0)return;
     int platesSize = calculatePlateListSize();
     vector<string> plates(platesSize);
     int rep = 1;
     for(int i = 0; i<chars.size();i++){
         vector<OCRChar> oChars = chars[i];
         int numCycles = oChars.size()*rep;
         int iterations = platesSize/numCycles;
         for(int j=0;j<iterations;j++){
             for(int k= 0; k<oChars.size();k++){
                 for(int l=0;l<rep;l++){
                     plates[j*oChars.size()*rep+k*rep+l] += oChars[k].getCharacter();
                 }
             }
         }
         rep = numCycles;
     }

     plateNums = plates;
}

int Plate::calculatePlateListSize(){
    int platesSize = 1;
    for(int i = 0; i<chars.size();i++){
        platesSize *= chars[i].size();
    }
    return platesSize;
}