Headlines News :
Home » , , » Learn C++ in 12 Days - Day 2

Learn C++ in 12 Days - Day 2

Written By Ente Malayalam on Friday, May 24, 2013 | 5/24/2013

DAY – 2

            In yesterday’s class we have seen an overview about object oriented programming and the different design steps which have to be followed to efficiently solve a real world problem using this programming technique. Different object oriented programming languages exist in today’s world. Some examples are object Pascal, Eiffel, clos and java.
            From today’s class we are going to learn about a very beautiful programming language named C++ which was developed by a great person named Bjarne Stroustrup.  If you notice, you can see that I have not included this name in the list of object oriented languages. It is because C++ is not considered to be a pure object oriented language instead it is a hybrid language. In the sense, along with object oriented concepts, C++ supports procedural language also to the maximum extend.
            Or in other words, C++ is considered to be the superset of C. It has complete backward compatibility with C language which helps us to used old C program in our current day C++ compilers. It also helps beginners to easily migrate from C to C++.
           
Even though our aim is to design / find solution for a real world problem using the object oriented concepts of C++, since this language perfectly supports structured programming it is possible to write procedural like programs using C++. So first let’s see how to make use of procedural approach in C++.
Lets write a very basic program in C++ and see how things work here and how it differs from your C language.

//My first program in C++

#include <iostream.h>

bool Check_Equal(int, int);

int main()
{
        int Val1, Val2;

        cout << "Enter the values to be compared" << endl;
        cin >> Val1 >> Val2;

        bool Result;
        Result = Check_Equal(Val1, Val2);

        if(Result)
                cout << "Both values are same" << endl;
        else
                cout << "Both values are not same" << endl;
        return 0;
}
bool Check_Equal(int V1, int V2)
{
        bool Check_Result =  V1 == V2;
        return Check_Result;
}


Even though the program seems to be very simple, there are lot of things to be learnt from this program. Let’s start from the first line and analyze it.

            First line is the comment. How do u write comments in your C language? Usually using /* */ right. Since C++ is backward compatible with C, it is perfectly legal to use that here. But usually for one line comments, in C++ , we prefer // to be used in place of /* */. So while you code your program, make it a practice that you are using // for single line comments and /* */ for multi line comments.
            Second line as you know is the pre processor directive. As u know, a part of the compiler called the preprocessor deals with these directives before it begins the real compilation process. Here it includes the contents of the standard header file iostream. It is a header with a input output functionality similar to you stdio.h. It includes the declaration of the standard input output library in C++ which is later used in our programs.
If you notice here you can see two functions present in this program. One is main() and the other one is Check_Equal(int, int). Syntax wise C functions and C++ functions looks the same right. But even then there are few restrictions in C++ functions.
C++ is a pretty strict language. In C++, prototype declaration of functions is a must. But in C, as you know, if arguments and return type are of int type, you can even avoid the prototype declaration. Again writing functions with no return type is not allowed in C++ where as C just allows you to move forward with a simple warning.
            Let’s talk about the first function main(). As you know, it is the starting point of every program. Immediately followed is the variable declaration. Again similar to the C style with the difference that in C++ we have the flexibility of declaring the variables anywhere in the program before it is used. In this program you can see a variable Result  declared before its use.
            When you compile this program you can c that cout statements behaves like your printf in C and cin statements behaves like your scanf in C. How does this work? A complete description of this statement requires a deeper understanding of the language. For the time being I will jus explain briefly what is happening here?
            cout and cin are described as the predefined objects of standard output / input stream. Let’s start with the word stream. Stream just refers to the flow of data. Or I can say that stream is an imaginary device through which data flows. Take an eg, lets say this class room, we r having a two way communication here. The information is flowing from my side to your side and the air between us is acting as a media / stream through with the data flows. In this example we can see that for a proper communication there need to be solid persons on either side of the stream.
Now consider our programming environment , the data can either flow towards the output side ie) towards the monitor or the data can even flow towards the input side ie) from the keyboard. In either cases , you can c that on one side of the stream, we have a hardware device. To interact with the hardware device, there need to be a solid person on the LHS. And in our language, this solid person is an object. We can diagrammatically represent it as below.


 



           
  

cin is a pre defined object in our library which interacts with the input stream ie) our keyboard and cout is a pre defined object in our library which interacts with the output stream ie) our monitor.
            cin always works with an operator known as get from operator with a symbol >> (also known as extraction operator) and cout always works with an operator known an put to operator(also known as insertion  operator) with a symbol <<. Have you seen / used these two operators before? Yes right. They were acting as bitwise operators or more specifically shift operators in our C language. In C++ also, it is perfectly capable of working with bits. But in this situation, it acts completely like a new operator. Ie) a single person existing in many forms. An alternate term for many is “poly” and alternate term for forms is “morph”. So this property can be called as “polymorphism”. We will talk about it in depth in our later sessions.
            Here the left shift operator is made to behave like put to operator and right shift operator is made to behave like get from operator.
The working of put to operator in association with cout is shown below. The put to operator inserts the data on the RHS to cout object on its LHS. Since cout is an object directly associated with monitor, it automatically takes up the responsibility of  pushing the data to the monitor.



Monitor     <---------      cout  <----------  <<  <------------------ data

The working of get from operator in association with cin is shown below.



Keyboard                              cin                                    >>                                  data

Since cin is directly associated with keyboard, the data typed from the keyboard will be automatically associated with cin. The get from operator extracts the contents of cin object and puts it in the variable on the right.
            Hope you got a general idea about how it works. We will be talking more about these objects later in our classes.
            The next line in this program which is unfamiliar to u will be the declaration ‘bool b’. This is a declaration similar to ur int a. Boolean is a new data type introduced in C++. The general syntax for it is
            Bool variable_name
The speciality of boolean is it can have only two values. True (internally hash defined to 1)and false(internally hash defined to zero). It is similar to a character variable of 1 byte but limited to storing only two values. So if ever a character variable has to manipulated as a flag(which should take only 1 and 0), it is always better to go for booleans. It is mostly used in logical operations, it provides more readability to the program.
            The only thing unfamiliar to you in this program now will be endl.As u might have guessed it is performing the same functionality of your ‘\n’. endl is termed as a manipulator. Functionality wise the only difference between these two is in the case of stream buffer. In the sense, every stream is associated with a buffer. For eg: if you are trying to display something to your monitor, it doesn’t go directly to the monitor, instead it first goes to an intermediate buffer. Only when the buffer is full, it is flushed to the monitor. Same is the case with input buffer also. Now when endl is inserted to the buffer, internally it actually inserts a \n to the buffer. But it doesn’t wait for the buffer to get full. Immediately after inserting \n the buffer will be flushed where as if you are using \n instead of endl, buffer flushing will occur only when the buffer is full.

Try to compile this program. You people will be encountering a warning right. A backward compatibility warning telling you something about the .h extension used along with iostream.h. Let’s c why this warning is coming and how to avoid this warning.         

This warning arises due to the second line in your program. Ie) include statement. U were writing it as iostream.h. Now this creates problem in this new compilers. This is bcos c++ is no longer using .h extensions. If u use some old compiler like turbo n compile it, it will work perfectly. Now when I tell you that there is not .h extensions, ur normal tendency will be remove the .h and compile the program. Even then ur compiler is going to throw you an error telling that cin and cout are unresolved.
            So how we can solve this problem!! To solve this you have to know about a new feature introduced in C++ known as namespaces. Now y do u go for namespaces? Jus consider the eg we took yesterday. Washing machine program. As we discussed, this program will have small independent modules handled by individuals.

Each and every module will be using their own set of variables n functions in their programs. Now as I shown in the above picture, the variables / functions names used by one module might have been used by some other module also. While creating the object file for each module independently, it wont create any problem. But when you try to link it, the program may show you re-declaration error for the variables n function names used more than once.
            One way of solving it is instructing each n every programmer to use only a particular set of variables. But this method is not that feasible. So designers designed a new technique in which they started creating small blocks. All the variable n function names used in the program was put inside this block. N when this variables are accessed outside, they started associating the variable names to the block name. these blocks were technically termed as namespaces. The syntax of the namespace is

namespace namespace_name  {
            //variables n functions
}

The namespace name is unique through out. Now even if persons use variables with same name, since it is inside a particular namespace it won’t cause any re-declaration error.one very important thing to remember is even though they are inside a so called namespace block they will still have all the properties of global variables.

Associating the variable with the namespace name can be done either using a new operator known as scope resolution operator (::) or using a directive known as “using”. First lets c how to do with scope resolution operator. Lets take an eg:

//illustrating the effect of local n global variables

#include <iostream.h>

int Value = 100;

int main()      {
        int Value = 200;

        cout << Value << endl;
       
        return 0;
}
In this program , cout statement is going to print only 200 since local variables will be having higher preference over global variables. So if we want to access the global variable in main, it is our responsibility to explicit tell our compiler that the variable you are going to access doesn’t belong to the current scope n it belongs to the global scope. This is done using scope resolution operator n how u have to write it is ::Value

So rewriting the above program




//illustrating the use of scope resolution operator in simple program

#include <iostream.h>
int Value = 100;
int main()      {
        int Value = 200;
        cout << Value << endl;
        cout << ::Value << endl;
        return 0;
}

now applying the same concept to namespaces.

#include <iostream.h>
namespace first
{
        int g = 10;
}
namespace second
{
        float g = 30.2;
}
int main()
{
        cout << first :: g << endl;
        cout << second :: g << endl;
}

So here you can notice that more than one namespace is having variables with the same name. lets take a little more complex example and work on it.

//illustrating namespace using scope resolution operator

#include <iostream.h>
namespace College_Student       {
        struct Student  {
                char Name[20];
                int Batch_No;
                float Marks;
        };
        void Display_Details(struct Student S)  {
                cout << S.Name << endl;
                cout << S.Batch_No << endl;
                cout << S.Marks << endl;
        }
}
int main()      {
        College_Student ::  Student Anu;

        strcpy(Anu.Name, "AnuShri");
        Anu.Batch_No = 221;
        Anu.Marks = 80;

        College_Student :: Display_Details(Anu);

        return 0;
}

Another method of associating variable names with namespace name is using a keyword termed as “using”. This keyword can be sued in two different ways.
  1. Using directive
  2. Using declaration

Using directive :

            The syntax for using directive is
                        using namespace namespace_name;

lets try to modify the above program using using directive.

//illustrating namespace using directive

#include <iostream.h>

namespace College_Student       {
        struct Student  {
                char Name[20];
                int Batch_No;
                float Marks;
        };
        void Display_Details(struct Student S) {
                cout << S.Name << endl;
                cout << S.Batch_No << endl;
                cout << S.Marks << endl;
        }
}






int main()      {
        using namespace College_Student;

        Student Anu;

        strcpy(Anu.Name, "AnuShri");
        Anu.Batch_No = 221;
        Anu.Marks = 80;

        Display_Details(Anu);

        return 0;
}

If you notice you can see that once we use the directive, it is like bringing the presence of the entire variables in the namespace into main. ie) I can use all the variables in the namespace in the main after my directive statement.

Using declaration:

            If using using declaration, u have to bring the presence of each and every variable in to the scope where you are using it before using that particular variable. The syntax for that is
            using namespace_name :: variable_name;

Lets try to modify the above program with using declaration.

//illustrating namespace using declarations

#include <iostream.h>

namespace College_Student       {
        struct Student  {
                char Name[20];
                int Batch_No;
                float Marks;
        };
        void Display_Details(Student S) {
                cout << S.Name << endl;
                cout << S.Batch_No << endl;
                cout << S.Marks << endl;
        }
}



int main()      {
        using College_Student :: Student;
        Student Anu;
        strcpy(Anu.Name, "AnuShri");
        Anu.Batch_No = 221;
        Anu.Marks = 80;
        using College_Student :: Display_Details; //declarations
        Display_Details(Anu);

        return 0;
}

Now if you compare the two program we get a feeling like directive is simply the cumulative of declarations right. but it is not at all true. There is a major difference between directive and declaration. Consider the below program using declaration.

//illustrating difference of directive n declaration
#include <iostream.h>

namespace College_Student       {
        struct Student  {
                char Name[20];
                int Batch_No;
                float Marks;
        };
        Student Anu;
        void Display_Details(Student S) {
                cout << S.Name << endl;
                cout << S.Batch_No << endl;
                cout << S.Marks << endl;
        }
}
int main()      {

        using College_Student :: Anu;

        strcpy(Anu.Name, "AnuShri");
        Anu.Batch_No = 221;
        Anu.Marks = 80;

        using College_Student :: Display_Details;
        Display_Details(Anu);

        struct Student  {};
        Student Anu;
}
Here once I bring the name Anu from namespace to main, declaration of another variable with the same name in main is going to through error telling that the names are conflicting. Where as jus notice the below program with directive

//illustrating difference between directive and declaration

#include <iostream.h>

namespace College_Student       {
        struct Student  {
                char Name[20];
                int Batch_No;
                float Marks;
        };
        Student Anu;
        void Display_Details(Student S) {
                cout << S.Name << endl;
                cout << S.Batch_No << endl;
                cout << S.Marks << endl;
        }
}

int main()      {

        using namespace College_Student;

        strcpy(Anu.Name, "AnuShri");
        Anu.Batch_No = 221;
        Anu.Marks = 80;

        Display_Details(Anu);


        struct Student  {};

        Student Anu;
        return 0;
}

Here declaration of another variable with the same name doesn’t throw any error. Instead the local variable will simply override the namespace variable.

So which one is better. Using declaration is always considered to be better since it shows us explicit error while names conflict.

Now back to our header files and .h extensions. Before n all, all the libraries were defined globally. The problem here was, the function names or variable names used in the library cannot be used by the programmer. For eg: if you try to use strcpy as the name for ur function, it will throw you error. This was a burden for the programmer. He has to think what are the function names he should use in his programs.
            Keeping this thing in mind, the designers have taken away the concept of global header files. Instead they created new header files without .h extensions. For eg: iostream. In this new header file, they declared a namespace named as std. N then the contents of the previous header file was put inside this namespace. So now when ever you want to use the contents of the header file outside, you have to associate it with std either using scope resolution or using the directive using.
            Now modifying our first program using all the three methods
//illustrating using scope resolution operator

#include <iostream>

bool Check_Equal(int, int);

int main()
{
        int Val1, Val2;

        std :: cout << "Enter the values to be compared" << std :: endl;
        std :: cin >> Val1 >> Val2;

        bool Result;

        Result = Check_Equal(Val1, Val2);

        if(Result)
                std :: cout << "Both values are same" << std :: endl;
        else
                std :: cout << "Both values are not same" << std :: endl;

        return 0;
}
bool Check_Equal(int V1, int V2)
{
        bool Check_Result =  V1 == V2;
}






//illustrating using directive

#include <iostream>

bool Check_Equal(int, int);

int main()
{
        using namespace std;

        int Val1, Val2;

        cout << "Enter the values to be compared" << endl;
        cin >> Val1 >> Val2;

        bool Result;

        Result = Check_Equal(Val1, Val2);

        if(Result)
                cout << "Both values are same" << endl;
        else
                cout << "Both values are not same" << endl;

        return 0;
}
bool Check_Equal(int V1, int V2)
{
        bool Check_Result =  V1 == V2;
}
















//illustrating using declaration

#include <iostream>

bool Check_Equal(int, int);

int main()
{
        using std :: cin;
        using std :: cout;
        using std :: endl;

        int Val1, Val2;

        cout << "Enter the values to be compared" << endl;
        cin >> Val1 >> Val2;

        bool Result;

        Result = Check_Equal(Val1, Val2);

        if(Result)
                cout << "Both values are same" << endl;
        else
                cout << "Both values are not same" << endl;

        return 0;
}
bool Check_Equal(int V1, int V2)
{
        bool Check_Result =  V1 == V2;
}

This is how you have to use header files in your program and the most commonly used among this is directive. The C++ designers have even modified the C header files by including namespaces. For eg: if you want to use stdio.h, remove the .h and add a c before stdio. Ie) cstdio. Even in this header file there is a namespace named as std. or I should say that the namespace std; is extended in multiple header files.

Now we know how to use our header files and write procedural like program in C++.


REFERENCE :

C++ Complete Reference : Herbert Schildt
C++ Primer Plus : Stephen Prata


Share this article :

0 comments:

Post a Comment

 
Support : Creating Website | Johny Template | Maskolis | Johny Portal | Johny Magazine | Johny News | Johny Demosite
Copyright © 2011. Education World - All Rights Reserved
Template Modify by Creating Website Inspired Wordpress Hack
Proudly powered by Blogger