Deleting a object pointer passed to a constructor function causing an error

Question

I'm new to C++ so and I'm trying to learn it with help of examples from Wikipedia. I played with classes a bit and I have an segmentation fault error.

Here is my code:

class SomeClass {};

class AnotherClass {
    SomeClass* sc
    public:
        AnotherClass(SomeClass* SC):( sc = SC; ){}

        //***********************************************************************
        ~AnotherClass(){ delete sc; } //here I'm getting rid of internal pointer
        //***********************************************************************
};

int main( int argc, char* argv[] ) {
    SomeClass* SC = new SomeClass();
    AnotherClass* AC = new AnotherClass(SC);

    delete AC;

    // *****************************************************
    delete SC; //i think that this line might cause an error
    //******************************************************

    return 0;
}

I thought, that I should delete every pointer to get the heap memory free?! Could you please point out my mistake.

Edit:

Here is my real code:

#include <iostream>
#include <string>

using namespace std;

class Pizza {
    string dough;
    public:
        Pizza(string d):dough(d) {}
            void setDough( string value ) { dough = value; }
            string getDough() { return dough; }
};

class PizzaBuilder {
    Pizza* pizza;

    public:
        PizzaBuilder( Pizza* p ) { pizza = p; }
        ~PizzaBuilder() { delete pizza; cout << "PizzaBuilder Destructor." << endl;}

        PizzaBuilder* addExtra(string extra) { 
            string special = pizza->getDough() + " and extra " + extra;
            pizza->setDough(special);
            return this;
        }
        Pizza* getPizza() { return pizza; }
    };

int main(int argc, char* argv[]) {

    Pizza* p = new Pizza("My Special DOVE!");
    PizzaBuilder* pb = new PizzaBuilder(p);

    pb->addExtra("Mushrooms")->addExtra("Anchovies")->addExtra("Zefir")->addExtra("Chilli");

    cout << p->getDough() << endl;

    delete pb;
    delete p;

    return 0;
}

Answer 1

delete does not delete the pointer, as you may think. It deletes the object the pointer points to. So you are deleting the object pointed by SC twice: once from main and another from the destructor of the object pointed by AC, called automatically when deleting it.

And deleting an object more than once is undefined behavior.

Answer 2

You need to decide who owns the object. It seems that you want AnotherClass to own the SomeClass object, given you delete it in the destructor, so therefore you shouldn't be deleteing it in main(). Double deleteing causes undefined behaviour.

The best way to avoid this would be to use std::shared_ptr, which manages multiple references to the same object in memory:

#include <memory>

class SomeClass {};

class AnotherClass {
    std::shared_ptr<SomeClass> sc
    public:
        AnotherClass(std::shared_ptr<SomeClass> SC): sc(SC){}

        //***********************************************************************
        ~AnotherClass(){ /* nothing */}
        //***********************************************************************
};

int main( int argc, char* argv[] ) {
    std::shared_ptr<SomeClass> SC(new SomeClass());
    std::shared_ptr<AnotherClass> AC(new AnotherClass(SC));


    return 0;
}

Notice the lack of calls to delete.

Answer 3

First, try not to deal in raw pointers. Especially not when beginning C++. Try using values instead.

That said, when you pass SC to the constructor, the object stores the pointer, so it has a pointer to the same object you created in main. In the destructor, it deletes that object. Then main tries to delete the object too. Boom.