Classes Help!!!

Code:

class ParentClass
{
	public:
		ParentClass(string str_inputfile)
		{
			// do stuff
		}
};

Code:

class ChildClass : public ParentClass
{
	public:
		ChildClass(string inputstr)
		{
			// do stuff
		}
};

This gives me the errors:

Code:

main.cpp:417: error: no matching function for call to ‘ParentClass::ParentClass()’
main.cpp:345: note: candidates are: ParentClass::ParentClass(std::string)
main.cpp:343: note:                 ParentClass::ParentClass(const ParentClass&)

What does it mean by "no matching function call" ?

So I have to redefine *every* function in a parent class to get inheritance working?? That's annoying

No. Rather, ParentClass does not have a default constructor. Therefore, all subclass constructors must invoke one of ParentClass' constructors in their initialisation lists, e.g.,

Code:

ChildClass(string inputstr) : ParentClass(inputstr)
{
    // do stuff
}

By the way, you may wish to pass std::string objects by const reference in this case.

Will this actually call the parent's constructor? The parent constructor is doing some stuff that I really don't want the child to be doing again hehe

Yes, it does. The initializer list directly calls a constructor of the mentioned object.

What kind of things does the base class do that you don't want the derived class doing? Maybe the base class constructor shouldn't do it either, or maybe it needs a default constructor?

Originally Posted by Elysia

Yes, it does. The initializer list directly calls a constructor of the mentioned object.

Hmm, I see.

I guess I should modify it then. Thanks all =]

I changed some stuff around, and now I have this:

Code:

class GraphObj
{
	public:
		GraphObj(const string inputstr)
		{
			line = inputstr;
		}

		//virtual ~GraphObj() = 0;

		virtual void draw(Image& img) = 0;
	private:
		string line;
};

And

Code:

class Line : public GraphObj
{
	public:
		Line(const string inputstr) : GraphObj(inputstr)
		{
			line = inputstr;
		}

		//~Line() : ~GraphObj()
		//{
		//}

		void draw(Image& img)
		{
			// do stuff
		}
	private:
		string line;
};

Two questions:

If I want to use inheritance, do I have to have the stuff in bold, or is it done automatically for me? (So I can delete it and the "line" variable will still be created / initialized)

Also, it gives me some warnings:

Code:

main.cpp:24: warning: ‘class GraphObj’ has virtual functions but non-virtual destructor
main.cpp:37: warning: ‘class Line’ has virtual functions but non-virtual destructor

I tried to add the destructor stuff in but I'm not sure if I'm doing it right (the stuff commented out), because it gives a bunch of nasty errors about linking...

I don't want to write a destructor for every one of my subclasses, but do I *have* to do it if I want to get rid of the warning?

Absolutely delete it.

The problem is that you need an implementation of a destructor, even if it's pure. Easier to not make it pure, since you have a pure function already. (The only reason to make a destructor pure is
to make a class abstract when it has no natural pure functions.)

Code:

virtual ~GraphObj() {}

You don't need to explicitly create a destructor in any of the derived classes.

If I want to use inheritance, do I have to have the stuff in bold, or is it done automatically for me? (So I can delete it and the "line" variable will still be created / initialized)

Yes, though line will not be accessible to the derived class since it is private.

I tried to add it in but I'm not sure if I'm doing it right.

You are correct to write:

Code:

virtual ~GraphObj() = 0;

But you still need to implement the base class destructor since it will be invoked by the derived class destructor:

Code:

GraphObj::~GraphObj() {}

The derived class destructor can be left out (since the compiler generated one will do). If you implement it, the syntax would be:

Code:

Line::~Line()
{
    // ...
}

Originally Posted by CornedBee

Absolutely delete it.

The problem is that you need an implementation of a destructor, even if it's pure. Easier to not make it pure, since you have a pure function already. (The only reason to make a destructor pure is
to make a class abstract when it has no natural pure functions.)

Code:

virtual ~GraphObj() {}

You don't need to explicitly create a destructor in any of the derived classes.

Aha!

I commented it out and it gave an error since line was private, so I made it protected.

And then the destructor stuff, so I have:

Code:

class GraphObj
{
	public:
		GraphObj(const string inputstr)
		{
			line = inputstr;
		}
		virtual ~GraphObj() {};
		virtual void draw(Image& img) = 0;
	protected:
		string line;
};

Code:

class Line : public GraphObj
{
	public:
		Line(const string inputstr) : GraphObj(inputstr)
		{
		}
		void draw(Image& img)
		{
			// stuff
		}
};

No compile errors or warnings!!

Now, my constructor in Line is completely blank... Do I even need it? Looks odd...

Originally Posted by laserlight

Yes, though line will not be accessible to the derived class since it is private.


You are correct to write:

Code:

virtual ~GraphObj() = 0;

But you still need to implement the base class destructor since it will be invoked by the derived class destructor:

Code:

GraphObj::~GraphObj() {}

The derived class destructor can be left out (since the compiler generated one will do). If you implement it, the syntax would be:

Code:

Line::~Line()
{
    // ...
}

What's the difference between doing:

virtual ~GraphObj() {};

or

GraphObj::~GraphObj() {};

in my base class?



Edit: hmm, nevermind, it gives the warning again about non-virtual functions with the 2nd method

Originally Posted by Paul22000

What's the difference between doing:

Code:

		virtual ~GraphObj() {}

or

Code:

		GraphObj::~GraphObj() {}

in my base class?

The first can be put inline the actual class definition and the second is placed outside the definition, so called implementation. Other that that, there's nothing different about them.
And btw, drop the ";" after definitions (even if they're inline in the class definition).

Edit: hmm, nevermind, it gives the warning again about non-virtual functions with the 2nd method

What warning is that again?

Originally Posted by Elysia

The first can be put inline the actual class definition and the second is placed outside the definition, so called implementation. Other that that, there's nothing different about them.
And btw, drop the ";" after definitions (even if they're inline in the class definition).


What warning is that again?

The virtual functions thing

main.cpp:24: warning: ‘class GraphObj’ has virtual functions but non-virtual destructor
main.cpp:37: warning: ‘class Line’ has virtual functions but non-virtual destructor

Hmm, guess I'll just use the virtual destructor way heh. I never have to call it myself so whatever is easier hehe

-----

Which semicolon? After class definitions?

class Blah
{

};

If I remove it, it gives errors

Code:

main.cpp:271: error: multiple types in one declaration

Are you aware of the purpose of virtual functions, especially virtual destructors?
If you aren't doing anything special in the destructor, you can omit the virtual destructors and ignore the warnings, but as they say, if a class has virtual functions, then it is also recommended that they have a virtual destructor.

What's the difference between doing:

virtual ~GraphObj() {};

or

GraphObj::~GraphObj() {};

in my base class?

Well the difference is really minor.

Code:

class Graph {
   public:
   virtual ~Graph() { 
      // defined inside the class
   }
};

class Graph {
   public:
   virtual ~Graph();
};

Graph::~Graph() {
   // defined outside the class
}

I've heard that defining functions inside the class suggests inlining them to the compiler, but that shouldn't work much better than the inline keyword. I've typically treated class declarations as outlines of the implementation and rarely put the implementations in the class. This helps me separate implementation from the class design.