0xC0000005：读取位置 0xccccccd0 时发生访问冲突。 C++

Question

当我尝试将一个字符串（存储在类中）设置为等于另一个字符串时，我遇到了上述问题。我梳理啊梳理试图找出是不是我没有初始化任何变量，但是找不到这样的情况。在调试模式中，我收到上述错误。在发布模式下，它会挂起，Win7 会寻找问题，没有重大中止或重试窗口。这是相关的代码，我的主程序还有另一个头文件，如果您认为应该包含它，我将包含导致错误的行。语言显然是C++。

//Error occurs in this area:
   Car one;
   one = two;
   one.addExtra ("Windows");

   log << "Car one: " << one << endl;
   two = Car(one); // call copy constructor.
//I realize when I call the first one = two, there are no extras
//stored int Car one, which is what differs between the two. Remaining 
//code. Extras header:

#include <iostream>
#include <string>
#include <string.h>
using namespace std;

class Extras
{
public:
    friend class Car;
    friend int main();
    friend ostream& operator << (ostream& os, const Extras& in);
    friend class CarLot;
    Extras(const Extras& other);
    Extras& operator=(Extras  &rhs);
    Extras(string in);
    Extras();
    ~Extras();
    void modify_ext(string* in);
    //string ex_list;
private:
    int place;
    string *ex_list;
};
//Extras.cpp:
#include "Extras.h"

Extras::Extras(string in)
{
    delete ex_list;
    ex_list = new string;
    place = 0;
    //ex_list = new string[4];
    (*ex_list) = in;
    place++;
}

Extras::Extras()
{
    //ex_list = new string[4];
    place = 0;
    //for(int i = 0; i < 4; i++)
    ex_list = new string;
    *ex_list = "0";
}

//Overloaded << operator for Extras class to
//easily output array contents
ostream& operator<< (ostream& os, Extras const &in)
{
    os << *(in.ex_list);
    return os;
}

Extras& Extras::operator=(Extras &rhs)
{
    if(this != &rhs)
    {
        //string temp;
        //temp = rhs.ex_list;
        modify_ext(rhs.ex_list);
        cout << endl << endl << ex_list << endl << endl;
        place = rhs.place;
    }
    return *this;
}

Extras::Extras(const Extras& other) : place(other.place), ex_list(other.ex_list)
{
    //for(int i = 0; i < 4; i++)
        //ex_list = other.ex_list;
}

void Extras::modify_ext(string* in)
{
    delete ex_list;
    ex_list = new string;
    (*ex_list).resize((*in).size());
    for(unsigned int i = 0; i < (*in).size(); i++)
        ex_list[i] = in[i];
}

Extras::~Extras()
{
    delete ex_list;
    place = 0;
}

//Car Header:
#include "Extras.h"

class Car
{
public:
    friend class Extras;
    friend Extras& Extras::operator=(Extras &rhs);
    friend int main();
    friend ostream& operator<< (ostream& os, const Car& in);
    friend class CarLot;
    friend void add_extra();
    ~Car();
    Car();
    Car(Car& other);
    Car(string in_name, int in_year, string in_color, float in_cost);
    Car& operator=(Car const &rhs);
    void edit_extr(int in);
    void addExtra(string in);
private:
    string name, color;
    int year, extr_num;
    float cost;
    Extras  *extr;
};

//Car.cpp:


 #include "car.h"

//Constructor
Car::Car(string in_name, int in_year, string in_color, float in_cost)
{
    name = in_name;
    color = in_color;
    year = in_year;
    cost = in_cost;
    extr = new Extras[3];
    extr_num = 0;
}

//Overloaded = operator
Car& Car::operator=(Car const &rhs)
{
    if(this != &rhs)
    {
        name = rhs.name;
        color = rhs.color;
        year = rhs.year;
        cost = rhs.cost;
        //delete extr;
        extr = rhs.extr;
        extr_num = rhs.extr_num;
    }
    return *this;

}



//Default Constructor
Car::Car()
{
    name = "TEMP";
    color = "BLUE";
    year = 0;
    cost = 0;
    extr = new Extras[3];
    extr_num = 0;
}

//Destructor
Car::~Car()
{
    delete extr;
    extr = NULL;
}

//Copy constructor
Car::Car(Car& other) : name(other.name), color(other.color), year(other.year), 
    cost(other.cost), extr_num(other.extr_num)

{
    //delete extr;
    for(int i = 0; i < extr_num; i++)
    {
        extr[i].modify_ext(other.extr[i].ex_list);
        extr[i].place = other.extr[i].place;
    }
}





//Overloaded << operator for Car class 
ostream& operator<< (ostream& os, const Car& in)
{
    os.precision(2);
    os << in.name << ", " << in.year << ", " 
        << in.color << ", $"<< in.cost << ", ";
    os << "extras include: ";
    for(int k = 0; k < in.extr_num; k++)
    {
        os << in.extr[k] << ", ";
    }
    os << endl;
    return os;
}

void Car::edit_extr(int in)
{
    Extras* temp;
    temp = new Extras[in];
    for(int i = 0; i < in; i++)
        temp[i] = extr[i];
    extr_num = in;
    delete extr;
    extr = temp;
}

void Car::addExtra(string in)
{
    if(extr_num == 3)
    {
        //log << "Car has too many extras.";
        return;
    }
    //edit_extr(extr_num + 1);
    *(extr[extr_num].ex_list) = in;
    extr[extr_num].place++;
    extr_num++;
}

正如我所说，我还有一个额外的标头、另一个类和一个主程序（如果需要包含这些内容），但我认为这对于任何人来说都足够了（抱歉！）。任何帮助将不胜感激。

Answer 1

我看到的是损坏的：

---

two = Car(one); // call copy constructor.

不，它使用复制构造函数创建一个临时对象，将其传递给 two 上的 operator=()，然后销毁临时对象。

---

Extras& operator=(Extras  &rhs);

应该是：

Extras& operator=(const Extras &rhs);

---

Extras::Extras(string in)
{
    delete ex_list;
    ex_list = new string;
    place = 0;
    //ex_list = new string[4];
    (*ex_list) = in;
    place++;
}

更好：

Extras::Extras(const string& in): place(1), ex_list(new string(in))
{
}

---

Extras::Extras(const Extras& other) : place(other.place), ex_list(other.ex_list)
{
    //for(int i = 0; i < 4; i++)
        //ex_list = other.ex_list;
}

查看默认构造函数，很明显 Extras 对象拥有 ex_list 中的字符串。但是，此复制构造函数声明原始对象的 ex_list 的所有权。它应该制作自己的副本：

Extras::Extras(const Extras& other): place(other.place), 
    ex_list(new string(other.ex_list))
{
}

---

void Extras::modify_ext(string* in)
{
    delete ex_list;
    ex_list = new string;
    (*ex_list).resize((*in).size());
    for(unsigned int i = 0; i < (*in).size(); i++)
        ex_list[i] = in[i];
}

您正在复制字符串。您所需要的只是：

void Extras::modify_ext(const string* in)
{
    *ex_list = *in;
}

---

继续讨论汽车...

friend class Extras;
friend Extras& Extras::operator=(Extras &rhs);
friend int main();
friend ostream& operator<< (ostream& os, const Car& in);
friend class CarLot;
friend void add_extra();

您应该考虑重构代码以摆脱这些。

---

Car(Car& other);
Car(string in_name, int in_year, string in_color, float in_cost);

应该是：

Car(const Car& other);
Car(const string& in_name, int in_year, const string& in_color, float in_cost);

将对象传递给函数时，引用是您的朋友。

---

我要在这里停下来。

Answer 2

在构造函数中，您将删除 ex_list。它甚至还没有被分配，所以这是错误的。删除它并在分配新字符串时执行此操作：

ex_list = new string(in);

这样您就可以使用字符串复制构造函数。您可以在构造函数中删除您在下面尝试执行的其余操作，因为这将为您完成。

编辑：

实际上，这段代码中存在很多问题。您是否有任何理由希望字符串在内部成为指针？您在很多不同的地方都没有正确使用指针。当我向下滚动时，我只注意到第一个。

Answer 3

使用 VC++ 进行调试构建时的分配器使用一些魔法值来填充分配的区域。特别是，0xCC 是已分配但现在已释放的内存。因此，地址 0xCCCCCCD0 看起来可疑地像是距已释放的内存中的指针的一个小偏移量（例如，到结构或类成员）。鉴于此，马克·洛瑟的答案看起来很有希望。