This PPT covers a small introduction of C++. 1. OOPS Feature. 2. Pointers 3. References 4. Class, Constructor(s)

1. C++ - Introduction
Sangharsh Agarwal

2. 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 Bjarne
Stroustrup 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).

3. Programming
• Programming is the
craft of transforming
requirements into
something that
computer can
execute.
• Programmer creates
the “recipe” that
computer can
understand and
execute.

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

5. 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.

6. 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

7. 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.

8. Features of OOP
• Classes and Objects
• Message and Methods
• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

9. 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.

10. 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.

11. 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.

12. Inheritance Example

13. 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

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

15. 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.

16. 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;
}

17. Getting Started
• Step 1: Write the Source Code:
• Step 2: Build the Executable Code:

18. Getting Started….
• Step 3: Run the Executable Code:

19. • /* ...... */
// ... 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.

20. • 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.

21. 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 directive
and 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.

22. 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.

23. 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.

24. C++ Program Template

25. 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.

26. Pointers in C++…
Output:
Value of var variable: 20
Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20

27. 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;

28. C++ References…
Output:
Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7

29. 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.

30. 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

31. 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.

32. Constructor..
Output:
Object is being created
Length of line : 6

33. Parameterized Constructor
Output:
Object is being created, length = 10
Length of line : 10
Length of line : 6

34. 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/advan
ce-oops-concepts-8752156