Category: cplusplus

C++ Object Oriented ”; Previous Next The prime purpose of C++ programming was to add object orientation to the C programming language, which is in itself one of the most powerful programming languages. The core of the pure object-oriented programming is to create an object, in code, that has certain properties and methods. While designing C++ modules, we try to see whole world in the form of objects. For example a car is an object which has certain properties such as color, number of doors, and the like. It also has certain methods such as accelerate, brake, and so on. There are a few principle concepts that form the foundation of object-oriented programming − Object This is the basic unit of object oriented programming. That is both data and function that operate on data are bundled as a unit called as object. Class When you define a class, you define a blueprint for an object. This doesn”t actually define any data, but it does define what the class name means, that is, what an object of the class will consist of and what operations can be performed on such an object. Abstraction Data abstraction refers to, providing only essential information to the outside world and hiding their background details, i.e., to represent the needed information in program without presenting the details. For example, a database system hides certain details of how data is stored and created and maintained. Similar way, C++ classes provides different methods to the outside world without giving internal detail about those methods and data. Encapsulation Encapsulation is placing the data and the functions that work on that data in the same place. While working with procedural languages, it is not always clear which functions work on which variables but object-oriented programming provides you framework to place the data and the relevant functions together in the same object. Inheritance One of the most useful aspects of object-oriented programming is code reusability. As the name suggests Inheritance is the process of forming a new class from an existing class that is from the existing class called as base class, new class is formed called as derived class. This is a very important concept of object-oriented programming since this feature helps to reduce the code size. Polymorphism The ability to use an operator or function in different ways in other words giving different meaning or functions to the operators or functions is called polymorphism. Poly refers to many. That is a single function or an operator functioning in many ways different upon the usage is called polymorphism. Overloading The concept of overloading is also a branch of polymorphism. When the exiting operator or function is made to operate on new data type, it is said to be overloaded. Print Page Previous Next Advertisements ”;

C++ Web Programming ”; Previous Next What is CGI? The Common Gateway Interface, or CGI, is a set of standards that define how information is exchanged between the web server and a custom script. The CGI specs are currently maintained by the NCSA and NCSA defines CGI is as follows − The Common Gateway Interface, or CGI, is a standard for external gateway programs to interface with information servers such as HTTP servers. The current version is CGI/1.1 and CGI/1.2 is under progress. Web Browsing To understand the concept of CGI, let”s see what happens when we click a hyperlink to browse a particular web page or URL. Your browser contacts the HTTP web server and demand for the URL ie. filename. Web Server will parse the URL and will look for the filename. If it finds requested file then web server sends that file back to the browser otherwise sends an error message indicating that you have requested a wrong file. Web browser takes response from web server and displays either the received file or error message based on the received response. However, it is possible to set up the HTTP server in such a way that whenever a file in a certain directory is requested, that file is not sent back; instead it is executed as a program, and produced output from the program is sent back to your browser to display. The Common Gateway Interface (CGI) is a standard protocol for enabling applications (called CGI programs or CGI scripts) to interact with Web servers and with clients. These CGI programs can be a written in Python, PERL, Shell, C or C++ etc. CGI Architecture Diagram The following simple program shows a simple architecture of CGI − Web Server Configuration Before you proceed with CGI Programming, make sure that your Web Server supports CGI and it is configured to handle CGI Programs. All the CGI Programs to be executed by the HTTP server are kept in a pre-configured directory. This directory is called CGI directory and by convention it is named as /var/www/cgi-bin. By convention CGI files will have extension as .cgi, though they are C++ executable. By default, Apache Web Server is configured to run CGI programs in /var/www/cgi-bin. If you want to specify any other directory to run your CGI scripts, you can modify the following section in the httpd.conf file − <Directory “/var/www/cgi-bin”> AllowOverride None Options ExecCGI Order allow,deny Allow from all </Directory> <Directory “/var/www/cgi-bin”> Options All </Directory> Here, I assume that you have Web Server up and running successfully and you are able to run any other CGI program like Perl or Shell etc. First CGI Program Consider the following C++ Program content − #include <iostream> using namespace std; int main () { cout << “Content-type:text/htmlrnrn”; cout << “<html>n”; cout << “<head>n”; cout << “<title>Hello World – First CGI Program</title>n”; cout << “</head>n”; cout << “<body>n”; cout << “<h2>Hello World! This is my first CGI program</h2>n”; cout << “</body>n”; cout << “</html>n”; return 0; } Compile above code and name the executable as cplusplus.cgi. This file is being kept in /var/www/cgi-bin directory and it has following content. Before running your CGI program make sure you have change mode of file using chmod 755 cplusplus.cgi UNIX command to make file executable. My First CGI program The above C++ program is a simple program which is writing its output on STDOUT file i.e. screen. There is one important and extra feature available which is first line printing Content-type:text/htmlrnrn. This line is sent back to the browser and specify the content type to be displayed on the browser screen. Now you must have understood the basic concept of CGI and you can write many complicated CGI programs using Python. A C++ CGI program can interact with any other external system, such as RDBMS, to exchange information. HTTP Header The line Content-type:text/htmlrnrn is a part of HTTP header, which is sent to the browser to understand the content. All the HTTP header will be in the following form − HTTP Field Name: Field Content For Example Content-type: text/htmlrnrn There are few other important HTTP headers, which you will use frequently in your CGI Programming. Sr.No Header & Description 1 Content-type: A MIME string defining the format of the file being returned. Example is Content-type:text/html. 2 Expires: Date The date the information becomes invalid. This should be used by the browser to decide when a page needs to be refreshed. A valid date string should be in the format 01 Jan 1998 12:00:00 GMT. 3 Location: URL The URL that should be returned instead of the URL requested. You can use this filed to redirect a request to any file. 4 Last-modified: Date The date of last modification of the resource. 5 Content-length: N The length, in bytes, of the data being returned. The browser uses this value to report the estimated download time for a file. 6 Set-Cookie: String Set the cookie passed through the string. CGI Environment Variables All the CGI program will have access to the following environment variables. These variables play an important role while writing any CGI program. Sr.No Variable Name & Description 1 CONTENT_TYPE The data type of the content, used when the client is sending attached content to the server. For example file upload etc. 2 CONTENT_LENGTH The length of the query information that is available only for POST requests. 3 HTTP_COOKIE Returns the set cookies in the form of key & value pair. 4 HTTP_USER_AGENT The User-Agent request-header field contains information about the user agent originating the request. It is a name of the web browser. 5 PATH_INFO The path for the CGI script. 6 QUERY_STRING The URL-encoded information that is sent with GET method request. 7 REMOTE_ADDR The IP address of the remote host making the request. This can be useful for logging or for authentication purpose. 8 REMOTE_HOST The fully qualified name of the host making the request. If this information is not available then

C++ Variable Types ”; Previous Next A variable provides us with named storage that our programs can manipulate. Each variable in C++ has a specific type, which determines the size and layout of the variable”s memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable. The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because C++ is case-sensitive − There are following basic types of variable in C++ as explained in last chapter − Sr.No Type & Description 1 bool Stores either value true or false. 2 char Typically a single octet (one byte). This is an integer type. 3 int The most natural size of integer for the machine. 4 float A single-precision floating point value. 5 double A double-precision floating point value. 6 void Represents the absence of type. 7 wchar_t A wide character type. C++ also allows to define various other types of variables, which we will cover in subsequent chapters like Enumeration, Pointer, Array, Reference, Data structures, and Classes. Following section will cover how to define, declare and use various types of variables. Variable Definition in C++ A variable definition tells the compiler where and how much storage to create for the variable. A variable definition specifies a data type, and contains a list of one or more variables of that type as follows − type variable_list; Here, type must be a valid C++ data type including char, w_char, int, float, double, bool or any user-defined object, etc., and variable_list may consist of one or more identifier names separated by commas. Some valid declarations are shown here − int i, j, k; char c, ch; float f, salary; double d; The line int i, j, k; both declares and defines the variables i, j and k; which instructs the compiler to create variables named i, j and k of type int. Variables can be initialized (assigned an initial value) in their declaration. The initializer consists of an equal sign followed by a constant expression as follows − type variable_name = value; Some examples are − extern int d = 3, f = 5; // declaration of d and f. int d = 3, f = 5; // definition and initializing d and f. byte z = 22; // definition and initializes z. char x = ”x”; // the variable x has the value ”x”. For definition without an initializer: variables with static storage duration are implicitly initialized with NULL (all bytes have the value 0); the initial value of all other variables is undefined. Variable Declaration in C++ A variable declaration provides assurance to the compiler that there is one variable existing with the given type and name so that compiler proceed for further compilation without needing complete detail about the variable. A variable declaration has its meaning at the time of compilation only, compiler needs actual variable definition at the time of linking of the program. A variable declaration is useful when you are using multiple files and you define your variable in one of the files which will be available at the time of linking of the program. You will use extern keyword to declare a variable at any place. Though you can declare a variable multiple times in your C++ program, but it can be defined only once in a file, a function or a block of code. Example Try the following example where a variable has been declared at the top, but it has been defined inside the main function − Live Demo #include <iostream> using namespace std; // Variable declaration: extern int a, b; extern int c; extern float f; int main () { // Variable definition: int a, b; int c; float f; // actual initialization a = 10; b = 20; c = a + b; cout << c << endl ; f = 70.0/3.0; cout << f << endl ; return 0; } When the above code is compiled and executed, it produces the following result − 30 23.3333 Same concept applies on function declaration where you provide a function name at the time of its declaration and its actual definition can be given anywhere else. For example − // function declaration int func(); int main() { // function call int i = func(); } // function definition int func() { return 0; } Lvalues and Rvalues There are two kinds of expressions in C++ − lvalue − Expressions that refer to a memory location is called “lvalue” expression. An lvalue may appear as either the left-hand or right-hand side of an assignment. rvalue − The term rvalue refers to a data value that is stored at some address in memory. An rvalue is an expression that cannot have a value assigned to it which means an rvalue may appear on the right- but not left-hand side of an assignment. Variables are lvalues and so may appear on the left-hand side of an assignment. Numeric literals are rvalues and so may not be assigned and can not appear on the left-hand side. Following is a valid statement − int g = 20; But the following is not a valid statement and would generate compile-time error − 10 = 20; Print Page Previous Next Advertisements ”;

Variable Scope in C++ ”; Previous Next A scope is a region of the program and broadly speaking there are three places, where variables can be declared − Inside a function or a block which is called local variables, In the definition of function parameters which is called formal parameters. Outside of all functions which is called global variables. We will learn what is a function and it”s parameter in subsequent chapters. Here let us explain what are local and global variables. Local Variables Variables that are declared inside a function or block are local variables. They can be used only by statements that are inside that function or block of code. Local variables are not known to functions outside their own. Following is the example using local variables − Live Demo #include <iostream> using namespace std; int main () { // Local variable declaration: int a, b; int c; // actual initialization a = 10; b = 20; c = a + b; cout << c; return 0; } Global Variables Global variables are defined outside of all the functions, usually on top of the program. The global variables will hold their value throughout the life-time of your program. A global variable can be accessed by any function. That is, a global variable is available for use throughout your entire program after its declaration. Following is the example using global and local variables − Live Demo #include <iostream> using namespace std; // Global variable declaration: int g; int main () { // Local variable declaration: int a, b; // actual initialization a = 10; b = 20; g = a + b; cout << g; return 0; } A program can have same name for local and global variables but value of local variable inside a function will take preference. For example − Live Demo #include <iostream> using namespace std; // Global variable declaration: int g = 20; int main () { // Local variable declaration: int g = 10; cout << g; return 0; } When the above code is compiled and executed, it produces the following result − 10 Initializing Local and Global Variables When a local variable is defined, it is not initialized by the system, you must initialize it yourself. Global variables are initialized automatically by the system when you define them as follows − Data Type Initializer int 0 char ”” float 0 double 0 pointer NULL It is a good programming practice to initialize variables properly, otherwise sometimes program would produce unexpected result. Print Page Previous Next Advertisements ”;

C++ Dynamic Memory ”; Previous Next A good understanding of how dynamic memory really works in C++ is essential to becoming a good C++ programmer. Memory in your C++ program is divided into two parts − The stack − All variables declared inside the function will take up memory from the stack. The heap − This is unused memory of the program and can be used to allocate the memory dynamically when program runs. Many times, you are not aware in advance how much memory you will need to store particular information in a defined variable and the size of required memory can be determined at run time. You can allocate memory at run time within the heap for the variable of a given type using a special operator in C++ which returns the address of the space allocated. This operator is called new operator. If you are not in need of dynamically allocated memory anymore, you can use delete operator, which de-allocates memory that was previously allocated by new operator. new and delete Operators There is following generic syntax to use new operator to allocate memory dynamically for any data-type. new data-type; Here, data-type could be any built-in data type including an array or any user defined data types include class or structure. Let us start with built-in data types. For example we can define a pointer to type double and then request that the memory be allocated at execution time. We can do this using the new operator with the following statements − double* pvalue = NULL; // Pointer initialized with null pvalue = new double; // Request memory for the variable The memory may not have been allocated successfully, if the free store had been used up. So it is good practice to check if new operator is returning NULL pointer and take appropriate action as below − double* pvalue = NULL; if( !(pvalue = new double )) { cout << “Error: out of memory.” <<endl; exit(1); } The malloc() function from C, still exists in C++, but it is recommended to avoid using malloc() function. The main advantage of new over malloc() is that new doesn”t just allocate memory, it constructs objects which is prime purpose of C++. At any point, when you feel a variable that has been dynamically allocated is not anymore required, you can free up the memory that it occupies in the free store with the ‘delete’ operator as follows − delete pvalue; // Release memory pointed to by pvalue Let us put above concepts and form the following example to show how ‘new’ and ‘delete’ work − Live Demo #include <iostream> using namespace std; int main () { double* pvalue = NULL; // Pointer initialized with null pvalue = new double; // Request memory for the variable *pvalue = 29494.99; // Store value at allocated address cout << “Value of pvalue : ” << *pvalue << endl; delete pvalue; // free up the memory. return 0; } If we compile and run above code, this would produce the following result − Value of pvalue : 29495 Dynamic Memory Allocation for Arrays Consider you want to allocate memory for an array of characters, i.e., string of 20 characters. Using the same syntax what we have used above we can allocate memory dynamically as shown below. char* pvalue = NULL; // Pointer initialized with null pvalue = new char[20]; // Request memory for the variable To remove the array that we have just created the statement would look like this − delete [] pvalue; // Delete array pointed to by pvalue Following the similar generic syntax of new operator, you can allocate for a multi-dimensional array as follows − double** pvalue = NULL; // Pointer initialized with null pvalue = new double [3][4]; // Allocate memory for a 3×4 array However, the syntax to release the memory for multi-dimensional array will still remain same as above − delete [] pvalue; // Delete array pointed to by pvalue Dynamic Memory Allocation for Objects Objects are no different from simple data types. For example, consider the following code where we are going to use an array of objects to clarify the concept − Live Demo #include <iostream> using namespace std; class Box { public: Box() { cout << “Constructor called!” <<endl; } ~Box() { cout << “Destructor called!” <<endl; } }; int main() { Box* myBoxArray = new Box[4]; delete [] myBoxArray; // Delete array return 0; } If you were to allocate an array of four Box objects, the Simple constructor would be called four times and similarly while deleting these objects, destructor will also be called same number of times. If we compile and run above code, this would produce the following result − Constructor called! Constructor called! Constructor called! Constructor called! Destructor called! Destructor called! Destructor called! Destructor called! Print Page Previous Next Advertisements ”;

C++ STL Tutorial ”; Previous Next Hope you have already understood the concept of C++ Template which we have discussed earlier. The C++ STL (Standard Template Library) is a powerful set of C++ template classes to provide general-purpose classes and functions with templates that implement many popular and commonly used algorithms and data structures like vectors, lists, queues, and stacks. At the core of the C++ Standard Template Library are following three well-structured components − Sr.No Component & Description 1 Containers Containers are used to manage collections of objects of a certain kind. There are several different types of containers like deque, list, vector, map etc. 2 Algorithms Algorithms act on containers. They provide the means by which you will perform initialization, sorting, searching, and transforming of the contents of containers. 3 Iterators Iterators are used to step through the elements of collections of objects. These collections may be containers or subsets of containers. We will discuss about all the three C++ STL components in next chapter while discussing C++ Standard Library. For now, keep in mind that all the three components have a rich set of pre-defined functions which help us in doing complicated tasks in very easy fashion. Let us take the following program that demonstrates the vector container (a C++ Standard Template) which is similar to an array with an exception that it automatically handles its own storage requirements in case it grows − Live Demo #include <iostream> #include <vector> using namespace std; int main() { // create a vector to store int vector<int> vec; int i; // display the original size of vec cout << “vector size = ” << vec.size() << endl; // push 5 values into the vector for(i = 0; i < 5; i++) { vec.push_back(i); } // display extended size of vec cout << “extended vector size = ” << vec.size() << endl; // access 5 values from the vector for(i = 0; i < 5; i++) { cout << “value of vec [” << i << “] = ” << vec[i] << endl; } // use iterator to access the values vector<int>::iterator v = vec.begin(); while( v != vec.end()) { cout << “value of v = ” << *v << endl; v++; } return 0; } When the above code is compiled and executed, it produces the following result − vector size = 0 extended vector size = 5 value of vec [0] = 0 value of vec [1] = 1 value of vec [2] = 2 value of vec [3] = 3 value of vec [4] = 4 value of v = 0 value of v = 1 value of v = 2 value of v = 3 value of v = 4 Here are following points to be noted related to various functions we used in the above example − The push_back( ) member function inserts value at the end of the vector, expanding its size as needed. The size( ) function displays the size of the vector. The function begin( ) returns an iterator to the start of the vector. The function end( ) returns an iterator to the end of the vector. Print Page Previous Next Advertisements ”;

C++ Strings ”; Previous Next C++ provides following two types of string representations − The C-style character string. The string class type introduced with Standard C++. The C-Style Character String The C-style character string originated within the C language and continues to be supported within C++. This string is actually a one-dimensional array of characters which is terminated by a null character ””. Thus a null-terminated string contains the characters that comprise the string followed by a null. The following declaration and initialization create a string consisting of the word “Hello”. To hold the null character at the end of the array, the size of the character array containing the string is one more than the number of characters in the word “Hello.” char greeting[6] = {”H”, ”e”, ”l”, ”l”, ”o”, ””}; If you follow the rule of array initialization, then you can write the above statement as follows − char greeting[] = “Hello”; Following is the memory presentation of above defined string in C/C++ − Actually, you do not place the null character at the end of a string constant. The C++ compiler automatically places the ”” at the end of the string when it initializes the array. Let us try to print above-mentioned string − Live Demo #include <iostream> using namespace std; int main () { char greeting[6] = {”H”, ”e”, ”l”, ”l”, ”o”, ””}; cout << “Greeting message: “; cout << greeting << endl; return 0; } When the above code is compiled and executed, it produces the following result − Greeting message: Hello C++ supports a wide range of functions that manipulate null-terminated strings − Sr.No Function & Purpose 1 strcpy(s1, s2); Copies string s2 into string s1. 2 strcat(s1, s2); Concatenates string s2 onto the end of string s1. 3 strlen(s1); Returns the length of string s1. 4 strcmp(s1, s2); Returns 0 if s1 and s2 are the same; less than 0 if s1<s2; greater than 0 if s1>s2. 5 strchr(s1, ch); Returns a pointer to the first occurrence of character ch in string s1. 6 strstr(s1, s2); Returns a pointer to the first occurrence of string s2 in string s1. Following example makes use of few of the above-mentioned functions − Live Demo #include <iostream> #include <cstring> using namespace std; int main () { char str1[10] = “Hello”; char str2[10] = “World”; char str3[10]; int len ; // copy str1 into str3 strcpy( str3, str1); cout << “strcpy( str3, str1) : ” << str3 << endl; // concatenates str1 and str2 strcat( str1, str2); cout << “strcat( str1, str2): ” << str1 << endl; // total lenghth of str1 after concatenation len = strlen(str1); cout << “strlen(str1) : ” << len << endl; return 0; } When the above code is compiled and executed, it produces result something as follows − strcpy( str3, str1) : Hello strcat( str1, str2): HelloWorld strlen(str1) : 10 The String Class in C++ The standard C++ library provides a string class type that supports all the operations mentioned above, additionally much more functionality. Let us check the following example − Live Demo #include <iostream> #include <string> using namespace std; int main () { string str1 = “Hello”; string str2 = “World”; string str3; int len ; // copy str1 into str3 str3 = str1; cout << “str3 : ” << str3 << endl; // concatenates str1 and str2 str3 = str1 + str2; cout << “str1 + str2 : ” << str3 << endl; // total length of str3 after concatenation len = str3.size(); cout << “str3.size() : ” << len << endl; return 0; } When the above code is compiled and executed, it produces result something as follows − str3 : Hello str1 + str2 : HelloWorld str3.size() : 10 Print Page Previous Next Advertisements ”;

C++ References ”; Previous Next A reference variable is an alias, that is, another name for an already existing variable. Once a reference is initialized with a variable, either the variable name or the reference name may be used to refer to the variable. References vs Pointers References are often confused with pointers but three major differences between references and pointers are − You cannot have NULL references. You must always be able to assume that a reference is connected to a legitimate piece of storage. Once a reference is initialized to an object, it cannot be changed to refer to another object. Pointers can be pointed to another object at any time. A reference must be initialized when it is created. Pointers can be initialized at any time. Creating References in C++ Think of a variable name as a label attached to the variable”s location in memory. You can then think of a reference as a second label attached to that memory location. Therefore, you can access the contents of the variable through either the original variable name or the reference. For example, suppose we have the following example − int i = 17; We can declare reference variables for i as follows. int& r = i; Read the & in these declarations as reference. Thus, read the first declaration as “r is an integer reference initialized to i” and read the second declaration as “s is a double reference initialized to d.”. Following example makes use of references on int and double − Live Demo #include <iostream> using namespace std; int main () { // declare simple variables int i; double d; // declare reference variables int& r = i; double& s = d; i = 5; cout << “Value of i : ” << i << endl; cout << “Value of i reference : ” << r << endl; d = 11.7; cout << “Value of d : ” << d << endl; cout << “Value of d reference : ” << s << endl; return 0; } When the above code is compiled together and executed, it produces the following result − Value of i : 5 Value of i reference : 5 Value of d : 11.7 Value of d reference : 11.7 References are usually used for function argument lists and function return values. So following are two important subjects related to C++ references which should be clear to a C++ programmer − Sr.No Concept & Description 1 References as Parameters C++ supports passing references as function parameter more safely than parameters. 2 Reference as Return Value You can return reference from a C++ function like any other data type. Print Page Previous Next Advertisements ”;

C++ Inheritance ”; Previous Next One of the most important concepts in object-oriented programming is that of inheritance. Inheritance allows us to define a class in terms of another class, which makes it easier to create and maintain an application. This also provides an opportunity to reuse the code functionality and fast implementation time. When creating a class, instead of writing completely new data members and member functions, the programmer can designate that the new class should inherit the members of an existing class. This existing class is called the base class, and the new class is referred to as the derived class. The idea of inheritance implements the is a relationship. For example, mammal IS-A animal, dog IS-A mammal hence dog IS-A animal as well and so on. Base and Derived Classes A class can be derived from more than one classes, which means it can inherit data and functions from multiple base classes. To define a derived class, we use a class derivation list to specify the base class(es). A class derivation list names one or more base classes and has the form − class derived-class: access-specifier base-class Where access-specifier is one of public, protected, or private, and base-class is the name of a previously defined class. If the access-specifier is not used, then it is private by default. Consider a base class Shape and its derived class Rectangle as follows − Live Demo #include <iostream> using namespace std; // Base class class Shape { public: void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // Derived class class Rectangle: public Shape { public: int getArea() { return (width * height); } }; int main(void) { Rectangle Rect; Rect.setWidth(5); Rect.setHeight(7); // Print the area of the object. cout << “Total area: ” << Rect.getArea() << endl; return 0; } When the above code is compiled and executed, it produces the following result − Total area: 35 Access Control and Inheritance A derived class can access all the non-private members of its base class. Thus base-class members that should not be accessible to the member functions of derived classes should be declared private in the base class. We can summarize the different access types according to – who can access them in the following way − Access public protected private Same class yes yes yes Derived classes yes yes no Outside classes yes no no A derived class inherits all base class methods with the following exceptions − Constructors, destructors and copy constructors of the base class. Overloaded operators of the base class. The friend functions of the base class. Type of Inheritance When deriving a class from a base class, the base class may be inherited through public, protected or private inheritance. The type of inheritance is specified by the access-specifier as explained above. We hardly use protected or private inheritance, but public inheritance is commonly used. While using different type of inheritance, following rules are applied − Public Inheritance − When deriving a class from a public base class, public members of the base class become public members of the derived class and protected members of the base class become protected members of the derived class. A base class”s private members are never accessible directly from a derived class, but can be accessed through calls to the public and protected members of the base class. Protected Inheritance − When deriving from a protected base class, public and protected members of the base class become protected members of the derived class. Private Inheritance − When deriving from a private base class, public and protected members of the base class become private members of the derived class. Multiple Inheritance A C++ class can inherit members from more than one class and here is the extended syntax − class derived-class: access baseA, access baseB…. Where access is one of public, protected, or private and would be given for every base class and they will be separated by comma as shown above. Let us try the following example − Live Demo #include <iostream> using namespace std; // Base class Shape class Shape { public: void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } protected: int width; int height; }; // Base class PaintCost class PaintCost { public: int getCost(int area) { return area * 70; } }; // Derived class class Rectangle: public Shape, public PaintCost { public: int getArea() { return (width * height); } }; int main(void) { Rectangle Rect; int area; Rect.setWidth(5); Rect.setHeight(7); area = Rect.getArea(); // Print the area of the object. cout << “Total area: ” << Rect.getArea() << endl; // Print the total cost of painting cout << “Total paint cost: $” << Rect.getCost(area) << endl; return 0; } When the above code is compiled and executed, it produces the following result − Total area: 35 Total paint cost: $2450 Print Page Previous Next Advertisements ”;

C++ Templates ”; Previous Next Templates are the foundation of generic programming, which involves writing code in a way that is independent of any particular type. A template is a blueprint or formula for creating a generic class or a function. The library containers like iterators and algorithms are examples of generic programming and have been developed using template concept. There is a single definition of each container, such as vector, but we can define many different kinds of vectors for example, vector <int> or vector <string>. You can use templates to define functions as well as classes, let us see how they work − Function Template The general form of a template function definition is shown here − template <class type> ret-type func-name(parameter list) { // body of function } Here, type is a placeholder name for a data type used by the function. This name can be used within the function definition. The following is the example of a function template that returns the maximum of two values − Live Demo #include <iostream> #include <string> using namespace std; template <typename T> inline T const& Max (T const& a, T const& b) { return a < b ? b:a; } int main () { int i = 39; int j = 20; cout << “Max(i, j): ” << Max(i, j) << endl; double f1 = 13.5; double f2 = 20.7; cout << “Max(f1, f2): ” << Max(f1, f2) << endl; string s1 = “Hello”; string s2 = “World”; cout << “Max(s1, s2): ” << Max(s1, s2) << endl; return 0; } If we compile and run above code, this would produce the following result − Max(i, j): 39 Max(f1, f2): 20.7 Max(s1, s2): World Class Template Just as we can define function templates, we can also define class templates. The general form of a generic class declaration is shown here − template <class type> class class-name { . . . } Here, type is the placeholder type name, which will be specified when a class is instantiated. You can define more than one generic data type by using a comma-separated list. Following is the example to define class Stack<> and implement generic methods to push and pop the elements from the stack − Live Demo #include <iostream> #include <vector> #include <cstdlib> #include <string> #include <stdexcept> using namespace std; template <class T> class Stack { private: vector<T> elems; // elements public: void push(T const&); // push element void pop(); // pop element T top() const; // return top element bool empty() const { // return true if empty. return elems.empty(); } }; template <class T> void Stack<T>::push (T const& elem) { // append copy of passed element elems.push_back(elem); } template <class T> void Stack<T>::pop () { if (elems.empty()) { throw out_of_range(“Stack<>::pop(): empty stack”); } // remove last element elems.pop_back(); } template <class T> T Stack<T>::top () const { if (elems.empty()) { throw out_of_range(“Stack<>::top(): empty stack”); } // return copy of last element return elems.back(); } int main() { try { Stack<int> intStack; // stack of ints Stack<string> stringStack; // stack of strings // manipulate int stack intStack.push(7); cout << intStack.top() <<endl; // manipulate string stack stringStack.push(“hello”); cout << stringStack.top() << std::endl; stringStack.pop(); stringStack.pop(); } catch (exception const& ex) { cerr << “Exception: ” << ex.what() <<endl; return -1; } } If we compile and run above code, this would produce the following result − 7 hello Exception: Stack<>::pop(): empty stack Print Page Previous Next Advertisements ”;