复制构造函数中的内存泄漏

Question

I have tried to read lots of solutions to memory leaks occur in copy constructor, but i still didnt understans how to solve it.

For example i have a "Person" class that has those mambers and functions (header files):

#include "Object.h"
#include <string.h>
#include <iostream>
using namespace std;
class Person: public Object
{

private:
    char * p_name;
    int  length;
public:
    virtual Object * copy() const;
    virtual void print(ostream & os) const;
    Person(char * name);
    Person(const Person & per);
    ~Person();
};

In this program Im trying to enter "Objects" to a Vector while Person and Vector inherit from Object. In both of the copy const i have memory leak problems (the program is working excellent).

For example in this code im getting a memory leaks of all of those 5 char arrays. I have more problems also in Vector memory leaks, but lets start in this simple code in the main (that occurs 5 memory leaks of the char array):

int main ()
{
    const int SIZE = 5;
    Person* persons[SIZE];
    int i;

    // preparation of name array 
    for (i = 0; i<SIZE; i++) {
        char* tmp = new char[10];
        sprintf(tmp, "P-%d", i);
        persons[i] = new Person(tmp);
    }

    for (i = 0; i < SIZE; i++)
        delete persons[i];

    return 0;
}

Person class is:

#include "Person.h"
using namespace std;



Object * Person::copy() const
{
    Person * p = new Person(*this);
    return p;
}

void Person::print(ostream & os) const
{
    for (int i = 0; i < this->length-1; i++)
    {
        os << this->p_name[i];
    }
}


Person::Person(char * name)
{
    delete this->p_name;
    this->length = strlen(name)+1;
    p_name = new char[length];
    strncpy(p_name, name, length);
}

Person::Person(const Person & per)
{
    delete[] this->p_name;
    this->length = strlen(per.p_name) + 1;
    this->p_name = new char[this->length];
    strncpy(this->p_name, per.p_name, this->length);
}

Person::~Person()
{
    delete[] this->p_name;
}

I would be thankful for your help!!

Answer 1

You don't have just a memory leak. You have a full-fledged, memory-corrupting, undefined behavior:

Person::Person(char * name)
{
    delete this->p_name;

This is your constructor. The p_name class member does not appear to be initialized in any way. And the first thing you do, is you try to delete it.

So, whatever random value p_name will contain, as a result of the most recent set of cosmic rays striking the RAM capacitors that hold its initial value, the first thing the constructor does is try to free the pointed-to memory.

Before you can worry about any alleged leaks from your copy constructor, you need to fix a bunch of problems, like this, elsewhere.

Answer 2

In main(), the tmp char array is not deleted, and that's the first memory leakage I'm seeing.

In the Person(char * name) constructor you call a delete on

Person::Person(char * name)
{
     delete this->p_name;

the p_name is not allocated, so the behavior is undefined. And p_name is an array, so delete[] should be used.

if you use the std::string class, you can at least avoid the confusion between delete and delete[]

Answer 3

in main(), where you prepare your c you allocate 5 char buffers, that're never freed

also (not speaking of std::string which would help you with your string stuff) , get rid of the unneeded "this->"s:

Person::Person(const Person & per)  
{
    delete[] this->p_name;
    this->length = strlen(per.p_name) + 1;
    this->p_name = new char[this->length];
    strncpy(this->p_name, per.p_name, this->length);
}

could look like this:

Person::Person(const Person & per)
{
    delete[] p_name;
    length = strlen(per.p_name) + 1;
    p_name = new char[length];
    strncpy(p_name, per.p_name, length);
}

Answer 4

There are some problems with delete.

In your main, in the first while you have to delete temp ; in the second well just don't use it, use delete [] persons .

In your copy constructor don't use delete this->p_name , that's not correct.

At first you have to set the pointer to null so p_name=NULL, and then use setters and getters, same for your value constructor.

And in your destructor, test if p_name exists before deleting it.