Give example of abstraction in C++?  

hi,friend

Abstraction in C++ Programming
Introduction
Abstract ion is a central concept in computer science. Object-oriented programming supports abstractions to a higher degree that almost all other programming paradigms. Classes model abstractions in object-oriented programming.

Classes represent abstractions in object-oriented programs and are the central focus of the analysis and design done before any programming starts. Good object-oriented programs are based on good classes. A class is good when it accurately and usefully models some concept in the problem that a program is trying to solve. The objective of this lab is to address some of those aspects of class design.

At a higher level of abstraction, our interest in objects is in what they can do and what properties they possess. We refer to these abstractly as an object's behaviors and attributes. At a lower level of abstraction, our interest in objects is in how they represent their attributes and the algorithms they use to implement behaviors.
friends in C++
Data hiding is an important principle to be followed in software design and implementation. However, circumstances arise in program design in which data hiding forces compromises with nice abstractions. Consider the possibility that two objects must work together to perform some algorithm, but that algorithm requires one object to know something about the implementation of the other object--perhaps so it can access some attribute that is not supposed to be changed by just any object in a program. Defining a public operation means that any object in the program can access that implementation, which from the perspective of data hiding is completely undesirable.

C++ provides a special feature which allows a class to declare some other program component (a function or another class) to be a friend.

Consider, for example, the input and output of an object in the Rational class whose specification is given below:

class Rational {
public:
Rational(int numerator, int denominator);

Rational operator+(const Rational& r) const;
Rational operator-(const Rational& r) const;
Rational operator*(const Rational& r) const;
Rational operator/(const Rational& r) const;
Rational& operator=(const Rational& r);
private:
int gcd(int a, int b); // compute greatest common divisor of _a_ and _b_
void reduce(); // reduce my numerator and denominator
// to lowest terms
int myNum; // my numerator
int myDenom; // my denominator
};

Note the lack of a default constructor. The designers of this class have thus insisted that every instance of this class be created with an actual value by requiring a numerator and a denominator be specified for every instance. Note, too, that once an instance is constructed, its value can never be changed since there are no operations in the public interface to modify either the numerator or the denominator. Nor are there operations to return the values of numerator or the denominator.

What is the best way to design an operation to read a rational from an input stream? One choice is to put an operation in the Rational class's public interface to read in a rational number, for example:

void streamIn(istream& is);

We could adopt a convention that every class have such a member function. In this case, the operation seems to violate the unchangeability of the values in an object in the class Rational. Consider that the class's interface--that is, the set of operations in the public part--does not provide any mechanism for changing the numerator or denominator in a rational number. Adding a streamIn() operation introduces a way to change the values as long as they are read in from a stream. This results in code segments such as:

Rational q(1, 2);
q.streamIn(cin); // Read in a rational

Answered by Nz at 10:36 PM on September 05, 2008

Abstraction - The ability of an object to provide a virtual representation of a physical object or process. Using the concept of abstraction, you can reference an object without needing to describe in detail every individual attribute of the object.
The abstraction of core class of the active object (Cactive) looks like this:


class CActive : public CBase
{
public:
IMPORT_C virtual ~CActive();
IMPORT_C void Cancel();
inline TBool IsActive() const;
inline TInt Priority() const;
protected:
IMPORT_C CActive(TInt aPriority);
IMPORT_C void SetActive();

// Pure virtual functions

/*
Implements cancellation of outstanding request.
This function is called as part of the active
object's Cancel().
*/
virtual void DoCancel() =0;

/*
Handles an active object's request completion event.
A derived class must provide an implementation to handle the completed request.
The function is called by the active scheduler when a request completion event occurs.
*/
virtual void RunL() =0;

public:
//The request status associated with an asynchronous request.
TRequestStatus iStatus;

private:
TBool iActive;
TPriQueLink iLink;
friend class CActiveScheduler;
};

It encapsulates both the issuing of a request to an asynchronous service provider and the handling of completed requests.

In the abstraction notice that, two APIs are made as pure virtual, so that the User of Active Objects (CActive) has to implement their own Active Object inheriting from CActive and have to give implementation to RunL() and DoCancel(). The Active Scheduler will call RunL, when there is a outstanding request pending from that active object and there are no other active objects that are of higher priority. User Specific behavior will be implemented in RunL of Active Object.

DoCancel will be called internally by the Cancel (CActive::Cancel will call DoCancel of derived class) function, where user will give implementation for canceling the outstanding request and does the resource specific cancel operation for all User Specific resources.

So, it's the way of changing the behiour of the existing Framework with out changing the existing framework. We can have as many as Active objects with different behiour as per our requirement.

Answered by Nishu's at 10:02 PM on September 05, 2008

data abstraction is a process of representing the essential features without including implementation details.

The main idea behind data abstraction is to give a clear separation between properties of data type and the associated implementation details.

This separation is achieved in order that the properties of the abstract data type are visible to the user interface and the implementation details are hidden.

Thus, abstraction forms the basic platform for the creation of user-defined data types called objects. Data abstraction is the process of refining data to its essential form.

For example-

void f(String* a, String* b) {
String* c = new String;
c->append(a);
c->append(b);
// ...
}

For more information-
http://www.exfor sys.com/tutorials/c-plus-plus/ abstraction.html

Answered by Nagendra at 6:54 PM on September 05, 2008

bstraction is one of the most powerful and vital features provided by object-oriented C++ programming language. Modularity is very important in any programming language, it provides flexibility to users for using the programming language. This aspect is well achieved with high performance by the concept of abstraction in C++. In object-oriented programming language the programmer can abstract both data and code when needed.

What is Abstraction

The concept of abstraction relates to the idea of hiding data that are not needed for presentation. The main idea behind data abstraction is to give a clear separation between properties of data type and the associated implementation details. This separation is achieved in order that the properties of the abstract data type are visible to the user interface and the implementation details are hidden. Thus, abstraction forms the basic platform for the creation of user-defined data types called objects. Data abstraction is the process of refining data to its essential form. An Abstract Data Type is defined as a data type that is defined in terms of the operations that it supports and not in terms of its structure or implementation.

In object-oriented programming language C++, it is possible to create and provide an interface that accesses only certain elements of data types. The programmer can decide which user to give or grant access to and hide the other details. This concept is called data hiding which is similar in concept to data abstraction.
How Types of Abstraction Differs:

There are two broad types of abstraction; functional abstraction and data abstraction. The main difference between functional abstraction and data abstraction is that functional abstraction refers to a function that can be used without taking into account how the function is implemented. Data abstraction refers to the data that can be used without taking into account how the data are stored. There is also a difference in the way the access takes place in functional abstraction and data abstraction. In functional abstraction, access to the function is provided through a specific interface defined to invoke the function. In contrast, in data abstraction, access to the data is provided through a specific set of operations defined to examine and manipulate the data. For instance, when a programmer is using C++ standard data types, this means that users are using the concept of data abstraction. When using data types, the users are not concerned with how the data is stored but they are concerned with what operations are provided and what properties are supported.

for details,please visit:
http://www.exforsys.co m/tutorials/c-plus-plus/abstra ction.html

Answered by jaivir at 6:18 PM on September 05, 2008

Hi friend,

Abstraction is one of the most powerful and vital features provided by object-oriented C++ programming language. Modularity is very important in any programming language, it provides flexibility to users for using the programming language. This aspect is well achieved with high performance by the concept of abstraction in C++. In object-oriented programming language the programmer can abstract both data and code when needed.

Abstract Classes

An abstract class is a class whose role is only meant to lay a foundation for those classes that would need a common behavior or similar characteristics. Therefore, an abstract class is used only as a base class for inheritance. A class is made abstract by declaring at least one its member functions as a “pure” virtual function.

Only a virtual function can be made “pure”. The syntax of declaring a pure function is:

virtual ReturnType FunctionName() = 0;

The virtual keyword is required to make sure that a (any) child of this class can implement this function as it deems fit. The ReturnType is the data type that the function will return. The FunctionName is an appropriate name for the function. The = 0 is required. It lets the compiler know that this function is a pure virtual function.

When a function has been declared as pure virtual, you do not need to implement it. Instead, each inherited class of an abstract class must provide its own implementation of the pure member function.

When creating an abstract class, you can declare all of its member functions as pure. Here is an example:

//---------------- ------------------------------ -----------------------------
struct TTent
{
virtual int WhatIsTheCapacity() = 0;
virtual double TentArea() = 0;
virtual double TentVolume() = 0;
virtual char* TextureColor() = 0;
};
//-------------------- ------------------------------ -------------------------

I n this case, the class does not need a source file or any implementation because none of its member functions will be implemented.

An abstract base class can also have a mix of pure and non-pure functions. Here is an example:

//---------------- ------------------------------ -----------------------------
struct TTent
{
virtual int WhatIsTheCapacity() = 0;
virtual double TentArea() = 0;
virtual double TentVolume() = 0;
virtual char* TextureColor() = 0; // Pure virtual function
virtual char* TextureName(); // Virtual function
int ShapeType(); // Regular member function
};
//-------------- ------------------------------ ------------------------------ -

In this case, as we have done with the other classes so far, you must implement the non-pure functions in the base and let the inherited classes implement their own version(s) of the pure virtual function(s).


Implementin g Abstract Classes

1. Create a new C++ Console Application and save it in a folder called Polygons
2. Save the class as Main and the project as RegPolygons
3. Add a new class and save it as Polygon
4. On the Status Bar, click the Polygon.h tab and create a regular class as follows:


//---------------------------- ------------------------------ -----------------
#ifndef PolygonH
#define PolygonH
//---------------------------- ------------------------------ -----------------
namespace Shapes
{
class TPolygon
{
public:
TPolygon(int s = 0, char *n = "", double r = 0.00);
virtual ~TPolygon();
void setNbrOfSides(const int n);
int getNbrOfSides() const { return NbrOfSides; }
void setPolyName(const char *n);
char * getPolyName() const { return PolyName; }
void setRadius(const double r);
double getRadius() const { return Radius; }
double CentralAngle() const;
double InteriorAngle() con

Answered by kokila vani at 5:14 PM on September 05, 2008

well, The following snippet taken from LinAlg's validation code shows a declaration and applications of a functor TestUnit. This functor carries a private lexical environment -- variable is_unit -- which stores the object's state. This variable is exported as read-only.

static void test_special_creation(const int dim)
{
class TestUnit : public ConstElementAction
{
bool is_unit;
void operation(const REAL element)
{ if( is_unit ) is_unit = i==j ? element == 1.0 : element == 0; }
public: TestUnit(void) : is_unit(true) {}
bool is_indeed_unit(void) const { return is_unit; }
};

Matrix m(dim,dim);
{
TestUnit test_unit;
m.apply(test_unit);
assert( !test_unit.is_indeed_unit() );
}

Matrix m2 = unit(m);
{
TestUnit test_unit;
m2.apply(test_unit);
assert( test_unit.is_indeed_unit() );
}
}

Source: http://okmij.org/ftp/c++-diges t/Functional-Cpp.html

Answered by Satya ~ at 5:03 PM on September 05, 2008

Abstraction is one of the most powerful and vital features provided by object-oriented C++ programming language. Modularity is very important in any programming language, it provides flexibility to users for using the programming language. This aspect is well achieved with high performance by the concept of abstraction in C++. In object-oriented programming language the programmer can abstract both data and code when needed.

Answered by Hem@nt .... at 4:59 PM on September 05, 2008

well,A high-level programming language developed by Bjarne Stroustrup at Bell Labs. C++ adds object-oriented features to its predecessor, C. C++ is one of the most popular programming language for graphical applications, such as those that run in Windows and Macintosh environments. Abstraction is one of the most powerful and vital features provided by object-oriented C++ programming language. Modularity is very important in any programming language, it provides flexibility to users for using the programming language. This aspect is well achieved with high performance by the concept of abstraction in C++. In object-oriented programming language the programmer can abstract both data and code when needed.

Answered by Debashis at 4:32 PM on September 05, 2008

The concept of abstraction relates to the idea of hiding data that are not needed for presentation. The main idea behind data abstraction is to give a clear separation between properties of data type and the associated implementation details. This separation is achieved in order that the properties of the abstract data type are visible to the user interface and the implementation details are hidden. Thus, abstraction forms the basic platform for the creation of user-defined data types called objects. Data abstraction is the process of refining data to its essential form. An Abstract Data Type is defined as a data type that is defined in terms of the operations that it supports and not in terms of its structure or implementation.

In object-oriented programming language C++, it is possible to create and provide an interface that accesses only certain elements of data types. The programmer can decide which user to give or grant access to and hide the other details. This concept is called data hiding which is similar in concept to data abstraction.

For example, a class Car would be made up of an Engine, Gearbox, Steering objects, and many more components. To build the Car class, one does not need to know how the different components work internally, but only how to interface with them, i.e., send messages to them, receive messages from them, and perhaps make the different objects composing the class interact with each other.

Answered by Ashish Yadav at 4:31 PM on September 05, 2008

well, Typically, the aim of a responsible programmer is to reasonably quickly produce a program that correctly performs its task, does so with reasonable efficiency, and is maintainable. The key to fast development, correctness, efficiency, and maintainability is to use a suitable level of abstraction supported by good libraries. This short paper provides a view of how C++ can be used to support that aim. The aim of this is not to be “advanced”, but to make a couple of simple but important points.
Doing anything significant using only basic language features – that is, without the use of libraries – is unpleasant and unproductive. The key to elegant code and productivity lies in the production and use of libraries. That’s true in any language. C++ provides features, such as classes, class hierarchies, templates, exceptions, and namespaces, to directly support library building and use [Stroustrup,2000]. The design of C++ favors systems programming and applications where performance is essential or where resources must be carefully managed [Stroustrup,1994].
Consider a very simple example: To read an unknown number of characters from a keyboard, file, or network connection, we need to set aside a fixed size buffer, read individual characters into that buffer, check that we are not overflowing our allocation (or we’ll face memory corruptions and could cause security problems), expand the buffer as needed (or truncate the input), and finally report the number of characters read back to the application. Doing all this “by hand” is tedious and error prone. The C++ standard library provides types, such as string and istream (input stream) that makes such operations trivial to write.
source site: http://www.research.att.com/~b s/abstraction.pdf

Answered by Nidhi Singh at 4:24 PM on September 05, 2008