C++ tutorials

 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
programs with clarity, extensibility and ease of
maintenance, incorporating the spirit and efficiency of
C.

/* Simple hello world program*/
# include <iostream>// This is include directive
using namespace std;
int main()
{
cout << “Hello World!”; //C++ statement
return 0;
}

 Average of numbers.
◦ It will take two numbers from the console and print the
average of the two numbers.

 Keywords
 Identifiers
 Constants
 Strings
 Operators

 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, unsigned, using, virtual, void,
volatile, wchar_t, while

 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.
◦ A declared keyword cannot be used as a variable.

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
long int 4 -2147483648 to 2147483647
signed: -2147483648 to 2147483647
float 4 3.4E-38 to 3.4E+38
double 8 1.7E-308 to 1.7E+308
long double 10 3.4E-4932 to 1.1E+4932

 This program will take different values from
console and perform various mathematical
operation on these values and print the result to
the console.

 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.
enum shape {circle, square, triangle};
enum colour {red, blue=4, green=8};

 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.
◦ Concept of constant pointer introduced in c++.

 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
◦ L’ab’ //wide-character constant

 Using the qualifier const
◦ const float pi = 3.14;
 Using enum
◦ enum{x,y,z};
◦ enum{x=200,y=300,z=400};
◦ enum{off,on};

 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 ()
{
string mystring = "This is a string";
cout << mystring;
return 0;
}

 Constant expressions
 Integral expressions
 Float expressions
 Pointer expressions
 Relational expressions
 Logical expressions
 Bitwise expressions

 The if statement
Simple if statement if…..else statement
if(expression)
{
statement 1;
}
statement 2;
statement 3;
if(expression)
{
statement 1;
}
else
{
statement 2;
}
statement 3;

 The switch statement
switch(expression)
{
case 1:
statement1;
break|continue;
case 2:
statement2;
continue|break;
.
.
.
default:
statement3;
}
statement4;

 The do-while statement
do
{
statement1;
}
while(condition);
statement2;

 The while statement
while(condition)
{
statement1;
}
statement2;

 The for statement
for (intialization;condition;increment)
{
statement1;
}
statement2;

 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.
 It can be overloaded.

 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
◦ function-name(argument-list);
◦ volume(a,b,c);

 The main function
 Returns a value of type int to the operating
system.
int main()
{
………
………
return(0);
}

 This program will take the values of length,
breadth and height and prints the volume of the
cube. It uses the function to calculate it.

 Parameter Passing
◦ Pass by value
◦ Pass by reference
Reference variable Pointers
void swap (int &a, int &b)
{
int t=a;
a=b;
b=t;
}
void swap(int *a, int *b)
{
int t;
t=*a;
*a=*b;
*b=t;
}
swap(m,n); swap(&m,&n);

 Parameter passing
◦ Return by reference
int & max (int &x, int &x)
{
if(x>y)
return x;
else
return y;
}
max(a,b)=-1;

 C++ allows to use the same function name to
create functions that perform a variety of different
tasks.
 This is know as function polymorphism in OOP.
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
add(5,10);//uses prototype 1
add(15,10.0);//uses prototype 4
add(12.5,7.5); //uses prototype 3
add(5,10,15); //uses prototype 2
add(0.75,5); //uses prototype5

 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;
Final_Total=A.total_marks + 5;

 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
◦ They do not permit data hiding.

 Can hold variables and functions as members.
 Can also declare some of its members as
‘private’.
 C++ introduces another user-defined type known
as ‘class’ to incorporate all these extensions.

 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:
variable declarations;//class
function declarations;//members
};//Terminates with a semicolon

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

 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
{……}obj1,obj2,obj3;

 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.
Same as normal function declaration.

 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
Manager[i].putdata();

 This program will create an array, takes the values
for each of the element and displays it.

 An object may be used as a function arguments.

 This program creates a ‘time’ class in hour and
minute format. There is a function called ‘sum’
performs the addition of time of two object and
assign it to the object that has called the 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 both the classes, thereby allowing the
access to the private data of these classes. This
function need not to be the member function of
any of these classes.

 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.
 Usually, it has the objects as arguments.

 This program declares a function ‘max’ as friend
to two classes and demonstrate how to use them.

 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
functions called constructor and destructor to
automatically initialize and destroy the objects.

 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);
….
….
};
integer :: integer(void){ m=0;n=0;}

 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
‘delete’ when memory allocation is required.

 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
int num1(0,100);//implicit call

 Multiple Constructors
class integer
{
int m,n;
public:
integer(void);
integer(int x, int y);
….
….
};
integer :: integer(void){ m=0;n=0;}
integer :: integer(int x,int y){ m=x;n=y;}

 Program demonstrate the use of 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;};
….
};
integer num1(num2);

 Is used to destroy the objects that have been
created.
~complex(){}
 Never takes any arguments nor does return any
value.

 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 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);
◦ friend int operator==(vector,vector);

friend void operator-(space &s);
void operator-(space &s)
{
s.x=-s.x;
s.y=-s.y;
s.x=-s.z;
}

 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
defined in both the ways (member
function and friend function).

 Using member functions
complex complex::operator+(complex c)
{
complex temp;
temp.x=x+c.x;
temp.y=y+c.y;
return(temp);
}

 Using friend function.
friend complex operator+(complex, complex);
//declaration
complex operator+(complex a, complex b)
{return complex ((a.x+b.x),(a.y+b.y));}
//defination

 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.
 Base class ---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 class are privately derived or publicly
derived.

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=”<<“nn”;
}

 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
…………
};

 Multilevel Inheritance
class A{…};
Class B : public A{…};
Class C : public B{…};
 Multiple Inheritance
class P : public M, public N{…};

C++ tutorials

Recommended

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to C++ tutorials (20)

Recently uploaded (20)

C++ tutorials