C / C++ / MFC

hrishiS wrote:

But there is always a small difference between the abstract class and interface

hrishiS wrote:

Anyway, when we talk about interface also, when do we need/use them exactly

template<class T>
class IIterable
{
   virtual void First() = 0;
   virtual bool Next() = 0;
   virtual const T& Current() const = 0;
};

hrishiS wrote:

- we need interface, in order to make an generic structure of so many class. Later when some one adds one more class, it forces the implementer of the class to follow some generic rules (must have those virtual methods)....

template<class T>
bool Find(IIterable<T> const& i, T const& lookFor)
{
   i.First();
   do
   {
      if (i.Current() == lookFor) return true;
   } while (i.Next());
   return false;
}

class DirectoryTreeWalker
{
   DirectoryTreeWalker(std::string& path) { … }
   void WalkIt() { // Go through the directory tree, call FoundAFile when you see a file, FoundADirectory for a directory }
private:
   virtual void FoundAFile(const std::string& file) = 0;
   virtual void FoundADirectory(const std::string& file) = 0;
};

hrishiS wrote:

But there is always a small difference between the abstract class and interface.

hrishiS wrote:

Anyway, when we talk about interface also, when do we need/use them exactly?Could you please give me a practical example.

class CLogger
{
public:
   void LogMessage(const string& message)
   {
      string formattedMessage = FormatMessage(message);
      OutputMessage(formattedMessage);
   }

protected:
   string FormatMessage(const string& message) { /* Formats the message properly and returns it */ }
   virtual void OutputMessage(const string& message) = 0;

};

class CConsoleLogger : public CLogger
{
protected:
   void OutputMessage(const string& message) { /* Output the message to the console */ }
};

#include<iostream>

class IDumpable
{
public :
  virtual void  dump()=0;
};


class A: public IDumpable
{
  int _a;
public:
  A(int a):_a(a){}
  virtual void dump(){ std::cout << _a << std::endl;}
};

class B: public IDumpable
{
  static int _counter;
  double _d;
  int _id;
public:
  B(double d):_d(d){_id=B::_counter++;} 
  virtual void dump(){ std::cout << "(" << _id << ") " << _d << std::endl;}
};


int B::_counter=0;


void dump( IDumpable * pid[], int size)
{
  int i;
  for (i=0; i<size; i++)
  {
     pid[i]->dump();
  }
}

void main()
{
  IDumpable *pid[3];
  pid[0] = new A(10);
  pid[1] = new B(5.7);
  pid[2] = new B(10.745);
  dump(pid, sizeof(pid)/sizeof(pid[0]));
}

Kushagra Tiwari wrote:

and If they know it ..we should also be able to device the same