Gaurav Saxena VECC

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

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

Keywords Identifiers Constants Strings Operators

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.

C++ Data Types

User-defined type
structure union class enumeration

Built-in type

Derived type
array function pointer reference

Integral type

Void

Floating type

int

char

float

double

Type char

Bytes 1

Range -128 to 127 signed: -128 to 127 unsigned: 0 to 255 -31768 to 32767 signed: -32768 to 32767 unsigned: 0 to 65535 -32768 to 32767 signed: -31768 to 32767 unsigned: 0 to 65535 -2147483648 to 2147483647 signed: -2147483648 to 2147483647 unsigned: 0 to 4294967295 3.4E-38 to 3.4E+38 1.7E-308 to 1.7E+308 3.4E-4932 to 1.1E+4932

short int

int

long int

float double long double

4 8 10

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

Enumerated Data Type

Basis for OOP. Classes enable to combine data and procedures.

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

Keywords Identifiers Constants Strings Operators

Refer to fixed values that do not change in thw execution of the program.
123 12.34 037 0x2 C++ A Lab //decimal integer //floating point integer //octal integer //Hexa decimal //string constant //character constant //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};

Keywords Identifiers Constants Strings Operators

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

Keywords Identifiers Constants Strings Operators

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
void swap (int &a, int &b) { int t=a; a=b; b=t; } swap(m,n);

Pointers
void swap(int *a, int *b) { int t; t=*a; *a=*b; *b=t; } 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 doesnt 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

Defining Member Functions
Object-name.function-name(actual-arguments); obj1.setdata(100,34.4);

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

be used as a function

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() { get_ab(); c=b*get_a(); }

void display() { show_a(); cout<<b=<<b<<\n <<c=<<\n\n; }

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{};