what is inline function

8/8/2019 What is Inline Function

1/22

What is Inline Function?

Inline functions are functions where the call is made to inline functions. The actual code

then gets placed in the calling program.

Reason for the need of Inline Function:

Normally, a function call transfers the control from the calling program to the function

and after the execution of the program returns the control back to the calling program

after the function call. These concepts of function saved program space and memoryspace are used because the function is stored only in one place and is only executed when

it is called. This concept of function execution may be time consuming since the registers

and other processes must be saved before the function gets called.

The extra time needed and the process of saving is valid for larger functions. If thefunction is short, the programmer may wish to place the code of the function in the

calling program in order for it to be executed. This type of function is best handled by the

inline function. In this situation, the programmer may be wondering why not write theshort code repeatedly inside the program wherever needed instead of going for inline

function? Although this could accomplish the task, the problem lies in the loss of clarity

of the program. If the programmer repeats the same code many times, there will be a lossof clarity in the program. The alternative approach is to allow inline functions to achieve

the same purpose, with the concept of functions.

What happens when an inline function is written?

The inline function takes the format as a normal function but when it is compiled it iscompiled as inline code. The function is placed separately as inline function, thus adding

readability to the source program. When the program is compiled, the code present in

function body is replaced in the place of function call.

General Format of inline Function:

The general format of inline function is as follows:

inline datatype function_name(arguments)


2/22

The keyword inline specified in the above example, designates the function as inline

function. For example, if a programmer wishes to have a function named exforsys withreturn value as integer and with no arguments as inline it is written as follows:

inline int exforsys( )

Example:

The concept of inline functions:

#include int exforsys(int);void main( ){int x;cout >x;cout


3/22

The output would be the same even when the inline function is written solely as a

function. The concept, however, is different. When the program is compiled, the code

present in the inline function exforsys( ) is replaced in the place of function call in thecalling program. The concept of inline function is used in this example because the

function is a small line of code.

The above example, when compiled, would have the structure as follows:

#include int exforsys(int);void main( ){int x;cout >x;

//The exforsys(x) gets replaced with code return 5*x1;cout


4/22

A friend function is used for accessing the non-public members of a class. A class can

allow non-member functions and other classes to access its own private data, by making

them friends. Thus, a friend function is an ordinary function or a member of anotherclass.

How to define and use Friend Function in C++:

The friend function is written as any other normal function, except the function

declaration of these functions is preceded with the keyword friend. The friend functionmust have the class to which it is declared as friend passed to it in argument.

Some important points to note while using friend functions in C++:

The keyword friend is placed only in the function declaration ofthe friend function and not in the function definition..

It is possible to declare a function as friend in any number ofclasses..

When a class is declared as a friend, the friend class has accessto the private data of the class that made this a friend..

A friend function, even though it is not a member function, wouldhave the rights to access the private members of the class..

It is possible to declare the friend function as either privateor public..

The function can be invoked without the use of an object. Thefriend function has its argument as objects, seen in examplebelow.

Example to understand the friend function:

#include

class exforsys{private:int a,b;public:void test(){a=100;b=200;}


5/22

friend int compute(exforsys e1)

//Friend Function Declaration with keyword friend and with the object of class exforsys towhich it is friend passed to it};

int compute(exforsys e1){

//Friend Function Definition which has access to private datareturn int(e1.a+e2.b)-5;}

main(){exforsys e;e.test();cout


6/22

static return_data_type fucntionname()

//Static function defined with keyword static{statement1;

//Statements for execution inside static functionstatement2;....................}

For example if a function exforsys returning nothing is to bedeclared as staic function it is done as follows:

static void exforsys(){

........;

.......;}

Accessing Static Function:

A normal member function is accessed using the object and an operator called the dot

member access operator. The functions declared static or static functions are accessedusing only the class name and the scope resolution operator, unlike in normal member

functions where these are not used.

Example:

The declaration of static member function and how to access static member function:

#include class example{

private:static int sum; //Static dataint x;public:

example() //Constructor of the class{sum=sum+1;x=sum;}


7/22

~example() //Destructor of the class{sum=sum-1;}

static void exforsys()

//Static function exforsys( ) defined with keyword static{cout


8/22

In the above example, the function exforsys() is defined as static function and the

integer data type sum is declared as static data type. Four objects e1, e2, e3 and e4 are

created for the class example. The constructor of the class example increments the sumby 1 and the destructor of the class decrements sum by 1.

The static function is accessed using the class name example and the scope resolution

operator:: as

example::exforsys();

But the normal member function number() is accessed using the object name and the dot

member access operator as

e1.number()e2.number()

e3.number()e4.number()

The first time the static function exforsys() is called, there was one object created and

thus, the sum is incremented by 1 in the constructor printing the result of sum as 1.When

the static function exforsys() is called the second time, there were three more objectse2,e3 and e4 created which results in the sum incremented thrice from 1 in the

constructor of the corresponding class example, resulting in the value of sum as 4, which

is displayed in the second result. Applying the above explanation, it is clear that the static

function operates on the class and not in object. To access static function the programmercan use the class name, followed by the scope resolution operator, as seen in example

above.

What is Pure Virtual Function:

Pure Virtual Function is a Virtual function with no body.


9/22

Declaration of Pure Virtual Function:

Since pure virtual function has no body, the programmer must add the notation =0 for

declaration of the pure virtual function in the base class.

General Syntax of Pure Virtual Function takes the form:

class classname //This denotes the base class of C++ virtual function{public:

virtual void virtualfunctioname() = 0 //This denotes the pure virtual function in

C++};

The other concept of pure virtual function remains the same as described in the previous

section of virtual function.

To understand the declaration and usage of Pure Virtual Function, refer to this example:

class Exforsys{public:

virtual void example()=0; //Denotes pure virtual Function Definition};

class Exf1:public Exforsys{public:void example()

{cout


10/22


11/22

In the above example, there are two derived classes Exf1 and Exf2 from the base classExforsys. As shown in the above diagram, the Training class is derived from both of the

derived classes Exf1 and Exf2. In this scenario, if a user has a member function in the

class Training where the user wants to access the data or member functions of the classExforsys it would result in error if it is performed like this:

class Exforsys{protected:int x;};

class Exf1:public Exforsys

{ };

class Exf2:public Exforsys{ };

class Training:public Exf1,public Exf2{public:int example(){return x;}};

The above program results in a compile time error as the member function example() ofclass Training tries to access member data x of class Exforsys. This results in an error

because the derived classes Exf1 and Exf2 (derived from base class Exforsys) create

copies of Exforsys called subobjects.


12/22

This means that each of the subobjects have Exforsys member data and member

functions and each have one copy of member data x. When the member function of theclass Training tries to access member data x, confusion arises as to which of the two

copies it must access since it derived from both derived classes, resulting in a compiletime error.

When this occurs, Virtual base class is used. Both of the derived classes Exf1 and Exf2are created as virtual base classes, meaning they should share a common subobject in

their base class.

For Example:

class Exforsys{protected:int x;;

class Exf1:virtual public Exforsys{ };

class Exf2:virtual public Exforsys{ };

class Training:public Exf1,public Exf2{public:int example(){return x;}};

C++ Polymorphism

Introduction

Polymorphism is the ability to use an operator or function in different ways.

Polymorphism gives different meanings or functions to the operators or functions. Poly,

referring to many, signifies the many uses of these operators and functions. A single


13/22

function usage or an operator functioning in many ways can be called polymorphism.

Polymorphism refers to codes, operations or objects that behave differently in different

contexts.

Below is a simple example of the above concept of polymorphism:

6 + 10

The above refers to integer addition.

The same + operator can be used with different meanings with strings:

"Exforsys" + "Training"

The same + operator can also be used for floating point addition:

7.15 + 3.78

Polymorphism is a powerful feature of the object oriented programming language C++. Asingle operator + behaves differently in different contexts such as integer, float or strings

referring the concept ofpolymorphism. The above concept leads to operatoroverloading.

The concept of overloading is also a branch ofpolymorphism. When the exiting operatoror function operates on new data type it is overloaded. This feature of polymorphism

leads to the concept ofvirtual methods.

Polymorphism refers to the ability to call different functions by using only one type offunction call. Suppose a programmer wants to code vehicles of different shapes such as

circles, squares, rectangles, etc. One way to define each of these classes is to have a

member function for each that makes vehicles of each shape. Another convenient

approach the programmer can take is to define a base class named Shape and then createan instance of that class. The programmer can have array that hold pointers to all


14/22

different objects of the vehicle followed by a simple loop structure to make the vehicle,

as per the shape desired, by inserting pointers into the defined array. This approach leads

to different functions executed by the same function call. Polymorphism is used to givedifferent meanings to the same concept. This is the basis forVirtual function

implementation.

In polymorphism, a single function or an operator functioning in many ways dependsupon the usage to function properly. In order for this to occur, the following conditions

must apply:

All different classes must be derived from a single base class. In the above

example, the shapes of vehicles (circle, triangle, rectangle) are from the single

base class called Shape. The member function must be declared virtual in the base class. In the above

example, the member function for making the vehicle should be made as virtual tothe base class.

Features and Advantages of the concept of Polymorphism:

Applications are Easily Extendable:

Once an application is written using the concept of polymorphism, it can easily be

extended, providing new objects that conform to the original interface. It is unnecessary

to recompile original programs by adding new types. Only re-linking is necessary toexhibit the new changes along with the old application. This is the greatest achievement

of C++ object-oriented programming. In programming language, there has always been aneed for adding and customizing. By utilizing the concept of polymorphism, time and

work effort is reduced in addition to making future maintenance easier.

Helps in reusability of code.

Provides easier maintenance of applications. Helps in achieving robustness in applications.

Types of Polymorphism:

C++ provides three different types of polymorphism.

Virtual functions


15/22


16/22

Encapsulation is the process of combining data and functions into a single unit called

class. Using the method of encapsulation, the programmer cannot directly access the data.

Data is only accessible through the functions present inside the class. Data encapsulationled to the important concept of data hiding. Data hiding is the implementation details of a

class that are hidden from the user. The concept of restricted access led programmers to

write specialized functions or methods for performing the operations on hidden membersof the class. Attention must be paid to ensure that the class is designed properly.

Neither too much access nor too much control must be placed on the operations in order

to make the class user friendly. Hiding the implementation details and providing

restrictive access leads to the concept of abstract data type. Encapsulation leads to theconcept of data hiding, but the concept of encapsulation must not be restricted to

information hiding. Encapsulation clearly represents the ability to bundle related data and

functionality within a single, autonomous entity called a class.

For instance:

class Exforsys{public:int sample();int example(char *se)int endfunc();.........

......... //Other member functions

private:int x;float sq;..........

......... //Other data members};

In the above example, the data members integer x, float sq and other data members and

member functions sample(),example(char* se),endfunc() and other member functions arebundled and put inside a single autonomous entity called class Exforsys. This exemplifies

the concept of Encapsulation. This special feature is available in object-oriented languageC++ but not available in procedural language C. There are advantages of using thisencapsulated approach in C++. One advantage is that it reduces human errors. The data

and functions bundled inside the class take total control of maintenance and thus human

errors are reduced. It is clear from the above example that the encapsulated objects act as

a black box for other parts of the program through interaction. Although encapsulatedobjects provide functionality, the calling objects will not know the implementation

details. This enhances the security of the application.


17/22

The key strength behind Data Encapsulation in C++ is that the keywords or the access

specifiers can be placed in the class declaration as public, protected or private. A classplaced after the keyword public is accessible to all the users of the class. The elements

placed after the keyword private are accessible only to the methods of the class. Inbetween the public and the private access specifiers, there exists the protected access

specifier. Elements placed after the keyword protected are accessible only to the methodsof the class or classes derived from that class.

The concept of encapsulation shows that a non-member function cannot access an

object's private or protected data. This adds security, but in some cases the programmermight require an unrelated function to operate on an object of two different classes. The

programmer is then able to utilize the concept of friend functions. Encapsulation alone is

a powerful feature that leads to information hiding, abstract data type and friendfunctions.

Features and Advantages of the concept of Encapsulation:

* Makes Maintenance of Application Easier:

Complex and critical applications are difficult to maintain. The cost associated withmaintaining the application is higher than that of developing the application properly. Toresolve this maintenance difficulty, the object-oriented programming language C++

created the concept of encapsulation which bundles data and related functions together as

a unit called class. Thus, making maintenance much easier on the class level.

* Improves the Understandability of the Application

* Enhanced Security:

There are numerous reasons for the enhancement of security using the concept ofEncapsulation in C++. The access specifier acts as the key strength behind the concept of

security and provides access to members of class as needed by users. This prevents


18/22

unauthorized access. If an application needs to be extended or customized in later stages

of development, the task of adding new functions becomes easier without breaking

existing code or applications, there by giving an additional security to existingapplication.

C++ Operator Overloading Part II

Operator overloading is a very important aspect of object-oriented programming. Binary

operators can be overloaded in a similar manner as unary operators. In this C++ tutorial,you will learn about Binary Operating Overloading explained along with syntax and

example.

Operator Overloading Binary Operators

Binary operators, when overloaded, are given new functionality. The function defined for

binary operator overloading, as with unary operator overloading, can be member function

or friend function.

The difference is in the number of arguments used by the function. In the case of binary

operator overloading, when the function is a member function then the number ofarguments used by the operator member function is one (see below example). When the

function defined for the binary operator overloading is a friend function, then it uses two

arguments.

Binary operator overloading, as in unary operator overloading, is performed using akeyword operator.

Binary operator overloading example:

#include class Exforsys

{private:int x;int y;

public:

Exforsys() //Constructor


19/22

{ x=0; y=0; }

void getvalue( ) //Member Function for Inputting Values{cout > x;cout > y;}

void displayvalue( ) //Member Function for Outputting Values{cout


20/22


21/22

C++ Abstraction

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, itprovides 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-orientedprogramming 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 forpresentation. 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 userinterface 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 datatype 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 aninterface 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; functionalabstraction 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 thefunction 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 conceptof 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.

Reasons for the need of Abstraction


22/22

Flexibility in approach:

By hiding data or abstracting details that are not needed for presentation, the programmer

achieves greater flexibility in approach.

Enhanced Security:

Abstraction gives access to data or details that are needed by users and hide theimplementation details, giving enhanced security to application.

Easier Replacement:

With the concept of abstraction in object-oriented programming language, it is possible to

replace code without recompilation. This makes the process easier and saves time for

users.

Modular Approach:

In object-oriented programming language C++, the abstraction concept helps users to

divide the project application into modules and test each of them separately. Then all

modules are integrated and ultimately tested together. This approach makes theapplication development easier.

There are various ways of achieving abstraction in object-oriented programming

language C++. One approach is to take modular based code that is broken apart into

smaller segments, known as functions. This functional or modular approach helps the

code to be reused again and again when needed. For example, a programmer might writea function for computing an average and another programmer might write a function for

computing salary. These functions can be reused when needed, by anyone. The modular

based approach helps to centralize all data of a similar type, under the control of a typemodule. Defining module types allow the module to be an abstract data type. In many

other programming languages, there is a small drawback associated with the approach to

accessing module type.

what is inline function

Documents