Thread: constructors in classes

A constructor constructs an object and a destructor destroys an object. Its that simple. You can have many constructors but only one destructor. This says that there are many ways to make an object but only one way to destroy them.

A constructor has the same name as the class. If it takes no parameters then it is a default constructor. If it takes a single parameter of type const yourclass& then it is a copy constructor. The destructor is denoted by the tilde symbol and also has the name of the class. So for class yourclass the destructor would be ~yourclass()
The easiest way to learn about constructors and destructors is to put cout messages in them and step thru your code line by line in a debugger and watch what happens. See when each get called and work out why.

Code:

class myclass
{
public:
myclass() { cout<<"myclassval=0"; myclassval=0; }
myclass(int val) { cout<<"myclassval=val"; myclassval=val; }
~myclass(){cout<<"destructing";}
private:
int myclassval;
};

int main(void)
{
myclass x;
myclass y(20);
}

Is it more clear?

It's important to know that when you are writing a class, it doesn't exist, so in your class declaration you can't have:

Code:

class myclass
{
     int x = 10;  // error

};

instead you might do:

Code:

class myclass
{
     int x;
public:
     myclass() { x = 10; }
};

So a constructor (among other things) gives you a way to initialise your variables before doing anything else when you create an object.

here's another example:

Code:

class thisClass
{
   public:
      thisClass();
      thisClass(int);
   private:
      int thisVariable;
};
thisClass::thisClass()
{
   thisVariable=0;
}
thisClass::thisClass(int variableFromMain)
{
   thisVariable=variableFromMain
}

int main()
{
   ...
   thisClass classObject;
   thisClass classObjectVariable(32);

   cout<<classObject.thisVariable<<endl;  //outputs "0"
   cout<<classObjectVariable.thisVariable<<endl;   //outputs "32"
   ...
}

hope that makes it clearer why you can have more than one constructor...

Can I just ask a small question?

Why do people do this with classes:

Code:

class myclass
{
public:
     myclass() { x = 20; }

private:
     int x;
};

Why do functions first instead of variables, if you do variables first you save yourself a "private:" and it doesn't really affect readability either way, is there something I don't know about?

EDIT: The egg came first, something laid an egg and from that egg a bird emerged which can be classed as a chicken.

It's just style. Most people put the interface first, then the implementation. In fact, many experienced programmers use the "pimpl idiom" to hide the entire implementation behind a "compilation firewall". For example:

Code:

// file MyClass.h

class MyClass{
public:
  MyClass(/*...*/);
  MyClass(const MyClass &);
  ~MyClass();
  MyClass& operator=(const MyClass &);
private:
  struct Impl;
  Impl * pImpl;
};

Code:

// file MyClass.cpp

struct MyClass::Impl{
  int x;
  float y;
}

// Rest of the implementation

In this way, the implementation and interface are totally separate, and any change to the implementation will affect only one .cpp file, reducing compile time drastically on large, interdependant projects. It also often drastically reduces header interdependance; the header file can get away with many fewer #includes.

Plus, you can make a library, and only the public interface of the object is exposed to the users.

not sure if I was clear, unless I didn't understand what you said (likely).

What I meant was, as classes default to private why would you put public stuff first and private after that? It seems more logical to do it the other way.

Originally posted by HybridM
not sure if I was clear, unless I didn't understand what you said (likely).

What I meant was, as classes default to private why would you put public stuff first and private after that? It seems more logical to do it the other way.

There is no right or wrong way. For example, this is perfectly valid:

Code:

class Foo
{
        int x;
    public:
        void setX( int toThis ) { x = toThis; }
    private:
        int y;
    public:
        void setY( int toThis ) { y = toThis; }

    ...repeat over and over...
};

However, the reason people put the public information first is so you can see the interface, and not worry about the internals. Example:

Code:

class Foo
{
    public:
        void setFoo( type value );
        void setBar( type value );
        type getFoo( void );
        type getBar( void );

    private:
        //stuff here
};

If you want to see right off what you can do with this class, the interface tells you that you can set and get two objects. Why would I care what the private internals of this object were, when all I want to do is set and get some thing when using this class?

Anyway, that's the basic idea behind it.

Quzah.