Hey Chaithanya, 

what kind of abstraction are you referring to? Do you talk about interfaces/abstract classes, do you talk about data abstraction? Are you looking for template mechanisms? What in detail are you looking for?

Along with my questions I added some example for an interface an data abstraction (including source link for more information)

Data Abstraction (see http://www.tutorialspoint.com/cplusplus/cpp_data_abstraction.htm)

========

#include

using namespace std;

class Adder{

  public:

  // constructor

  Adder(int i = 0)

  {

    total = i;

  }

  // interface to outside world

  void addNum(int number)

  {

    total += number;

  }

  // interface to outside world

  int getTotal()

  {

    return total;

  };

  private:

  // hidden data from outside world

  int total;

};

int main( )

{

  Adder a;

  a.addNum(10);

  a.addNum(20);

  a.addNum(30);

  cout

Hello,

To the best of my knowledge:

Abstraction is interessant only if you want to do polymorphism, or to prevent the instantiation of a specific class, otherwise it's more appropriate to use simple inheritance.

To do polymorphism you need a pointer or a reference to an object, and you need a virtual method.

If those conditions are satisfied you can enjoy all the advantages of abstraction and polymorphism.

Steps:

1- Create an abstract class

2- Create a virtual method possibly without implementation.

3- Create one or more derived classes from the abstract class

4- Implement the virtual method in all derived classes (it's important if the abstract class don't give an implementation).

5- Create as many instantiations as you want of derieved (concrete) classes (you can create a list of the abstract class pointers, and each pointer will reference a concrete instantiation).

6- Create an abstract class pointer (you can not instantiate the abstract class) and reference a concrete instantiation. (or you can just iterate over a list if you created it before)

7- Call the virtual method using the abstract class pointer.

Result:

You will have different results depending on the object you are referencing.

Notes:

If the method is not virtual, it will not work. you will get the result of the abstract class implementation even if you are referencing an instantiation of another class.

If you don't use pointers it will not work, because it will not be possible to know the referenced object class type.

I hope it's clear enough, if you want examples you just make a google search: abstract classes polymorphism example

http://www.cplusplus.com/doc/tutorial/polymorphism/

http://www.java2s.com/Code/Cpp/Class/Objectarraypolymorphism.htm

Good luck!

abstraction mechanism that has to separate interface from implementaion, i am searching for that.  For this which concepts i have to use in c++.

Hello again,

Possibly you are looking for design patterns. There are a lot of design patterns, each one is usefull in a specific case. But it seems to me that you are more likely looking for the adapter design pattern ?

The idea of the adapter design pattern, is that you could have an implementation of some class methods, but you could make as many interfaces as you want for those methods. So that you have access only to the given interface and not the real implementation.

https://sourcemaking.com/design_patterns/adapter/cpp/1

In the previous example, you want that each derived class from the class rectangle uses the method draw(). So you create an abstract class with a virtual method draw().

You have an old implementation of a rectangle (the class legacyRectangle), that uses an old method (oldDraw()), and you want to adapte it so that it could use the method draw(). 

You create an adapter (new class), that inherit from both the abstract class (interface) and the old class (legacyRectangle). (notice the mention private). and you give an implementation of the wanted method draw() using the old method (oldDraw()).

Result:

You had an independant implementation, and you hade an independant interface, and you joined them both: You have now an old implementation with the interface you want.

_______________________________________________________

If it doesn't help, maybe you could give a short description of what you want to do, with a very simple example (not code just the concept or the idea). 

Here is an example that my students have found helpful.  First, build an abstract superclass representing generic employees:

---

class Employee {

public:

  Employee(const string& name, unsigned id) { myName = name; myID = id;}

  string getName() const { return myName; }

  virtual double getPay() const = 0;

  void writePayCheckTo(ostream& out) const

  { out

There are two main features in C++ for creating abstraction through polymorphism. Skimming the answers above, it looks like one of them, inheritance, has been well addressed. You make a base class with virtual methods and then create derived classes that inherit from it using public inheritance. After that, pointers and references to the base class are polymorphic as they can refer to instances of the derived classes as well.

Another mechanism is templating. This is the approach used more broadly in the standard libraries, and I would argue it is more appropriate for general use in C++. All the collections and generic algorithms in the C++ libraries use templates for polymorphism. You see this when you create something like std::vector. The type argument of int tells C++ what type it will be working with. Each new type actually gets compiled to a different implementation. So templated classes are really just templates for classes that are actually fleshed out when you provide a type. The same is true for template functions, though template functions can often infer the template types based on their arguments.

The primary different between the two is that inheritance provides dynamic polymorphism while templates are static. That is to say that the exact type for inheritance isn't known until runtime, and dynamic dispatch is used to make the virtual method calls go to the right implementations. There is some overhead to that in the storing of a v-table pointer in each object and the branch created by calling the function that the v-table points to. This allows you to do things like make a std::vector that might contain multiple different derived types of Shape with the mix determined at runtime by what is happening.

Templates won't let you do that, but they generally have less overhead and produce faster code (assuming you don't abuse the templates to the point of having code bloat). The template values must be determined at compile time. This leads to the field of template metaprogramming where you get the compiler to solve things before the program is even run. This form of abstraction is a bit more limited, but in many ways I think that it fits better with the general model/approach/style of C++ coding.

I second the previous post about resorting to stackoverflow.com. Plenty of examples provided that should help you with implementation...