OPPS with C++

1UNIT -1 Basic concepts of OOPS and Structure of C++ program In this tutorial you will learn about Objects, Classes, Inheritance, Data Abstraction, Data Encapsulation, Polymorphism, Overloading, Reusability. Before starting to learn C++ it is essential that one must have a basic knowledge of the concepts of Object oriented programming. Some of the important object oriented features are namely: In order to understand the basic concepts in C++, the programmer must have a command of the basic terminology in object-oriented programming. Below is a brief outline of the concepts of Object-oriented programming languages: Objects: Object is the basic unit of object-oriented programming. Objects are identified by its unique name. An object represents a particular instance of a class. There can be more than one instance of an object. Each instance of an object can hold its own relevant data. An Object is a collection of data members and associated member functions also known as methods. 2 Classes: Classes are data types based on which objects are created. Objects with similar properties and methods are grouped together to form a Class. Thus a Class represent a set of individual objects. Characteristics of an object are represented in a class as Properties. The actions that can be performed by objects becomes functions of the class and is referred to as Methods. For example consider we have a Class of Cars under which Santro Xing, Alto and WaganR represents individual Objects. In this context each Car Object will have its own, Model, Year of Manufacture, Colour, Top Speed, Engine Power etc., which form Properties of the Car class and the associated actions i.e., object functions like Start, Move, Stop form the Methods of Car Class. No memory is allocated when a class is created. Memory is allocated only when an object is created, i.e., when an instance of a class is created. Inheritance: Inheritance is the process of forming a new class from an existing class or base class. The base class is also known as parent class or super class, The new class that is formed is called derived class. Derived class is also known as a child class or sub class. Inheritance helps in reducing the overall code size of the program, which is an important concept in object-oriented programming. Data Abstraction: Data Abstraction increases the power of programming language by creating user defined data types. Data Abstraction also represents the needed information in the program without presenting the details. Data Encapsulation: Data Encapsulation combines data and functions into a single unit called Class. When using Data Encapsulation, data is not accessed directly; it is only accessible through the functions present inside the class. Data Encapsulation enables the important concept of data hiding possible. Polymorphism: Polymorphism allows routines to use variables of different types at different times. An operator or function can be given different meanings or functions. Polymorphism refers to a single function or multi-functioning operator performing in different ways. Overloading: Overloading is one type of Polymorphism. It allows an object to have different meanings, depending on its context. When an exiting operator or function begins to operate on new data type, or class, it is understood to be overloaded. 3 Reusability: This term refers to the ability for multiple programmers to use the same written and debugged existing class of data. This is a time saving device and adds code efficiency to the language. Additionally, the programmer can incorporate new features to the existing class, further developing the application and allowing users to achieve increased performance. This time saving feature optimizes code, helps in gaining secured applications and facilitates easier maintenance on the application. The implementation of each of the above object-oriented programming features for C++ will be highlighted in later sections. A sample program to understand the basic structure of C++ //program to read employee details and to output the data #include <iostream.h> → Preprocessor directive class employee → Class Declaration { private: char empname[50]; int empno; public: void getvalue() { cout<<”INPUT EMP NAME:”; cint>>empname; cout<<”INPUT EMP NO:”; cint>>empno; } void displayvalue() { cout<<”EMP NAME:”<<empname; coout<<EMP NO:”<<empno; } }; main() { employee e1; → Creation of Object e1.getvalue(); e1.displayvalu(); } 4 Variables A variable is the storage location in memory that is stored by its value. A variable is identified or denoted by a variable name. The variable name is a sequence of one or more letters, digits or underscore, for example: character _ Rules for defining variable name: A variable name can have one or more letters or digits or underscore for example character _. . White space, punctuation symbols or other characters are not permitted to denote variable name. . A variable name must begin with a letter. . Variable names cannot be keywords or any reserved words of the C++ programming language. . C++ is a case-sensitive language. Variable names written in capital letters differ from variable names with the same name but written in small letters. For example, the variable name EXFORSYS differs from the variable name exforsys. As previously explained, a variable is the storage location in memory that is stored by variable value. The amount of memory allocated or occupied by each variable differs as per the data stored. The amount of memory used to store a single character is different from that of storing a single integer. A variable must be declared for the specific data type. Data Types Below is a list of the most commonly used Data Types in C++ programming language: short int int long int float double long double char bool short int : This data type is used to represent short integer. int: This data type is used to represent integer. 5 long int: This data type is used to represent long integer. float: This data type is used to represent floating point number. double: This data type is used to represent double precision floating point number. long double: This data type is used to represent double precision floating point number. char: This data type is used to represent a single character. bool: This data type is used to represent boolean value. It can take one of two values: True or False. Using variable names and data type, we shall now learn how to declare variables. Declaring Variables: In order for a variable to be used in C++ programming language, the variable must first be declared. The syntax for declaring variable names is data type variable name; The date type can be int or float or any of the data types listed above. A variable name is given based on the rules for defining variable name (refer above rules). Example: int a; This declares a variable name a of type int. If there exists more than one variable of the same type, such variables can be represented by separating variable names using comma. For instance int x,y,z This declares 3 variables x, y and z all of data type int. The data type using integers (int, short int, long int) are further assigned a value of signed or unsigned. Signed integers signify positive and negative number value. Unsigned integers signify only positive numbers or zero. For example it is declared as 6 unsigned short int a; signed int z; By default, unspecified integers signify a signed integer. For example: int a; is declared a signed integer It is possible to initialize values to variables: data type variable name = value; Example: int a=0; int b=5; Constants Constants have fixed value. Constants, like variables, contain data type. Integer constants are represented as decimal notation, octal notation, and hexadecimal notation. Decimal notation is represented with a number. Octal notation is represented with the number preceded by a zero character. A hexadecimal number is preceded with the characters 0x. Example 80 represent decimal 0115 represent octal 0x167 represent hexadecimal By default, the integer constant is represented with a number. The unsigned integer constant is represented with an appended character u. The long integer constant is represented with character l. Example: 78 represent int 85u present unsigned int 78l represent long 7 Floating point constants are numbers with decimal point and/or exponent. Example 2.1567 4.02e24 These examples are valid floating point constants. Floating point constants can be represented with f for floating and l for double precision floating point numbers. Character constants have single character presented between single quotes. Example „c‟ „a‟ are all character constants. Strings are sequences of characters signifying string constants. These sequence of characters are represented between double quotes. Example: “Exforsys Training” is an example of string constant. C++ Objects and Classes An Overview about Objects and Classes In object-oriented programming language C++, the data and functions (procedures to manipulate the data) are bundled together as a self-contained unit called an object. A class is an extended concept similar to that of structure in C programming language, this class describes the data properties alone. In C++ programming language, class describes both the properties (data) and behaviors (functions) of objects. Classes are not objects, but they are used to instantiate objects. Features of Class: Classes contain data known as members and member functions. As a unit, the collection of members and member functions is an object. Therefore, this unit of objects make up a class. 8 How to write a Class: In Structure in C programming language, a structure is specified with a name. The C++ programming language extends this concept. A class is specified with a name after the keyword class. The starting flower brace symbol, {is placed at the beginning of the code. Following the flower brace symbol, the body of the class is defined with the member functions data. Then the class is closed with a flower brace symbol} and concluded with a colon;. class exforsys { data; member functions; …………… }; There are different access specifiers for defining the data and functions present inside a class. Access specifiers: Access specifiers are used to identify access rights for the data and member functions of the class. There are three main types of access specifiers in C++ programming language: private public protected A private member within a class denotes that only members of the same class have accessibility. The private member is inaccessible from outside the class. . Public members are accessible from outside the class. . A protected access specifier is a stage between private and public access. If member functions defined in a class are protected, they cannot be accessed from outside the class but can be accessed from the derived class. When defining access specifiers, the programmer must use the keywords: private, public or protected when needed, followed by a semicolon and then define the data and member functions under it. class exforsys { 9 private: int x,y; public: void sum() { ……… ……… } }; In the code above, the member x and y are defined as private access specifiers. The member function sum is defined as a public access specifier. General Template of a class: General structure for defining a class is: class classname { acess specifier: data member; member functions; acess specifier: data member; member functions; }; Generally, in class, all members (data) would be declared as private and the member functions would be declared as public. Private is the default access level for specifiers. If no access specifiers are identified for members of a class, the members are defaulted to private access. class exforsys { int x,y; public: void sum() { ……… ……… } }; 10 In this example, for members x and y of the class exforsys there are no access specifiers identified. exforsys would have the default access specifier as private. Creation of Objects: Once the class is created, one or more objects can be created from the class as objects are instance of the class. Juts as we declare a variable of data type int as: int x; Objects are also declared as: class name followed by object name; exforsys e1; This declares e1 to be an object of class exforsys. For example a complete class and object declaration is given below: class exforsys { private: int x,y; public: void sum() { ……… ……… } }; main() { exforsys e1; …………… …………… } The object can also be declared immediately after the class definition. In other words the object name can also be placed immediately before the closing flower brace symbol } of the class declaration. 11 For example class exforsys { private: int x,y; public: void sum() { ……… ……… } }e1; The above code also declares an object e1 of class exforsys. It is important to understand that in object-oriented programming language, when a class is created no memory is allocated. It is only when an object is created is memory then allocated. How to Access C++ Class Members It is possible to access the class members after a class is defined and objects are created. General syntax to access class member: Object_name.function_name (arguments); The dot („.‟) used above is called the dot operator or class member access operator. The dot operator is used to connect the object and the member function. This concept is similar to that of accessing structure members in C programming language. The private data of a class can be accessed only through the member function of that class. For example, A class and object are defined below: class exforsys { int a, b; public: void sum(int,int); } e1; Then the member access is written as: 12 e1.sum(5,6); Where e1 is the object of class exforsys and sum() is the member function of the class. The programmer now understands declaration of a class, creation of an object and accessibility of members of a class. It is also possible to declare more than one object within a class: class exforsys { private: int a; public: void sum(int) { ……… ……… } }; main() { exforsys e1,e2; ………… ………… } In these two objects e1 and e2 are declared of class exforsys. By default, the access specifier for members of a class is private. The default access specifier for a structure is public. This is an important difference to recognize and understand in object- oriented C++ programming language. class exforsys { int x; //Here access specifier is private by default }; whereas struct exforsys 13 { int x; //Here access specifier is public by default }; It is not always the case that the member function declaration and definition takes place within the class itself. Sometimes, declaration of member function alone can occur within the class. The programmer may choose to place the definition outside the class. In a situation such as this, it is important to understand the identifying member function of a particular class. This is performed by using the operator :: this is called scope resolution operator. class exforsys { private: int a; public: void getvalues() // Only Member Function declaration is done }; void exforsys :: void getvalues() // Here Member Function is defined { ……………… ……………… } main() { exforsys e1,e2; ………… } So the usage of scope resolution operator is as follows: 14 Overview of the Basic Structure of C++ Programming The next structure present in the program is the class definition. This starts with the keyword class followed by class name employee. Within the class are data and functions. The data defined in the class are generally private and functions are public. These explanations we will be detailed in later sections. The class declaration ends with a semicolon. . main() function is present in all C++ programs. . An object e1 is created in employee class. Using this e1 the functions present in the employee class are accessed and there by data are accessed. . The input namely ename and eno is got using the input statement namely cin and the values are outputted using the output statement namely cout. What is a function? A function is a structure that has a number of program statements grouped as a unit with a name given to the unit. Function can be invoked from any part of the C++ program. Features of Function: To understand why the program structure is written separately and given a name, the programmer must have a clear idea of the features and benefits of function. This will encourage better understanding of function usage: Use of Functions gives a Structured Programming Approach Reduces Program Size: The piece of code that needs to be executed, or the piece of code that is repeated in different parts of the program, can be written separately as a function and stored in a place in memory. Whenever and wherever needed, the programmer can invoke the function and use the code to be executed. Thus, the program size is reduced. Having known about the function and its features let us see how to declare, define and call a function in a C++ program. Declaring a Function: It has been discussed that, in order for a variable to be used, it must be declared. Just like variables, it follows that function definitions must be declared. The general method of declaring a function is to declare the function in the beginning of the program. The general format for declaring a function is 15 return_datatype function name(arguments); Suppose we have a function named as exforsys which return nothing from the function it is declared as void exforsys( ); This declared would inform the compiler that the presence of the function exforsys is there in the program. In the above the return type void tells the compiler that the function has no return value and also the empty braces ( ) indicate that the function takes no arguments. Defining a function: The definition is the place where the actual function program statements or in other words the program code is placed. The general format of the function definition is as follows: return_datatype functionname(arguments) //Declarator { program statements //Function Body …….. ………. } In the above the declarator must match the function declaration already made. That is the function name, the return type and the number of arguments all must be same as the function declaration made. In fact if arguments are declared and defined. The order of arguments defined here must match the order declared in the function declaration. After the declarator the braces starts and the function body is placed. The function body has the set of program statements which are to be executed by the function. Then the function definition ends with } ending braces. For example let us see how to define a function exforsys declared as void that prints first five integers. void exforsys( ) { int i; for (i=1;i<=5;i++) cout<< i; } The output of the function when it is called would be 16 12345 Calling the function: The function must be called for it to get executed. This process is performed by calling the function wherever required. The general format for making the function call would be as follows: functionname(); When the function is called the control, transfers to the function and all the statements present in the function definition gets executed and after which the control, returns back to the statement following the function call. In the above example when the programmer executes the function exforsys, he can call the function in main as follows: exforsys(); Let us see a complete program in C++ to help the programmer to understand the function concepts described above: The output of the above program is 12345 End of Program Concept of Function with Arguments In this C++ Tutorial you will learn about Concept of Function with Arguments - What is an argument Declaring a function, Function Definition and Calling the function. Previous chapters of this tutorial have discussed simple function definition writing, declaration of function and function call. In this chapter, the definition, declaration and call function with arguments will be addressed. What is an argument? An argument is the value that is passed from the program to the function call. This can also be considered as input to the function from the program from which it is called. How to declare a function passed with argument Declaring a function: 17 The general format for declaring the function remains the same as before except the data type passed as arguments in functions are in the same order in which it is defined in function. The format for declaring a function with arguments is: return_datatype functionname(datatype1,datatype2,..); In this example, the data types are the types of data passed in the function definition as arguments to the function. Care must be taken to mention the number of arguments and the order of arguments in the same way as in function definition. For example, suppose a function named exforsys takes two integer values as arguments in its functions definition and returns an integer value. The function declaration of exforsys would be written: int exforsys(int,int); Function Definition: The function definition has the same syntax as the function definition previously defined, but with added arguments. The general format for defining a function with arguments is written as: return_datatype functionname(datatype1 variable1,datatype2 variable2,..) { …………. Program statements …………. return( variable); } In the above example, the return data type defines the data type of the value returned by the function. The arguments are passed inside the function name after parentheses with the data type and the variable of each argument. Care must be taken to mention the number of arguments and the order of arguments in the same way as in function declaration. For example, if the function exforsys takes two integer values x and y and adds them and returns the value z the function definition would be defined as follows: int exforsys(int x,int y) { int z; z=x+y; return(z); } In the above program segment, a return statement takes the general format 18 return(variable) ; This value specified in the return as argument would be returned to the calling program. In this example, the value returned is z, which is an integer value, the data type returned by the function exforsys is mentioned as int. Calling the function: The calling of function takes the same syntax as the name of the function but with value for the arguments passed. The function call is made in the calling program and this is where the value of arguments or the input to the function definition is given. The general format for calling the function with arguments is functionname(value1,value2,…); In the above exforsys function suppose integer value 5 and 6 are passed, the function call would be as follows: exforsys(5,6); As soon as the function call exforsys is made the control, transfers to the function definition and the assignment of 5 to x and 6 to y are made as below. int exforsys(int x,int y) exforsys(5,6); It is possible to store the return value of the function in a variable. In the above example, the assignment of the function call to integer variable b can be produced as follows: int b; b = exforsys(5,6); The above statement assigns the returned value of the function exforsys. The value z is then added to the value of x and y to the variable b. So, variable b takes the value 11. Let us see the whole program to understand in brief the concept of function with arguments The output of the above program would be 19 #include int exforsys(int,int); void main() { int b; int s=5,u=6; b=exforsys(s,u); cout&lt;&lt;”\n The Output is:”&lt; } int exforsys(int x,int y) { int z; z=x+y; return(z); } The Output is:11 C++ Function Passing Types In this C++ tutorial, you will learn about function passing types, two types of arguments passing in functions - passed by value and passed by reference are discussed here. The arguments passed to a function can be performed in two ways: Passed By Value Passed By Reference Passed By Value: In the earlier chapter, all examples for the function with arguments were passed by value. Arguments passed by value are the copies of the values of variables and are passed to the function. The variables defined in the calling function are not passed in this manner. For example: int s=5, u=6; int z; z = exforsys(s,u) would pass values as int exforsys(int x, int y) z = exforsys(5,6); 20 Thus, the copies of the values 5 and 6 are passed to the function definition and not the variables s and u. Thus, any changes in the variable x and y would not have any effect or change the variables s and u. Because s and u are not passed in this manner, only copies of the variables are passed to the function definition. Passed By Reference: Passed by reference indicates a contrast in that the variables are not passed by value. When a variable is passed by reference, it passes the variable to the function definition and not the copies of the value. Any changes to the variable in function definition would effect or reflect corresponding changes in the variables passed as reference. The symbol used for denoting the passed by reference is & (ampersand). For Example: Suppose two integer variables x and y are defined in the calling function, the main program with values x=5 and y=4. Suppose the function exforsys receives the value as passed by reference from this function it is defined and called as follows: #include <iostream.h> void main( ) { void exforsys(int&,int&); //Function Declaration - & denotes passed by reference int x=5,y=4; exforsys(x,y); cout<<”\n The output from Calling program is:”; cout<<”\n x=”<< x; cout<<”\n y=”<< y; } void exforsys(int& s, int& u) //Function Definition - & denotes passed by reference { s=s*10; u=u*10; } 21 In the above example, the reference arguments are indicated by the symbol ampersand & following the data type of the argument. In the above program, since the variables or arguments are passed by reference the assignment is as follows: void exforsys(int& s, int& u) exforsys(x, y); The variable x and y are passed to the called function exforsys where it is associated with variables s and u. Whatever changes were made in the variable s and u effect or reflect on the variables x and y respectively and vice versa. Only in the above, the function multiplied the value of variable s and u by 10 which is reflected in the variable a and b. Thus, in this case, it has not returned any value by using return statement. The programmer must take careful notice and make use of the passed by reference concept by returning more than one value. By using the concept of passing by reference, it is possible to return more than one value. The output of the above program would be The output from Calling program is: x=50 y=40 C++ Inline Functions In this C++ tutorial, you will learn about Inline function, what is inline function, reason for the need of inline function, what happens when an inline function is written, general format of inline function explained with example. What is Inline Function? Inline functions are functions where the call is made to inline functions. The actual code then gets placed in the calling program. Reason for the need of Inline Function: Normally, a function call transfers the control from the calling program to the function and after the execution of the program returns the control back to the calling program after the function call. These concepts of function saved program space and memory space are used because the function is stored only in one place and is only executed when it is called. This concept of function execution may be time consuming since the registers and other processes must be saved before the function gets called. The extra time needed and the process of saving is valid for larger functions. If the function is short, the programmer may wish to place the code of the function in the calling program in order for it to be executed. This type of function is best handled by the inline function. In this situation, 22 the programmer may be wondering “why not write the short code repeatedly inside the program wherever needed instead of going for inline function?” Although this could accomplish the task, the problem lies in the loss of clarity of the program. If the programmer repeats the same code many times, there will be a loss of clarity in the program. The alternative approach is to allow inline functions to achieve the same purpose, with the concept of functions. What happens when an inline function is written? The inline function takes the format as a normal function but when it is compiled it is compiled as inline code. The function is placed separately as inline function, thus adding readability to the source program. When the program is compiled, the code present in function body is replaced in the place of function call. General Format of inline Function: The general format of inline function is as follows: inline datatype function_name(arguments) The keyword inline specified in the above example, designates the function as inline function. For example, if a programmer wishes to have a function named exforsys with return value as integer and with no arguments as inline it is written as follows: inline int exforsys( ) Example: The concept of inline functions: #include <iostream.h> int exforsys(int); void main( ) { int x; cout << “\n Enter the Input Value: ”; cin>>x; cout<<”\n The Output is: “ << exforsys(x); } inline int exforsys(int x1) { return 5*x1; } 23 The output of the above program is: Enter the Input Value: 10 The Output is: 50 The output would be the same even when the inline function is written solely as a function. The concept, however, is different. When the program is compiled, the code present in the inline function exforsys( ) is replaced in the place of function call in the calling program. The concept of inline function is used in this example because the function is a small line of code. The above example, when compiled, would have the structure as follows: #include <iostream.h> int exforsys(int); void main( ) { int x; cout << “\n Enter the Input Value: ”; cin>>x; //The exforsys(x) gets replaced with code return 5*x1; cout<<”\n The Output is: “ << exforsys(x); } When the above program is written as normal function the compiled code would look like below: #include <iostream.h> int exforsys(int); void main( ) { int x; cout << “\n Enter the Input Value: ”; cin>>x; //Call is made to the function exforsys cout<<”\n The Output is: “ << exforsys(x); } int exforsys(int x1) { return 5*x1; } 24 A programmer must make wise choices when to use inline functions. Inline functions will save time and are useful if the function is very small. If the function is large, use of inline functions must be avoided. Scope of Variables in Function In this C++ Tutorial you will learn about Scope of Variables in Function viz Local Variables - Scope of Local Variables, Global Variables - Scope of Global Variables. The scope of the variables can be broadly be classified as Local Variables Global Variables Local Variables: The variables defined local to the block of the function would be accessible only within the block of the function and not outside the function. Such variables are called local variables. That is in other words the scope of the local variables is limited to the function in which these variables are declared. Let us see this with a small example: #include <iostream.h> int exforsys(int,int); void main( ) { int b; int s=5,u=6; b=exforsys(s,u); cout<<”\n The Output is:”<<b; } int exforsys(int x,int y) { int z; z=x+y; return(z); } In the above program the variables x, y, z are accessible only inside the function exforsys( ) and their scope is limited only to the function exforsys( ) and not outside the function. Thus the variables x, y, z are local to the function exforsys. Similarly one would not be able to access variable b inside the function exforsys as such. This is because variable b is local to function main. 25 Global Variables: Global variables are one which are visible in any part of the program code and can be used within all functions and outside all functions used in the program. The method of declaring global variables is to declare the variable outside the function or block. For instance #include <iostream.h> int x,y,z; //Global Variables float a,b,c; //Global Variables void main( ) { int s,u; //Local Variables float w,q; //Local Variables …….. ……………. } In the above the integer variables x, y and z and the float variables a, b and c which are declared outside the block are global variables and the integer variables s and u and the float variables w and q which are declared inside the function block are called local variables. Thus the scope of global variables is between the point of declaration and the end of compilation unit whereas scope of local variables is between the point of declaration and the end of innermost enclosing compound statement. Let us see an example which has number of local and global variable declarations with number of inner blocks to understand the concept of local and global variables scope in detail. #include <iostream.h> int g; void main( ) { int a; { int b; b=25; a=45; g=65; } a=50; exforsys( ); } void exforsys( ) 26 { g = 30; //Scope of g is throughout the program and so is used between function calls } Scope of b is till the first braces shaded as Yellow Scope of a is till the end of main brace shaded as red In the context of scope of variables in functions comes the important concept named as storage class which is discussed in detail in next section. Static Functions - An Introduction The static member functions have a class scope and they do not have access to the 'this' pointer of the class. When a member is declared as static that is a static member of class have only one such data for the entire class even though there are many objects created for the class. The main usage of static function is when the programmer wants to have a function which is accessible even when the class is not instantiated. Defining Static Function: This is done by using the keyword static before the member function which is to be declared as static function. General syntax: static return_data_type fucntionname() //Static function defined with keyword static { statement1; statement2; //Statements for execution inside static function .......... .......... } For example if a function exforsys returning nothing is to be declared as staic function it is done as follows: static void exforsys() { ........; .......; } Accessing Static Function: 27 We have seen in our earlier sections about accessing a normal member function. To recollect a normal member function gets accessed using the object and an operator called as the dot member access operator. The function declared as static or static functions gets accessed using just the class name and the operator called as scope resolution operator which is not possible in case of normal member functions. Let us see an example to understand the declaration of static member function and how to access static member function in detail: #include <iostream.h> class example { private: static int sum; //Static data int x; public: example() //Constructor of the class { sum=sum+1; x=sum; } ~example() //Destructor of the class { sum=sum-1; } static void exforsys() //Static function exforsys( ) defined with keyword static { cout<<"\nResult is: "<<sum; } void number() //Normal member function number( ) { cout<<"\nNumber is: "<<x; } }; void main() { example e1; example::exforsys(); //Static function exforsys() accessed using class name example and the scope resolution operator :: example e2,e3,e4; 28 example::exforsys(); e1.number(); e2.number(); //Normal member function accessed using object e1 and the dot member access operator . e3.number(); e4.number(); } The output of the above program is: Result is: 1 Result is: 4 Number is: 1 Number is: 2 Number is: 3 Number is: 4 In the above we have seen that the function exforsys() s defined as static function and the integer data type sum is declared as static data type. We see that four objects e1, e2, e3 and e4 are created for the class example. The constructor of the class example increments the sum by 1 and the destructor of the class decrements sum by 1. We can see that the static function is accessed using the class name example and the scope resolution operator :: as example::exforsys(); But the normal member function number() is accessed using the object name and the dot member access operator as e1.number() e2.number() e3.number() e4.number() The first time when the static function exforsys() is called there was one object created and this the sum gets incremented by 1 in the constructor printing the result of sum as 1.When the static function exforsys() is called the second time there were three more objects e2,e3 and e4 created which makes the sum to gets incremented thrice from 1 in the constructor of the corresponding class namely example making the value of sum as 4 which is displayed in the second result. From the above explanation it is clear that the static function operate on the class and not in object generally. Also for accessing static function one can use the class name followed by the scope resolution operator as seen in example above. One must note the following while using static member functions: 29 A static member function can access only static member data, static member functions and data and functions outside the class. So one must take essential care not to use static member function like a non-static member function which can access all of the above including the static data member. A non-static member functions can be declared as virtual but care must be taken not to declare a static member function as virtual. One must first understand the concept of static data also while learning the context of static functions. It is possible to declare a data member of a class as static irrespective of it being public or private type in class definition. If a data is declared as static then the static data gets created and initialized only once. That is unlike non-static data members that are created again and again, for each separate object of the class the static data gets created and initialized only once. Just like the concept of static data, in which the variables are shared by all objects of the class in static functions also it apply to all objects of the class A non-static member function can be called only after instantiating the class as an object. But it is not the case with static member functions. Because a static member function can be called, even when a class is not instantiated, Also a static member function cannot have access to the 'this' pointer of the class. C++ Friend Functions In this C++ tutorials, you will learn about friend functions, need for friend function, how to define and use friend function and few important points regarding friend function, explained with example. Need for Friend Function: As discussed in the earlier sections on access specifiers, when a data is declared as private inside a class, then it is not accessible from outside the class. A function that is not a member or an external class will not be able to access the private data. A programmer may have a situation where he or she would need to access private data from non-member functions and external classes. For handling such cases, the concept of Friend functions is a useful tool. 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++: 30 The friend function is written as any other normal function, except the function declaration of these functions is preceded with the keyword friend. The friend function must have the class to which it is declared as friend passed to it in argument. Some important points to note while using friend functions in C++: The keyword friend is placed only in the function declaration of the friend function and not in the function definition. . It is possible to declare a function as friend in any number of classes. . When a class is declared as a friend, the friend class has access to the private data of the class that made this a friend. . A friend function, even though it is not a member function, would have the rights to access the private members of the class. . It is possible to declare the friend function as either private or public. . The function can be invoked without the use of an object. The friend function has its argument as objects, seen in example below. Example to understand the friend function: #include class exforsys { private: int a,b; public: void test() { a=100; b=200; } friend int compute(exforsys e1) //Friend Function Declaration with keyword friend and with the object of class exforsys to which it is friend passed to it }; int compute(exforsys e1) { //Friend Function Definition which has access to private data 31 return int(e1.a+e2.b)-5; } main() { exforsys e; e.test(); cout<<"The result is:"< //Calling of Friend Function with object as argument. } The output of the above program is The result is:295 The function compute() is a non-member function of the class exforsys. In order to make this function have access to the private data a and b of class exforsys , it is created as a friend function for the class exforsys. As a first step, the function compute() is declared as friend in the class exforsys as: friend int compute (exforsys e1) The keyword friend is placed before the function. The function definition is written as a normal function and thus, the function has access to the private data a and b of the class exforsys. It is declared as friend inside the class, the private data values a and b are added, 5 is subtracted from the result, giving 295 as the result. This is returned by the function and thus the output is displayed as shown above. Concept of Pointers: Every storage location of memory has an associated address. Address is a number that grows sequentially. For every program placed in memory, each variable or function in the program has an associated address. The address of operator: The address of operator or Reference operator is denoted by the notation &. When the user wants to get the address of a variable, then the reference operator & can be used. The operator & is used to find the address associated with a variable. The syntax of the reference operator is as follows: &variablename This means that the address of the variablename is achieved. 32 For Example #include <iostream.h> void main() { int exf=200; int test=300; cout<<endl<<&exf <<endl<<&test; } The output of the above program is: 0x92343456 0x78252348 The &exf has the address associated with the integer variable exf and the &test has the address associated with the integer variable test which are displayed using the cout statement. Using the understanding of address of operators, the discussion turns to the concept of pointers. exforsys = 100; test = exforsys; x = &exforsys; Using the above information, the assignment takes place as below: exforsys is an integer variable having the value of 100 stored in memory address location 3501. When the variable exforsys is assigned to the variable test in the second statement: test = exforsys; The value of the variable exforsys 100 is copied to the variable test. In the third statement, the address of the variable exforsys is denoted by reference operator &exforsys is assigned to the variable x as: 33 x = &exforsys; The address of the variable 3501 and not the contents of the variable exforsys is copied into the variable x. The pointers concept fits in this statement. Pointers are the variable that store the reference to another variable. Pointers are variables that store the address of the variable that it is pointed by. Variable x is referred to as the pointer in the above example. The programmer must note that the address operator placed before a variable is not the same as operator & placed after the variable. For example, &x is not same as x&. Variable &x refers to address operator whereas x& refer to reference operator&. Pointer is a variable that holds the address, also called pointer variable. Defining Pointer Variables or Pointer: In order to define pointer variables, the programmer must use the operator denoted as * in C++. The symbol * when placed before a pointer, variable means that it as a pointer to. While defining variables, the data type is placed before it. When the programmer wants to define the integer variable i it is written: int i; A programmer may think that to define pointer variable there is a separate data type. But this is not the case. There is no separate data type for pointer available. When a programmer defines a pointer variable, he or she can point to integer, float, char. The compiler must know the type of data the pointer is pointing to. To define pointer variable is as follows: datatype_of_ variable_pointedto* pointer_varaible; For example: char* ch; This defines that ch is a pointer variable which points to char data type. int* i; This defines that i is a pointer variable which points to int data type. float* f; This defines that f is a pointer variable which points to float data type. C++ Void Pointer and Null Pointer 34 In this C++ tutorial, you will learn about two interesting types of pointers; void pointers and Null Pointer. These pointers will be discussed in conjunction with syntax, usage and example. Pointer to Void General Syntax: void* pointer_variable; Void is used as a keyword. Referring back to pointer definitions and usage, it is known that the data type the pointer variable defines is the same as the data type the pointer points to. The address placed in a pointer must have the same type as the pointer. For example: int i; float f; int* exf; float* test; then exf=&i; Is correct because the address of integer variable is stored in an integer pointer. If a user writes the statement: exf=&f; Then this statement produces an error. The address of the float variable is stored in an integer pointer that is incorrect. Similarly, if the programmer tries to place the address of an integer variable to a float pointer, such as: test=&i; The above statement will also show an error. The Pointer to Void is a special type of pointer that the programmer can use to point to any data type. Using the above example, the programmer declares pointer to void in this manner: void* sample; 35 Using the above example‟s definition and assigning the pointer to void to the address of an integer variable is perfectly correct. sample=&i; Using the above example to define the pointer to void and assign the pointer to void to the address of a float variable as below is also perfectly correct. sample=&f; Pointer to void, or a void pointer, is a special type of pointer that has a great facility of pointing to any data type. There are limitations in the usage of void pointers that are explained below. The concept of dereferencing using the operator * has been explained in an earlier section of this tutorial. The programmer must note that void pointers cannot be de-referenced in the same manner. Direct dereferencing of void pointer is not permitted. The programmer must change the pointer to void as any other pointer type that points to valid data types such as, int, char, float and then dereference it. This conversion of pointer to some other valid data type is achieved by using the concept of type-casting (refer to type-casting section of this tutorial). NULL Pointer: The concept of NULL pointer is different from the above concept of void pointer. NULL pointer is a type of pointer of any data type and generally takes a value as zero. This is, however, not mandatory. This denotes that NULL pointer does not point to any valid memory address. For example: int* exforsys; exforsys=0; The above statement denotes exforsys as an integer pointer type that does not point to a valid memory address. This shows that exforsys has a NULL pointer value. The difference between void pointers and NULL pointers: A Void pointer is a special type of pointer of void and denotes that it can point to any data type. NULL pointers can take any pointer type, but do not point to any valid reference or memory address. It is important to note that a NULL pointer is different from a pointer that is not initialized. For example, if a programmer uses the program below: #include <iostream.h> int *exforsys; 36 void main() { *exforsys=100; } The output of the above program is NULL POINTER ASSIGNMENT The above program will result in a runtime error. This means that the pointer variable exforsys is not assigned any valid address and, therefore, attempting to access the address 0 gives the above error message. UNIT-2 What is Type Conversion It is the process of converting one type into another. In other words converting an expression of a given type into another is called type casting. How to achieve this There are two ways of achieving the type conversion namely: Automatic Conversion otherwise called as Implicit Conversion Type casting otherwise called as Explicit Conversion Let us see each of these in detail: Automatic Conversion otherwise called as Implicit Conversion This is not done by any conversions or operators. In other words value gets automatically converted to the specific type in which it is assigned. Let us see this with an example: #include <iostream.h> void main() { short x=6000; 37 int y; y=a; } In the above example the data type short namely variable x is converted to int and is assigned to the integer variable y. So as above it is possible to convert short to int, int to float and so on. Type casting otherwise called as Explicit Conversion Explicit conversion can be done using type cast operator and the general syntax for doing this is datatype (expression); Here in the above datatype is the type which the programmer wants the expression to gets changed as In C++ the type casting can be done in either of the two ways mentioned below namely: C-style casting C++-style casting The C-style casting takes the synatx as (type) expression This can also be used in C++. Apart from the above the other form of type casting that can be used specifically in C++ programming language namely C++-style casting is as below namely: type (expression) This approach was adopted since it provided more clarity to the C++ programmers rather than the C-style casting. Say for instance the as per C-style casting (type) firstVariable * secondVariable is not clear but when a programmer uses the C++ style casting it is much more clearer as below type (firstVariable) * secondVariable 38 Let us see the concept of type casting in C++ with a small example: #include <iostream.h> void main() { int a; float b,c; cout<< “Enter the value of a:”; cin>>a; cout<< “\n Enter the value of b:”; cin>>b; c = float(a)+b; cout<<”\n The value of c is:”<<c; } The output of the above program is Enter the value of a: 10 Enter the value of b: 12.5 The value of c is: 22.5 Constructors: What is the use of Constructor The main use of constructors is to initialize objects. The function of initialization is automatically carried out by the use of a special member function called a constructor. General Syntax of Constructor Constructor is a special member function that takes the same name as the class name. The syntax generally is as given below: <class name> { arguments}; The default constructor for a class X has the form X::X() In the above example the arguments is optional. The constructor is automatically named when an object is created. A constructor is named whenever an object is defined or dynamically allocated using the "new" operator. There are several forms in which a constructor can take its shape namely: 39 Default Constructor: This constructor has no arguments in it. Default Constructor is also called as no argument constructor. For example: class Exforsys { private: int a,b; public: Exforsys(); ... }; Exforsys :: Exforsys() { a=0; b=0; } Copy constructor: This constructor takes one argument. Also called one argument constructor. The main use of copy constructor is to initialize the objects while in creation, also used to copy an object. The copy constructor allows the programmer to create a new object from an existing one by initialization. For example to invoke a copy constructor the programmer writes: Exforsys e3(e2); or Exforsys e3=e2; Both the above formats can be sued to invoke a copy constructor. For Example: 40 #include <iostream.h> class Exforsys() { private: int a; public: Exforsys() { } Exforsys(int w) { a=w; } Exforsys(Exforsys& e) { a=e.a; cout<<” Example of Copy Constructor”; } void result() { cout<< a; } }; void main() { Exforsys e1(50); Exforsys e3(e1); cout<< “\ne3=”;e3.result(); } In the above the copy constructor takes one argument an object of type Exforsys which is passed by reference. The output of the above program is Example of Copy Constructor e3=50 Some important points about constructors: A constructor takes the same name as the class name. The programmer cannot declare a constructor as virtual or static, nor can the programmer declare a constructor as const, volatile, or const volatile. No return type is specified for a constructor. The constructor must be defined in the public. The constructor must be a public member. 41 Overloading of constructors is possible. This will be explained in later sections of this tutorial. Destructors What is the use of Destructors Destructors are also special member functions used in C++ programming language. Destructors have the opposite function of a constructor. The main use of destructors is to release dynamic allocated memory. Destructors are used to free memory, release resources and to perform other clean up. Destructors are automatically named when an object is destroyed. Like constructors, destructors also take the same name as that of the class name. General Syntax of Destructors ~ classname(); The above is the general syntax of a destructor. In the above, the symbol tilda ~ represents a destructor which precedes the name of the class. Some important points about destructors: Destructors take the same name as the class name. Like the constructor, the destructor must also be defined in the public. The destructor must be a public member. The Destructor does not take any argument which means that destructors cannot be overloaded. No return type is specified for destructors. For example: class Exforsys { private: …………… public: Exforsys() { } ~ Exforsys() { } } Operator Overloading 42 Operator overloading is a very important feature of Object Oriented Programming. Curious to know why!!? It is because by using this facility programmer would be able to create new definitions to existing operators. In fact in other words a single operator can take up several functions as desired by programmers depending on the argument taken by the operator by using the operator overloading facility. After knowing about the feature of operator overloading now let us see how to define and use this concept of operator overloading in C++ programming language. We have seen in previous sections the different types of operators. Broadly classifying operators are of two types namely: Unary Operators Binary Operators Unary Operators: As the name implies takes operate on only one operand. Some unary operators are namely ++ called as Increment operator, -- called as Decrement Operator, ! , ~, unary minus. Binary Operators: The arithmetic operators, comparison operators, and arithmetic assignment operators all this which we have seen in previous section of operators come under this category. Both the above classification of operators can be overloaded. So let us see in detail each of this. Operator Overloading – Unary operators As said before operator overloading helps the programmer to define a new functionality for the existing operator. This is done by using the keyword operator. The general syntax for defining an operator overloading is as follows: return_type classname :: operator operator symbol(argument) { ………….. statements; } Thus the above clearly specifies that operator overloading is defined as a member function by making use of the keyword operator. 43 In the above: return_type – is the data type returned by the function class name - is the name of the class operator – is the keyword operator symbol – is the symbol of the operator which is being overloaded or defined for new functionality :: - is the scope resolution operator which is used to use the function definition outside the class. The usage of this is clearly defined in our earlier section of How to define class members. For example Suppose we have a class say Exforsys and if the programmer wants to define a operator overloading for unary operator say ++, the function is defined as Inside the class Exforsys the data type that is returned by the overloaded operator is defined as class Exforsys { private: ………. public: void operator ++( ); ………… }; So the important steps involved in defining an operator overloading in case of unary operators are namely: Inside the class the operator overloaded member function is defined with the return data type as member function or a friend function. The concept of friend function we will 44 define in later sections. If in this case of unary operator overloading if the function is a member function then the number of arguments taken by the operator member function is none as seen in the below example. In case if the function defined for the operator overloading is a friend function which we will discuss in later section then it takes one argument. The operator overloading is defined as member function outside the class using the scope resolution operator with the keyword operator as explained above Now let us see how to use this overloaded operator member function in the program #include <iostream.h> class Exforsys { private: int x; public: Exforsys( ) { x=0; } //Constructor void display(); void Exforsys ++( ); }; void Exforsys :: display() { cout<<”\nValue of x is: “ << x; } void Exforsys :: operator ++( ) //Operator Overloading for operator ++ defined { ++x; } void main( ) { Exforsys e1,e2; //Object e1 and e2 created cout<<”Before Increment” cout <<”\nObject e1: ”<<e1.display(); cout <<”\nObject e2: ”<<e2.display(); ++e1; //Operator overloading applied ++e2; cout<<”\n After Increment” cout <<”\nObject e1: ”<<e1.display(); cout <<”\nObject e2: ”<<e2.display(); } The output of the above program is: 45 Before Increment Object e1: Value of x is: 0 Object e1: Value of x is: 0 Before Increment Object e1: Value of x is: 1 Object e1: Value of x is: 1 In the above example we have created 2 objects e1 and e2 f class Exforsys. The operator ++ is overloaded and the function is defined outside the class Exforsys. When the program starts the constructor Exforsys of the class Exforsys initialize the values as zero and so when the values are displayed for the objects e1 and e2 it is displayed as zero. When the object ++e1 and ++e2 is called the operator overloading function gets applied and thus value of x gets incremented for each object separately. So now when the values are displayed for objects e1 and e2 it is incremented once each and gets printed as one for each object e1 and e2. This is how unary operators get overloaded. We will see in detail how to overload binary operators in next section Operator Overloading – Binary Operators Binary operators, when overloaded, are given new functionality. The function defined for binary operator overloading, as with unary operator overloading, can be member function or friend function. The difference is in the number of arguments used by the function. In the case of binary operator overloading, when the function is a member function then the number of arguments used by the operator member function is one (see below example). When the function defined for the binary operator overloading is a friend function, then it uses two arguments. Binary operator overloading, as in unary operator overloading, is performed using a keyword operator. Binary operator overloading example: 46 #include <iostream.h> class Exforsys { private: int x; int y; public: Exforsys() //Constructor { x=0; y=0; } void getvalue( ) //Member Function for Inputting Values { cout << “\n Enter value for x: “; cin >> x; cout << “\n Enter value for y: “; cin>> y; } void displayvalue( ) //Member Function for Outputting Values { cout <<”value of x is: “ << x <<”; value of y is: “<<y } Exforsys operator +(Exforsys); }; Exforsys Exforsys :: operator + (Exforsys e2) //Binary operator overloading for + operator defined { int x1 = x+ e2.x; int y1 = y+e2.y; return Exforsys(x1,y1); } void main( ) { Exforsys e1,e2,e3; //Objects e1, e2, e3 created cout<<\n”Enter value for Object e1:”; e1.getvalue( ); cout<<\n”Enter value for Object e2:”; e2.getvalue( ); e3= e1+ e2; //Binary Overloaded operator used cout<< “\nValue of e1 is:”<<e1.displayvalue(); cout<< “\nValue of e2 is:”<<e2.displayvalue(); 47 cout<< “\nValue of e3 is:”<<e3.displayvalue(); } The output of the above program is: Enter value for Object e1: Enter value for x: 10 Enter value for y: 20 Enter value for Object e2: Enter value for x: 30 Enter value for y: 40 Value of e1 is: value of x is: 10; value of y is: 20 Value of e2 is: value of x is: 30; value of y is: 40 Value of e3 is: value of x is: 40; value of y is: 60 In the above example, the class Exforsys has created three objects e1, e2, e3. The values are entered for objects e1 and e2. The binary operator overloading for the operator „+‟ is declared as a member function inside the class Exforsys. The definition is performed outside the class Exforsys by using the scope resolution operator and the keyword operator. The important aspect is the statement: e3= e1 + e2; The binary overloaded operator „+‟ is used. In this statement, the argument on the left side of the operator „+‟, e1, is the object of the class Exforsys in which the binary overloaded operator „+‟ is a member function. The right side of the operator „+‟ is e2. This is passed as an argument to the operator „+‟ . Since the object e2 is passed as argument to the operator‟+‟ inside the function defined for binary operator overloading, the values are accessed as e2.x and e2.y. This is added with e1.x and e1.y, which are accessed directly as x and y. The return value is of type class Exforsys as defined by the above example. There are important things to consider in operator overloading with C++ programming language. Operator overloading adds new functionality to its existing operators. The programmer must add proper comments concerning the new functionality of the overloaded operator. The program will be efficient and readable only if operator overloading is used only when necessary. Some operators cannot be overloaded: scope resolution operator denoted by :: member access operator or the dot operator denoted by . the conditional operator denoted by ?: and pointer to member operator denoted by .* 48 C++ Memory Management operators Need for Memory Management operators The concept of arrays has a block of memory reserved. The disadvantage with the concept of arrays is that the programmer must know, while programming, the size of memory to be allocated in addition to the array size remaining constant. In programming there may be scenarios where programmers may not know the memory needed until run time. In this case, the programmer can opt to reserve as much memory as possible, assigning the maximum memory space needed to tackle this situation. This would result in wastage of unused memory spaces. Memory management operators are used to handle this situation in C++ programming language What are memory management operators? There are two types of memory management operators in C++: new delete These two memory management operators are used for allocating and freeing memory blocks in efficient and convenient ways. New operator: The new operator in C++ is used for dynamic storage allocation. This operator can be used to create object of any type. General syntax of new operator in C++: The general syntax of new operator in C++ is as follows: pointer variable = new datatype; In the above statement, new is a keyword and the pointer variable is a variable of type datatype. For example: int *a=new int; In the above example, the new operator allocates sufficient memory to hold the object of datatype int and returns a pointer to its starting point. The pointer variable a holds the address of memory space allocated. 49 Dynamic variables are never initialized by the compiler. Therefore, the programmer should make it a practice to first assign them a value. The assignment can be made in either of the two ways: int *a = new int; *a = 20; or int *a = new int(20); delete operator: The delete operator in C++ is used for releasing memory space when the object is no longer needed. Once a new operator is used, it is efficient to use the corresponding delete operator for release of memory. General syntax of delete operator in C++: The general syntax of delete operator in C++ is as follows: delete pointer variable; In the above example, delete is a keyword and the pointer variable is the pointer that points to the objects already created in the new operator. Some of the important points the programmer must note while using memory management operators are described below: The programmer must take care not to free or delete a pointer variable that has already been deleted. . Overloading of new and delete operator is possible (to be discussed in detail in later section on overloading). . We know that sizeof operator is used for computing the size of the object. Using memory management operator, the size of the object is automatically computed. . The programmer must take care not to free or delete pointer variables that have not been allocated using a new operator. . Null pointer is returned by the new operator when there is insufficient memory available for allocation. 50 Example: to understand the concept of new and delete memory management operator in C++: #include <iostream.h> void main() { //Allocates using new operator memory space in memory for storing a integer datatype int *a= new a; *a=100; cout << " The Output is:a="<<a; //Memory Released using delete operator delete a; } The output of the above program is The Output is:a=100 In the above program, the statement: int *a= new a; Holds memory space in memory for storing a integer datatype. The statement: *a=100 This denotes that the value present in address location pointed by the pointer variable a is 100 and this value of a is printed in the output statement giving the output shown in the example above. The memory allocated by the new operator for storing the integer variable pointed by a is released using the delete operator as: delete a; C++ Dereference Operator In this C++ tutorial, you will learn how to access the value of variables pointed by the pointer variables using pointer concept discussed in detail. It is possible to access the value of variables pointed by the pointer variables using pointer. This is performed by using the Dereference operator in C++ which has the notation *. 51 The general syntax of the Dereference operator is as follows: *pointer_variable In this example, pointer variable denotes the variable defined as pointer. The * placed before the pointer_variable denotes the value pointed by the pointer_variable. For example: exforsys = 100; test = exforsys; x = &exforsys; y=*x; In the above example, the assignment takes place as below: In the above example, the exforsys is a integer variable having the value of 100 stored in memory address location 3501. The variable exforsys is assigned to the variable test in the second statement: test = exforsys; The value of the variable exforsys is 100 and is then copied to the variable test. 52 In the third statement, the address of the variable exforsys denoted by reference operator &exforsys is assigned to the variable x as: x = &exforsys; The address of the variable 3501 and not the contents of the variable exforsys is then copied into the variable x. The fourth statement makes use of the deference operator: y=*x This means that the value pointed to by the pointer variable x gives the value 100 to y. Some points for the programmer to note: The programmer must note that the x refers to the address 3501 whereas *x refers to the value stored in the address 3501 namely 100. . The reference operator is denoted by & and deference operator denoted by * . Both differ in their meaning and functionality. The reference operator denotes the address of. The dereference operator denotes the value pointed by. In short, a deference variable can be denoted as referenced. . If the programmer wants to define more than two pointer variables, then comma operator may be used in this instance. The programmer must carefully place pointer symbol * before each pointer variable. For instance, if the user wishes to define two integer pointer variables, e1 and e2, this can be done as follows: int *e1,*e2; If the programmer declares: int *e1,e2; This means that e1 is a pointer variable pointing to integer data type but e2 is only an integer data type and not a pointer type. The programmer must ensure to place * before each pointer variable. The dereferencing or indirect addressing is performed using the indirection operator * used to access the value stored in an address. The defining of pointer variable: 53 int* exf; The definition of pointer variable as in the above case is the pointer variable exf. It is also possible to assign value to pointer variable using indirection operator. This gives the same effect as working with variables. For Example: #include void main() { int example,test; int* exforsys; exforsys=&example; example=200; test=200; *exforsys=100; test=*exforsys; cout< cout< } The output of the above program is 100 100 In the above example, the pointer variable exforsys points to integer variable example and takes the address of the variable example as: test and example have initial values of 200. 54 The statement: *exforsys=100 Sets the value of the variable pointed by pointer variable exforsys as 100. This is equivalent to setting example=100. The assignment is as follows: example test The statement test=*exforsys; sets the value of variable test with the value pointed by the pointer variable exforsys which is 100 as seen in the above example. Test also becomes 100 and the assignment becomes: Both results are displayed having the value 100. 55 UNIT-3 C++ Inheritance Introduction What is Inheritance? Inheritance is the process by which new classes called derived classes are created from existing classes called base classes. The derived classes have all the features of the base class and the programmer can choose to add new features specific to the newly created derived class. For example, a programmer can create a base class named fruit and define derived classes as mango, orange, banana, etc. Each of these derived classes, (mango, orange, banana, etc.) has all the features of the base class (fruit) with additional attributes or features specific to these newly created derived classes. Mango would have its own defined features, orange would have its own defined features, banana would have its own defined features, etc. This concept of Inheritance leads to the concept of polymorphism. Features or Advantages of Inheritance: Reusability: Inheritance helps the code to be reused in many situations. The base class is defined and once it is compiled, it need not be reworked. Using the concept of inheritance, the programmer can create as many derived classes from the base class as needed while adding specific features to each derived class as needed. Saves Time and Effort: The above concept of reusability achieved by inheritance saves the programmer time and effort. Since the main code written can be reused in various situations as needed. I ncreases Program Structure which results in greater reliability. Polymorphism General Format for implementing the concept of Inheritance: class derived_classname: access specifier baseclassname For example, if the base class is exforsys and the derived class is sample it is specified as: 56 class sample: public exforsys The above makes sample have access to both public and protected variables of base class exforsys. Reminder about public, private and protected access specifiers: If a member or variables defined in a class is private, then they are accessible by members of the same class only and cannot be accessed from outside the class. . Public members and variables are accessible from outside the class. . Protected access specifier is a stage between private and public. If a member functions or variables defined in a class are protected, then they cannot be accessed from outside the class but can be accessed from the derived class. Inheritance Example: class exforsys { public: exforsys(void) { x=0; } void f(int n1) { x= n1*5; } void output(void) { cout<<x; } private: int x; }; class sample: public exforsys { public: sample(void) { s1=0; } void f1(int n1) { s1=n1*10; } void output(void) { exforsys::output(); cout << s1; 57 } private: int s1; }; int main(void) { sample s; s.f(10); s.output(); s.f1(20); s.output(); } The output of the above program is 50 200 In the above example, the derived class is sample and the base class is exforsys. The derived class defined above has access to all public and private variables. Derived classes cannot have access to base class constructors and destructors. The derived class would be able to add new member functions, or variables, or new constructors or new destructors. In the above example, the derived class sample has new member function f1( ) added in it. The line: sample s; creates a derived class object named as s. When this is created, space is allocated for the data members inherited from the base class exforsys and space is additionally allocated for the data members defined in the derived class sample. The base class constructor exforsys is used to initialize the base class data members and the derived class constructor sample is used to initialize the data members defined in derived class. The access specifier specified in the line: class sample: public exforsys Public indicates that the public data members which are inherited from the base class by the derived class sample remains public in the derived class. 58 Inheritance leads to various issues such as: What is Inherited types of inheritance accessibility modes (public, private and protected) in inheritance Friend function and inheritance etc. #include <iostream> using namespace std; class Cpolygon { protected: int width, height; public: void input_values (int one, int two) { width=one; height=two; } }; class Crectangle: public Cpolygon { public: int area () { return (width * height); } }; class Ctriangle: public Cpolygon { public: int area () { return (width * height / 2); } }; int main () { Crectangle rectangle; Ctriangle triangle; rectangle.input_values (2,2); 59 triangle.input_values (2,2); cout << rectangle.area() << endl; cout << triangle.area() << endl; return 0; } In the example above we have used the protected members of the class Cpolygon in the class Crectangle and in the Ctriangle class. This is only possible through Inheritance. What is inherited? When inheritance is done, various links and tables (index, virtual etc) are created which are used to provide the accessibility of the members of the base class in derived class and in other class hierarchy. This means saying “public members are inherited” is better to say as “public members become accessible”. A derived class inherits every member of a base class except: its constructor and its destructor its friends its operator=() members Types of I nheritance There are five different inheritances supported in C++: (1) Simple / Single (2) Multilevel (3) Hierarchical (4) Multiple (5) Hybrid 60 Multiple I nheritance Multiple inheritance is achieved whenever more than one class acts as base classes for other classes. This makes the members of the base classes accessible in the derived class, resulting in better integration and broader re-usability. Take a look at an example: #include <iostream> using namespace std; class Cpolygon { protected: int width, height; public: void input_values (int one, int two) { width=one; height=two; } }; class Cprint { public: void printing (int output); 61 }; void Cprint::printing (int output) { cout << output << endl; } class Crectangle: public Cpolygon, public Cprint { public: int area () { return (width * height); } }; class Ctriangle: public Cpolygon, public Cprint { public: int area () { return (width * height / 2); } }; int main () { Crectangle rectangle; Ctriangle triangle; rectangle.input_values (2,2); triangle.input_values (2,2); rectangle.printing (rectangle.area()); triangle.printing (triangle.area()); return 0; } Note:the two public statements in the Crectangle class and Ctriangle class. Accessibility modes and I nheritance We can use the following chart for seeing the accessibility of the members in the Base class (first class) and derived class (second class). 62 Here X indicates that the members are not inherited, i.e. they are not accessible in the derived class. C++ Polymorphism Introduction Polymorphism is the ability to use an operator or function in different ways. Polymorphism gives different meanings or functions to the operators or functions. Poly, referring to many, signifies the many uses of these operators and functions. A single function usage or an operator functioning in many ways can be called polymorphism. Polymorphism refers to codes, operations or objects that behave differently in different contexts. Below is a simple example of the above concept of polymorphism: 6 + 10 The above refers to integer addition. The same + operator can be used with different meanings with strings: "Exforsys" + "Training" The same + operator can also be used for floating point addition: 7.15 + 3.78 Polymorphism is a powerful feature of the object oriented programming language C++. A single operator + behaves differently in different contexts such as integer, float or strings referring the concept of polymorphism. The above concept leads to operator overloading. The concept of 63 overloading is also a branch of polymorphism. When the exiting operator or function operates on new data type it is overloaded. This feature of polymorphism leads to the concept of virtual methods. Polymorphism refers to the ability to call different functions by using only one type of function call. Suppose a programmer wants to code vehicles of different shapes such as circles, squares, rectangles, etc. One way to define each of these classes is to have a member function for each that makes vehicles of each shape. Another convenient approach the programmer can take is to define a base class named Shape and then create an instance of that class. The programmer can have array that hold pointers to all different objects of the vehicle followed by a simple loop structure to make the vehicle, as per the shape desired, by inserting pointers into the defined array. This approach leads to different functions executed by the same function call. Polymorphism is used to give different meanings to the same concept. This is the basis for Virtual function implementation. In polymorphism, a single function or an operator functioning in many ways depends upon the usage to function properly. In order for this to occur, the following conditions must apply: All different classes must be derived from a single base class. In the above example, the shapes of vehicles (circle, triangle, rectangle) are from the single base class called Shape. The member function must be declared virtual in the base class. In the above example, the member function for making the vehicle should be made as virtual to the base class. Features and Advantages of the concept of Polymorphism: Applications are Easily Extendable: Once an application is written using the concept of polymorphism, it can easily be extended, providing new objects that conform to the original interface. It is unnecessary to recompile original programs by adding new types. Only re-linking is necessary to exhibit the new changes along with the old application. This is the greatest achievement of C++ object-oriented programming. In programming language, there has always been a need for adding and customizing. By utilizing the concept of polymorphism, time and work effort is reduced in addition to making future maintenance easier. Helps in reusability of code. Provides easier maintenance of applications. Helps in achieving robustness in applications. Types of Polymorphism: C++ provides three different types of polymorphism. Virtual functions Function name overloading Operator overloading 64 In addition to the above three types of polymorphism, there exist other kinds of polymorphism: run-time compile-time ad-hoc polymorphism parametric polymorphism Other types of polymorphism defined: run-time: The run-time polymorphism is implemented with inheritance and virtual functions. compile-time: The compile-time polymorphism is implemented with templates. ad-hoc polymorphism: If the range of actual types that can be used is finite and the combinations must be individually specified prior to use, this is called ad-hoc polymorphism. parametric polymorphism: If all code is written without mention of any specific type and thus can be used transparently with any number of new types it is called parametric polymorphism. In general, there are two main categories of Polymorphism namely Ad Hoc Polymorphism Pure Polymorphism Overloading concepts fall under the category of Ad Hoc Polymorphism and Virtual methods. Templates or parametric classes fall under the category of Pure Polymorphism. Virtual Functions What are Virtual Functions? Virtual, as the name implies, is something that exists in effect but not in reality. The concept of virtual function is the same as a function, but it does not really exist although it appears in needed places in a program. The object-oriented programming language C++ implements the concept of virtual function as a simple member function, like all member functions of the class. The functionality of virtual functions can be over-ridden in its derived classes. The programmer must pay attention not to confuse this concept with function overloading. Function overloading is 65 a different concept and will be explained in later sections of this tutorial. Virtual function is a mechanism to implement the concept of polymorphism (the ability to give different meanings to one function). Need for Virtual Function: The vital reason for having a virtual function is to implement a different functionality in the derived class. For example: a Make function in a class Vehicle may have to make a Vehicle with red color. A class called FourWheeler, derived or inherited from Vehicle, may have to use a blue background and 4 tires as wheels. For this scenario, the Make function for FourWheeler should now have a different functionality from the one at the class called Vehicle. This concept is called Virtual Function. Properties of Virtual Functions: Dynamic Binding Property: Virtual Functions are resolved during run-time or dynamic binding. Virtual functions are also simple member functions. The main difference between a non-virtual C++ member function and a virtual member function is in the way they are both resolved. A non-virtual C++ member function is resolved during compile time or static binding. Virtual Functions are resolved during run-time or dynamic binding Virtual functions are member functions of a class. Virtual functions are declared with the keyword virtual, detailed in an example below. Virtual function takes a different functionality in the derived class. Declaration of Virtual Function: Virtual functions are member functions declared with the keyword virtual. For example, the general syntax to declare a Virtual Function uses: class classname //This denotes the base class of C++ virtual function { public: virtual void memberfunctionname() //This denotes the C++ virtual function { ............. ............ } }; 66 Referring back to the Vehicle example, the declaration of Virtual function would take the shape below: class Vehicle //This denotes the base class of C++ virtual function { public: virtual void Make() //This denotes the C++ virtual function { cout <<"Member function of Base Class Vehicle Accessed"<<endl; } }; After the virtual function is declared, the derived class is defined. In this derived class, the new definition of the virtual function takes place. When the class FourWheeler is derived or inherited from Vehicle and defined by the virtual function in the class FourWheeler, it is written as: class Vehicle //This denotes the base class of C++ virtual function { public: virtual void Make() //This denotes the C++ virtual function { cout <<"Member function of Base Class Vehicle Accessed"<<endl; } }; class FourWheeler : public Vehicle { public: void Make() { cout<<"Virtual Member function of Derived class FourWheeler Accessed"<<endl; } }; void main() { Vehicle *a, *b; a = new Vehicle(); a->Make(); b = new FourWheeler(); b->Make(); } 67 In the above example, it is evidenced that after declaring the member functions Make() as virtual inside the base class Vehicle, class FourWheeler is derived from the base class Vehicle. In this derived class, the new implementation for virtual function Make() is placed. The programmer might be surprised to see the function call differs and the output is then printed as above. If the member function has not been declared as virtual, the base class member function is always called because linking takes place during compile time and is therefore static. In this example, the member function is declared virtual and the address is bounded only during run time, making it dynamic binding and thus the derived class member function is called. To achieve the concept of dynamic binding in C++, the compiler creates a v-table each time a virtual function is declared. This v-table contains classes and pointers to the functions from each of the objects of the derived class. This is used by the compiler whenever a virtual function is needed. C++ Pure Virtual Function and Virtual Base Class In this C++ tutorial, you will learn about pure virtual function, declaration of pure virtual function and virtual base class, virtual base class and how to implement a virtual base class, explained with examples. What is Pure Virtual Function: Pure Virtual Function is a Virtual function with no body. Declaration of Pure Virtual Function: Since pure virtual function has no body, the programmer must add the notation =0 for declaration of the pure virtual function in the base class. General Syntax of Pure Virtual Function takes the form: class classname //This denotes the base class of C++ virtual function { public: virtual void virtualfunctioname() = 0 //This denotes the pure virtual function in C++ }; The other concept of pure virtual function remains the same as described in the previous section of virtual function. 68 To understand the declaration and usage of Pure Virtual Function, refer to this example: class Exforsys { public: virtual void example()=0; //Denotes pure virtual Function Definition }; class Exf1:public Exforsys { public: void example() { cout<<"Welcome"; } }; class Exf2:public Exforsys { public: void example() { cout<<"To Training"; } }; void main() { Exforsys* arra[2]; Exf1 e1; Exf2 e2; arra[0]=&e1; arra[1]=&e2; arra[0]->example(); arra[1]->example(); } Since the above example has no body, the pure virtual function example() is declared with notation =0 in the base class Exforsys. The two derived class named Exf1 and Exf2 are derived from the base class Exforsys. The pure virtual function example() takes up new definition. In the main function, a list of pointers is defined to the base class. 69 Two objects named e1 and e2 are defined for derived classes Exf1 and Exf2. The address of the objects e1 and e2 are stored in the array pointers which are then used for accessing the pure virtual function example() belonging to both the derived class EXf1 and EXf2 and thus, the output is as in the above example. The programmer must clearly understand the concept of pure virtual functions having no body in the base class and the notation =0 is independent of value assignment. The notation =0 simply indicates the Virtual function is a pure virtual function as it has no body. Some programmers might want to remove this pure virtual function from the base class as it has no body but this would result in an error. Without the declaration of the pure virtual function in the base class, accessing statements of the pure virtual function such as, arra[0]->example() and arra[1]->example() would result in an error. The pointers should point to the base class Exforsys. Special care must be taken not to remove the statement of declaration of the pure virtual function in the base class. Virtual Base Class In the above example, there are two derived classes Exf1 and Exf2 from the base class Exforsys. As shown in the above diagram, the Training class is derived from both of the derived classes Exf1 and Exf2. In this scenario, if a user has a member function in the class Training where the user wants to access the data or member functions of the class Exforsys it would result in error if it is performed like this: class Exforsys { protected: int x; }; class Exf1:public Exforsys { }; 70 class Exf2:public Exforsys { }; class Training:public Exf1,public Exf2 { public: int example() { return x; } }; The above program results in a compile time error as the member function example() of class Training tries to access member data x of class Exforsys. This results in an error because the derived classes Exf1 and Exf2 (derived from base class Exforsys) create copies of Exforsys called subobjects. This means that each of the subobjects have Exforsys member data and member functions and each have one copy of member data x. When the member function of the class Training tries to access member data x, confusion arises as to which of the two copies it must access since it derived from both derived classes, resulting in a compile time error. When this occurs, Virtual base class is used. Both of the derived classes Exf1 and Exf2 are created as virtual base classes, meaning they should share a common subobject in their base class. For Example: class Exforsys { protected: int x; ; class Exf1:virtual public Exforsys { }; class Exf2:virtual public Exforsys { }; class Training:public Exf1,public Exf2 { 71 public: int example() { return x; } }; In the above example, both Exf1 and Exf2 are created as Virtual base classes by using the keyword virtual. This enables them to share a common subobject of their base class Exforsys. This results in only one copy that the member function example() of Class Training can access the member data x. C++ Polymorphism and Abstract Base Class Before you start reading this C++ tutorial on polymorphism you should have a good understanding of class inheritance and pointers. I ntroduction to Polymorphism Polymorphism is by far the most important and widely used concept in object oriented programming. Some of the widely used technologies and libraries like COM, MFC etc. have polymorphism as their foundation. If you look at all the original design patterns, almost every pattern uses polymorphism in its structure. Polymorphism is a mechanism that allows you to implement a function in different ways. Pointers to base class We have seen that it is possible to derive a class from a base class and that we can add functionality to member functions. One of the features of derived classes is that a pointer to a derived class is type-compatible with a pointer to its base class. Polymorphism takes advantage of this feature. Let‟s take a look at an example of a base class and derived classes: #include <iostream> using namespace std; class CPolygon { protected: int width, height; public: 72 void setup (int first, int second) { width= first; height= second; } }; class CRectangle: public CPolygon { public: int area() { return (width * height); } }; class CTriangle: public CPolygon { public: int area() { return (width * height / 2); } }; int main () { CRectangle rectangle; CTriangle triangle; CPolygon * ptr_polygon1 = &rectangle; CPolygon * ptr_polygon2 = &triangle; ptr_polygon1->setup(2,2); ptr_polygon2->setup(2,2); cout << rectangle.area () << endl; cout << triangle.area () << endl; return 0; } As you can see, we create two pointers (ptr_polygon1 and ptr_polygon2) that point to the objects of class CPolygon. Then we assign to these pointers the address of (using the reference 73 ampersand sign) the objects rectangle and triangle. Both rectangle and triangle are objects of classes derived from CPolygon. In the cout statement we use the objects rectangle and triangle instead of the pointers ptr_polygon1 and ptr_polygon2. We do this because ptr_polygon1 and ptr_polygon2 are of the type CPolygon. This means we can only use the pointers to refer to members that CRectangle and CTriangle inherit from Cpolygon. If we want to use the pointers to class CPolygon then area() should be declared in the class CPolygon and not only in the derived classes CRectangle and Ctriangle. The problem is that we use different versions of area() in the derived classes – CRectangle and Ctriangle – so we can‟t implement one version of area() in the base class CPolygon. (If they were the same we had no problem.) We can fix this by using virtual members. Virtual Members A virtual member is a member of a base class that we can redefine in its derived classes. To declare a member as virtual we must use the keyword virtual. Let‟s change our previous example: #include <iostream> using namespace std; class CPolygon { protected: int width, height; public: void setup (int first, int second) { width= first; height= second; } virtual int area() { return (0); } }; class CRectangle: public CPolygon { 74 public: int area() { return (width * height); } }; class CTriangle: public CPolygon { public: int area() { return (width * height / 2); } }; int main () { CRectangle rectangle; CTriangle triangle; CPolygon polygon; CPolygon * ptr_polygon1 = &rectangle; CPolygon * ptr_polygon2 = &triangle; CPolygon * ptr_polygon3 = &polygon; ptr_polygon1->setup(2,2); ptr_polygon2->setup(2,2); ptr_polygon3->setup(2,2); cout << ptr_polygon1->area () << endl; cout << ptr_polygon2->area () << endl; cout << ptr_polygon3->area () << endl; return 0; } Because of the change – adding area() as a virtual member of CPolygon – now all the three classes have all the same members (width, height, setup() and area().) A class that declares or inherits a virtual function is called a polymorphic class. 75 Abstract Base Classes (ABC) At the design level, an abstract base class (ABC) corresponds to an abstract concept. For instance: if you ask to draw a shape, I will probably ask what kind of shape. The term “shape” is an abstract concept, it could be a circle, a square, etc, etc. You could say in C++ that class CShape is an abstract base class (ABC) and class circle (etc) could be a derived class. As we look at the C++ language we could say that an abstract base class has one or more pure virtual member functions. In the example above we put an implementation (return (0);) in the virtual member function area(). If we want to change it into a pure virtual member function we use =0; instead of the return (0). So the class will look like this: class CPolygon { protected: int width, height; public: void setup (int first, int second) { width= first; height= second; } virtual int area() = 0; }; This pure virtual function area() makes CPolygon an abstract base class. But you have to remember the following: by adding a pure virtual member to the base class, you are forced to also add the member to any derived class. So our example should now look like this: #include <iostream> using namespace std; class CPolygon { protected: int width, height; public: void setup (int first, int second) { 76 width= first; height= second; } virtual int area() = 0; }; class CRectangle: public CPolygon { public: int area(void) { return (width * height); } }; class CTriangle: public CPolygon { public: int area(void) { return (width * height / 2); } }; int main () { CRectangle rectangle; CTriangle triangle; CPolygon * ptr_polygon1 = &rectangle; CPolygon * ptr_polygon2 = &triangle; ptr_polygon1->setup(2,2); ptr_polygon2->setup(2,2); cout << ptr_polygon1->area () << endl; cout << ptr_polygon2->area () << endl; return 0; } Note: there is also an extra void in the derived classes CRectangle and CTriangle. Using a unique type of pointer (CPolygon*) we can point to objects of different but related classes. 77 We can make use of that. For instance: we could implement an extra function member in the abstract base class CPolygon that can print the result of the area() function. (Remember that CPolygon itself has no implementation for the function area() and still we can use it, isn‟t it cool.) After implementation of such a function the example will look like this: #include <iostream> using namespace std; class CPolygon { protected: int width, height; public: void setup (int first, int second) { width= first; height= second; } virtual int area(void) = 0; void onscreen(void) { cout << this->area() << endl; } }; class CRectangle: public CPolygon { public: int area(void) { return (width * height); } }; class CTriangle: public CPolygon { public: int area(void) { return (width * height / 2); } }; int main () { 78 CRectangle rectangle; CTriangle triangle; CPolygon * ptr_polygon1 = &rectangle; CPolygon * ptr_polygon2 = &triangle; ptr_polygon1->setup(2,2); ptr_polygon2->setup(2,2); ptr_polygon1->onscreen(); ptr_polygon2->onscreen(); return 0; } As you can see this can be very useful. Dynamic Allocation In an earlier tutorial we already looked at dynamic allocation using the „new‟ operator. (So we don‟t have to explain that again). In this last section we will change the previous example and we will dynamically allocate the objects. Take a look at the next example: #include <iostream> using namespace std; class CPolygon { protected: int width, height; public: void setup (int first, int second) { width= first; height= second; } virtual int area(void) = 0; void onscreen(void) { cout << this->area() << endl; } }; 79 class CRectangle: public CPolygon { public: int area(void) { return (width * height); } }; class CTriangle: public CPolygon { public: int area(void) { return (width * height / 2); } }; int main () { CPolygon * ptr_polygon1 = new CRectangle; CPolygon * ptr_polygon2 = new CTriangle; ptr_polygon1->setup(2,2); ptr_polygon2->setup(2,2); ptr_polygon1->onscreen(); ptr_polygon2->onscreen(); delete ptr_polygon1; delete ptr_polygon2; return 0; } Typecasting Typecasting is the concept of converting the value of one type into another type. For example, you might have a float that you need to use in a function that requires an integer. 80 I mplicit conversion Almost every compiler makes use of what is called automatic typecasting. It automatically converts one type into another type. If the compiler converts a type it will normally give a warning. For example this warning: conversion from „double‟ to „int‟, possible loss of data. The problem with this is, that you get a warning (normally you want to compile without warnings and errors) and you are not in control. With control we mean, you did not decide to convert to another type, the compiler did. Also the possible loss of data could be unwanted. Explicit conversion The C and C++ languages have ways to give you back control. This can be done with what is called an explicit conversion. Sure you may still lose data, but you decide when to convert to another type and you don‟t get any compiler warnings. Let‟s take a look at an example that uses implicit and explicit conversion: #include <iostream> using namespace std; int main() { int a; double b=2.55; a = b; cout << a << endl; a = (int)b; cout << a << endl; a = int(b); cout << a << endl; } Note: the output of all cout statements is 2. The first conversion is an implicit conversion (the compiler decides.) As explained before, the compiler should give a warning. The second conversion is an explicit typecast, in this case the C style explicit typecast. 81 The third conversion is also explicit typecast, in this case the C++ style explicit typecast. Four typecast operators The C++ language has four typecast operators: static_cast reinterpret_cast const_cast dynamic_cast Static_cast Automatic conversions are common in every C++ program. You have: Standard conversion. For instance: from short to int or from int to float. User defined conversions (Class conversions.) Conversion from derived class to base class. (Take a look at the inheritance tutorial) The static_cast can be used for all these types of conversion. Take a look at an example: int a = 5; int b = 2; double out; // typecast a to double out = static_cast<double>(a)/b; It may take some time to get used to the notation of the typecast statement. (The rumour goes that Bjarne Stroustrup made it difficult on purpose, to discourage the use of typecasting.) Between the angle brackets you place to which type the object should be casted. Between the parentheses you place the object that is casted. It is not possible to use static_cast on const objects to non-const objects. For this you have to use const_cast. (Further down we take a look at const_cast.) If an automatic conversion is valid (from enum to int for instance) then you can use static_cast to do the opposite (from int to enum.) For instance: enum my_numbers { a=10, c=100, e=1000 }; 82 const my_numbers b = static_cast<my_numbers> (50); const my_numbers d = static_cast<my_numbers> (500); Note: We add some new values (b and d). These are type-cast from int to enum. Reinterpret_cast The reinterpret_cast is used for casts that are not save: Between integers and pointers Between pointers and pointers Between function-pointers and function-pointers For instance the typecast from an integer to a character pointer: char *ptr_my = reinterpret_cast<char *>(0xb0000); Note: the example above uses a fixed memory location. If we use the reinterpret_cast on a null-pointer then we get a null-pointer of the asked type: char *ptr_my = 0; int *ptr_my_second = reinterpret_cast<int *>(ptr_my); The reinterpret_cast is almost as dangerous as an “old fashion” cast. The only guaranty that you get is that if you cast an object back to the original data-type (before the first cast) then the original value is also restored (of course only if the data-type was big enough to hold the value.) The only difference with an old fashion cast is that const is respected. This means that a reinterpret_cast can not be used to cast a const object to non-const object. For instance: char *const MY = 0; // This is not valid because MY is a const!! int *ptr_my = reinterpret_cast<int *>( MY); 83 Const_cast The only way to cast away the const properties of an object is to use const_cast. Take a look at an example: void a(Person* b); int main() { const Person *ptr_my = new Person("Joe"); a( const_cast<Person *>(ptr_my) ); } The use of const_cast on an object doesn‟t guarantee that the object can be used (after the const is cast away.) Because it is possible that the const-objects are put in read-only memory by the program. The const_cast can not be used to cast to other data-types, as it is possible with the other cast functions. Take a look at the next example: int a; const char *ptr_my = "Hello"; a = const_cast<int *>(ptr_my); a = reinterpret_cast<const char*>(ptr_my); a = reinterpret_cast<int *>(const_cast<char *>(ptr_my) ); Note: casting from const char * to int * isn‟t very good (not to say a very dirty trick.) Normally you won‟t do this. The first statement (const_cast) will give an error, because the const_cast can‟t convert the type. The second statement (reinterpret_cast) will also give an error, because the reinterpret_cast can‟t cast the const away. The third statement will work (mind the note. It is a dirty trick, better not use it.) That is all for this tutorial. In typecasting part 2 we will look at RTTI, dynamic_cast, typeid and type_info. 84 RTTI, dynamic_cast, typeid and type_info Before you start this C++ programming tutorial on RTTI, dynamic_cast, typeid and type_info, make sure you fully understand the previous tutorial on static_cast, const_cast and reinterpret_cast. Runtime Type I nformation (RTTI ) Runtime Type Information (RTTI) is the concept of determining the type of any variable during execution (runtime.) The RTTI mechanism contains: The operator dynamic_cast The operator typeid The struct type_info RTTI can only be used with polymorphic types. This means that with each class you make, you must have at least one virtual function (either directly or through inheritance.) Compatibility note: On some compilers you have to enable support of RTTI to keep track of dynamic types. So to make use of dynamic_cast (see next section) you have to enable this feature. See you compiler documentation for more detail. Dynamic_cast The dynamic_cast can only be used with pointers and references to objects. It makes sure that the result of the type conversion is valid and complete object of the requested class. This is way a dynamic_cast will always be successful if we use it to cast a class to one of its base classes. Take a look at the example: class Base_Class { }; class Derived_Class: public Base_Class { }; Base_Class a; Base_Class * ptr_a; Derived_Class b; Derived_Class * ptr_b; ptr_a = dynamic_cast<Base_Class *>(&b); ptr_b = dynamic_cast<Derived_Class *>(&a); The first dynamic_cast statement will work because we cast from derived to base. The second dynamic_cast statement will produce a compilation error because base to derived conversion is not allowed with dynamic_cast unless the base class is polymorphic. 85 If a class is polymorphic then dynamic_cast will perform a special check during execution. This check ensures that the expression is a valid and complete object of the requested class. Take a look at the example: // dynamic_cast #include <iostream> #include <exception> using namespace std; class Base_Class { virtual void dummy() {} }; class Derived_Class: public Base_Class { int a; }; int main () { try { Base_Class * ptr_a = new Derived_Class; Base_Class * ptr_b = new Base_Class; Derived_Class * ptr_c; ptr_c = dynamic_cast< Derived_Class *>(ptr_a); if (ptr_c ==0) cout << "Null pointer on first type-cast" << endl; ptr_c = dynamic_cast< Derived_Class *>(ptr_b); if (ptr_c ==0) cout << "Null pointer on second type-cast" << endl; } catch (exception& my_ex) {cout << "Exception: " << my_ex.what();} return 0; } In the example we perform two dynamic_casts from pointer objects of type Base_Class* (namely ptr_a and ptr_b) to a pointer object of type Derived_Class*. If everything goes well then the first one should be successful and the second one will fail. The pointers ptr_a and ptr_b are both of the type Base_Class. The pointer ptr_a points to an object of the type Derived_Class. The pointer ptr_b points to an object of the type Base_Class. So when the dynamic type cast is performed then ptr_a is pointing to a full object of class Derived_Class, but the pointer ptr_b points to an object of class Base_Class. This object is an incomplete object of class Derived_Class; thus this cast will fail! Because this dynamic_cast fails a null pointer is returned to indicate a failure. When a reference type is converted with dynamic_cast and the conversion fails then there will be an exception thrown out instead of the null pointer. The exception will be of the type bad_cast. 86 With dynamic_cast it is also possible to cast null pointers even between the pointers of unrelated classes. Dynamic_cast can cast pointers of any type to void pointer(void*). Typeid and typ_info If a class hierarchy is used then the programmer doesn‟t have to worry (in most cases) about the data-type of a pointer or reference, because the polymorphic mechanism takes care of it. In some cases the programmer wants to know if an object of a derived class is used. Then the programmer can make use of dynamic_cast. (If the dynamic cast is successful, then the pointer will point to an object of a derived class or to a class that is derived from that derived class.) But there are circumstances that the programmer (not often) wants to know the prizes data-type. Then the programmer can use the typeid operator. The typeid operator can be used with: Variables Expressions Data-types Take a look at the typeid example: #include <iostream> #include <typeinfo> using namespace std; int main () { int * a; int b; a=0; b=0; if (typeid(a) != typeid(b)) { cout << "a and b are of different types:\n"; cout << "a is: " << typeid(a).name() << '\n'; cout << "b is: " << typeid(b).name() << '\n'; } return 0; } Note: the extra header file typeinfo. 87 The result of a typeid is a const type_info&. The class type_info is part of the standard C++ library and contains information about data-types. (This information can be different. It all depends on how it is implemented.) A bad_typeid exception is thrown by typeid, if the type that is evaluated by typeid is a pointer that is preceded by a dereference operator and that pointer has a null value. UNIT-4 What is a Stream? A stream is an object where a program can either insert or extract characters to or from it. The standard input and output stream objects of C++ are declared in the header file iostream. Standard Input Stream Generally, the device used for input is the keyboard. For inputting, the keyword cin is used, which is an object. The overloaded operator of extraction, >>, is used on the standard input stream, in this case: cin stream. Syntax for using the standard input stream is cin followed by the operator >> followed by the variable that stores the data extracted from the stream. For example: int prog; cin >> prog; In the example above, the variable prog is declared as an integer type variable. The next statement is the cin statement. The cin statement waits for input from the user‟s keyboard that is then stored in the integer variable prog. The input stream cin wait before proceeding for processing or storing the value. This duration is dependent on the user pressing the RETURN key on the keyboard. The input stream cin waits for the user to press the RETURN key then begins to process the command. It is also possible to request input for more than one variable in a single input stream statement. A single cin statement is as follows: cin >> x >> y; is the same as: cin >> x; cin >> y; 88 In both of the above cases, two values are input by the user, one value for the variable x and another value for the variable y. // This is a sample program This is a comment Statement #include <iostream.h> Header File Inclusion Statement void main() { int sample, example; cin >> sample; cin >> example; } If a programmer wants to write comments in C++ program, the comments should follow after a pair of slashes denoted by //. All the characters after the // are ignored by C++ compiler and the programmer can choose to comment after the // In the above example, two integer variables are input with values. The programmer can produce input of any data type. It is also possible to input strings in C++ program using cin. This is performed using the same procedures. The vital point to note is cin stops when it encounters a blank space. When using a cin, it is possible to produce only one word. If a user wants to input a sentence, then the above approach would be tiresome. For this purpose, there is a function in C++ called getline. Standard Output Stream By default, the device used for output is the screen of the computer. For outputting values the keyword cout is used, which is an object. The insertion operator << is used on the standard output cout stream. The syntax for using the standard output stream is cout followed by the operator << followed by the value to be inserted or output by the insertion operator. For example: int prog; cin >> prog; cout << prog; In the above example, the variable prog is declared as an integer type variable. The next statement is the cin statement that waits for input from the user‟s keyboard. This information is then stored in the integer variable prog. The value of prog is displayed on the screen by the standard output stream cout. It is also possible to display a sentence as follows: cout << “ Training given by Exforsys”; 89 The above gives output as: Training given by Exforsys If a programmer chooses to use constant strings of characters, they must be enclosed between double quotes “ ”. In this situation, it is important to note the difference between the two statements below: cout << "exforsys"; cout << exforsys; In the above, the first statement displays on the screen as exforsys. The second statement outputs the value of the variable exforsys. As previously explained, the extraction operator >> can be used more than once in a single cin statement. Similarly, it is possible to use the insertion operator << more than once in a cout statement. For example cout << "Exforsys" << "gives" << "excellent training"; This produces output on the screen as: Exforsys gives excellent training The above concept is mainly used if the programmer chooses to print string constants followed by variables. In this next example, the programmer chooses to display a combination of string constants and variables. For example int a=50; cout << "Exforsys has given" << a << "numbers of trainings"; This produces the output as: Exforsys has given 50 numbers of trainings Below is one more example: 90 cout << “Exforsys”; cout << “Training”; The above produces output as: Exforsys Training An important point to note from the above example is cout does not give a line break unless specified. If the programmer chooses to display output in a new line, it must be explicitly specified in cout by using the \n which denotes newline character. for example cout << "Exforsys\n "; cout << "Training"; gives output as Exforsys Training There is also another way for specifying newline that is by using endl manipulator. For example cout << "Exforsys" << endl; cout << "Training"; gives the same output as Exforsys Training Example to demonstrate the use of input and output streams // Example to demonstrate the use of Input and Output streams #include <iostream.h> void main() { int a,b; cout << “Enter the value of a:”; cin >> a; b=a+10; 91 cout << “Value of b is:”<<b; } File IO in C++ (text and binary files) This C++ programming language tutorial will be in two parts. The first (this one) will cover the theory behind IO and in the second tutorial we will look at some examples. I nput-Output Input – Output is a process of transfer of data from one computer device to another or from one part of the computer to another. There are three categories of Input-Output: Standard IO Memory IO Network IO Standard IO is used frequently for which C++ provides cin, cout, cerr and clog streams. IO in C++ is done through stream classes, which are having the following inheritance hierarchy: We can use the ifstream, ofstream and fstream classes to perform file IO. (cin is an object of class istream and cout is an object of class ostream.) 92 File IO means transfer of data from secondary memory (hard disk) to main memory or vice-versa. A schematic showing the flow of data and classes involved is as follows: Note: The arrows indicate the flow of data. Text and binary files The C++ language supports two types of files: Text files Binary files The basic difference between text files and binary files is that in text files various character translations are performed such as “\r+\f” is converted into “\n”, whereas in binary files no such translations are performed. By default, C++ opens the files in text mode. In the tables below we will see the various steps and operations that can (or must) be performed to use files in C++: 1)Creating or opening a file For writing data Text Files ofstream out (”myfile.txt”); or ofstream out; Binary Files ofstream out (”myfile.txt”,ios::binary); or ofstream out; 93 out.open(”myfile.txt”); out.open(”myfile.txt”, ios::binary); For Appending (adding text at the end of the existing file) Text Files ofstream out(”myfile.txt”,ios::app); or ofstream out; out.open(”myfile.txt”, ios::app); Binary Files ofstream out (”myfile.txt”,ios::app|ios::binary); or ofstream out; out.open(”myfile.txt”, ios::app | ios::binary); For reading data Text Files ifstream in (”myfile.txt”); or ifstream in ; in.open(”myfile.txt”); Binary Files ifstream in (”myfile.txt”, ios::binary); or ifstream in ; in.open(”myfile.txt”, ios::binary); 2) Closing Files (after reading or writing) ofstream object “out” Ifstream object “in” out.close(); in.close(); 3) Reading / Writing Data to and from files Data Functions for reading file Function for writing into file 94 char get(); put(); 1 word >> (extraction operator) << (insertion operator) >=1 word getline(); << (insertion operator) Objects read() write() Binary data Same as above Same as above 4) Functions that can be used to perform special tasks Operation function Description Checking end of file. eof() Used to check eof during the reading of file Check if an operation fails. bad() Returns true if a reading or writing operation fails. Check if an operation fails. Fail() Returns true in the same cases as bad(), but also in the case that a format error happens. Checking for opened file. is_open(); Checks if the file is opened or not, returns true if the file is opened else false Number of bytes already read. gcount() Returns count of the bytes read from the file 95 Ignoring characters during file read. ignore() Ignores n bytes from the file. (get pointer is positioned after n character) Checking next character. peek() Checks the next available character, will not increase the get pointer to next character. Random access (only for binary files). seekg() seekp() tellg() tellp() In case of binary files random access is performed using these functions. They either give or set the position of get and put pointers on the particular location Read and Write characters (text file) In the example below we will write and read characters from a text file. We will write a character (given by the user) to a file test.txt as long as the answer to the question “Continue?:” is replayed with y (from yes). If we answer with something else the program must close the test.txt file. The last part of the program will read all characters in the file test.txt. #include<iostream> #include<fstream> using namespace std; int main(int argc, char *argv[]) { //code to write characters in a file char c, ans; ans='y'; //Open an output stream ofstream out ("test.txt"); if(out.is_open()) { //Loop will continue until something other then y is entered 96 while (ans=='y') { cout <<endl << "Continue ?"; cin >> ans; if(ans=='y') { cout << endl << "Enter Character :"; cin >> c; out.put(c); } } } out.close(); //code for reading file completely ifstream in("test.txt"); if(in.is_open()) { while(!in.eof()) { c = in.get(); if(!in.eof()) cout << c; } } in.close(); } Special flags The table below shows the special flags that can be used to manage files. (These flags are used during opening of the files). ios::app Opens the file in append mode ios::ate Opens the file and set the cursor at end of the file ios::binary Opens the file in binary mode ios::in Opens the file for reading ios::out Opens the file for writing ios::trunc Opens the file and truncates all the contents from it 97 Binary copy In the next example we will copy a binary file to another binary file. We will open two files in binary mode, one for reading and one for writing. If both are open then we will copy the content of one file to another. #include<iostream> #include<fstream> using namespace std; int main(int argc, char *argv[]) { //Open an input and output stream in binary mode ifstream in("myimage.jpg",ios::binary); ofstream out("myimage1.jpg",ios::binary); if(in.is_open() && out.is_open()) { while(!in.eof()) { out.put(in.get()); } } //Close both files in.close(); out.close(); } Note: of course you need to supply the myimage.jpg file to copy (or any other jpg file). Reading and writing an object In this last example we will write and read an object (student object) to and from a file: #include<iostream> #include<fstream> using namespace std; class Student 98 { char name[20]; int mark; public: void GetStudentData(); void ShowStudentData(); }; void Student :: GetStudentData() { cout << "Enter Student Name:" << endl; cin >> name; cout << "Enter Student Mark:" << endl; cin >> mark; } void Student :: ShowStudentData() { cout << "Student Details are:" << endl; cout << "Name: " << name << endl << "Mark: " << mark << endl; } int main(int argc, char *argv[]) { char ans='y'; Student sobj; //We open student.dat in append mode ofstream out("student.dat", ios::app); if(out.is_open()) { //Loop will continue until something other then y is entered while( ans == 'y') { cout << endl << "Continue ?"; cin >> ans; if(ans == 'y') { sobj.GetStudentData(); out.write((char*) & sobj, sizeof(sobj)); } } } out.close(); 99 ifstream in("student.dat"); if(in.is_open()) { while(!in.eof()) { in.read((char*) &sobj, sizeof(sobj)); if(!in.eof()) { sobj.ShowStudentData(); } } } in.close(); } As you can see there are many ways to do file IO in the C++ programming language. IOstream Library (Standard Input / Output Streams Library ) The iostream library is an object-oriented library that provides input and output functionality using streams. A stream is an abstraction that represents a device on which input and ouput operations are performed. A stream can basically be represented as a source or destination of characters of indefinite length. 100 Streams are generally associated to a physical source or destination of characters, like a disk file, the keyboard, or the console, so the characters gotten or written to/from our abstraction called stream are physically input/output to the physical device. For example, file streams are C++ objects to manipulate and interact with files; Once a file stream is used to open a file, any input or output operation performed on that stream is physically reflected in the file. To operate with streams, C++ provides the standard iostream library, which contains the following elements: Basic class templates The base of the iostream library is the hierarchy of class templates. The class templates provide most of the functionality of the library in a type-independent fashion. This is a set of class templates, each one having two template parameters: the char type (charT) parameter, that determines the type of elements that are going to be manipulated and the traits parameter, that provides additional characteristics specific for a particular type of elements. The class templates in this class hierarchy have the same name as their char-type instantiations but with the prefix basic_. For example, the class template which istream is instantiated from is called basic_istream, the one from which fstream is is called basic_fstream, and so on... The only exception is ios_base, which is by itself type-independent, and therefore is not based on a template, but is a regular class. Class template instantiations The library incorporates two standard sets of instantiations of the entire iostream class template hierarchy: one is narrow-oriented, to manipulate elements of type char and another one, wide-oriented, to manipulate elements of type wchar_t. The narrow-oriented (char type) instantiation is probably the better known part of the iostream library. Classes like ios, istream and ofstream are narrow-oriented. The diagram on top of this page shows the names and relationships of narrow-oriented classes. The classes of the wide-oriented (wchar_t) instatiation follow the same naming conventions as the narrow-oriented instantiation but with the name of each class and object prefixed with a w character, forming wios, wistream and wofstream, as an example. Standard objects As part of the iostream library, the header file <iostream> declares certain objects that are used to perform input and output operations on the standard input and output. 101 They are divided in two sets: narrow-oriented objects, which are the popular cin, cout, cerr and clog and their wide-oriented counterparts, declared as wcin, wcout, wcerr and wclog. Types The iostream classes barely use fundamental types on their member's prototypes. They generally use defined types that depend on the traits used in their instantiation. For the default char and wchar_t instantiations, types streampos, streamoff and streamsize are used to represent positions, offsets and sizes, respectively. Manipulators Manipulators are global functions designed to be used together with insertion (<<) and extraction (>>) operators performed on iostream stream objects. They generally modify properties and formatting settings of the streams. endl, hex and scientific are some examples of manipulators. Organization The library and its hierarchy of classes is split in different files: <ios>, <istream>, <ostream>, <streambuf> and <iosfwd> aren't usually included directly in most C++ programs. They describe the base classes of the hierarchy and are automatically included by other header files of the library that contain derived classes. <iostream> declares the objects used to communicate through the standard input and output (including cin and cout). <fstream> defines the file stream classes (like the template basic_ifstream or the class ofstream) as well as the internal buffer objects used with these (basic_filebuf). These classes are used to manipulate files using streams. <sstream>: The classes defined in this file are used to manipulate string objects as if they were streams. <iomanip> declares some standard manipulators with parameters to be used with extraction and insertion operators to modify internal flags and formatting options. Compatibility notes The names, prototypes and examples included in this reference for the iostream classes mostly describe and use the char instantiations of the class templates instead of the templates themselves, even though these classes are only one of their possible instantiations. We believe this provides a better readability and is arguably as easy to obtain the names and prototypes of the basic template from the char instantiation as the opposite. Elements of the iostream library (char instantitation) Classes: ios_base Base class with type-independent members for the standard stream classes (class) ios Base class with type-dependent members for the standard stream classes (class) 102 istream Input stream (class) ostream Output Stream (class) iostream Input/Output Stream (class) ifstream Input file stream class (class) ofstream Output file stream (class) fstream Input/output file stream class (class) istringstream Input string stream class (class) ostringstream Output string stream class (class) stringstream Input/output string stream class (class) streambuf Base buffer class for streams (class) filebuf File stream buffer (class) stringbuf String stream buffer (class) Objects: cin Standard input stream (object) cout Standard output stream (object) cerr Standard output stream for errors (object) clog Standard output stream for logging (object) Types: fpos Stream position class template (class template) streamoff Stream offset type (type) streampos Stream position type (type) streamsize Stream size type (types) Manipulators: boolalpha Alphanumerical bool values (manipulator function) dec Use decimal base (manipulator function) endl Insert newline and flush (manipulator function) 103 ends Insert null character (manipulator function) fixed Use fixed-point notation (manipulator function) flush Flush stream buffer (manipulator function) hex Use hexadecimal base (manipulator function) internal Adjust field by inserting characters at an internal position (manipulator function) left Adjust output to the left (manipulator function) noboolalpha No alphanumerical bool values (manipulator function) noshowbase Do not show numerical base prefixes (manipulator function) noshowpoint Do not show decimal point (manipulator function) noshowpos Do not show positive signs (manipulator function) noskipws Do not skip whitespaces (manipulator function) nounitbuf Do not force flushes after insertions (manipulator function) nouppercase Do not generate upper case letters (manipulator function) oct Use octal base (manipulator function) resetiosflags Reset format flags (manipulator function) right Adjust output to the right (manipulator function) scientific Use scientific notation (manipulator function) setbase Set basefield flag (manipulator function) setfill Set fill character (manipulator function) setiosflags Set format flags (manipulator function) setprecision Set decimal precision (manipulator function) 104 setw Set field width (manipulator function) showbase Show numerical base prefixes (manipulator function) showpoint Show decimal point (manipulator function) showpos Show positive signs (manipulator function) skipws Skip whitespaces (manipulator function) unitbuf Flush buffer after insertions (manipulator function) uppercase Generate upper-case letters (manipulator function) ws Extract whitespaces (manipulator function) What is a Manipulator? Manipulators are operators used in C++ for formatting output. The data is manipulated by the programmer‟s choice of display. There are numerous manipulators available in C++. Some of the more commonly used manipulators are provided here below: endl Manipulator: This manipulator has the same functionality as the „\n‟ newline character. For example: cout << "Exforsys" << endl; cout << "Training"; 105 produces the output: Exforsys Training setw Manipulator: This manipulator sets the minimum field width on output. The syntax is: setw(x) Here setw causes the number or string that follows it to be printed within a field of x characters wide and x is the argument set in setw manipulator. The header file that must be included while using setw manipulator is <iomanip.h> #include <iostream.h> #include <iomanip.h> void main( ) { int x1=12345,x2= 23456, x3=7892; cout << setw(8) << ”Exforsys” << setw(20) << ”Values” << endl << setw(8) << “E1234567” << setw(20)<< x1 << end << setw(8) << “S1234567” << setw(20)<< x2 << end << setw(8) << “A1234567” << setw(20)<< x3 << end; } The output of the above example is: setw(8) setw(20) Exforsys Values E1234567 12345 106 S1234567 23456 A1234567 7892 setfill Manipulator: This is used after setw manipulator. If a value does not entirely fill a field, then the character specified in the setfill argument of the manipulator is used for filling the fields. #include <iostream.h> #include <iomanip.h> void main( ) { cout << setw(10) << setfill('$') << 50 << 33 << endl; } The output of the above program is $$$$$$$$5033 This is because the setw sets 10 width for the field and the number 50 has only 2 positions in it. So the remaining 8 positions are filled with $ symbol which is specified in the setfill argument. setprecision Manipulator: The setprecision Manipulator is used with floating point numbers. It is used to set the number of digits printed to the right of the decimal point. This may be used in two forms: fixed scientific These two forms are used when the keywords fixed or scientific are appropriately used before the setprecision manipulator. The keyword fixed before the setprecision manipulator prints the 107 floating point number in fixed notation. The keyword scientific before the setprecision manipulator prints the floating point number in scientific notation. #include <iostream.h> #include <iomanip.h> void main( ) { float x = 0.1; cout << fixed << setprecision(3) << x << endl; cout << sceintific << x << endl; } The above gives ouput as: 0.100 1.000000e-001 C++ Tutorial – Namespaces and anonymous namespaces Namespaces are used in the C++ programming language to create a separate region for a group of variables, functions and classes etc. Namespaces are needed because there can be many functions, variables for classes in one program and they can conflict with the existing names of variables, functions and classes. C++ uses namespace to avoid the conflicts. The concept can be depicted using the following diagram: 108 The following will list the primary reasons due to which a conflict can occur: Between User defined variables/functions/classes and built in Library variables/functions/classes (e.g. sqrt(), abs() etc.) Between the separately included library and built in library Between the variables/functions/classes of the one separately included library and the same of the other separately included library Creating Namespaces The C++ language include the keyword “namespace” for creating namespaces. namespace { members of namespace; } Take a look at an example: #include<iostream> using namespace std; namespace myconstants { const double pi = 3.141592; } namespace myshapes { double area; double perimeter; void AreaOfCircle(double radius) { area = myconstants::pi * radius * radius; } void PerimeterOfCircle(double radius) { perimeter = 2 * myconstants::pi * radius; } } int main(int argc, char * argv[]) { 109 double r; cout << endl << "Enter Radius:"; cin >> r; myshapes::AreaOfCircle(r); cout << endl << "Area of the Circle is :" << myshapes::area; myshapes::PerimeterOfCircle(r); cout << endl << "Perimeter of the Circle is :" << myshapes::perimeter; } Namespaces have the following important points: 1) We can have more than one namespace of the same name. This gives the advantage of defining the same namespace in more than one file (although they can be created in the same file as well). Take a look at an example: #include<iostream> using namespace std; namespace mynamespace { int x; } namespace mynamespace { int y; } int main(int argc, char * argv[]) { mynamespace::x = mynamespace::y =5; cout << mynamespace::x << endl << mynamespace::y; } 2)We can have anonymous namespaces (namespace with no name). They are directly usable in the same program and are used for declaring unique identifiers. It also avoids making global static variable. The “anonymous” namespace you have created will only be accessible within the file you created it in. 110 Take a look at an example: /*This is file1.cpp*/ #include<iostream> using namespace std; namespace { int local; } void func(); int main() { local = 1; cout << "Local=" << local << endl; func(); cout << "Local=" << local << endl; return 0; } /* This is file2.cpp */ namespace { // Should not collide with other files int local; } void func() { local = 2; } Note: you will need to include both the files in the same project. The result of this program should be: Local = 1 Local = 1 111 It should not be: Local = 1 Local = 2 3) C++ has a default namespace named std, which contains all the default library of the C++ included using #include directive. Using Namespaces Namespaces are used with the „using‟ keyword, which makes all the members of the namespace available in the current program and the members can be used directly, without taking reference of the namespace. Namespaces are also usable by taking their name reference with scope resolution operator. This method allows distinguishing between the members of the same name in two different namespaces. Take a look at an example: #include<iostream> using namespace std; namespace mynamespace { int i,j; } using namespace mynamespace; int main(int argc, char *argv[]) { cout << endl << i << ", " << j; } Or without the „using‟ keyword: #include<iostream> using namespace std; namespace mynamespace { 112 int i,j; } int main(int argc, char *argv[]) { std::cout << endl << mynamespace::i << ", " << mynamespace::j; } Namespace alias It is also possible to declare an alternate name for an existing namespace. We can use the following format: namespace new_name = current_name; Namespace std All the files in the C++ standard library declare all of its entities within the std namespace. For that reason we include the „using namespace std;‟ statement in most programs that is using any entity defined in iostream. UNIT-5 Unit-5 C++ Function templates are those functions which can handle different data types without separate code for each of them. For a similar operation on several kinds of data types, a programmer need not write different versions by overloading a function. It is enough if he writes a C++ template based function. This will take care of all the data types. There are two types of templates in C++, viz., function templates and class templates. This article deals with only the function templates. There are lot of occasions, where we might need to write the same functions for different data types. A favorite example can be addition of two variables. The variable can be integer, float or double. The requirement will be to return the corresponding return type based on the input type. If we start writing one function for each of the data type, then we will end up with 4 to 5 different functions, which can be a night mare for maintenance. 113 C++ templates come to our rescue in such situations. When we use C++ function templates, only one function signature needs to be created. The C++ compiler will automatically generate the required functions for handling the individual data types . This is how a programmer's life is made a lot easier. C++ Template functions - Details: Let us assume a small example for Add function. If the requirement is to use this Add function for both integer and float, then two functions are to be created for each of the data type (overloading). int Add(int a,int b) { return a+b;} // function Without C++ template float Add(float a, float b) { return a+b;} // function Without C++ template If there are some more data types to be handled, more functions should be added. But if we use a c++ function template, the whole process is reduced to a single c++ function template. The following will be the code fragment for Add function. template <class T> T Add(T a, T b) //C++ function template sample { return a+b; } This c++ function template definition will be enough. Now when the integer version of the function, the compiler generates an Add function compatible for integer data type and if float is called it generates float type and so on. Here T is the typename. This is dynamically determined by the compiler according to the parameter passed. The keyword class means, the parameter can be of any type. It can even be a class. C++ Template functions - Applicability: C++ function templates can be used wherever the same functionality has to be performed with a number of data types. Though very useful, lots of care should be taken to test the C++ template functions during development. A well written c++ template will go a long way in saving time for programmers. C++ Class Templates are used where we have multiple copies of code for different data types with the same logic. If a set of functions or classes have the same functionality for different data types, they becomes good candidates for being written as Templates. 114 One good area where this C++ Class Templates are suited can be container classes. Very famous examples for these container classes will be the STL classes like vector, list etc., Once code is written as a C++ class template, it can support all data types. Though very useful, It is advisable to write a class as a template after getting a good hands-on experience on the logic (by writing the code with normal data types). There are cases where we need specialization for writing optimized code for specific data types. This C++ class template Specialization article gives a brief description. This article describes how to declare, define and use the C++ Class Templates in practice. This tries to build a very preliminary Queue, using the STL::Vector container class. This code is written and tested with Microsoft Visual C++ 5.00. Declaring C++ Class Templates: Declaration of C++ class template should start with the keyword template. A parameter should be included inside angular brackets. The parameter inside the angular brackets, can be either the keyword class or typename. This is followed by the class body declaration with the member data and member functions. The following is the declaration for a sample Queue class. //Sample code snippet for C++ Class Template template <typename T> class MyQueue { std::vector<T> data; public: void Add(T const &d); void Remove(); void Print(); }; The keyword class highlighted in blue color, is not related to the typename. This is a mandatory keyword to be included for declaring a template class. Defining member functions - C++ Class Templates: If the functions are defined outside the template class body, they should always be defined with the full template definition. Other conventions of writing the function in C++ class templates are the same as writing normal c++ functions. template <typename T> void MyQueue<T> ::Add(T const &d) { data.push_back(d); } template <typename T> void MyQueue<T>::Remove() { 115 data.erase(data.begin( ) + 0,data.begin( ) + 1); } template <typename T> void MyQueue<T>::Print() { std::vector <int>::iterator It1; It1 = data.begin(); for ( It1 = data.begin( ) ; It1 != data.end( ) ; It1++ ) cout << " " << *It1<<endl; } The Add function adds the data to the end of the vector. The remove function removes the first element. These functionalities make this C++ class Template behave like a normal Queue. The print function prints all the data using the iterator. Full Program - C++ Class Templates: //C++_Class_Templates.cpp #include <iostream.h> #include <vector> template <typename T> class MyQueue { std::vector<T> data; public: void Add(T const &); void Remove(); void Print(); }; template <typename T> void MyQueue<T> ::Add(T const &d) { data.push_back(d); } template <typename T> void MyQueue<T>::Remove() { data.erase(data.begin( ) + 0,data.begin( ) + 1); } template <typename T> void MyQueue<T>::Print() { 116 std::vector <int>::iterator It1; It1 = data.begin(); for ( It1 = data.begin( ) ; It1 != data.end( ) ; It1++ ) cout << " " << *It1<<endl; } //Usage for C++ class templates void main() { MyQueue<int> q; q.Add(1); q.Add(2); cout<<"Before removing data"<<endl; q.Print(); q.Remove(); cout<<"After removing data"<<endl; q.Print(); } Advantages of C++ Class Templates: One C++ Class Template can handle different types of parameters. Compiler generates classes for only the used types. If the template is instantiated for int type, compiler generates only an int version for the c++ template class. Templates reduce the effort on coding for different data types to a single set of code. Testing and debugging efforts are reduced. Templates Function templates Function templates are special functions that can operate with generic types. This allows us to create a function template whose functionality can be adapted to more than one type or class without repeating the entire code for each type. In C++ this can be achieved using template parameters. A template parameter is a special kind of parameter that can be used to pass a type as argument: just like regular function parameters can be used to pass values to a function, template parameters allow to pass also types to a function. These function templates can use these parameters as if they were any other regular type. 117 The format for declaring function templates with type parameters is: template <class identifier> function_declaration; template <typename identifier> function_declaration; The only difference between both prototypes is the use of either the keyword class or the keyword typename. Its use is indistinct, since both expressions have exactly the same meaning and behave exactly the same way. For example, to create a template function that returns the greater one of two objects we could use: template <class myType> myType GetMax (myType a, myType b) { return (a>b?a:b); } Here we have created a template function with myType as its template parameter. This template parameter represents a type that has not yet been specified, but that can be used in the template function as if it were a regular type. As you can see, the function template GetMax returns the greater of two parameters of this still-undefined type. To use this function template we use the following format for the function call: function_name <type> (parameters); For example, to call GetMax to compare two integer values of type int we can write: int x,y; GetMax <int> (x,y); When the compiler encounters this call to a template function, it uses the template to automatically generate a function replacing each appearance of myType by the type passed as the actual template parameter (int in this case) and then calls it. This process is automatically performed by the compiler and is invisible to the programmer. Here is the entire example: // function template #include <iostream> 6 10 118 using namespace std; template <class T> T GetMax (T a, T b) { T result; result = (a>b)? a : b; return (result); } int main () { int i=5, j=6, k; long l=10, m=5, n; k=GetMax<int>(i,j); n=GetMax<long>(l,m); cout << k << endl; cout << n << endl; return 0; } In this case, we have used T as the template parameter name instead of myType because it is shorter and in fact is a very common template parameter name. But you can use any identifier you like. In the example above we used the function template GetMax() twice. The first time with arguments of type int and the second one with arguments of type long. The compiler has instantiated and then called each time the appropriate version of the function. As you can see, the type T is used within the GetMax() template function even to declare new objects of that type: T result; Therefore, result will be an object of the same type as the parameters a and b when the function template is instantiated with a specific type. In this specific case where the generic type T is used as a parameter for GetMax the compiler can find out automatically which data type has to instantiate without having to explicitly specify it within angle brackets (like we have done before specifying <int> and <long>). So we could have written instead: int i,j; GetMax (i,j); 119 Since both i and j are of type int, and the compiler can automatically find out that the template parameter can only be int. This implicit method produces exactly the same result: // function template II #include <iostream> using namespace std; template <class T> T GetMax (T a, T b) { return (a>b?a:b); } int main () { int i=5, j=6, k; long l=10, m=5, n; k=GetMax(i,j); n=GetMax(l,m); cout << k << endl; cout << n << endl; return 0; } 6 10 Notice how in this case, we called our function template GetMax() without explicitly specifying the type between angle-brackets <>. The compiler automatically determines what type is needed on each call. Because our template function includes only one template parameter (class T) and the function template itself accepts two parameters, both of this T type, we cannot call our function template with two objects of different types as arguments: int i; long l; k = GetMax (i,l); This would not be correct, since our GetMax function template expects two arguments of the same type, and in this call to it we use objects of two different types. We can also define function templates that accept more than one type parameter, simply by specifying more template parameters between the angle brackets. For example: template <class T, class U> 120 T GetMin (T a, U b) { return (a<b?a:b); } In this case, our function template GetMin() accepts two parameters of different types and returns an object of the same type as the first parameter (T) that is passed. For example, after that declaration we could call GetMin() with: int i,j; long l; i = GetMin<int,long> (j,l); or simply: i = GetMin (j,l); even though j and l have different types, since the compiler can determine the appropriate instantiation anyway. Class templates We also have the possibility to write class templates, so that a class can have members that use template parameters as types. For example: template <class T> class mypair { T values [2]; public: mypair (T first, T second) { values[0]=first; values[1]=second; } }; The class that we have just defined serves to store two elements of any valid type. For example, if we wanted to declare an object of this class to store two integer values of type int with the values 115 and 36 we would write: mypair<int> myobject (115, 36); this same class would also be used to create an object to store any other type: mypair<double> myfloats (3.0, 2.18); 121 The only member function in the previous class template has been defined inline within the class declaration itself. In case that we define a function member outside the declaration of the class template, we must always precede that definition with the template <...> prefix: // class templates #include <iostream> using namespace std; template <class T> class mypair { T a, b; public: mypair (T first, T second) {a=first; b=second;} T getmax (); }; template <class T> T mypair<T>::getmax () { T retval; retval = a>b? a : b; return retval; } int main () { mypair <int> myobject (100, 75); cout << myobject.getmax(); return 0; } 100 Notice the syntax of the definition of member function getmax: template <class T> T mypair<T>::getmax () Confused by so many T's? There are three T's in this declaration: The first one is the template parameter. The second T refers to the type returned by the function. And the third T (the one between angle brackets) is also a requirement: It specifies that this function's template parameter is also the class template parameter. 122 Template specialization If we want to define a different implementation for a template when a specific type is passed as template parameter, we can declare a specialization of that template. For example, let's suppose that we have a very simple class called mycontainer that can store one element of any type and that it has just one member function called increase, which increases its value. But we find that when it stores an element of type char it would be more convenient to have a completely different implementation with a function member uppercase, so we decide to declare a class template specialization for that type: // template specialization #include <iostream> using namespace std; // class template: template <class T> class mycontainer { T element; public: mycontainer (T arg) {element=arg;} T increase () {return ++element;} }; // class template specialization: template <> class mycontainer <char> { char element; public: mycontainer (char arg) {element=arg;} char uppercase () { if ((element>='a')&&(element<='z')) element+='A'-'a'; return element; } }; int main () { mycontainer<int> myint (7); mycontainer<char> mychar ('j'); cout << myint.increase() << endl; cout << mychar.uppercase() << endl; return 0; } 8 J 123 This is the syntax used in the class template specialization: template <> class mycontainer <char> { ... }; First of all, notice that we precede the class template name with an emptytemplate<> parameter list. This is to explicitly declare it as a template specialization. But more important than this prefix, is the <char> specialization parameter after the class template name. This specialization parameter itself identifies the type for which we are going to declare a template class specialization (char). Notice the differences between the generic class template and the specialization: template <class T> class mycontainer { ... }; template <> class mycontainer <char> { ... }; The first line is the generic template, and the second one is the specialization. When we declare specializations for a template class, we must also define all its members, even those exactly equal to the generic template class, because there is no "inheritance" of members from the generic template to the specialization. Non-type parameters for templates Besides the template arguments that are preceded by the class or typename keywords , which represent types, templates can also have regular typed parameters, similar to those found in functions. As an example, have a look at this class template that is used to contain sequences of elements: // sequence template #include <iostream> using namespace std; template <class T, int N> class mysequence { T memblock [N]; public: void setmember (int x, T value); T getmember (int x); }; template <class T, int N> 100 3.1416 124 void mysequence<T,N>::setmember (int x, T value) { memblock[x]=value; } template <class T, int N> T mysequence<T,N>::getmember (int x) { return memblock[x]; } int main () { mysequence <int,5> myints; mysequence <double,5> myfloats; myints.setmember (0,100); myfloats.setmember (3,3.1416); cout << myints.getmember(0) << '\n'; cout << myfloats.getmember(3) << '\n'; return 0; } It is also possible to set default values or types for class template parameters. For example, if the previous class template definition had been: template <class T=char, int N=10> class mysequence {..}; We could create objects using the default template parameters by declaring: mysequence<> myseq; Which would be equivalent to: mysequence<char,10> myseq; Templates and multiple-file projects From the point of view of the compiler, templates are not normal functions or classes. They are compiled on demand, meaning that the code of a template function is not compiled until an instantiation with specific template arguments is required. At that moment, when an instantiation is required, the compiler generates a function specifically for those arguments from the template. When projects grow it is usual to split the code of a program in different source code files. In these cases, the interface and implementation are generally separated. Taking a library of functions as example, the interface generally consists of declarations of the prototypes of all the 125 functions that can be called. These are generally declared in a "header file" with a .h extension, and the implementation (the definition of these functions) is in an independent file with c++ code. Because templates are compiled when required, this forces a restriction for multi-file projects: the implementation (definition) of a template class or function must be in the same file as its declaration. That means that we cannot separate the interface in a separate header file, and that we must include both interface and implementation in any file that uses the templates. Since no code is generated until a template is instantiated when required, compilers are prepared to allow the inclusion more than once of the same template file with both declarations and definitions in a project without generating linkage errors.