Thread: Classes: constructors, destructors ???

Okay, I will try to explain a little, then if you have any questions just post back. Take the following code for example.

Code:

class CPoint
{
    private:
      int m_x;
      int m_y;
};

There is a simple class for a point, not terribly interesting. Now I didn't explicity declare my destructor and contructor because there are default ones supplied for you if you do not specify one. I could specify mine own like this.

Code:

class CPoint
{
    private:
      int m_x;
      int m_y;

    public:
      CPoint();   // Constructor
      ~CPoint(); // Destructor
};

The constructor is called when the class variable is created or instantiated. The destructor is called either when the variable goes out of scope, or you call delete on a pointer variable.

If i wanted to though, I could make my own special constructor. Take this code.

Code:

// CPoint.h file...
class CPoint
{
    private:
      int m_x;
      int m_y;

    public:
      CPoint( int x, int y );   // Constructor
      ~CPoint(); // Destructor
};

// CPoint.cpp file   (implementation of class)
#include "CPoint.h"

CPoint::CPoint( int x, int y )
{
    m_x = x;
    m_y = y;
}

CPoint::~CPoint( )
{
}

I don't know if that really clears anything up but perhaps. If you have more specific questions just ask.

Hello newbie!

Constructors and destructors, basically, are just functions like the others you can include within your class. The only difference is, they are sometimes invoked automatically (and in a subtle way).
Isn't that cool?

Anyway, here's the trick:

1) Everytime you declare a class object in some function, the constructor is invoked and whatever you place inside that will be read and statements are executed. Ideally, the constructor must contain initializers for your private and protected data in your class.

2) Everytime you leave the a block statement in which you have declared a class object, the destructor is invoked. The block statements could be anything inside curly braces (functions are block statements too). Be careful though; when I said it leaves a block, I meant that it enters the "opening" curly brace '{' and leaves the "closing" curly brace '}'. If you just made a jump to some other block without finishing the previous object-containing block, the destructor will not be automatically invoked.

Aside from that fact, destructors can also be manually invoked (like placing a statement that calls the destructor). You can use this if you intend to jump out of a block and you find that the object in the previous block is no longer useful.

If you have further questions, don't hesitate to ask. That's the only way to learn effectively.

You can delete it easily, just go to edit and then hit delete.

(Click!) ...and post has been deleted!

Sorry guys, there are a few things here that have to be said:

The only difference is, they are sometimes invoked automatically (and in a subtle way).

That's utter rubbish. When an object is instantiated, is it constructed ie. the constructor is called. There is nothing 'subtle' about it at all, and it's not something that happens 'sometimes', it happens all the time. If you have defined a constructor (which you should always do even if it doesn't do anything), it WILL get called when your object is instantiated.

Same goes for destructors. When an object goes out of scope, or is 'delete'd the destructor WILL be called (there are exceptions when people are using polymorphism and haven't declared destructors as virtual, in which case some destructors may not be called, but that's just bad programming). Whether you like it or not it gets called. Again, there's nothing subtle here.

destructors can also be manually invoked

yes they can, but you should NEVER EVER do this. There is no need for it. If you have code in the destructor that you wish to execute at other times, then put it in another function, and call that from the destructor. Don't ever call the destructor directly.

cheers
U.

(Oh shoot! Dammit it happened again) Sorry about that. That unregistered post is mine. My login time expired so my name wasn't reflected.

Originally posted by Hershlag
ACTUALLY, I'm going to throw a whole bomb into the mix!

There is a case where constructors and destructurs would not be called!

try this:

Code:

MyClass *test;

test = (MyClass*)new char[sizeof(MyClass)];
test->SomeMemberFunction();
delete [] (char *)test;

this is 100% legal and the constructors and destructors do not get called! what do you think about that?

Yeah but that's just trying to fool the compiler......and you wouldnt do that purposely...Your just calling the constructor of a char (which if it has one does very little) and casting the memory reference back to your pointer...its what's after new that has its constructor called.....

Cool though

Code:

#include <iostream>
using namespace std;

class Class1{
public:
	Class1(){cout << "Class1 constructor" << endl;}
	~Class1(){cout << "Class1 destructor" << endl;}
};

class Class2{
public:
	Class2(){cout << "Class2 constructor" << endl;}
	~Class2(){cout << "Class2 destructor" << endl;}
};

int main()
{
	Class1* MyClass;
	MyClass = (Class1*)new Class2;
	delete (Class2*)MyClass;
	return 0;
}