C++ - Introduction

Sangharsh Agarwal

Introduction of C++

• C++ is successor to C, a procedural language.

• C++ (Previously named as ‘C with classes’) was developed in early 1980’s by BjarneStroustrup of AT&T Bell labs.

• Most of C is subset of C++.

• C++ is Object Oriented Programming language (Not completly OOP language due to its predecessor i.e. C).

Programming

• Programming is the craft of transforming requirements into something that computer can execute.

• Programmer creates the “recipe” that computer can understand and execute.

Procedural programming

• Programmer implements requirement by breaking down them to small steps (functional decomposition).

Object oriented programming

• Break down requirements into objects with responsibilities, not into functional steps.

• Lets you think about object hierarchies and interactions instead of program control flow.

• A completely different programming paradigm.

Why OOPS?

• To modularize software development, just like any other engineering discipline.

• To make software projects more manageable and predictable.

• For better maintainability, since software maintenance costs were more than the development costs.

• For more re-use code and prevent ‘reinvention of wheel’** every time.

**reinventing the wheel is a phrase that means to duplicate a basic method that has already previously been created or optimized by others

Features of OOP

• Emphasis on data rather on procedure.

• Programs are divided into what are known as “objects”.

• Functions that operate on data of an object are tied together in a data structure.

• Object may communicate with each other through functions.

• New data and functions can be added easily whenever necessary.

Features of OOP

• Classes and Objects

• Message and Methods

• Encapsulation

• Inheritance

• Polymorphism

• Abstraction

Classes and Objects

• Object oriented programming uses objects.

• An object is a thing, both tangible and intangible. Account, Vehicle, Employee etc.

• To create an object inside a compute program we must provide a definition for objects – how they behave and what kinds of information they maintain – called a class.

• An object is called an instance of a class.

• Object interacts with each other via message.

Encapsulation

• Encapsulation is the packing of data and functions into a single component. The features of encapsulation are supported using classes in most object-oriented programming languages, although other alternatives also exist.

• Encapsulation is:– A language mechanism for restricting access to some

of the object's components. (public, private, protected)

– A language construct that facilitates the bundling of data with the methods (or other functions) operating on that data.

Inheritance

• Inheritance is a mechanism in OOP to design two or more entities that are different but share many common features.

– Feature common to all classes are defined in the superclass.

– The classes that inherit common features from the superclass are called subclasses.

Inheritance Example

Polymorphism

• Polymorphism indicates the meaning of “many forms”.

• Polymorphism present a method that can have many definitions. Polymorphism is related to “overloading” and “overriding”.

• Overloading indicates a method can have different definitions by defining different type of parameters.– getPrice() : void

– getPrice(string name) : void

Polymorphism….

• Overriding indicates subclass and the parent class has the same methods, parameters and return type(namely to redefine the methods in parent class).

Abstraction

• Abstraction is the process of modeling only relevant features

– Hide unnecessary details which are irrelevant for current for current purpose (and/or user).

• Reduces complexity and aids understanding.

• Abstraction provides the freedom to defer implementation decisions by avoiding commitments to details.

Abstraction example

#include <iostream>

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 << "Total " << a.getTotal()

<<endl;

return 0;

}

Getting Started

• Step 1: Write the Source Code:

• Step 2: Build the Executable Code:

Getting Started….

• Step 3: Run the Executable Code:

• /* ...... */// ... until the end of the line

– These are called comments. Comments are NOT executable and are ignored by the compiler; but they provide useful explanation and documentation to your readers (and to yourself three days later). There are two kinds of comments:• Multi-line Comment: begins with /* and ends with */. It may span more than one

lines (as in Lines 1-3).• End-of-line Comment: begins with // and lasts until the end of the current line (as in

Lines 4, 7, 8, 9 and 10).

• #include <iostream>using namespace std;

– The "#include" is called a preprocessor directive. – Preprocessor directives begin with a # sign. – They are processed before compilation. – The directive "#include <iostream>" tells the preprocessor to

include the "iostream" header file to support input/output operations. – The "using namespace std;" statement declares std as the default

namespace used in this program. The names cout and endl, which is used in this program, belong to the std namespace. These two lines shall be present in all our programs.

• int main() { ... body ... }

– defines the so-called main() function. The main() function is the entry point of program execution. main() is required to return an int (integer).

• cout << "hello, world" << endl;

– "cout" refers to the standard output (or Console OUTput). The symbol << is called the stream insertion operator (or put-to operator), which is used to put the string "hello, world" to the console. "endl" denotes the END-of-Line or newline, which is put to the console to bring the cursor to the beginning of the next line.

• return 0;

– terminates the main() function and returns a value of 0 to the operating system. Typically, return value of 0 signals normal termination; whereas value of non-zero (usually 1) signals abnormal termination. This line is optional. C++ compiler will implicitly insert a "return 0;" to the end of the main() function.

C++ Terminology and Syntax

• Statement: A programming statement performs a piece of programming action. It must be terminated by a semicolon (;) (just like an English sentence is ended with a period), as in Lines 5, 8 and 9.

• Preprocessor Directive: The #include (Line 4) is a preprocessor directiveand NOT a programming statement. A preprocessor directive begins with hash sign (#). It is processed before compiling the program. A preprocessor directive is NOT terminated by a semicolon - take note of this unusual rule.

• Block: A block is a group of programming statements enclosed by braces { }. This group of statements is treated as one single unit. There is one block in this program, which contains the body of the main() function. There is no need to put a semicolon after the closing brace.

C++ Terminology and Syntax…

• Comments: A multi-line comment begins with /* and ends with */, which may span more than one line. An end-of-line comment begins with // and lasts till the end of the line. Comments are NOT executable statements and are ignored by the compiler; but they provide useful explanation and documentation. Use comments liberally.

• Whitespaces: Blank, tab, and newline are collectively called whitespaces. Extra whitespaces are ignored, i.e., only one whitespace is needed to separate the tokens. Nevertheless, extra white spaces and newlines could help you and your readers better understand your program. Use extra whitespaces and newlines liberally.

• Case Sensitivity: C++ is case sensitive - a ROSE is NOT a Rose, and is NOT a rose.

The Process of Writing a C++ Program

• Step 1: Write the source codes (.cpp) and header files (.h).

• Step 2: Pre-process the source codes according to the preprocessor directives. Preprocessor directives begin with a hash sign (#), e.g., #include and #define. They indicate that certain manipulations (such as including another file or replacement of symbols) are to be performed BEFORE compilation.

• Step 3: Compile the pre-processed source codes into object codes (.obj, .o).

• Step 4: Link the compiled object codes with other object codes and the library object codes (.lib, .a) to produce the executable code (.exe).

• Step 5: Load the executable code into computer memory.

• Step 6: Run the executable code, with the input to produce the desried output.

C++ Program Template

Pointers

• A pointer is a variable whose value is the address of another variable.

• The general form of a pointer variable declaration is:

type *var-name;

• Here, type is the pointer's base type; it must be a valid C++ type and var-name is the name of the pointer variable.

• int *ip; // pointer to an integer

• double *dp; // pointer to a double

• float *fp; // pointer to a float

• char *ch // pointer to character Reading Pointers in C++:1. const char * ptr :- ptr is pointer to character constant. 2. char const * ptr :- ptr is pointer to constant character. Both 1 and 2 is same.3. char *const ptr :- ptr is constant pointer to character.4. const char * const ptr :- ptr is constant pointer to constant character.

Pointers in C++…

Output:

Value of var variable: 20

Address stored in ip variable: 0xbfc601ac

Value of *ip variable: 20

C++ References

• A reference variable is an alias, that is, another name for an already existing variable. Once a reference is initialized with a variable, either the variable name or the reference name may be used to refer to the variable.

• Creating References in C++:– Think of a variable name as a label attached to the variable's

location in memory. You can then think of a reference as a second label attached to that memory location. Therefore, you can access the contents of the variable through either the original variable name or the reference. For example, suppose we have the following example:• int i = 17;

– We can declare reference variables for i as follows.• int& r = i;

C++ References…

Output:

Value of i : 5

Value of i reference : 5

Value of d : 11.7

Value of d reference : 11.7

C++ References vs Pointers:

• References are often confused with pointers but three major differences between references and pointers are: (Program)– You cannot have NULL references. You must always be

able to assume that a reference is connected to a legitimate piece of storage.

– Once a reference is initialized to an object, it cannot be changed to refer to another object. Pointers can be pointed to another object at any time.

– A reference must be initialized when it is created. Pointers can be initialized at any time.

Classes example:

• A class is used to specify the form of an object and it combines data representation and methods for manipulating that data into one neat package. The data and functions within a class are called members of the class.

• C++ class definitions:

class Box {

public:

double length; // Length of a box

double breadth; // Breadth of a box

double height; // Height of a box };

• Define C++ Objects

Box Box1; // Declare Box1 of type Box

Box Box2; // Declare Box2 of type Box

Classes with Constructor

• A class constructor is a special member function of a class that is executed whenever we create new objects of that class.

Constructor..Output:

Object is being created

Length of line : 6

Parameterized Constructor

Output:

Object is being created, length = 10

Length of line : 10

Length of line : 6

References

• http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-096-introduction-to-c-january-iap-2011/lecture-notes/MIT6_096IAP11_lec03.pdf

• http://www.slideshare.net/sangharshcs/advance-oops-concepts-8752156