ZeePedia Add to Favourites   |   Contact us


Introduction to Programming

<<< Previous Assignment Operator, Self Assignmentm, Pointer, Conversions Next >>>
 
img
CS201 ­ Introduction to Programming
Lecture Handout
Introduction to Programming
Lecture No. 33
Reading Material
Deitel & Deitel - C++ How to Program
Chapter. 7, 8
7.5, 8.1, 8.2, 8.7, 8.9
Summary
22)
Operator Overloading
23)
Assignment Operator
24)
Example
25)
this Pointer
26)
Self Assignment
27)
Returning this Pointer from a Function
28)
Conversions
29)
Sample Program (conversion by constructor)
Operator Overloading
As earlier discussed, overloading of operators is carried out in classes on some occasions
to enable ourselves to write a code that looks simple and clean. Suppose, there is a class
and its two objects, say a and b, have been defined. Addition of these objects in the class
by writing a + b will mean that we are adding two different objects (objects are instance
of a class which is a user defined data type). We want our code to be simple and elegant.
In object base programming, more effort is made in class definitions, as classes are data
types that know how to manipulate themselves. These know how to add objects of their
own type together, how to display themselves and do many other manipulations. While
discussing date class in the previous lecture, we referred to many examples. In an
example, we tried to increment the `date'. The best way is to encapsulate it in the class
itself and not in the main program when we come around to use the date class.
Assignment Operator
At first, we ascertain whether there is need of an assignment operator or not? It is needed
when we are going to assign one object to the other, that means when we want to have
Page 417
img
CS201 ­ Introduction to Programming
expression like a = b. C++ provides a default assignment operator. This operator does a
member-wise assignment. Let's say, we have in a structure of a class three integers and
two floats as data members. Now we take two objects of this class a and b and write a =
b. Here the first integer of a will have the value of first integer of b. The second will have
the value of second integer and so on. This means that it is a member-wise copy. The
default assignment operator does this. But what is to do if we want to do something more,
in some special cases?
Now let's define a String class. We will define it our self, without taking the built in
String class of C. We know that a string is nothing but an array of characters. So we
define our String class, with a data member buffer, it is a pointer to character and is
written as *buf i.e. a pointer to character (array). There are constructors and destructors of
the class. There is a member function length that returns the length of the string of the
calling object. Now we want an assignment operator for this class. Suppose we have a
constructor that allows placing a string into the buffer. It can be written in the main
program as under:
String s1 ( "This is a test" ) ;
Thus, an object of String has been created and initialized. The string "This is a test" has
been placed in its buffer. Obviously, the buffer will be large enough to hold this string as
defined in our constructor. We allocate the memory for the buffer by using new operator.
What happens if we have another String object, let's say s2, and want to write s2 = s1 ;
Here we know that the buffer is nothing but a pointer to a memory location. If it is an
array of characters, the name of the array is nothing but a pointer to the start of the
memory location. If default assignment operator is used here, the value of one pointer i.e.
buf of one object will be assigned to buf of the other object. It means there will be the
same address in the both objects. Suppose we delete the object s1, the destructor of this
object will free the allocated memory while giving it back to the free store. Now the buf
of s2 holds the address of memory, which actually has gone to free store, (by the
destructor of s1). It is no longer allocated, and thus creates a problem. Such problems are
faced often while using default assignment operator. To avoid such problems, we have to
write our own assignment operator.
Before going on into the string assignment operator, let's have a look on the addition
operator, which we have defined for strings. There is a point in it to discuss. When we
defined addition operator for strings, we talked about that what we have to do if we want
to add (concatenate) a string into the other string. There we had a simple structure i.e.
there is a string defined char buf with a space of 30 characters. If we have two string
objects and the strings are full in the both objects. Then how these will be added? Now
suppose for the moment that we are not doing memory allocation. We have a fixed string
buffer in the memory. It is important that the addition operator should perform an error
check. It should take length of first string , then the length of second string, before adding
them up, and check whether it is greater than the length defined in the String (i.e. 30 in
this case). If it is greater than that, we should provide it some logical behavior. If it is not
Page 418
img
CS201 ­ Introduction to Programming
greater, then it should add the strings. Thus, it is important that we should do proper error
checking.
Now in the assignment operator, the problem here is that the buf, that we have defined,
should not point to the same memory location in two different objects of type String.
Each object should have its own space and value in the memory for its string. So when
we write a statement like s2 = s1, we want to make sure that at assignment time, the
addresses should not be assigned. But there should be proper space and the strings should
be copied there. Let's see how we can do this.
Now take a look on the code itself. It is quiet straight forward what we want to do is that
we are defining an assignment operator (i.e. =) for the String class. Remember that the
object on left side will call the = operator. If we write a statement like s2 = s1; s2 will be
the calling object and s1 will be passed to the = operator as an argument. So the data
structure of s2 i.e. buf is available without specifying any prefix. We have to access the
buf of s1 by writing s1.buf.
Suppose s2 has already a value. It means that if s2 has a value, its buffer has allocated
some space in the memory. Moreover, there is a character string in it. So to make an
assignment first empty that memory of s2 as we want to write something in that memory.
We do not know whether the value, we are going to write, is less or greater than the
already existing one. So the first statement is:
delete buf ;
Here we write buf without any prefix as it is buf of the calling object. Now this buffer is
free and needs new space. This space should be large enough so that it can hold the string
of s1. First we find the length of the string of s1 and then we use the new operator and
give it a value that is one more than the length of the buffer of s1. So we write it as:
buf = new char[length + 1] ;
where length is the length of s1. Here buf is without a prefix so it is the buf of object on
the left hand side i.e. s2. Now, when the buf of s2 has a valid memory address, we copy
the buf of s1 into the buf of s2 with the use of string copy function (strcpy). We write it
as:
strcpy ( buf, s1.buf ) ;.
Now the buf of string of s1 has been copied in the buf of s2 that are located at different
spaces in the memory. The advantage of it is that now if we delete one object s1 or s2, it
will not affect the other one. The complete code of this example is given below.
Example
/*This program defines the assignment operator. We copy the string of one object
Page 419
img
CS201 ­ Introduction to Programming
into the string of other object using different spaces for both strings in the memory.
*/
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
// class definition
class String
{
private :
char *buf ;
public:
// constructors
String();
String( const char *s )
{
buf = new char [ 30 ];
strcpy (buf,s);
}
// display the string
void display ( )
{
cout << buf << endl ;
}
// getting the length of the string
int length ()const
{
return strlen(buf);
}
// overloading assignment operator
void operator = ( const String &other );
};
// ----------- Assignment operator
void String::operator = ( const String &other )
{
int length ;
length = other.length();
delete buf;
buf = new char [length + 1];
strcpy( buf, other.buf );
}
//the main program that uses the new String class with its assignment operator:
main()
{
Page 420
img
CS201 ­ Introduction to Programming
String myString( "here's my string" );
cout << "My string is = " ;
myString.display();
cout << '\n';
String yourString( "here's your string" );
cout << "Your string is = " ;
yourString.display();
cout << '\n';
yourString = myString;
cout << "After assignment, your string is = " ;
yourString.display();
cout << '\n';
system ("pause");
}
Following is the output of the program.
My string is = here's my string
Your string is = here's your string
After assignment, your string is = here's my string
The above example is regarding the strings. Yet in general, this example pertains to all
classes in which we do memory manipulations. Whenever we use objects that allocate
memory, it is important that an assignment operator (=) should be defined for it.
Otherwise, the default operator will copy the values of addresses and pointers. The actual
values and memory allocation will not be done by it.
Let's go on and look what happens when we actually do this assignment? In the
assignment of integers, say we have three integers i, j and k with some values. It is quiet
legal to write as i = j ; By this ,we assign the value of j to i. After this we write k = i ; this
assigns the value of i to k. In C, we can write the above two assignment statements in one
line as follows
k=i=j;
This line means first the value of j is assigned to i and that value of i is assigned to k.
The mechanism that makes this work is that in C or C++ every expression itself has a
value. This value allows these chained assignment statements to work. For example,
when we write k = i = j ; then at first i = j is executed. The value at the left hand side of
this assignment statement is the value of the expression that is returned to the part `k ='
.This value is later assigned to k. Now take another example. Suppose we have the
following statement:
Page 421
img
CS201 ­ Introduction to Programming
k = i = ++j ;
In this statement, we use the pre-increment operator, as the increment operator (++) is
written before j. This pre-increment operator will increment the value of j by 1 and this
new value will be assigned to i. It is pertinent to note that this way ++j returns a value
that is used in the statement. After this, the value of i is assigned to k. For integers, it is
ok. Now, how can we make this mechanism work with our String objects. We have three
String objects s1, s2 and s3. Let's say there is a value (a string ) in the buffer of s1. How
can we write s3 = s2 = s1;. We have written s2 = s1 in the previous example in
assignment operator. We notice that there is no return statement in the code of the
assignment operator. It means that operator actually returns nothing as it has a void return
type. If this function is not returning any thing then s3 = s2 = s1 ; cannot work. We make
this work with the help of this pointer.
this Pointer
Whenever an object calls a member function, the function implicitly gets a pointer from
the calling object. That pointer is known as this pointer. `this' is a key word. We cannot
use it as a variable name. `this' pointer is present in the function, referring to the calling
object. For example, if we have to refer a member, let's say buf, of our String class, we
can write it simply as:
buf ;
That means the buf of calling object is being considered. We can also write it as
this->buf ;
i.e. the data member of the object pointed by this pointer is being called. These ( buf and
this->buf ) are exactly the same. We can also write it in a third way as:
(*this).buf ;.
So these three statements are exactly equivalent. Normally we do not use the statements
written with this key word. We write simply buf to refer to the calling object.
In the statement (*this).buf ; The parentheses are necessary as we know that in object.buf
the binding of dot operator is stronger than the *. Without parentheses the object.buf is
resolved first and is dereferenced. So to dereference this pointer to get the object, we
enforced it by putting it in parentheses.
Self Assignment
Suppose, we have an integer `i. In the program, somewhere, we write i = i ; It's a do
nothing line which does nothing. It is not an error too. Now think about the String object,
we have a string s that has initialized to a string, say, `This is a test'. And then we write s
= s ; The behavior of equal operator that we have defined for the String object is that it, at
first deletes the buffer of the calling object. While writing s = s ; the assignment operator
Page 422
img
CS201 ­ Introduction to Programming
frees the buffer of s. Later, it tries to take the buffer of the object on right hand side,
which already has been deleted and trying to allocate space and assign it to s. This is
known as self-assignment. Normally, self -assignment is not directly used in the
programs. But sometimes, it is needed. Suppose we have the address of an object in a
pointer. We write:
String s, *sptr ;
Now sptr is a pointer to a String while s is a String object. In the code of a program we
can write
sptr = &s ;
This statement assigns the address of s to the pointer sptr. Now some where in the
program we write s = *sptr ; that means we assign to s the object being pointed by sptr.
As sptr has the address of s , earlier assigned to it. This has the same effect as s = s ;. The
buffer of s will be deleted and the assignment will not be done. Thus, the program will
become unpredictable. So self-assignment is very dangerous especially at a time when we
have memory manipulation in a class. The String class is a classic example of it in which
we do memory allocation. To avoid this, in the equal operator (operator=), we should first
check whether the calling object (L.H.S.) and the object being gotten (R.H.S.) are the
same or not. So we can write the equal operator (operator=) as follows
void String::operator=( const String &other )
{
if( this == &other )
return;
delete buf;
length = other.length;
buf = new char[length + 1];
strcpy( buf, other.buf );
}
Here above, the statement if ( this == &other) checks that if the calling object (which is
referred by this) is the same as the object being called then do nothing and return as in
this case it is a self assignment. By doing this little change in our assignment operator, it
has become safe to use. So it is the first usage of this pointer that is a check against self
assignment.
Page 423
img
CS201 ­ Introduction to Programming
Returning this Pointer From a Function
Now lets look at the second use of this pointer. We want to do the assignment as
s3 = s2 = s1 ;
In this statement the value of s2 = s1 is assigned to s3. So to do this it is necessary that
the assignment operator should return a value. Thus, our assignment operator will expand
so that it could return a value. The assignment operator, till by now copies the string on
right hand side to the left hand side. This means s2 = s1 ; can be done by this. Now we
want that this s2 should be assigned to s3, which can be done only if s2 = s1 returns s2
(an object). So we need to return a String object. Here becomes the use of this pointer, we
will write as
return *this ;
Here, in the assignment operator code this is referring to the calling object (i.e. s2 in this
case). So when we write return *this ; it means return the calling object ( object on
L.H.S.) as a value. Thus s3 gets the value of s2 by executing s3 = s2 where s2 is the
value returned by the assignment operator by s2 = s1; Thus the complete assignment
operator (i.e. operator= function) that returns a reference to an object will be written as
under
String &String::operator=( const String &other )
{
if( &other == this )  //if calling and passed objects are
return *this;
// same then do nothing and
return
delete buf;
Page 424
img
CS201 ­ Introduction to Programming
length = other.length;
buf = new char[length + 1];
strcpy( buf, other.buf );
return *this;
}
Now, here the first line shows that this operator= function returns a reference to an
object of type String and this function takes a reference as an argument. The above
version of operator= function takes a reference as an argument. First of all it checks it
with the calling object to avoid self assignment. Then it deletes the buffer of calling
object and creates a new buffer large enough to hold the argument object. And then at the
last it returns the reference of the calling object by using this pointer.
With this version of the assignment operator ( operator= function) we can chain together
assignments of String objects like s3 = s2 = s1 ;
Actually, we have been using this pointer in chained statements of cout. For example, we
write
cout << a << b << c ;
Where a, b, and c are any data type. It works in the way that the stream of cout i.e. << is
left associative. It means first cout << a is executed and to further execute it, the second
<< should have cout on its left hand side. So here, in a way, in this operator overloading,
a reference to the calling object that is cout is being returned to the stream insertion <<.
Thus a reference of cout is returned, and (as a reference to cout is returned) the << sees a
cout on left hand side and thus the next << b is executed and it returns a reference to cout
and with this reference the next << c works. This all work is carried out by this pointer.
We have seen that value can be returned from a function with this pointer. We used it
with assignment operator. Lets consider our previous example of Date class. In that class
we defined increment operator, plus operator, plus equal operator, minus operator and
minus equal operator. Suppose we have Date objects d1, d2 and d3. When we write like
d2 = d1++ ; or d2 = d1 + 1 ; here we realize that the + operator and the ++ operator
should return a value. Similarly, other operators should also return a value. Now let's
consider the code of Date class. Now we have rewritten these operators. The difference in
code of these is not more than that now it returns a reference to an object of type Date.
There are two changes in the previous code. First is in the declaration line where we now
use & sign for the reference and we write it like
Date& Date::operator+=(int days)
We write this for the all operators (i.e. +, ++, - and -=). Then in the function definition we
return the reference of the left hand side Date object ( i.e. calling object) by writing
return *this ;
Now we can rewrite the operator+= of the Date class as follows.
The declaration line in the class definition will be as
Page 425
img
CS201 ­ Introduction to Programming
Date& operator+=(int days);
And the function definition will be rewritten as the following.
Date& Date::operator+=(int days)
// return type reference to
object
{
for (int i=0; i < days; i++)
*this++;
return *this;  // return reference to object
}
This concludes that whenever we are writing arithmetic operator and want that it can be
used in chained statements (compound statements) then we have to return a value. The
easiest and most convenient way of returning that value is by returning a reference to the
calling object. So, by now we can easily write the statements of date object, just like we
write for integers or floats. We can write
date2 = date1 + 1 ;
Or
date2 = date1++ ;
and so on.
Conversions
Being in the C language, suppose we have an integer i and a float x. Now in the program
we write x = i ; As we know that the operations of int and float are different in the
memory. Therefore, we need to do some kind of conversion. The language automatically
converts i (int) to a float (or to whatever type is on the L.H.S.) and then does the
assignment.
Both C and C++ have a set of rules for converting one type to another. These rules are
used in the following situations
-
When assigning a value. For example, if you assign an integer to a variable of
type  long, the compiler converts the integer to a long.
-
When performing an arithmetic operation. For example, if you add an integer and
a
floating-point value, the compiler converts the integer to a float before it performs
the
addition.
-
When passing an argument to a function; for example, if you pass an integer to a
function that expects a long.
-
When returning a value from a function; for example, if you return a float from a
function that has double as its return type.
In all of these situations, the compiler performs the conversion implicitly. We can make
the conversion explicit by using a cast expression.
Page 426
img
CS201 ­ Introduction to Programming
Now the question arises that can we do conversion with objects of our own classes. The
answer is yes. If we go to the basic definition of a class it is nothing but a user defined
data type. As it is a user defined data type, we can also define conversion on it. When we
define a class in C++, we can specify the conversions that the compiler can apply when
we use instances of that class. We can define conversions between classes, or between a
class and a built-in type
There is an example of it. Suppose we have stored date in a serial number form. So now it
is not in the form of day, month and year but it is now a long integer. For example if we
start from January 1, 1900 then 111900 will be the day one, second January will be the
day 2, third January will be the day 3 and so on. Going on this way we reached in year
2000. There will be a serial number in year 2000. This will be a single long integer that
represents the number of days since a particular date. Now if we have a Date object
called d and an integer i. We can write d = i ; which means we want that i should go in
the serial part of d. This means convert the integer i into date object and then the value of
i should go into the serial number and then that object should be assigned to d. We can
make this conversion of Date object. We do this in the constructor of the class. We pass
the integer to the constructor, here convert it into a date, and the constructor then returns
a Date object. On the other hand, if there is no constructor then we can write conversion
function. We have used the conversion operator with cast. The way of casting is that we
write the name of the cast (type to which we want to convert) before the name of
variable. Thus if we have to write x = i ; where x is a float and i is an integer then we
write it with conversion function as x = (float) i ; The (float) will be the conversion
operator. Normally this conversion is done by default but sometimes we have to force it.
Now we want to write a conversion operator, which converts an integer to a Date object.
(here Date is not our old class, it's a new one). We can write a conversion function. This
function will be a member of the Date class. This function will return nothing, as it is a
conversion function. The syntax of this function will be Date () that means now this is a
conversion function.
In the body of this function we can write code of our own. Thus we can define the
operator, and it will work like that we write within the parentheses the name of the
conversion operator. The conversion functions are quiet interesting. They allow us to
manipulate objects of different classes. For example, we have two classes one is a truck
and other is a car. We want to convert the car to a truck. Here we can write a conversion
function, which says take a car convert it into a truck and then assign it to an object of
class truck.
Sample Program (conversion by constructor)
Lets take a look at an example in which the conversion functions are being used. There is
a class Fraction. Lets talk why we called it Fraction class. Suppose we have an
assignment
double x = 1/3 ;
Page 427
img
CS201 ­ Introduction to Programming
When we store 1/3 in the computer memory, it will be stored as a double precision
number. There is a double precision division of 1 by 3 and the answer 0.33333... is
stored. Here the number of 3s depends upon the space in the memory for a double
precision number. That value is assigned to a double variable. What happens if we
multiply that double variable by 3, that means we write 3 * x; where x was equal to 1/3
(0.33333...). The answer will be 0.99999..., whatever the number of digits was. The
problem here is that the answer of 3 * 1 / 3 is 1 and not 0.99999. This problem occurs,
when we want to represent the numbers exactly. The fraction class is the class in which
we provide numerator and denominator to the object and it stores them separately. It will
always keep them as an integer numerator and an integer denominator and we can do all
kinds of arithmetic with it. Now if 1 and 3 are stored separately as numerator and
denominator, how we can add them to some other fraction. We have enough tools at our
disposal. One of which is that we can overload the addition operator. We can add 1/3 and
2/5, the result of which is another fraction i.e. numerator and denominator. In this way we
have no worries of round off errors, the truncation and conversions of int and floats.
Considering the Fraction class we can think of a constructor which takes an integer and
converts it into a fraction. We do not want that as a fraction there should be some value
divided by zero. So we define the default constructor that takes two integers, one for
numerator and one for denominator. We provide a default value for the denominator that
is 1. It means that now we can construct a fraction by passing it a single integer, in which
case it will be represented as a fraction with the passed integer as a numerator and the
default vale i.e. 1 as the denominator. If we have a fraction object f and we write f = 3;
Then automatically this constructor (i.e. we defined) will be called which takes a single
integer as an argument. An object of type fraction will be created and the assignment will
be carried out. In a way, this is nothing more than a conversion operation. That is a
conversion of an integer into a fraction. Thus a constructor that takes only one parameter
is considered a conversion function; it specifies a conversion from the type of the
parameter to the type of the class.
So we can write a conversion function or we can use a constructor of single argument for
conversion operation. We cannot use both, we have to write one or the other. Be careful
about this. We don't use conversion functions often but sometimes it is useful to write
them. The conversion operators are useful for defining an implicit conversion from the
class to a class whose source code we don't have access to. For example, if we want a
conversion from our class to a class that resides within a library, we cannot define a
single-argument constructor for that class. Instead, we must use a conversion operator.
It makes our code easier and cleaner to maintain. It is important that pay more attention
while defining a class. A well-defined class will make their use easy in the programming.
Following is the code of the example stated above.
/* This program defines a class Fraction which stores numerator and
denominator of a fractional number separately. It also overloads the
addition operator for adding the fractional numbers so that exact results
can be obtained.
Page 428
img
CS201 ­ Introduction to Programming
*/
#include <stdlib.h>
#include <math.h>
#include <iostream.h>
// class definition
class Fraction
{
public:
Fraction();
Fraction( long num, long den );
void display() const;
Fraction operator+( const Fraction &second ) const;
private:
static long gcf( long first, long second );
long numerator, denominator;
};
// ----------- Default constructor
Fraction::Fraction()
{
numerator = 0;
denominator = 1;
}
// ----------- Constructor
Fraction::Fraction( long num, long den )
{
int factor;
if( den == 0 )
den = 1;
numerator = num;
denominator = den;
if( den < 0 )
{
numerator = -numerator;
denominator = -denominator;
}
factor = gcf( num, den );
if( factor > 1 )
{
numerator /= factor;
denominator /= factor;
}
}
// ----------- Function to print a Fraction
Page 429
img
CS201 ­ Introduction to Programming
void Fraction::display() const
{
cout << numerator << '/' << denominator;
}
// ----------- Overloaded + operator
Fraction Fraction::operator+( const Fraction &second ) const
{
long factor, mult1, mult2;
factor = gcf( denominator, second.denominator );
mult1 = denominator / factor;
mult2 = second.denominator / factor;
return Fraction( numerator * mult2 + second.numerator * mult1,
denominator * mult2 );
}
// ----------- Greatest common factor
// computed using iterative version of Euclid's algorithm
long Fraction::gcf( long first, long second )
{
int temp;
first = labs( first );
second = labs( second );
while( second > 0 )
{
temp = first % second;
first = second;
second = temp;
}
return first;
}
//main program
void main()
{
Fraction a, b( 23, 11 ), c( 2, 3 );
a = b + c;
a.display();
cout << '\n';
system("pause");
}
The output of the program is as follows
91/33
Page 430
img
CS201 ­ Introduction to Programming
Here is an example from the real world. What happens if we are dealing with currency?
The banks deal with currency by using computer programs. These programs maintain the
accounts by keeping the track of transactions and manipulating deposits and with drawls
of money. Suppose the bank declares that this year the profit ratio is 3.76 %. Now if the
program calculates the profit as 3.67 % of the balance, will it be exactly in rupees and
paisas or in dollars and cents? Normally, all the currencies have two decimal digits after
decimal point. Whenever we apply some kind of rates in percentage the result may
become in three or four decimal places. The banks cannot afford that the result of 90
paisas added to 9 rupees and 10 paisas become 10 rupees and 1 paisa. They have to
accurate arithmetic. So they do not rely on programs that use something like double
precisions to represent currencies. They would have rather written in the program to treat
it as a string. Thus 9 is a string, 10 is a string and the program should define string
addition such that the result of addition of the strings .10 and .90 should be 1.00. Thus,
there are many things that happen in real world that force us as the programmer to
program the things differently. So we do not use native data types.
The COBOL, COmmon Business Oriented Language has a facility that we can represent
the decimal numbers exactly. Internally it (the language) keeps them as strings in the
memory. There is no artificial computer representation of numbers. Now a day, the
languages provide us the facility by which we can define a data type according to a
specific requirement, as we defined fraction to store numerator and denominator
separately. By using this fraction data type, we never loose precision in arithmetic. The
same thing applies to the object like currency, where we can store the whole number part
and the fractional part both as separate integers and never loose accuracy. But whenever
we get into these classes, it is our responsibility to start writing all of the operators that
are required to make a complete class.
Page 431
Table of Contents:
  1. What is programming
  2. System Software, Application Software, C language
  3. C language: Variables, Data Types, Arithmetic Operators, Precedence of Operators
  4. C++: Examples of Expressions, Use of Operators
  5. Flow Charting, if/else structure, Logical Operators
  6. Repetition Structure (Loop), Overflow Condition, Infinite Loop, Properties of While loop, Flow Chart
  7. Do-While Statement, for Statement, Increment/decrement Operators
  8. Switch Statement, Break Statement, Continue Statement, Rules for structured Programming/Flow Charting
  9. Functions in C: Structure of a Function, Declaration and Definition of a Function
  10. Header Files, Scope of Identifiers, Functions, Call by Value, Call by Reference
  11. Arrays: Initialization of Arrays, Copying Arrays, Linear Search
  12. Character Arrays: Arrays Comparisonm, Sorting Arrays Searching arrays, Functions arrays, Multidimensional Arrays
  13. Array Manipulation, Real World Problem and Design Recipe
  14. Pointers: Declaration of Pointers, Bubble Sort Example, Pointers and Call By Reference
  15. Introduction, Relationship between Pointers and Arrays, Pointer Expressions and Arithmetic, Pointers Comparison, Pointer, String and Arrays
  16. Multi-dimensional Arrays, Pointers to Pointers, Command-line Arguments
  17. String Handling, String Manipulation Functions, Character Handling Functions, String Conversion Functions
  18. Files: Text File Handling, Output File Handling
  19. Sequential Access Files, Random Access Files, Setting the Position in a File, seekg() and tellg() Functions
  20. Structures, Declaration of a Structure, Initializing Structures, Functions and structures, Arrays of structures, sizeof operator
  21. Bit Manipulation Operators, AND Operator, OR Operator, Exclusive OR Operator, NOT Operator Bit Flags Masking Unsigned Integers
  22. Bitwise Manipulation and Assignment Operator, Programming Constructs
  23. Pre-processor, include directive, define directive, Other Preprocessor Directives, Macros
  24. Dynamic Memory Allocation, calloc, malloc, realloc Function, Dangling Pointers
  25. History of C/C++, Structured Programming, Default Function Arguments
  26. Classes and Objects, Structure of a class, Constructor
  27. Classes And Objects, Types of Constructors, Utility Functions, Destructors
  28. Memory Allocation in C++, Operator and Classes, Structures, Function in C++,
  29. Declaration of Friend Functions, Friend Classes
  30. Difference Between References and Pointers, Dangling References
  31. Operator Overloading, Non-member Operator Functions
  32. Overloading Minus Operator, Operators with Date Class, Unary Operators
  33. Assignment Operator, Self Assignmentm, Pointer, Conversions
  34. Dynamic Arrays of Objects, Overloading new and delete Operators
  35. Source and Destination of streams, Formatted Input and Output, Buffered Input/Output
  36. Stream Manipulations, Manipulators, Non Parameterized Manipulators, Formatting Manipulation
  37. Overloading Insertion and Extraction Operators
  38. User Defined Manipulator, Static keyword, Static Objects
  39. Pointers, References, Call by Value, Call by Reference, Dynamic Memory Allocation
  40. Advantages of Objects as Class Members, Structures as Class Members
  41. Overloading Template Functions, Template Functions and Objects
  42. Class Templates and Nontype Parameters, Templates and Static Members
  43. Matrices, Design Recipe, Problem Analysis, Design Issues and Class Interface
  44. Matrix Constructor, Matrix Class, Utility Functions of Matrix, Input, Transpose Function
  45. Operator Functions: Assignment, Addition, Plus-equal, Overloaded Plus, Minus, Multiplication, Insertion and Extraction