Programming Forums > Application Development > C++

The Dark · Feb 16th, 2006, 5:42 PM

Or even

bool CharCon::eq(Comparator &x)
{
	return (character == ((CharCon &)x).getValue());
}

Note that this means you are telling the compiler that x is always a CharCon - there is nothing to stop you passing in a different derived class to the eq function and your program will probably crash.

gizzy · Feb 16th, 2006, 6:43 PM

Got the tree working now

I am now considering using a stack to keep all the 'new' pointers together, in order to delete them at the end of the program.

Thanks for all the help folks.

grumpy · Feb 17th, 2006, 1:12 AM

If you want a bit more safety, you can also check the the Comparator is a CharCon like this;

(Toggle Plain Text)

bool CharCon::eq(Comparator &x)
{
      if (dynamic_cast<CharCon *>(&x) != (CharCon *)NULL)
      {
	   return (character == ((CharCon &)x).getValue());
      }
      else
      {
           do_something_else();
      }       
}

A better way, from a design perspective and a lot of practical perspectives as well, is for the Comparator class to provide member functions like getValue(), possibly as pure virtuals that are overridden by derived classes. That avoids the need to use casting. Of course, that sort of thing is a bit hard to retrofit if you're not allowed to change the Comparator class.

It is probably a good idea to provide a virtual destructor (even if it does nothing) in the Comparator class as well. Not important for the current problem, but saves difficulties with other types of problem.

nnxion · Feb 18th, 2006, 1:37 PM

Quote:

Originally Posted by grumpy

An abstract base class in C++ is a class that declares one or more pure virtual member functions. Optionally, in C++, any virtual member function can be defined whether it is pure or not (i.e. contrary to Dawei's and Cerulean's comments, an abstract base class CAN actually provide a body for any virtual function, whether it is pure or not). The existence of any virtual member functions, however, means that the class cannot be instantiated (just as it is not possible to create an instance of a Java interface).

I'm confused Robert, can you explain a bit more? I also thought that pure virtual functions lack implementation, so that the derived class, and only the derived class may do so later.

Arevos · Feb 18th, 2006, 2:11 PM

Quote:

Originally Posted by nnxion

I'm confused Robert, can you explain a bit more? I also thought that pure virtual functions lack implementation, so that the derived class, and only the derived class may do so later.

I think he meant that the existence of any pure virtual member functions prevent a class from being instantiated. Only the existance of pure virtual functions make a class abstract.

grumpy · Feb 18th, 2006, 5:14 PM

No. What I mean is that there is nothing preventing a class that declares a pure virtual function from also implementing it.

For example;

(Toggle Plain Text)

#include <iostream>
class Base
{
     public:

           Base(); 
           virtual ~Base() = 0;

           virtual void Operation() = 0;
};

class Derived : public Base
{
     public:

          Derived();
          ~Derived();
          void Operation();
}

// implement member functions

Base::Base()
{
    std::cout << "Constructing Base\n";
}

Base::~Base()    // We are actually REQUIRED to implement a destructor we declare even if it is pure virtual
{
    std::cout << "Destructing Base\n";
}

void Base::Operation()     //   YES, we are allowed to implement a pure virtual function
{
    std::cout << "Operating on Base\n";
}

Derived::Derived() : Base()    // explicitly initialising Base is optional
{
    std::cout << "Constructing Derived\n";
}

Derived::~Derived() 
{
    std::cout << "Destructing Derived\n";
}

void Derived::Operation()
{
    Base::Operation();                             // we can explicitly call a pure virtual function if we have implemented it
    std::cout << "Operating on Derived\n";
}

int main()
{
      Base *base = new Base;      // remove this line as it will result in compiler error as Base is abstract

      Derived *derived = new Derived;    //   OK.  We will see that Base's constructor is invoked, then Derived's

      derived->Operation();  //  OK.  We will see that Base::Operation is called by Derived::Operation()

      derived->Base::Operation()   //  I'll leave working out what this does as an exercise....

      delete derived;  // Derived's destructor is invoked then Base's
}

DaWei · Feb 18th, 2006, 5:46 PM

Well, I certainly learned something there. Thanks.

Arevos · Feb 18th, 2006, 7:29 PM

Quote:

Originally Posted by grumpy

No. What I mean is that there is nothing preventing a class that declares a pure virtual function from also implementing it.

Really? Didn't know you could do that

titaniumdecoy · Feb 18th, 2006, 7:53 PM

Since nobody seems to have mentioned it, I'm just wondering if everyone is aware that you can declare abstract classes in Java as well, and from what I understand from reading grumpy's post, they are essentially the same in both languages.

Jimbo · Feb 18th, 2006, 9:00 PM

Abstract classes will behave similarly between the two languages; however, in Java, you have to use the abstract keyword if you define a class that has a "pure virtual" (i.e. not yet defined) function.
C++:

(Toggle Plain Text)

class abs // no special keywords on this line
{
public:
	abs(){}
	virtual int something() = 0;
};
class full : public abs
{
public:
	full(){}
	int something() { return 1; }
};

Java:

(Toggle Plain Text)

public abstract class abs // have to have abstract here
{
	public abs() {}
	public abstract int something();
}
public class full extends abs
{
	public full() {}
	public int something() { return 1; }
}

Feb 16th, 2006, 5:42 PM	#11
The Dark Expert Programmer Join Date: Jun 2005 Posts: 825 Rep Power: 4	Or even (Toggle Plain Text) bool CharCon::eq(Comparator &x) { return (character == ((CharCon &)x).getValue()); } bool CharCon::eq(Comparator &x) { return (character == ((CharCon &)x).getValue()); } Note that this means you are telling the compiler that x is always a CharCon - there is nothing to stop you passing in a different derived class to the eq function and your program will probably crash.

Feb 17th, 2006, 1:12 AM	#13
grumpy Programming Guru Join Date: Jun 2005 Location: Adelaide, South Australia Posts: 1,207 Rep Power: 5	If you want a bit more safety, you can also check the the Comparator is a CharCon like this; (Toggle Plain Text) bool CharCon::eq(Comparator &x) { if (dynamic_cast<CharCon >(&x) != (CharCon )NULL) { return (character == ((CharCon &)x).getValue()); } else { do_something_else(); } } bool CharCon::eq(Comparator &x) { if (dynamic_cast<CharCon >(&x) != (CharCon )NULL) { return (character == ((CharCon &)x).getValue()); } else { do_something_else(); } } A better way, from a design perspective and a lot of practical perspectives as well, is for the Comparator class to provide member functions like getValue(), possibly as pure virtuals that are overridden by derived classes. That avoids the need to use casting. Of course, that sort of thing is a bit hard to retrofit if you're not allowed to change the Comparator class. It is probably a good idea to provide a virtual destructor (even if it does nothing) in the Comparator class as well. Not important for the current problem, but saves difficulties with other types of problem.

Feb 18th, 2006, 5:14 PM	#16
grumpy Programming Guru Join Date: Jun 2005 Location: Adelaide, South Australia Posts: 1,207 Rep Power: 5	No. What I mean is that there is nothing preventing a class that declares a pure virtual function from also implementing it. For example; (Toggle Plain Text) #include <iostream> class Base { public: Base(); virtual ~Base() = 0; virtual void Operation() = 0; }; class Derived : public Base { public: Derived(); ~Derived(); void Operation(); } // implement member functions Base::Base() { std::cout << "Constructing Base\n"; } Base::~Base() // We are actually REQUIRED to implement a destructor we declare even if it is pure virtual { std::cout << "Destructing Base\n"; } void Base::Operation() // YES, we are allowed to implement a pure virtual function { std::cout << "Operating on Base\n"; } Derived::Derived() : Base() // explicitly initialising Base is optional { std::cout << "Constructing Derived\n"; } Derived::~Derived() { std::cout << "Destructing Derived\n"; } void Derived::Operation() { Base::Operation(); // we can explicitly call a pure virtual function if we have implemented it std::cout << "Operating on Derived\n"; } int main() { Base base = new Base; // remove this line as it will result in compiler error as Base is abstract Derived derived = new Derived; // OK. We will see that Base's constructor is invoked, then Derived's derived->Operation(); // OK. We will see that Base::Operation is called by Derived::Operation() derived->Base::Operation() // I'll leave working out what this does as an exercise.... delete derived; // Derived's destructor is invoked then Base's } #include <iostream> class Base { public: Base(); virtual ~Base() = 0; virtual void Operation() = 0; }; class Derived : public Base { public: Derived(); ~Derived(); void Operation(); } // implement member functions Base::Base() { std::cout << "Constructing Base\n"; } Base::~Base() // We are actually REQUIRED to implement a destructor we declare even if it is pure virtual { std::cout << "Destructing Base\n"; } void Base::Operation() // YES, we are allowed to implement a pure virtual function { std::cout << "Operating on Base\n"; } Derived::Derived() : Base() // explicitly initialising Base is optional { std::cout << "Constructing Derived\n"; } Derived::~Derived() { std::cout << "Destructing Derived\n"; } void Derived::Operation() { Base::Operation(); // we can explicitly call a pure virtual function if we have implemented it std::cout << "Operating on Derived\n"; } int main() { Base base = new Base; // remove this line as it will result in compiler error as Base is abstract Derived derived = new Derived; // OK. We will see that Base's constructor is invoked, then Derived's derived->Operation(); // OK. We will see that Base::Operation is called by Derived::Operation() derived->Base::Operation() // I'll leave working out what this does as an exercise.... delete derived; // Derived's destructor is invoked then Base's }

Feb 18th, 2006, 5:46 PM	#17
DaWei Resident Grouch Join Date: Jun 2005 Posts: 6,453 Rep Power: 10	Well, I certainly learned something there. Thanks. __________________ Abstraction doesn't make it impossible to write bad code; it makes it possible to write superior code. Contributor's Corner: Grumpy on C++ Exceptions DaWei on Pointers

Feb 18th, 2006, 9:00 PM	#20
Jimbo Battle Programmer Join Date: Feb 2006 Location: Bellevue, WA, USA Posts: 754 Rep Power: 3	Abstract classes will behave similarly between the two languages; however, in Java, you have to use the abstract keyword if you define a class that has a "pure virtual" (i.e. not yet defined) function. C++: (Toggle Plain Text) class abs // no special keywords on this line { public: abs(){} virtual int something() = 0; }; class full : public abs { public: full(){} int something() { return 1; } }; class abs // no special keywords on this line { public: abs(){} virtual int something() = 0; }; class full : public abs { public: full(){} int something() { return 1; } }; Java: (Toggle Plain Text) public abstract class abs // have to have abstract here { public abs() {} public abstract int something(); } public class full extends abs { public full() {} public int something() { return 1; } } public abstract class abs // have to have abstract here { public abs() {} public abstract int something(); } public class full extends abs { public full() {} public int something() { return 1; } }

Feb 16th, 2006, 6:43 PM	#12
gizzy Newbie Join Date: Feb 2006 Location: Glasgow, Scotland Posts: 8 Rep Power: 0	Got the tree working now I am now considering using a stack to keep all the 'new' pointers together, in order to delete them at the end of the program. Thanks for all the help folks.

Feb 18th, 2006, 7:53 PM	#19
titaniumdecoy Expert Programmer Join Date: Nov 2005 Posts: 843 Rep Power: 3	Since nobody seems to have mentioned it, I'm just wondering if everyone is aware that you can declare abstract classes in Java as well, and from what I understand from reading grumpy's post, they are essentially the same in both languages.

Currently Active Users Viewing This Thread: 1 (0 members and 1 guests)

Thread Tools
Show Printable Version Email this Page
Display Modes
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode

Programming Forums > Application Development > C++

Java-style interfaces in C++