Question

基本上标题是什么。我一直在尝试使用char数组编写自己的字符串类，虽然我的代码在Visual Studio中运行时工作，但在使用gcc时我遇到了麻烦。问题似乎即将来临在我的getData函数中删除（可以在下面看到）我得到的例外是：

在string.exe中的0x6262436B（ucrtbased.dll）抛出异常：0xC0000005：访问冲突读取位置0xCCCCCCBC。发生了我的代码：

部首：

#pragma warning(disable:4996)
#ifndef STRING_STRING_H
#define STRING_STRING_H

#include<iostream>
#include<cstring>
#include<fstream>

class String {
private:
    char *data; //holds the text
    size_t maxSize; //maximum number of chars in data
    size_t currentSize; //current number of chars in data

    void getData(const char *, size_t maxSize); //sets currentSize to the other char* size and
                                                // copies the content of the other char* to data
public:
    String(); //default constructor
    ~String(); //destructor

    String(const String &); //copy-constructor(from String)
    String(const char *);   //copy-constructor(from char*)

    String operator=(const String &); //operator= (from string)
    String operator=(const char *);  //operator=(from char*)

    size_t length() const; //currentSize getter

    void addChar(const char); //adds a char to the data array

    void getLine(std::ifstream&,const char); // reads line till deliminator and stores it in this string object(all data previously stored is lost)

    size_t find(const char*); //searches for text in the string and if found returns the starting position , if not found returns -1;

    void print() const; //prints the string object to console

    char* toChar() const; //returns a new allocated char pointer with the text inside (must be deleted afterwards)
};


#endif //STRING_STRING_H

CPP：

#include "String.h"


String::String() {
    currentSize = 0;
    maxSize = 16;
    try {
        data = new char[maxSize];
        data[0] = '\0';
    }
    catch (std::bad_alloc &) {
        std::cerr << "Not enough memory" << std::endl;
        throw;
    }
}

String::~String() {
    delete[] data;
}

size_t String::length() const {
    return currentSize;
}

String::String(const String &other) {
    this->maxSize = other.maxSize;
    getData(other.data, maxSize);
}

String::String(const char *other) {
    this->maxSize = strlen(other) *2;
    getData(other, maxSize);
}

void String::getData(const char *dataSource, size_t maxSize) {
    currentSize = strlen(dataSource);
    try {
        char *newData = new char[maxSize];
        delete[] data;
        data = newData;
        strcpy(data, dataSource);
    }
    catch (std::bad_alloc &) {
        std::cerr << "Not enough memory" << std::endl;
        throw;
    }
}


String String::operator=(const String &other) {
    if (this != &other) {
        maxSize = other.maxSize;
        getData(other.data, maxSize);
    }
    return *this;
}

String String::operator=(const char *other) {
    if (this->data != other) {
        maxSize = strlen(other) *2;
        getData(other, maxSize);
    }
    return *this;
}

void String::addChar(const char newChar) {
    if (maxSize == currentSize+1) {
        maxSize *= 2;
        getData(this->data, maxSize);
    }
    data[currentSize++] = newChar;
}

void String::getLine(std::ifstream & is, const char delim='\n')
{
    char temp;
    while (!is.eof())
    {
        is.get(temp);
        if (temp == delim)
            break;
        else
            addChar(temp);
    }
    return;
}

size_t String::find(const char * text)
{
    size_t currPos=-1;
    bool found = 0;
    for (size_t i = 0; i < currentSize; i++)
    {
        if (data[i] == text[0])
        {
            for (size_t j = i+1; j < currentSize; j++)
            {
                if (data[j] == text[j - i])
                    found = 1;
                else
                {
                    found = 0;
                    break;
                }
            }
            if (found == 1)
            {
                currPos = i;
                break;
            }
        }
    }
    return currPos;
}

void String::print() const
{
    for (size_t i = 0; i < currentSize; i++)
    {
        std::cout << data[i];
    }
    std::cout << std::endl;
}

char * String::toChar() const
{
    char* text= new char[currentSize+1];
    for (size_t i = 0; i < currentSize; i++)
    {
        text[i] = data[i];
    }
    text[currentSize + 1] = 0;
    return text;
}

Answer 1

您的问题是由在未初始化的内存上调用delete []引起的。

在复制构造函数中，data成员在调用getData()之前未初始化。在getData()中，您使用的是delete [] data;。

您可以在构造函数中初始化data到nullptr以避免此问题。

在构造函数的主体之前将所有变量初始化为某个合理的值总是一个好主意。例如。您可以将复制构造函数实现为：

String::String(const String &other) : currentSize(0),
                                      maxSize(other.maxSize),
                                      data(nullptr)
{
    getData(other.data, maxSize);
}

同样，从char const*实现构造函数：

String::String(const char *other) : currentSize(0),
                                    maxSize(strlen(other) *2),
                                    data(nullptr)
{
    getData(other, maxSize);
}

试着写我自己的字符串类在gcc中获取异常

1 个答案: