Destructor is called after copy

[skittlekev]

Whenever my copy constructor is called, my destructor destroys is immediately after.


My copy constructor

CS1CStudent::CS1CStudent(const CS1CStudent& otherCS1CStudent)
{
	cout << "\n***************************\n";
        cout << "**Copy Constructor Called**\n";
        cout << "***************************";
          
        //copy name
        changeName(otherCS1CStudent.getName());
        
        //copy id
        changeId(otherCS1CStudent.getId());

        //copy phone #
        changePhone(otherCS1CStudent.getPhone());

        // copy age
        changeAge(otherCS1CStudent.getAge());

        //copy gender
        changeGender(otherCS1CStudent.getGender());
 
        //copy class standing
        changeClass(otherCS1CStudent.getClass());

        //copy gpa
        changeGpa(otherCS1CStudent.getGpa());
   
        //copy score
        totalScore = otherCS1CStudent.totalScore;

        //copy  knowledge of java
        java = otherCS1CStudent.java;

        //copy graduation date
        grad = otherCS1CStudent.grad;

        //copy street name
        street = new char [strlen(otherCS1CStudent.street) +1];
        strcpy(street, otherCS1CStudent.street);

        //copy city name
        city = new char[strlen(otherCS1CStudent.city) +1];
        strcpy(city, otherCS1CStudent.city);

        //copy state name
        state = new char[strlen(otherCS1CStudent.state) +1];
        strcpy(state, otherCS1CStudent.state);

        //copy zip
        zip = otherCS1CStudent.zip;

}

My destructor

CS1CStudent::~CS1CStudent()
{
      cout << "\n*********************\n";
      cout << "**Destructor Called**\n";
      cout << "*********************";
      delete [ ] street;
      delete [ ] city;
      delete [ ] state;
}

In my main I have

 CS1CStudent* cs1cPtr[4];

        cs1cPtr[0] = new CS1CStudent;
        cs1cPtr[1] = new CS1CStudent;
        cs1cPtr[2] = new CS1CStudent;
        cs1cPtr[3] = new CS1CStudent;

and this is where the problem occurs
*cs1cPtr[2] = cs1cPtr[0]->passAndReturnByCopy(*cs1cPtr[0]);

the function passAndReturnByCopy:

CS1CStudent CS1CStudent::passAndReturnByCopy(CS1CStudent cs1c)
{
	return cs1c;
}

and finally, the private members

private:
        int totalScore;
        bool java;
        dateType grad;

        char* street;
        char* city;
        char* state;
        int zip;

The copy constructor is called twice, once when you pass an object by value, and once when the object is returned from a function by value. But why is the destructor being called twice?

[cire]

The copy constructor is called twice, once when you pass an object by value, and once when the object is returned from a function by value. But why is the destructor being called twice?

Two objects were created. Why do you think they won't both be destroyed?