C++ Tutorials imp.ppt

C++ TUTORIALS

What is C++?

 _{C++ is an object oriented programming language.}

 _{C++ is an extension of C with a major addition of the}

class construct feature.

 _{C++ is superset of C.}

 _{Features like classes, inheritance, function overloading,}

and operator overloading make C++ a truly object-oriented language.

 _{OO features in C++ allow programmers to build large}

What is C++ (II)

• _C++

• _{Improves on many of C's features} • _{Has object-oriented capabilities}

• _{Increases software quality and reusability}

• _{Developed by Bjarne Stroustrup at Bell Labs}

• _{Called "C with classes“ (1979)}

• _{C++ (increment operator) (1983) - enhanced version of C}

• _{Superset of C}

• _{Can use a C++ compiler to compile C programs} • _{Gradually evolve the C programs to C++}

• ANSI C++

• _{Final version at http://www.ansi.org/}

Hello World!

/* Simple hello world program*/

# include <iostream>// This is include directive

using namespace std;

int main() {

cout << “Hello World!”; //C++ statement

Tokens

Tokens

• _Keywords

Keywords

 _{Some words are reserved for implementing the specific C++}

language features.

 _{asm, auto, bool, break, case, catch, char,}

class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true,

try, typedef, typeid, typename, union,

Tokens

Identifiers

• _{Identifiers refer to the names of variables, functions,}

arrays, classes , etc. created by the programmer.

• _{Rules for creating it.}

• _{Only alphabet characters, digits and underscore are permitted.} • _{The name cannot start with digit.}

• _{Uppercase and lowercase letters are distinct.}

Size and range of C++ basic data types

Type Bytes Range

char 1 -128 to 127

signed: -128 to 127 unsigned: 0 to 255

short int 2 -31768 to 32767

signed: -32768 to 32767 unsigned: 0 to 65535

int 2 -32768 to 32767

signed: -31768 to 32767 unsigned: 0 to 65535

long int 4 -2147483648 to 2147483647

signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295

float 4 3.4E-38 to 3.4E+38

double 8 1.7E-308 to 1.7E+308

User-Defined Data Types

 _{Structures and Classes}

◦ _{Basis for OOP.}

◦ _{Classes enable to combine data and procedures.}

 _{Enumerated Data Type}

◦ _{It provides a way to attaching names to the numbers} ◦ _{Increase comprehensibility of the code.}

◦ _{Alternative mean for creating symbolic constants}

◦ _{Enumerates a list of words by assigning them values 0,1,2 and so} on.

Derived Data Types

• _Arrays

• _{Values of similar type stored in continuous memory locations.}

• _{int a[10]; char string[3]=“xyz”;}

• _Functions

• _{Set of statements to perform specific tasks}

• _Pointers

• _{Special variables to store the memory location of other variables.} • _{Used in referencing memory.}

Tokens

• _Keywords • _Identifiers

• _Constants

Constants (literal)

• _{Refer to fixed values that do not change in thw execution}

of the program.

• _{123 //decimal integer}

• _{12.34 //floating point integer} • _{037 //octal integer}

• _{0x2 //Hexa decimal} • _{“C++” //string constant}

• _{‘A’ //character constant}

Constants(Symbolic)

• _{Using the qualifier const}

• _{const float pi = 3.14;}

• _{Using enum}

• _enum{x,y,z};

• _{enum{x=200,y=300,z=400};}

Tokens

• _Keywords • _Identifiers • _Constants

• _Strings

Strings

• _{Variables that can store non-numerical values that are}

longer than one single character are known as strings.

• _{The C++ language library provides support for strings}

through the standard _string class.

// my first string

#include <iostream> #include <string>

using namespace std; int main ()

{

Char mystring[ ] = "This is a string"; cout << mystring;

Tokens

• _Keywords • _Identifiers • _Constants • _Strings

Expressions and Their Types

Control Structures

• _{The if statement}

Simple if statement if…..else statement

Control Structures

• _{The switch statement}

Control Structure

• _{The do-while statement}

do {

statement1; }

Control Structures

• _{The while statement}

while(condition) {

statement1; }

Control Structures

• _{The for statement}

for (intialization;condition;increment) {

statement1; }

Functions

• _{A piece of code that perform specific task.} • _{Introduces modularity in the code.}

• _{Reduces the size of program.}

• _{C++ has added many new features to the functions to}

make them more reliable and flexible.

Functions

 _{Function declaration}

◦ _{return-type function-name (argument-list);} ◦ _{void show();}

◦ _{float volume(int x,float y,float z);}

 _{Function definition}

return-type function-name(argument-list) {

statement1; statement2; }

 _{Function call}

Functions

• _{The main function}

• _{Returns a value of type int to the operating system.}

int main() {

……… ………

Functions

• _{Parameter Passing}

• _{Call by value}

• _{Copy of data passed to function}

• _{Changes to copy do not change original} • _{Call by reference}

• _{Function can directly access data} • Changes affect original

Reference variable Pointers

void swap (int &a, int &b) {

int t=a; a=b; b=t; }

Functions

• _{Reference parameter alias for argument} • _{Use &}

void change(int &variable) {

variable += 3; }

• Adds 3 to the original variable input

• _{int y = &x}

• _{Changing y changes x as well}

Functions References

• _{Dangling references}

• _{Make sure to assign references to variables}

• _{If a function returns a reference to a variable, make sure the}

variable is static

• _{Otherwise, it is automatic and destroyed after function ends}

• _{Multiple references}

• _{Like pointers, each reference needs an &}

outline

1. Function prototypes

1.1 Initialize variables

2. Print _x

2.1 Call function and print x

2.2 Print _z

2.3 Call function and print _z 

3. Function Definition

1 // Fig. 15.5: fig15_05.cpp

2 // Comparing call-by-value and call-by-reference 3 // with references.

4 #include <iostream>

5

6 using std::cout;

7 using std::endl;

8

9 int squareByValue( int );

10 void squareByReference( int & );

11

12 int main()

13 {

14 int x = 2, z = 4;

15

16 cout << "x = " << x << " before squareByValue\n"

17 << "Value returned by squareByValue: "

18 << squareByValue( x ) << endl

19 << "x = " << x << " after squareByValue\n" << endl;

20

21 cout << "z = " << z << " before squareByReference" << endl;

22 squareByReference( z );

23 cout << "z = " << z << " after squareByReference" << endl;

24

25 return 0;

26 }

27

28 int squareByValue( int a )

29 {

3.1 Function Definition

Program Output

x = 2 before squareByValue

Value returned by squareByValue: 4 x = 2 after squareByValue

z = 4 before squareByReference z = 16 after squareByReference

32

33 void squareByReference( int &cRef )

34 {

35 cRef *= cRef; // caller's argument modified

Default Arguments and Empty Parameter

Lists

• If function parameter omitted, gets default value

– If not enough parameters specified, rightmost go to their defaults

• Set defaults in function prototype

1. Function prototype (notice defaults)

2. _main

2.1 Function calls (use default arguments)

3. Function definition

1 // Fig. 15.8: fig15_08.cpp

2 // Using default arguments

3 #include <iostream>

4

5 using std::cout;

6 using std::endl;

7

8 int boxVolume( int length = 1, int width = 1, int height = 1 );

9

10 int main()

11 {

12 cout << "The default box volume is: " << boxVolume()

13 << "\n\nThe volume of a box with length 10,\n"

14 << "width 1 and height 1 is: " << boxVolume( 10 )

15 << "\n\nThe volume of a box with length 10,\n"

16 << "width 5 and height 1 is: " << boxVolume( 10, 5 )

17 << "\n\nThe volume of a box with length 10,\n"

18 << "width 5 and height 2 is: " << boxVolume( 10, 5, 2 )

19 << endl;

20

21 return 0;

22 }

23

24 // Calculate the volume of a box

25 int boxVolume( int length, int width, int height )

26 {

27 return length * width * height;

Program Output

The default box volume is: 1

The volume of a box with length 10, width 1 and height 1 is: 10

The volume of a box with length 10, width 5 and height 1 is: 50

Function Overloading

• _{C++ allows to use the same function name to create functions that perform a variety of different tasks. OR} • _{Functions with same name and different parameters}

• _{Overloaded functions should perform similar tasks}

• This is know as function polymorphism in OOP. • Function to square ints and function to square floats

int square( int x) {return x * x;}

float square(float x) { return x * x; }

• Program chooses function by signature

• Signature determined by function name and parameter types • Type safe linkage - ensures proper overloaded function called

int add (int a, int b); //prototype 1

int add (int a, int b, int c); //prototype 2 double add (double x, double y);//prototype 3 double add (int p, double q);//prototype 4 double add (double p, int q); //prototype 5

1. Define overloaded function

2. Function calls

Program Output

1 // Fig. 15.10: fig15_10.cpp 2 // Using overloaded functions 3 #include <iostream>

4

5 using std::cout;

6 using std::endl;

7

8 int square( int x ) { return x * x; }

9

10 double square( double y ) { return y * y; }

11

12 int main()

13 {

14 cout << "The square of integer 7 is " << square( 7 )

15 << "\nThe square of double 7.5 is " << square( 7.5 )

16 << endl;

17

18 return 0;

19 }

The square of integer 7 is 49

Inline Functions

•

Function calls

• _{Cause execution-time overhead}

• _{Qualifier inline before function return type "advises" a function}

to be inlined

• _{Puts copy of function's code in place of function call}

• _{Speeds up performance but increases file size} • _{Compiler can ignore the inline qualifier}

• _{Ignores all but the smallest functions}

Inline fun example

• _{#include<iostream.h>} • _{class clsnam}

• _{{ public: int num;}

• _{inline void fun(int & a,int & b)} • _{

• _{cout<<"a="<< a; }} • _};

Friend Function?

• _{What is a Friend Function?}

• _{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 another class.

• _{How to define and use Friend Function in C++:}

• _{The friend function is written as any other normal function, except the}

Friend Fun Example

• _{#include<iostream.h>} • _{class clsnam}

• _{

• _{friend void fun(int a,int b);} • _{public: int num;}

• _};

• _{void fun(int a,int b)} • _{

• _{cout<<"a="<< a;} • _}

• _{void main()} • _{

Structures

 _{Structures Revisited}

◦ _{Makes convenient to handle a group of logically related data}

items.

struct student //declaration {

char name[20]; int roll_number; float total_marks; };

struct student A;// C declaration student A; //C++ declaration A.roll_number=999;

A.total_marks=595.5;

Structures

• _Limitations

• _{C doesn’t allow it to be treated like built-in data types.}

struct complex{float x; float y;}; struct complex c1,c2,c3;

c3=c1+c2;//Illegal in C

Structures in C++

• _{Can hold variables and functions as members.}

• _{Can also declare some of its members as ‘private’.}

• _{C++ introduces another user-defined type known as}

Classes and Objects

 _{Class is a way to bind the data and procedures that}

operates on data.

 _{Class declaration:}

class class_name {

private:

variable declarations;//class function declarations;//members public:

Classes and Objects

• _{Class members that have been declared as private can}

be accessed only from within the class.

• _{Public class members can be accessed from outside the}

class also.

• _{Supports data-hiding and data encapsulation features of}

Classes and Objects

• _{Objects are run time instance of a class.}

• _{Class is a representation of the object, and Object is the}

actual run time entity which holds data and function that has been defined in the class.

• _{Object declaration:}

class_name obj1;

class_name obj2,obj3; class class_name

Classes and Objects

 _{Accessing class members}

◦ _{Object-name.function-name(actual-arguments);}

◦ _{obj1.setdata(100,34.4);}

 _{Defining Member Functions}

◦ _{Outside the class definition.}

return-type class-name::function-name (argument declaration)

{

Function body; }

◦ _{Inside the class definition.}

Classes and Objects

 _{Object as arrays}

class employee {

char name [30]; float age;

public:

void getdata(void); void putdata(void); };

employee manager[3];//array of manager employee worker[75];//array of worker

Friendly Function

• _{Friend function are used in the situation where two}

classes want to share a common function.

• _{Scientist and manager classes want to share the function}

incometax().

• _{C++ allows the common function to be made friendly with}

Friend Function Characteristics

• _{It is not in the scope of the class, hence it cannot be}

called using the object of any class. It can be invoked normally.

• _{It cannot access member names directly, but with the help}

of an object. Eg obj1.x

• _{It can be declare either in the public or the private part of}

a class without affecting its meaning.

Program: Friend Function

• _{Friend function sample:} • _{#include <iostream.h>}

//Declaration of the function to be made as friend for the C++ Tutorial sample int AddToFriend(int x);

class CPP_Tutorial {

int private_data;

friend int AddToFriend(int x); public:

CPP_Tutorial() {

private_data = 5; }

};

int AddToFriend(int x) {

CPP_Tutorial var1;

return var1.private_data + x; }

int main() {

cout << "Added Result for this C++ tutorial: "<< AddToFriend(4)<<endl; } The output of the above C++ Tutorial sample will be

Constructors and Destructors

• _{In order to behave like built-in data types, the derived-data}

types such as ‘objects’ should automatically initialize when created and destroys when goes out of scope.

• _{For this reason C++ introduces a special member}

Constructors

• _{Name is same as that of class.}

• _{Invoked when ever an object of its associated class is}

created.

class integer {

int m,n; public:

integer(void); ….

…. };

Constructors Characteristics

 _{Declared in the public section.}

 _{Invoked automatically when the objects are created.}  _{Do not have return type.}

 _{Cannot be inherited. Though a derived class can call the}

base class constructor.

 _{Can have default arguments.}  _{Cannot be virtual.}

 _{We cannot refer to their addresses.}

 _{An object with a constructor (or destructor) cannot be}

used as a member of a union.

 _{They make ‘implicit calls’ to the operators ‘new’ and}

Constructors

• _{Parameterized Constructors}

class integer {

int m,n; public:

integer(int x, int y); ….

…. };

integer :: integer(int x,int y){ m=x;n=y;} integer num1 = integer(0,100);//explicit call

Constructors

• _{Multiple Constructors}

class integer {

int m,n; public:

integer(void);

integer(int x, int y); ….

…. };

integer :: integer(void){ m=0;n=0;}

Constructors

• _{Dynamic initialization of Objects}

cin>> real>>imag;

Obj1=complex(real,imag);

• _{Copy Constructor.}

class integer {

int m,n; public:

integer(integer &i){m=i.m;n=i.n;}; ….

};

Destructors

• _{Is used to destroy the objects that have been created.}

~complex(){}

Operator Overloading

• _{C++ tries to make the user-defined data types behave in}

much the same way as the built-in data types.

• _{In built-in data types we have:}

• _{c=a+b//a,b and c are of type ‘int’.}

• _{We can also have in C++:}

• _{object1=object2+object3;}

• _{C++ has the ability to provide the operators with a special}

meaning for a data type. This mechanism is known as

Defining Operator Overloading

• _{return-type class-name::operator op (arglist)}

• _{Operator functions must be either member functions or}

friend functions.

• _{vector operator+(vector);}

• _{vector operator-();}

• _{friend vector operator+(vector,vector);}

• _{friend vector operator-(vector);}

• _{int operator==(vector);}

An Example: Operator Overloading

with Friend Function

friend void operator-(space &s);

void operator-(space &s) {

Overloading Binary Operators

• _{a, b and c are objects of class ‘complex’}

• _{c=a.sum(b);//functional notation, function}

‘sum’ is member function.

• _{c=sum(a,b);//functional notation, function}

‘sum’ is friend function.

• _{c=a+b; // arithmetic notation, can be}

Overloading Binary Operators

• _{Using member functions}

complex complex::operator+(complex c) {

Overloading Binary Operators

• _{Using friend function.}

friend complex operator+(complex, complex); //declaration

Inheritance

 _{C++ strongly support the concept of reusability.}  _{C++ classes can be reused in several ways.}

 _{Creating new classes by reusing the properties of}

existing once.

 _{The reuse of a class that has already been tested,}

debugged and used many times can save us the effort of developing and testing the same again.

 _{Mechanism is Inheritance.}

Defining Derived Class

class derived-class-name : visibility-mode base-class-name {………};

• _{Visibility mode is optional.(by default: private)}

• _{Visibility mode specifies whether the features of the base}

An Example: Single Inheritance,

Private Derivation

d.get_ab(); d.get_a(); d.show();

Will not work.

void mul() void display()

{ {

get_ab(); show_a();

c=b*get_a(); cout<<“b=“<<b<<“\n”

} <<“c=”<<“\n\n”;

Inheritance: Private, Protected and

Public

 _{Inside the class.} class alpha {

private://optional

…………//visible inside this class only

protected://visible inside this class …………//and its immediate derived class

public://visible to all …………

Inheritance: Different types

• _{Multilevel Inheritance}

class A{…};

Class B : public A{…}; Class C : public B{…};

• _{Multiple Inheritance}