What is Abstraction in C?

Answer 1

C is not an object-oriented programming language and therefore has no concept of abstract classes.

In C++, however, an abstract class is a base class that declares one or more pure-virtual functions. An abstract base class is also known as an abstract data type (ADT). Pure-virtual functions differ from virtual functions in that virtual functions are expected to be overridden (but needn't be) while a pure-virtual function must be overridden (but needn't be implemented by the ADT). Once overridden by a derived class, the function reverts to being a virtual function with respect to further derivatives. However, only classes that provide or inherit a complete implementation of the pure-virtual interface can be instantiated in their own right; those that do not are themselves abstract data types.

Answer 2

An abstract class is a class which has atleast one pure virtual function.An abstract class does not have any objects.It is used just for sharing it's members to some other classes.the class that shares the members of base class should define the pure virtual function if not object is not been created

for example:

class classname

{

protected:

virtual datatype fname(parameters)=0;

};

Answer 3

Abstraction in any programming language is a higher-level construct that implements some lower-level functionality. To a large extent, we use abstractions to simplify our code. For instance, the C standard library consists of a number of low-level functions which we can combine in some way to create a higher-level function, thus increasing the level of abstraction. We can then combine these higher-level functions to increase the level of abstraction even further. With well-named abstractions, our code becomes largely self-documenting and thus easier to both read and maintain.

Answer 4

An Abstract class is a special kind of class that cannot be instantiated. It has one or more methods which are not implemented in the class. These methods are declared abstract and they do not contain any code inside them.

Ex:

abstract class Parent {

public abstract String getSon();

public abstract String getDaughter();

....

....

//More methods that contain specific behaviour/code in them

}

The above is an abstract class "Parent" that has a lot of functionality but it has declared two abstract methods which have no code inside them. Any class that has one or more abstract methods has to be abstract. This abstract class cannot be instantiated.

i.e., the below piece of code will not work. The code will not even compile.

Parent object = new Parent();

Purpose of Abstract Classes:

Abstract classes are generally used where you want an amount of behaviour to be used by the class that extends the abstract class while at the same time giving options to the child class to provide a certain amount of behaviour itself.

Answer 5

An abstract class is an abstract data type (ADT). An ADT has one or more pure-virtual functions that must be implemented in derived classes or they, too, become abstract. ADTs cannot be instantiated, even if they provide implementations for their pure-virtual functions. They are intended to be derived -- they merely provide the definition of an interface for those derivatives.

A virtual class is used when a derived class uses multiple inheritance, where two or more of the base classes inherit from a common base class. Since the derived class would inherit two or more versions of the common base class, an ambiguity exists as to which common base class would be used via implicit calls in the derived class. One way around this is to use explicit calls from the derived class. But by declaring all but one of the base classes to be virtual, only one copy of the common base class will be visible to the derived class.

Answer 6

Abstract classes are the same as abstract data types. They are conceptual, incomplete types, that are intended to act as base classes for other classes (both abstract and concrete) that ultimately share the common interface provided by the abstract base class. Being abstract, they cannot be instantiated directly, they must be derived from.

In order to become abstract, a class must have at least one pure-virtual method. All derivatives of an abstract base class must provide an implementation for all the base class' pure-virtual methods, otherwise they become abstract themselves. However, any implementations they do provide then become virtual methods, which can subsequently be inherited by further derivation. Only classes that provide or inherit a complete implementation for all pure-virtual methods can be physically instantiated (a concrete class).

To use an example, circles and squares are concrete classes that can be derived from a generic shape class. Since all shapes can be drawn it makes sense to percolate the draw() method up to the base class. However, the shape class cannot implement the draw() method without knowing what type of shape is derived from it. Thus the draw() method must be declared pure-virtual which renders the entire shape class abstract. This means we can no longer instantiate a shape class, but that's not a problem because we're only interested in instantiating concrete shapes like circles and squares, and any other type of shape we might choose to derive from shape in the future. The pure-virtual draw() method ensures that all derivatives provide their own specific draw() methods, thus the shape class need not even be aware of what types of shape are derived from it. It's merely providing a common interface for all types of shape.

Although we cannot instantiate a shape class directly, we can point or refer to the underlying shape class of any derivative. Thus we can create a collection of different shapes and call their draw methods without any regard to what types of shape they actually are. Each shape draws itself according to the derived class implementation which is guaranteed to exist otherwise the derived class simply would not exist.

Answer 7

a abstract class is class which has a abstract method which means a method does not its own body.

Answer 8

To provide a generic interface for two or more concrete classes.