Difference between C & C++

- 1 -

C++ (C with Classes)Object Oriented Programming (OOP)

The term Object Oriented Programming means a programming language that fully supports the object oriented (features) style of programming.Introduction

C++ is an object-oriented programming language developed by Bjarne Stroustrup at AT & T Bell Labs in the early 1980s.Since the class concept was the major addition to the original C language, it is called as "C with classes". However later in 1983, the name was changed to C++. The idea of C++ comes from the 'C' increment operator "++", there by suggesting that C++ is an incremented version of 'C'. C++ is a superset of C. Therefore almost all C programs are valid C++ programs.Difference between C & C++

C is a procedure-oriented programming language where everything is placed in the form of procedures or functions. While we concentrate on functions very little attention is given to the data that are being used by various functions & any function can access the information provided in other functions. It doesnt model the real world problems very well. It employs top-down approach in program design.

Where as C++ is an object-oriented programming language which treats data as a critical element in the program and it doesnt allow moving freely around the system. It binds the data & the functions that operate on data together and protects it from accidental use of other functions. OOP allows us to decompose a problem into a number of entities called objects and built data and functions around these objects.Advantages of OOP

1. Object Oriented Approach

2. Closer to real world object

3. Dynamic Declaration

4. Data Security

5. Code Re-Usability & ExtensibilityBasic concepts of Object-Oriented programming languageClassA class is a blueprint or prototype that defines the variables and the methods common to all objects of a certain kind.A class is a logical construct of an object.A class is an abstract representation of something, whereas an object is a usable example of the class.A class is an expanded concept of a structure in C, instead of holding only data; it can hold both data and functions. Once a class has been defined, you can create any number of objects based on that class.Object

An object is an instance (example or illustration) of a class. In terms of variables, a class would be the data type and an object would be the variable.An object is a physical reality.An object is a software bundle of related variables and methods. Software objects are often used to model real-world objects you find in everyday life.Polymorphism (many forms)

An ability to have more than one function with the same name, each having different functionality. The function going to execute is determined at run time. Polymorphism refers to the fact that a single operation can have different behavior in different objects.E.g.: Overloading, Overriding.Overloading:

Overloading is the practice of supplying more than one definition for a given function name in the same scope. The compiler is left to pick the appropriate version of the function or operator based on the arguments with which it is called.Inheritance

The mechanism of creating new classes by deriving the features from existing classes is called Inheritance.In OOP the concept of inheritance provides the idea of reusability & extensibility. This means that we can add additional features of an existing class without modifying it. This is possible by deriving a new class from the existing one. The new class will have the combined features of both the classes.Encapsulation

The method of packing all the data members & member functions into a single unit called class and the process is called EncapsulationData Hiding

The process of hiding the data members and member functions from access by the other class objects other than the same class objects.The data is not accessible to the outside world and only those functions which are placed in the class can access it, these functions provide the interface between objects data and the program. The insulation of data from direct access by the program is called data hiding.

Data AbstractionIt is the process of accessing the data members & member functions with the objects.

Abstraction refers to the act of representing essential features without including the background details and explanations. Classes use the concept of abstraction and defined as a list of abstraction attributes. Since the classes use the concept of data abstraction they are known as Abstract Data Type (ADT).Data Binding

Binding refers to the act of associating an object or a class with its member. If we can call a method fn() on an object o of a class c, we say that the object o is binded with the method fn(). This happens at compile time and is known as static or compile - time binding.The calls to the virtual member functions are resolved during run-time. This mechanism is known as dynamic binding. The most prominent reason why a virtual function will be used is to have a different functionality in the derived class. The difference between a non-virtual member function and a virtual member function is the non-virtual member functions are resolved at compile time.Structure of C++ program:

Include files

Class declaration

Member functions definition

Main function

{

Local declaration;

Object declaration;

Executable coding;

}

Syntax for Class Declaration

class class_name

{

access_specifier_1:

data members;

access_specifier_2:

member functions;

.

} object_names;

where class_name is a valid identifier for the class, object_names is an optional list of names for objects of this class. The body of the declaration can contain members, which can be either data or function declarations, or optionally access specifiers. All is very similar to the declaration on structures, except the new thing called access specifier. An access specifier is one of the following three keywords: private, public or protected. These specifiers modify the access rights that the members following them acquire:

private members of a class are accessible only within the class and by the public members of the same class or from their friends.

protected members are accessible from members of their same class and from their friends, but also from members of their derived classes.

public members are accessible from anywhere in the program where the object is visible.

By default, all members of a class declared with the class keyword have private access for all its members.

Function Definitions outside the class

Member functions that are declared inside a class have to be defined separately outside the class. They should have a function definition outside the class asreturn_type class_name :: function_name(arguments list)

{

function body;

}

The membership label class_name :: tells the compiler that the function belongs to the class class_name. That is the scope of the function is restricted to the class_name specified in the header line.

The symbol "::" is called Scope Resolution operator.The scope operator (::) specifies the class to which the member being declared belongs, granting exactly the same scope properties as if this function definition was directly included within the class definition.The only difference between defining a class member function completely within its class and to include only the prototype and later its definition, is that in the first case the function will automatically be considered an inline member function by the compiler, while in the second it will be a normal (not-inline) class member function, which in fact supposes no difference in behavior.Inline Function

They are shortcut functions that are not actually called; rather their code is expanded at the point of execution. If a function is declared with the keyword inline, the compiler does not call the actual function instead it copies the code from the inline function directly into the calling function.Inline is a hint to the compiler that you would like the function to be inlined. The compiler is free to ignore the hint and make a real function call.this pointer:

"this" is a pointer that points the address of the current object. The unique pointer is automatically passed to a member function when it is called. The pointer "this" acts as an implicit argument to all the member functions.Object Arrays

We know that an array can be of any data type including struct; similarly we can also have arrays of variables that are of the type class. Such variables are called arrays of objects.

class employ

{

char name[10];

int age;

public:

void inputdata();

void outputdata();

};

ex:-

employ emp[5];Create A Class With The Name Bank And Create An Array With 5 Cells And Accept Data And Print Data.

Example for an Object Arrays.

# include

# include

# include class bank

{

int acno,cbal;

char cname[20];

public:

void input();

void output();

};

void bank::input()

{

coutacno;

coutcname;

coutcbal;

}

void bank::output()

{

cout