[Resolved] Classes and Destructors

[The Hobo]

I've never officially learned about classes, I just use them all the time but never really understand them. So a few questions:

1) What is the purpose of the desctructor? Does it just clear up memory?

2) What's wrong with this?:

class square_info {
    private:
        float h, w;


    public:
        square_info () {
            h = 0;
            w = 0;
        }

        square_info (float height, float width) {
            h = height;
            w = width;
        }

        void print() {
            cout << "h: " << h << " | w: " << w << endl;
        }

        ~square_info(); //adding this line gives linking errors?
};

Thanks in advance.

[parksie]

It gives linker errors because you haven't defined any code for it.

A destructor isn't always required, no. If all the members in your class can automatically clear themselves up (like a string, int, whatever), you're ok. If you start storing pointers, then the destructor would need to deallocate that memory, or maybe release a mutex lock, or something.

[The Hobo]

What code should be defined for it?

And for now, I have to use it in my code because that's one of the requirements for my class assignments "have a constructor and destructor."

[parksie]

You do not need a destructor unless you require additional functionality. The compiler takes care of freeing the memory used by the instance itself, and calling the destructors of your members.

In this case, your destructor would just be empty. I'd remove the destructor and put a note saying that none was required.

[The Hobo]

Okay.

I'll just comment it out and put a little note in the code and hope she doesn't mark me down for it.

[parksie]

If she does...

a) complain loudly

b) send her my email address and tell her to explain herself

[The Hobo]

Just for reference, then, what type of code would go in the destructor?

~class_name() {
  pvariable = NULL;
}

I'm just trying to understand the destructor.

[parksie]

Say you had some kind of buffer class:

template <typename T>
class buffer {
public:
    buffer(size_t sz) {
        m_buf = new T[sz];
    }

    virtual ~buffer() {
        delete[] m_buf;
    }

    T& operator[](int idx) {
        return m_buf[idx];
    }

private:
    T *m_buf;
};

Can you see what's happening here? The virtual on the destructor makes sure that m_buf is deleted even if you have a derived class.

[The Hobo]

Thanks.

[Zaei]

My destructors usually look like this:

~x(){
    Release();
}

The Release() function essentiall cleans everything up, and resets the object to an uninitialized state, ie:

class Cup // yeah, whatever, there is a cup on my desk...
{
private:
    float m_amt;
public:
    Cup(){m_amt = 0.0f;}
    ~Cup(){ Release(); }
    void Fill(){ m_amt = 1.0f; }
    void Empty() {m_amt = 0.0f; }
    int Release() { m_amt = 0.0f; }
};

Z.

[The Hobo]

anywhere I can find a little more information that Release()?

[The Hobo]

Where is that at? I tried including stdlib, but I get:

C:\Programming\Cpp Stuff\classcrap\classcrap.cpp(28) : error C2065: 'Release' : undeclared identifier

[parksie]

It's one of his, he defines it himself.

[Zaei]

Release() is just another member function that you define... Look at my full class definition.

Z.

[Zaei]

The basic idea is that you can call Release() to reset the object at any point in your code, without actually destroying the object in question. You CAN do this with the destructor(calling it), though if you have a nice list of derived objects, its a bit easier to just call ->Release() on all of them.

Z.

[The Hobo]

Oh. I see.

I thought it was a magical function or something.