Understanding when objects get destroyed

Question

I was told in this answer to delete the member myValue in the destructor. But if I add it I am getting an exception. From the console messages it seems to be entering the destructor at two moments with the same object(!?)

Note: The code is my attempt to an exercise. In it we are given a code to which we can only add to it. Essentially the content of the main and the constructor without parameters is that is given. The rest is what I am adding to it to make it work.

My guess is that a copy of the object made during some function call is destroying the same myValue after exiting the function call. How is the right way to preserve the data pointed to by two objects in this case?

// ConsoleApplication1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>
using namespace std;

class MyFancyInt
{
public:
    // A constructor that inputs a value for initialization, so that line /*1*/ makes sense.
    MyFancyInt(int x) : myValue(new int(x))// The part after the : initializes myValue to point to the newly created int with value x.
    {
        cout << "Constructor that initializes with myValue = " << x << endl;
    };

    //Destructor.
    ~MyFancyInt()
    {  
        cout << "A MyFancyInt destroyed that had the myValue = "<< this->myValue<< " pointing to a "<< *(this->myValue) << endl;
        //delete myValue;
    };

    //A 'Copy Constructor', so that line /*3*/ makes sense. Aparently C++ creates default copy constructors.
    //A copy constructor input an already existing MyFancyInt, creates a new MyFancyInt and initializes it with the data of the former.
    MyFancyInt(MyFancyInt& x)
    {
        myValue = x.myValue;
    };

    //The construtor without parameters already given in the exercise.
    MyFancyInt()
    {
        cout << "Default constructor" << endl;
        myValue = 0;
    }

    // Friend function to overload the operator +. This one takes two MyFancyInt. It is not needed. It can be commented out.
    friend MyFancyInt operator+(MyFancyInt &x, MyFancyInt &y);

    // Friend function to overload the operator +. This one takes an int and a MyFancyInt. It is needed for line /*6*/.
    friend MyFancyInt operator+(int x, MyFancyInt &y);

    // Friend function to overload the operator +. This one takes a MyFancyInt and an int. It is needed for line /*5*/.
    friend MyFancyInt operator+(MyFancyInt &x, int y);

    // Friend function to overload the output stream operator <<. It is needed for the printing in line /*7*/.
    friend ostream& operator<<(ostream& os, const MyFancyInt& x);

    // Overloading the operator =. It is needed for line /*2*/, /*5*/, and /*6*/.
    MyFancyInt& operator=(const MyFancyInt &x);
private:
    int* myValue;

};

MyFancyInt operator+(MyFancyInt &x, MyFancyInt &y)
{
    cout << "MyFancyInt + MyFancyInt = " << x.myValue << " + " << y.myValue << "= " << *(x.myValue) << " + " << *(y.myValue) << endl;
    MyFancyInt z=MyFancyInt(*(x.myValue) + *(y.myValue));
    cout << "= " << *(z.myValue) << endl;
    return z;
};
 MyFancyInt operator+(int x, MyFancyInt &y)
 {
     cout << "int + MyFancyInt = " << x << " + " << y.myValue << " = " << x << " + " << *(y.myValue)<< endl;
     MyFancyInt z = MyFancyInt(x + *(y.myValue));
     cout << " = " << *(z.myValue) << endl;
     return z;
 };
 MyFancyInt operator+(MyFancyInt &x, int y)
 {
     cout << "MyFancyInt + int = " << x.myValue << " + " << y << " = " << *(x.myValue) << " + " << y << endl;
     MyFancyInt z = MyFancyInt(*(x.myValue) + y);
     cout << " = " << *(z.myValue) << endl;
     return z;
 };

 ostream& operator<<(ostream& os, const MyFancyInt& x)
 {
     os << *(x.myValue);
     return os;
 }

 MyFancyInt& MyFancyInt::operator=(const MyFancyInt &x)
 {
     cout << "Entering the assigment operator." << endl;
     myValue = x.myValue;
     return *this;
 };

int _tmain(int argc, _TCHAR* argv[])
{
    MyFancyInt mfi1(1);     /*1*/
    MyFancyInt mfi2 = mfi1; /*2*/
    MyFancyInt mfi3(mfi1);  /*3*/
    MyFancyInt mfi4;        /*4*/
    mfi4 = mfi3 + 2;        /*5*/
    mfi4 = 3 + mfi3;        /*6*/
    cout << mfi4 << endl;   /*7*/
    return 0;
}

Answer 1

The way your copy constructor is written, when you copy an object, both objects will be pointing to the same address and both will try to delete it.