C with Linux

Data structures using Cpp

2017-10-29T09:55:00.001-07:00

When my son told me that no one uses "C" nowadays, I realized my folly. I am writing an app, working my heads off, searching questions and solving them for an app which has lot of competition and may not find many users.

But writing all those 130 programs in C++ will take another year. (Yes I "have" written around 130 programs). It should not take another year, but you know me.

So I have come to this conclusion. Before I release the app, I will implement basic structures - LL, stack, queue and BT in C++. And I will also try to add another 30 more programs in C++. That is - versions of programs in C++ for which C programs already exist.

I see two advantages here - for the app user. a) he/she will be able to write DS programs in shorter and more compact and intuitive way. b) he/she will become more familiar with C++ language.

What better example do we get for encapsulation (keep your head and append and delete and display functions inside of the class), data hiding - private and public (head - what head are you talking about? You can only access the list. How we implement append, insert, delete or display is of no concern to you).

And for once, the reader will be happy to write a C++ program instead of C. Because there is no need to return head pointers, no need to use double pointers and no need to worry if the function modifies more than one parameter.

So I will post these C++ programs in my data structures blog. Happy DSing!

P.S. If you have not noticed already, all my data structure programs will be available in Data structures blog instead of C with Linux .

Linux processes

2017-07-11T08:48:00.000-07:00

Process in operating system is a program under execution. A process has its own memory space. In some operating systems, the term 'task' is used instead.

When a program starts execution, the process is created. And the process is destroyed when the program ends. A process may consist of one or more threads which execute instructions concurrently.

Process ID - pid

Every process has a unique identifier called process id or pid. And each process also has a parent process id called ppid. Parent is the process which started the execution of given process.

List of running processes

To know which processes are running at any given time, you can use ps command. But ps will show only processes belonging to the given terminal from where you are running ps command.

ps -el

This will list all processes running. l here is for long listing, where pid, ppid, command of the program and other informations are listed.

Given below is the screenshot of ps -el|less command

If you really want to know the tree structure of processes, you can given pstree command.

There are many more options available for ps command.

top command also lists the running processes dynamically in descending order of their cpu usage. It gives other informations such as memory usage, how long system has been up etc.

Pid of my program?

You can get the pid of your program and also ppid using two library functions, called - you get it - getpid() and getppid(). You need to include the header file unistd.h for these functions.

#include<stdio.h>
#include<unistd.h>
int main()
{
 printf("my pid is %u",getpid());
 printf("my ppid is %u",getppid());
 return 0;
}

And when you run the program, you notice that the ppid of the process is the pid of the shell.

Don't expect to see this pid of your program next time you run ps -el command. Your program runs two statements and ends. So the process is no longer present.

Can I create a new process through program?

Yes, you can create your own process using a function called fork(). fork() creates a new process by replicating the existing process. The new process is called child process and the existing one is called parent process.

The child process has ppid as that of parent process. As the child is the exact duplicate of parent process, it has a copy of all parent's variables, open file descriptor, shared memories.

fork() returns pid of the child process in parent's context and 0 in child's context. This can be used for differentiating between parent process and child process.

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
 int a = 10;
 int b=11;
 pid_t pid;
 printf("before fork, pid is %d\n",getpid());
 pid = fork();
 if(pid==0)
 {
  printf("I am child process. My pid is %d\n",getpid());
  printf("Child saying hello");
 }
 else 
 {
  printf("I am parent process. My pid is %d\n",getpid());
  printf("parent saying hello");
 }
}

The output of the program will be

before fork, pid is 5195
I am parent process. My pid is 5195
parent saying helloI am child process. My pid is 5196
Child saying hello

In the next post we will discus s more about fork and vfork and wait functions

Command line arguments in C

2017-05-31T05:16:00.000-07:00

What are the different ways of providing input in a c programme?

You have used scanf, gets, getc. There is another much easier way. That is to provide the values along with program name when executing it.

So instead of saying
./a.out you would use
./a.out hello world

When such arguments are provided they have to be accessed using main function with an int parameter and another array of char pointers.

These are called argc (argument count) and argv (argument vector) respectively.

int main (int argc, char *argv [])
{ ......}

Let us start with a simple program.

#include<stdio.h>
int main(int argc,char *argv[])
{
   printf("argc is %d\n",argc);
   printf("and argv[0] is %s\n",argv[0]);
   return 0;
}

If we compile and execute this program, the output will be

yourhomedir$./a.out
argc is 1
argv[0] is ./a.out

Let us understand the program. As we are running the program with no extra argument, argument count is 1 and 0th element of argument vector is executable name itself.

If we run the program again with hello world, argc will be 3

yourhomedir$./a.out hello world
argc is 3
argv[0] is ./a.out

Let us use these arguments and write a program to print all the command line arguments

#include<stdio.h>
int main(int argc,char *argv[])
{
   int i;
   printf("argc is %d\n",argc);
   for (i=0;i<argc;i++)
    printf("and argv[%d] is %s\n",i,argv[i]);
   return 0;
}

This is similar to previous program, except that we have added a loop to print all elements of argv in that loop. And the loop repeats argc number of times.

Let us compile and execute this.

yourhomedir$gcc b1.c
yourhomedir$./a.out hello beautiful world
argc is 4
argv[0] is ./a.out
argv[1] is hello
argv[2] is beautiful
argv[3] is world

You can write a program to add the numbers provided by command line arguments. You can store these numbers in an array and find the largest of all and so on.

But we will finally write a program to print a file whose name is given as command line argument.

#include<stdio.h>
#include<stdlib.h>
int main(int argc,char *argv[])
{
   if(argc<2)
   {
 printf("Syntax is ./a.out filename");
        return 0;
   }
   FILE *fptr = fopen(argv[1],"r");
   if(fptr==NULL)
      {
         printf("File open error");
         exit(1);
      }
   char *str;
   while( (str=fgets( str,100,fptr))!=NULL)
      printf("%s",str);
   fclose(fptr);
}

yourhomedir$gcc b2.c
yourhomedir$./a.out b2.c
#include<stdio.h>
#include<stdlib.h>
int main(int argc,char *argv[])
{
   if(argc<2)
   {
    printf("Syntax is ./a.out filename");
        return 0;
   }
   FILE *fptr = fopen(argv[1],"r");
   if(fptr==NULL)
      {
         printf("File open error");
         exit(1);
      }
   char *str;
   while( (str=fgets( str,100,fptr))!=NULL)
      printf("%s",str);
   fclose(fptr);
}

So what we are doing here is we take the 1st element of argv as filename and try to open that file. If file open is successful, we read one line at a time and display it on screen.

Quite simple. Isn't it?

For such programs and quiz on these topics, please download my app - C interview questions

Convert a number to hex

2017-01-26T06:10:00.000-08:00

I am not trying to cast a spell on you. What I am going to write is how to convert a decimal number into hexadecimal in C language.

int a = 100;
printf("%x",a);

So printf format specifier %x will print a value in hex. %o (oh not zero) will print the value in octal.

Is it that simple. It is simple. Do you also know that you can directly type your hex values to variables. And octal too.

int m = 0xff; //255
int n = 011;//octal - 9

So you type a number with prefix zero - it is treated as octal number. And prefix 0x - it is treated as hexadecimal.

One small program to end the post.

#include<stdio.h>
int main()
{
    int n;
    while (1)
    {
    printf("Enter a number: (-1 to quit)");
    scanf("%d",&n);
    if(n==-1)
       break;
    printf("%4d    %4o    %4x\n",n,n,n);
    }
}

The program prints numbers in decimal, octal and hexadecimal continuously until -1 is entered.

By the way, in C++, you need to use io manipulator hex and oct to print the numbers in hexadecimal and octal.

Liked this post? You will get plenty of such questions in my app C interview questions

Constants in C++

2016-11-29T22:59:00.000-08:00

Constant in C++ is a value which can not be modified. As in C, we can have literal constants using #define and we can have enums or we can define a variable to be const - fixed. Let us concentrate on const variables here.

By declaring a variable as const, we ensure that it is not modified accidentlly. Any modification to constant will give a compilation error.

In the program below, assignment to pi gives a compiler error because pi is defined as const.

int main()
{
    const float pi = 22.0/7;
    int radius = 12;
    radius++;/*ok*/
    pi = 3.14;/*error*/
}

Even function parameters can be constant. We have earlier discussed that making a reference parameter as constant is always better to avoid the function from modifying the argument.

void printnum(int & n)
{
    cout<<n++;
}
void printnum2(const int & n)
{
     cout<<n++;/*error*/
}
int main()
{
   int a = 10;
   printnum(a);
   cout<<a;/*prints 11*/
   printnum2(a);
}

In the code above, printnum() function increments the argument and it goes undetected by the compiler. Whereas, in printnum2(), n++ gives a compiler error, because the parameter is a constant reference, and so it can not be modified.

So unless your function intends to change the reference parameter, make it as constant reference parameter.

Now let us consider how to define and use constant members of a class.

Constant Data Members

A class can have constant data members by using keyword const in declaration. Such members can not be modified after the object is created.

The question arises - how do we initialize such const members?

Initializing const data members must be done using member initializer list. Because const data can not be assigned within constructor body.

class A
{
 const int n;
public:
 A();
};

A::A():n(22)
{
  n= 10;/*error*/
}

As can be seen in the example, const member n is initialized in member initializer list. And assigning a value to n, even in the constructor, gives an error.

So if a class has a const data member (a) write a constructor for that class (b) In the constructor, initialize the const member using member initializer list.

constant functions

A constant function CAN NOT modify the state of the object i.e. it can not modify any data member.

And constant objects can only call constant functions.

A const function is written by adding keyword const after the parameter list

class A
{
 int a;
public:
 void print() const;
 void seta(int m){a = m;}
};
void A::print() const
{
 cout<<a;
 // a = 0;/*invalid*/
}
int main()
{
 const A obj1;
 obj1.print();//valid
 obj1.seta(12);//error
 A obj2;
 obj2.seta(12);//valid
 obj2.print();//valid
}

As you can see in the code above, print() function, which is const, is not allowed to change a - the data member. obj1 which is a constant object can call only const function viz. print(). It can not call seta() function. But a non-constant object obj2 can call both const and non-const function.

Constant objects

If an object is declared as const, it can call only const functions. An ordinary object can call both const and non-const functions.

Mutable members:

Even from a constant object, mutable data members can be changed and they can be changed even inside a const functions.

class A
{
 mutable int num_accessed;/*mutable member*/
 int b;
public:
 /*other code*/
 void print() const;
};

void A::print() const
{
 cout<<num_accessed<<" "<<b;
 num_accessed++;/* valid. the member is mutable*/
}

In the code above, num_accessed is incremented within a const function and the program would compile without errors.

Multiple Inheritance in C++

2016-11-21T01:40:00.000-08:00

In C++ a class can inherit from more than one class. Other languages which support multiple inheritance are python, perl, common lisp etc.

In Java, C# and Ruby, it is not possible to have 2 or more base classes for a given class. But C++ allows it.

Syntax for multiple inheritance is

class cls-name:public base-cls1,public base-cls2,public base-cls3

{
/*code*/
}

The base class list is comma separated and must have access specifier for each base class. Each of these base classes must have been declared earlier.

Derived class objects contains sub-objects of each of the base classes.

class LAnimal
{
 public:
 void walk()
 {
 cout<<"walks";
 }
};
class WAnimal
{
 public:
 void swim()
 {
 cout<<"swims";
 }
};
class Amphibian:public LAnimal,public WAnimal
{
};
int main()
{
 Amphibian frog;
 frog.walk();
 frog.swim();
}

In the above example, class Amphibian inherits from 2 classes - LAnimal and WAnimal. It has members of both these base classes. It can call both walk() and swim() functions.

Constructors

The derived class constructor and destructors in multiple inheritace will call all of the base class constructors and destructors. The order of constructor invocations is same as declaration order of base classes.

Amphibian constructor will call LAnimal constructor first, then WAnimal constructor and finally Amphibian constructor. And order of destructor invocation is reverse of order of constructor invocation.

Dreaded diamond problem and Virtual Inheritance

When there is a multilevel and multiple inheritance together, derived class may contain more than one instance of an ancestor class. Accessing a member from this base class throws an ambiguity error.

class A
{
 int m;
public:
 void setm(int a){m = a;};
 int getm(){return m;}
 void print(){cout<<"m"<<m<<endl;}
};
class B: public A
{
public:
 B(){setm(10);};
};
class C:public A
{
public:
 C() {setm(20);};
};
class D:public B,public C
{
 /*multiple inherited class*/
};
int main()
{
 D obj;
 cout<<obj.getm();/*error*/
 obj.print();/*error*/
}

When we compile this program obj.print()throws ambiguity error.

obj has members of A class duplicated. It has 2 ms, one is set 10 in B class constructor. And the other is set to 20 in C class constructor. So obj.getm() causes a conflict, whether to use m from B class path or m from C class path.

Similarly when calling print(), compiler is unable to decide whether to call print through C class or print through B class.

This is called dreaded diamond problem because of the shape of inheritance diagram.

To avoid this error, virtual inheritance is used.

Virtual Inheritance

In virtual inheritance, in spite of multiple paths to a base class, base class object is included only once.

class A
{
 int m;
public:
 int getm(){return m;}
 void setm(int a){m = a;}
 void print(){cout<<"A print";}
};
class B:virtual public A
{
/***code**/
};
class C:public virtual A
{
/***code**/
};
class D:public B,public C
{
/**this has only one sub object of A*/
};
int main()
{
 /*code*/
 D obj;
 obj.print();/*No error*/
}

Both B and C class use virtual inheritance. So when D inherits from both B and C, it is inheriting only one sub-object of A class. So there is only one data member called m in D class and only one print function. There will not be any ambiguity when obj.print() function is called.

Also observe that obj causes A class constructor to be called only once and A destructor to be called only once.

And do you know what? This topic and other topics are explained nicely in my C++ app. May be you want to download it from google play.

Operator Overloading - II

2016-11-19T19:15:00.000-08:00

Let us consider some special cases of operator overloading

Overloading of subscript operator:

subscript operator can be overloaded to access the dynamically allocated array elements within an object.

class Arr
{
    int *arr;
    int size;

public:
    int& operator [](int n) ;
    int operator[](int n) const;
/****code *****/
};

int &Arr::operator [](int index)
{
    return arr[index];
}

int Arr::operator [](int index) const
{
    return arr[index];
}

Const version of operator function is written so that constant objects can also access array elements. Non-constant version is helpful in modifying the array elements.

Make sure that non-const version of [] function returns a reference, so that you can assign values using statement like

obj1[3]=99;

Increment and Decrement operator ++ and --:

++ and -- have prefix and postfix versions for basic data types. a++ and ++a. So how do we overload these operators with two versions?

For postfix versions of these functions, we should use a dummy int parameter.

class Number
{
    int num;
public:
    Number & operator++();/*prefix version*/
    Number operator++(int a);/*postfix version*/
/****code***/
};
Number & Number::operator++()
{
    num++;
    return *this;
}

Number Number::operator++(int dummy)
{
    Number temp = *this;
    num++;
    return temp;
}

int main()
{
    Number obj(9);
    Number obj2(1000);
    obj2 = ++obj;/*calls prefix*/
    obj = obj2++;/*calls postfix*/
}

new operator:

New operator takes size_t parameter and returns a void pointer. The easy way of overloading new operator would be

void *Number::operator new(size_t bytes)
{
    char *ptr = ::new char[bytes];/*call global new operator*/
    return (void*) ptr;
}

Note that compiler provided new operator for classes will be sufficient in most situations. You need to overload new and delete operator, only if you want to use your own block of memory for dynamic allocation.

Insertion and Extraction operators (<< and >>) :

These two operators are used to read and write objects from iostreams and files. These should be overloaded as non-member functions because their first parameter will not be the current class object. . >> must have istream object as first parameter and << must have ostream object as first parameter.

These two functions must return reference to iostream objects in order to use chaining in io operation. And it is necessary to use second parameter also as reference parameter in extraction operator as the function modifies object.

ostream & operator <<(ostream& out, Number & obj)
{
    out<<obj.num;
    return out;
}

istream & operator >>(istream& in, Number & obj)
{
    in>>obj.num;
    return in;
}

Conversion Operators:

These are used to convert objects to basic data types. They are written without return type. Instead, data type is the name of the operator.

class Number
{
    int a;
public:
    operator int()/*Converts Number object to int*/
    {
         return a;
    }
/****code*****/
};

Function call operator:

parantheses - () can be overloaded to create an object which behaves like a function. Such objects are called function objects or functors.

class Cube
{
public:
int operator ()(int n)
{
   return n*n*n;
}
};
int main()
{
    Cube cobj;
    int m = cobj(10);/*this cubes 10 and returns answer*/
}

Overloading of assignment operator:

Compiler provides overloaded assignment operator function for a class. But you have to write your own assignment operator function if you need deep copy.

Assignment operator function looks almost like a copy constructor. You allocate memory and you copy elements.

But before that, you should release earlier memory allocated.

There is one more problem however. What if you use a statement which ultimately becomes self assignment

ob1 = ob1;

In this case, if you delete memory, all hell breaks loose.

To avoid this problem, check for self assignment, then delete memory, allocate new memory and copy elements.

A& A::operator =(A & obj1)
{
    if(this !=&obj1)/*self assignment?*/
    {
      delete arr;
      arr = new int[obj1.n];
      for(int i=0;i<n;i++)
         arr[i] = obj1.arr[i];
    }
    return *this;
}

Function Overloading in C++

2016-11-19T11:27:00.001-08:00

Let us look as abs() function in C. You should abs() for int, fabs() for float, labs() for long. All these functions find absolute value of a number. As two functions can not have same name, C library has so many names for abs function. This is not the case in C++

In C++, two or more functions can have the same name if they have different number of parameters or different types of parameters. These are called overloaded functions.

Overloaded functions must differ by number of parameters or types of parameters or both. In case of class members, they can differ by const-ness.

int sum(int a,int b) {return a+b;}
int sum(int a,int b,int c){ return a+b+c;}
float sum(float m,float n) {return m+n;}

These three are all overloaded functions sum.

Two functions can not be overloaded, if they differ only by their return types.

int product(int a,int b);
float product(int a,int b);/*invalid*/

When an overloaded function is called, the compiler calls a version based on type of arguments and number of arguments.

int x,int y;

x=y=33;
x = sum(x,y,x+4);/*calls 3 parameter sum function*/

float m=sum(8.9f,1.2f);/*calls float sum function*/

double n=sum(12.1,3.2);/*ambiguity error*/

Last line produces compiler error because the compiler does not know whether to convert parameter to float or int.

As you can see, some times, the overloaded functions are very similar except for types of parameters. In such cases, we can use template functions which are generic functions.

C++ also has another type of overloading for classes. That is operator overloading where operator behavior is modified for the given class.

Get these notes in your mobile. Download my C++ Notes app.

Reference variables in C++

2016-11-19T11:14:00.003-08:00

In C language, we have call by value and call by pointer of functions. Both have their own drawbacks. C++ provides a better solution - call by reference.

A reference variable in C++ is an alias for another variable.

Such a variable looks like an ordinary variable but behaves like a pointer. It always refers to another variable.

In function calls, reference parameter modifies the actual argument, without the hassle of addresses and indirections.

Defining a reference variable

A reference variable is defined with & along with its name. It should always be initialized during definition.

 int &b = a;/*definition of a reference*/

b is a reference variable and it refers to a. That is b is another name for a.

Functions with reference parameters

A function with reference parameter changes the actual argument because the parameter is an alias for argument. In case of large structs and classes, it is better to send a reference parameter, as it avoids copying of data.

void triple(int &a)
{
    a *=3;
}
int main()
{
  int m = 10;
  triple(m);/*changes m to 30*/
  cout<<m;
}

In the above example, m is sent as a reference parameter. So m is changed by the function triple().

If the function needs a reference parameter for efficiency, but the function should not change the argument, you should define parameter as constant reference.

Notes

A reference should always be initialized to another variable while defining it.

A reference variable can not refer to a different variable later.

i.e. b = c ;

will not make b refer to c. Instead it assigns c to a.

A reference variable should always be initialized when defining.

float &m1 = m2; /*m1 is initialized to m2*/

An array of reference variables is not possible

If a function has a reference parameter, changes to this reference parameter will change the actual argument.

If a function returns a reference value, that function can be used in LHS of an assignment statement.

Returning a reference

A function returning a reference has the advantage that it can be used in LHS of an expression. But you have to make sure that, the return value of such a function is within the scope even when function exits.

int &fn1(int m,int n)
{
   if(m>n) return m; return n;
}
int main()
{
  int a1 = 3,b1=12;
  fn1(a1,b1) = 100;
}

Here main fn1() returns a reference to b1. So b1 will be set to 100 in the assignment statement of main().

Overload () operator

2016-11-18T22:27:00.000-08:00

Let us see how to overload parenthesis operator for matrix class such that matrix(i,j) returns ith row, jth column element of the matrix.

matrix.h

#ifndef MATRIX_H
#define MATRIX_H

class matrix
{
    int *elements;
    int nr,nc;
public:
   
    matrix();
    ~matrix();
    int getNrows(){return nr;}
    int getNcols(){return nc;}
    matrix(int nr,int nc);
    int & operator() (int row,int col);

};

#endif // MATRIX_H

#ifdef preprocessor directive was inserted by codelite IDE. What it does is to protect us from multiple inclusion of the same file. If matrix_h is not defined then only include its declaration.

Next let is look at data elements of the class viz nr,nc and elements. nr and nc are number of rows and columns of the matrix. Notice that these have only getters not setters because once a matrix is defined, you should not be able to change nr or nc.

Elements is where the elements of matrix are stored. I am using a one dimensional dynamic int array. So each access of element will have to be row*number of columns + col.

The class has a default constructor and constructor with 2 parameters - nr and nc.

matrix::matrix()
{
    nr = nc = 2;
    this->elements = new int[nr*nc];
    for(int i=0;i<nr*nc;i++)
    {
        elements[i]=0;
    }
}

matrix::~matrix()
{
}
matrix::matrix(int nr,int nc)
{
    this->nr = nr;
    this->nc = nc;
    this->elements = new int[nr*nc];
    for(int i=0;i<nr*nc;i++)
    {
        elements[i]=0;
    }
}

Constructors allocate memory to array. And initialize elements to 0. We have totally nr*nc elements in the matrix.

Now we should see how to overload () operator for this class.

int& matrix::operator()(int i,int j)
{
   int index = i*nc;
   index+=j;
   return elements[index];
}

The function just returns ith row and jth column element from the matrix. And index is i*numberOfColumns+j because my implementation is using 1 d array.

But a crucial point to remember is return type of operator function. It is int reference. Not just int. Because we must be able to assign values to the elements of the matrix with the help of this operator. So the function returns reference to ith row jth column element of the matrix.

Let us use it in action.

#include <iostream>
#include"matrix.h"
using namespace std;
int main( )
{
    matrix m(3,3);
    for(int i=0;i<3;i++)
        for(int j=0;j<3;j++)
        {
            int temp;
            cout<<"Value:";
            cin>>temp;
            m(i,j)=temp;
        }
       
      for(int i=0;i<m.getNrows();i++)
      {
        for(int j=0;j<m.getNcols();j++)
        {
            cout<<m(i,j)<<"  ";
        }  
        cout<<endl;
      }      
}

In main function we are creating a matrix of 3X3, reading values into it and displaying it back.

Download the complete program from here

Static members in C++

2016-11-17T22:59:00.000-08:00

Static data member

A static data member belongs to the class, not to any object. It is shared by all the objects of the class.

To make a data member static, it should be defined with keyword static inside the class body.

A static data MUST also be defined outside the body of the class because inside class, the declaration of static data is not definition.

class SimpleInterest
{
 static double rate;
 int amount;
 float period;
public:
 /*funnctions*/
};
double SimpleInterest::rate=0.07;/*definition*/

Static data members can be accessed using dot or arrow operator but they can also be accessed without an object, using class name followed by scope resolution operator.

int main()
{
 SimpleInterest::rate=0.08;
 SimpleInterest obj;
 float intrst = obj.amount*obj.period*obj.rate;
 cout<<intrst;
}

Static member functions

A static member function can be called directly without using any object, with class name and scope resolution operator.

A function is made static by using static keyword within the class body in function declaration.

Rules for static functions.

A static function can not use "this" pointer. Hence it can not access non-static data members.
A static function can not be const
Static function can not be virtual

class A
{
 int n;
 static int m;
public:
 A(int m);
 static void print() ;/*static function*/
};
int A::m=4;

void A::print()
{
 cout<<"Hello world";
 cout<<n;/*error. Can not access n*/
 cout<<m;/*no error. m is static*/}
int main()
{
 A::print();
}

print() function of A class, which is static can not access n, as n is non-static data.

Stack template class in C++

2016-11-17T08:06:00.001-08:00

Today let us write a template class Stack. Stack is a data structure of LIFO - last in first out. But of course, STL (standard template library) has a stack class in it and you can use it.

But still let us write our own Stack.

Stack needs the following methods - push, pop, empty and peek or top. push method add a value to the top of the stack. Pop removes a value from the top of the stack. empty finds out whether the stack is empty. peek returns the value from top of the stack without actually removing it.

Did you know that function call in most of these languages make use of Stack data structure for managing call frames. That is the reason, a return will return from the most recently called function.

Anyways. How do we implement the stack. We can use a vector or a deque from STL. If we want to use basic data types, we can use an array or our own linked list. Array will be limited by size of the array. So linked list?

template <class T>
struct node
{
    T num;
    struct node *next;
};

template <class T>
class Stack
{
       node <T>*topnode;
public:
      Stack();
      bool empty();
      void push(T data);
      T pop();
      T & top();
};

Why templates? Because our class becomes flexible and can be used for most data types.

We have self referential structure node with data and link to the next node. Data is a template variable. So it can be int, float, string etc.

Next we have class Stack which has one data parameter topnode or top of the stack. And we must have constructor and the four methods.

Constructor should initialize topofstack or topnode to 0. If you have written a similar program in C, you would have set it to NULL pointer. C++ prefers plain 0 for pointer rather than predefined constant 0. You know that NULL is nothing but a pointer with 0 value.

template <class T>
Stack<T>::Stack()
{
    topnode = 0;/*initialize*/
}

For push function, we have to create a new node using dynamic memory allocation. and place this node on top of stack. You should perform these operation in push operation.

create a new node
newnode->next = topnode
topnode = newnode

template<class T>
void Stack<T>::push(T data)
{
     node <T>*newnode = new node<T>;
     newnode->num = data;
     if(topnode){
         newnode->next = topnode;
     }else{
         newnode->next = 0;
     }
     topnode = newnode;
}

Similarly in pop operation, we have to perform

copy topnode to temp
topnode = topnode->next
copy value in temp to num
delete temp
return num

template<class T>
T Stack<T>::pop( )
{
    if(!empty())
        {
            node<T> * temp = topnode;
            topnode = topnode->next;
            T num = temp->num;
            delete temp;
            return num;
    }
    else
        {
             return (T)0;
        }
}

Empty is a simple function, you will just check if topnode is 0. If it is zero Stack is empty

template <class T>
bool Stack<T>::empty()
{
    return topnode==0;
}

But since all these functions are part of template class, they all must have template header before them.

Remember: For a template class, the class definition and also function definitions must be in header file.

Complete Program

Stack.h

template <class T>
struct node
{
    T num;
    struct node *next;
};

template <class T>
class Stack
{
       node <T>*topnode;
public:
      Stack();
      bool empty();
      void push(T data);
      T pop();
      T & top();
};


template <class T>
Stack<T>::Stack()
{
    topnode = 0;/*initialize*/
}
template <class T>
bool Stack<T>::empty()
{
    return topnode==0;
}

template<class T>
void Stack<T>::push(T data)
{
     node <T>*newnode = new node<T>;
     newnode->num = data;
     if(topnode){
         newnode->next = topnode;
     }else{
         newnode->next = 0;
     }
     topnode = newnode;
}

template<class T>
T Stack<T>::pop( )
{
    if(!empty())
        {
            node<T> * temp = topnode;
            topnode = topnode->next;
            T num = temp->num;
            delete temp;
            return num;
    }
    else
        {
             return (T)0;
        }
}

template<class T>
T& Stack<T>::top( )
{
    if(!empty())
        {                        
            T num = topnode->num;             
            return num;
        }
    else
        {
             return (T)0;
        }
}

main.cpp
#include <iostream>
#include"Stack.h"
using namespace std;
int main(int argc, char **argv)
{
 Stack<int> s1;
    for(int i=0;i<10;i++)
    {
        int m;
        cin>>m;
        s1.push(m);
    }
    while(!s1.empty())
    {
        int a;
        a = s1.pop();
        cout<<"Popped value is "<<a<<"\n";
    }
    Stack<char> s2;
    s2.push('c');
    s2.push('+');
    s2.push('+');
    
     while(!s2.empty())
    {
        char a;
        a = s2.pop();
        cout<< a<<"\n";
    }
}

C++ program with constructor and constant function

2016-11-13T06:29:00.001-08:00

Today let us write a program with class, member methods and constructor.

Q:
Write a class point with two data members x and y. Write getters and setters for these. Now create an array of 10 points and print the farthest point from the origin.

Point.h

class point
{
    float x;
    float y;
public:
    point(float m=0,float n=0);
    float  getx() const;
    float  gety() const;
    void setx(const float & a);
    void sety(const float & b);
};

Point.cpp

#include"Point.h"
point::point(float a,float b):x(a),y(b)
{
}
float   point::getx() const
{
    return x;
}
float   point::gety() const
{
    return y;
}
void point::setx(const float &a)  
{
   x = a;
}
void point::sety(const float &b)  
{
   y = b;
}

main.cpp

#include<iostream>
#include"Point.h"
#include<cmath>
using std::cin;
using std::cout;
 
int main()
{
    point pobj[4];
    for(int i=0;i<4;i++)
    {
        cout<<"Enter x and y of point"<<i<<":";
        float x1,y1;
        cin>>x1>>y1;
        pobj[i].setx(x1);
        pobj[i].sety(y1);
    }
    /*find farthest point*/
    float largest_dist = -1;
    int index = -1;
    for(int i=0;i<4;i++)
     {
         float squared_dist = pobj[i].getx()*pobj[i].getx() + pobj[i].gety()*pobj[i].gety();
         float dist_from_origin = sqrt(squared_dist);
         if(dist_from_origin>largest_dist)
         {
               largest_dist = dist_from_origin;
               index = i;
         }
     }
     cout<<"The farthest point is ("<<pobj[index].getx()<<","<<pobj[index].gety()<<")";
     return 0;
}

Now let us try to understand the code.

Point class has x and y as private data members. Which means main() function or any other outside function can not directly access the code. So the getters and setters. getter returns the data member. And setter changes it.

Let us look at getx() and gety(). They return data members x and y respectively. x and y of which Point. The point from where the function is called. this point. If you want you can add this pointer to the code.

float   point::getx() const
{
    return x;//or return this->x;
}
float   point::gety() const
{
    return y;
}

But why are these functions constants? Because getx and gety need not and should not change x and y co-ordinate. So making the function const ensures this. In const function, if state of an object is changed, there will be a compiler error.

But setx() and sety() are not const functions. Why? Because they have to change x and y.

Look at a modified main function. We have created a constant point p1 and called getx and gety on this constant object. No error. But when we call setx() on p1, there will be compiler error. Because a constant object can call only constant functions.

int main()
{
   const Point p1(10,3);
   cout<<p1.getx()<<","<<p1.gety();//no error
   float m;
   cin>>m;
   p1.setx(m);//error
   .....
}

Now let us look at the constructor

point::point(float a,float b):x(a),y(b)
{
}

The constructor is very simple. It takes two parameters a and b. And assigns x to a and y to b using member initializer list.x(a) , y(b) is equivalent to saying x=a; and y=b; inside the constructor

Member initializer list is faster than assignments and in case of constant data members, you should use member initializer. If x is const float, the x=a; in constructor throws a compilation error.

In main function, we are creating an array of 10 points and reading their x an y using a for loop. No, we are reading a temporary variable x1 and use this in setx function.

A simple


cin>>pobj[i].x

will throw compilation error. Because x is private. But won't it be simpler to make x and y as public and directly read and write them. NO. Because making data public violates the principle of Encapsulation and any future change in implementation affects other code which use this class. Always make data members as private

    point pobj[4];
    for(int i=0;i<4;i++)
    {
        cout<<"Enter x and y of point"<<i<<":";
        float x1,y1;
        cin>>x1>>y1;
        pobj[i].setx(x1);

Which constructor do array elements of pobj use here? We know that if a class has any user defined constructor, then compiler does not provide default constructor.

If we look at Point.h


class point
{
    float x;
    float y;
public:
    point(float m=0,float n=0);

we see that parameters m and n have default values 0 in the constructor. So the 2 parameter constructor behaves like default constructor (constructor with 0 parameters) and is called when initialing array elements.

The rest of the code is simple finding a largest element in an array kind of stuff.

Input Output operation in C++

2016-11-08T03:34:00.001-08:00

In C++, Input Output operations are performed using two objects - cin and cout. Note that they are not functions but objects. They use overloaded operators >> and <<. c here indicates console.

cin
cin is an istream object. Any variable like int, float, double or char array is read from console using cin object and extraction operator(>>). cin can also read user defined objects if their classes overload extraction operator.

e.g.

#include<iostream>
using namespace std;
int main() 
{ 
 int a; float b; int  c; 
 cin>>a; 
 cin>>b>>c;

}

Unlike scanf which has a complex syntax, cin does not use ampersand operator ( & ) and it does not need format specifiers like %d, %f.. To read multiple variables, >> operator is chained, comma is not used.

cout
cout is an object of ostream class and values can be written on console using cout and insertion operator(<<). cout also does not need format specifiers.

e.g.
cout<<"Hello world";
cout<<a<<b<<c;

endl
endl is an io manipulator. It prints the character \n and flushes the stream.

Other IO manipulators
C++ has a large set of io manipulators. Some of the main ones are

setw(n) and width(n) - set the width for subsequent fields.
left and right - justify the field to left or right. Only work after setw() or width()
setfill(ch) - if the field does not fill the width, ch is used to fill empty spaces
setprecision(n) - sets the number of digits printed after decimal point for floating point values
boolalpha - shows the boolean values as true and false instead of 1 and 0
noboolalpha - shows boolean values as 1 and 0
skipws and noskipws - by default white spaces are skipped when reading character input. noskipws will not skip white spaces.
hex, oct, dec - displays integers in the given numer system
setbase(8/10/6) - sets the base for number. Similar to hex, oct and dec

int n = 3;
cout<<"|"<<setw(10)<<n<<endl;
int m = 88;
cout<<hex<<m;//prints 58
bool b = true;
cout<<boolalpha<<b;//prints true
char str[30];
cin>>str;
cout<<"you typed "<<str;//prints only first word of input
cin.ignore(INT_MAX,'\n');
cin.getline(str,29);
cout<<"you typed "<<str;//prints the entire string

By default cin with strings reads only till first white space and next cin will read next word etc. So if you type "Hello world", your output will be "you typed Hello". To read the complete line of input, you can use cin.getline(char_array,size)

Another problem is after reading first word, the buffer has the rest of the string, So subsequent reads with cin will not wait for user input, instead take the value from buffer. Buffer can be flushed using cin.ignore(how_many,till_char);

If a wrong input is entered, an error flag is set which may cause infinite loop

while(m!=-1)
{
     cin>>m;
     cout<<m;
}

Here if a character is entered instead of a number, infinite loop is caused. To avoid it, clear the error flag and ignore the offending character.

while(m!=-1)
{
     cin>>m;
     if(cin.fail())
    {
         cin.clear();
         cin.ignore(INT_MAX,'\n');
     }
    else{
      cout<<m;
     }
}
NameSpaces

C++ organizes names into different namespaces in order to avoid name conflicts. All library functions and objects belong to the namespace "std". So to use cin and cout, we need to import this namespace. This is done using

using namespace std;

Or you can use the fully qualified names viz std::cin, std::cout.
:: is called scope resolution operator.

std::cout<<"Hello world";

bool
C++ has an additional data type bool. bool stores boolean values true and false. But for i/o operations true is treated as 1 and false is treated as 0.

bool m;
m=true;
cout<<m;//prints 1 here.

Know your operators

2016-11-03T04:22:00.000-07:00

You know basic operators of any programming language. You know very well that x is not multiplication, but * is. You also know that % does not give percentage, instead gives reminder. You also know about && || and !

But that is just basic stuff or as the cliche goes tip of the iceberg. C has a very rich set of operators. And these allow you to write very small and cryptic programs.

a++ or ++a?

You know about increment operators - pre-increment and post increment. You can increment your number a using ++a or a++. Which is better and why?

The answer is - it does not matter. Both increment the number - an integer. Please remember that you can not increment a float or a double. But you can increment a char - because char is basically an integer.

So you use a++; or ++a;

But it matters when this iincrement operation is used in an expression.

Let us look at an example.

 int m = 2, n=3;  
 m = 2 + ++n;

Here m will be 6 and n will be 4.

But if we use post increment operator

 int m = 2, n=3;  
 m = 2 + n++;

Here m will be 5 because 2+n is assigned to m and after that n is incremented.

Same rules apply to decrement operators --.

What is sum+=n?

You use this type of expression quite often.

sum = sum+n;

So, C has a short hand operator for this called +=

sum+=n;

is same as sum = sum+n;

You have such operators for all arithmetic and bitwise operators. You have -=, *=, /=, %=, <<=,>>=, &=,|=,^=

What is the relation?

Of course, you know about less than, greater than, less than or equal to, greater than or equal to ( <, >, <=, >=). But confusing operators for newbies are equal to and not equal to.

Equal to operator is not =.

= is assignment operator. Equal to is ==. And not equal to is !=.

 int a = n%2;  
 if(a==0)  
   printf("%d is even",n);  
 else  
   printf("%d is odd",n);

Three is a crowd

C has only one ternary operator?: . Ternary operator is an operator which takes 3 operands. This operator works like if - else statement.

  int m,n,p; m = 3;n=2;  
  p = m>n?m:n;

The second statement is equivalent to

 if(m>n)  
   p = m;  
 else  
   p = n;

You can write complete code to print even-ness of a number by tweaking this operator.

 int m;
 scanf("%d",&m);
  (m%2)?printf("Odd"):printf("Even);

Where is the address?

You can get the address of a variable using & operator. Please note that, & is also used for bitwise and operation and && is logical and.

int a =0;
 int *ptr = &a;//& is address operator

&a gives "address of" a.

 ptr = &(a+10)

produces error because a+10 is not lvalue and has no address.

Once we have address, we can get value at that address using * operator - called indirection operator .

 int b = *ptr;//indirection operator

b is assigned to the value at address in ptr.

Again the onus is on you to ensure that ptr points to correct location. If ptr is uninitialized or has 0 value or any other invalid value - you get the infamous segmentation fault.

Just a dot

Operator . is used to access member of a structure or a union. -> arrow operator is used to access member of a structure using a pointer.

 struct student {int id,char name[10]};  
 struct student s;  
 s.id = 10;  
 strcpy(s.name,"FooBar"};

 struct student *sptr = &s; sptr->id=11;

And the rest

There are bitwise operators &,|,!, ^ and complement. And there are left and right shift operators. Read about bitwise operators here

Magic!!!

2016-08-01T00:01:00.000-07:00

Google developers' page asks you to enchant the users.

So get ready for some magic.

You know that anything created will be destroyed. And the corollary is, anything destroyed would have been created earlier. Law of conservation of mass - Is it?

P.S. It is not the law of conservation of mass. The law says mass can not be created or destroyed. In my excitement to write a blog about magic, I overlooked it.

So in C++, creation is assisted (or followed) by constructor and destruction by destructor. So if I show you a program in which there is a destructor without a constructor, we are defying the common principle.

Take down this code and execute it.

 #include<iostream>  
 using namespace std;  
 class A  
 {  
   public:  
   A(){cout<<"constructor ";}  
   ~A(){cout<<"destructor ";}  
 };  
 void fn1(A obj)  
 {  
   cout<<"hello magical world ";  
 }  
 int main()  
 {  
    A obj1;  
    fn1(obj1);  
 }

What did you say the output was. Is it
constructor hello magical world destructor
?

No, It is not? Then is it

constructor hello magical world destructor destructor
?

It is. Isn't it? So the question is, where is the extra destructor coming from? One object - one constructor, one destructor. That is what is expected. But here we have one constructor and two destructors!

So we have destroyed an object without constructing it? Is this the THE MAGICAL OBJECT?

Tell me the reason.

Private constructor in C++

2016-07-07T00:31:00.001-07:00

An interview question asked will be "Can a constructor of a class be private".

Yes, it can be. By making a constructor as private, the program will compile fine. But the question is can we create objects from such a class. Of course not. How can we when we can not access the constructor?

But it is possible. We can create an object by having a static member function which creates an object by calling private constructor and return this object.

 #include<iostream>  
 using namespace std;  
 class A  
 {  
  int m; 
  A(){cout<<"constructor";} //this is private constructor
  public:  
  static A createObject();  
  
 };  
 A A::createObject()  
 {  
  return A();  
 }  
 int main()  
 {  
    A obj1 = A::createObject();   
 }

As we can see the function createObject() creates a temporary object using A() and returns this object.

Since the method is static, it can be called without using any object. It is called using class name and scope resolution operator.

Some time we not only want the constructor to be private, we want the class to let only one object created. Such a class is called singleton and has many applications. We will see how to create a singleton in a future post :)

Private destructor

This is tricky. No matter how we create a constructor, destructor should be called and there is no way we can avoid this. Nor can we call a private a destructor.

So even if we write a class with private destructor, we can NOT create an object from such a class. Because any object created must be destroyed which should call a destructor which is not possible.

Or should it be? What if we construct an object using dynamic memory allocation - using new. Then the object gets destroyed only if we call delete on that object.

So we can have a private destructor for a class, and create an object from that class using new operator, if we do not call delete to destroy that object.

 #include<iostream>  
 using namespace std;  
 class A  
 {  
  int m;  
  ~A(){}  
  public:  
  A(){}  
 };  
 int main()  
 {  
   A *ptr = new A;  
   cout<<"Hello world";  
 }

As we see here, an object of A class is created using new A, but it is not destroyed using delete. The program compiles and runs fine. Do not ask me what purpose does it serve. I don't know.

But next time some one asks you, can constructor or destructor of a class be private, impress them with a detailed answer.

Bitwise operators

2016-06-09T07:03:00.001-07:00

C is a small language. It has just 32 keywords. But it has a rich set of operators.

The operators which are commonly not used are bitwise operators. Here C comes closer to Assembly language because it lets you manipulate individual bits of a number.

Let us look at some examples.

int a,b,c;
a = 10;
b = 12;
c = a|b;

Here | is bitwise OR operator. Individual bits of a and b are ORed and result is stored in c.

a = 00001010
b = 00001100
c = 00001110

So c will be 14

A small summary of bitwise operators here

Operator	Description	Example
&	AND - If both bits are 1, result is 1. If not result is 0	10&4 is 1010 \| 0100 = 0000
\|	OR- If either bit is 1, result is 1. If not result is 0	10\|4 is 1010 \|0100 = 1110 = 14
^	EXOR - If either bits are 1, but not both, result is 1. If not result is 0	10^4 is 1010 ^ 0100 = 1110 10^8 is 1010 ^1000 = 0010 = 2
<<	LEFT SHIFT - Shifts bits by n places to the left, adding 0 in empty bits	10<<2 101000="40</td" 1010="">
>>	RIGHT SHIFT - Shifts bits by n places to the right adding 0 in empty bits	10<<2 101000="40" 1010="" are="" beyond="" bits="" lost="" lsb="" shifted="" td="">
>>	COMPLEMENT Complements all the bits. i.e. 1 to 0 and 0 to 1	~10 is 11110101 for unsigned char (1 byte)

Shift Operators

Left shift - <<, shifts all bits of a number to left by given number of bits. The empty bits in LSB are filled with 0.

e.g.

a = 10;
b = a<<2;

a = 00001010;
b = 00101000;

So b will be 40.

>> shifts all bits of the number to right by given number of bits. The bits pushed beyond LSB are lost.

a = 10;
b = a>>2;

000010101 >> 2 = 00000010

b becomes 2.

As you might have guessed, left shift operator multiplies the number by 2 to the power of n

Right shift divides the number by 2 to the power of n.

|=, &= and other operators

And arithmetic assignment operator, there are bitwise assignment operators.

|= &= ^= <<= >>=

a |=b ;
is equivalent to a = a|b;

Now time for some small program.

 #include<stdio.h>  
 int main()  
 {  
   int a =10;  
   int b = 1;  
   int c;  
   c = a|b;  
   printf("OR %d\n",c);  
   c = a&b;  
   printf("AND %d\n",c);  
   c = a^b;  
   printf("EXOR %d\n",c);  
   c = a<<b;  
   printf("Left shift %d\n",c);  
   a >>=b;  
   printf("right shift= %d\n",a);  
   c = ~b;  
   printf("complement of b%d\n",c);   
 }

int main() or void main()

2016-05-30T22:34:00.002-07:00

Many people still use void main() in their programs. Their justification is why should main return anything? and to where does it return a values? And my compiler accepts main() without return type.

main() should return a 0 value to indicate successful execution of the program.
main() returns the value to operating system.
If your program writes

main()
{ /********/}
it is int main().
Default return type in C is int, not void.

All modern compilers give a warning when you use void main(). In fact in C++, void main() will give compiler error

Two signatures of main function are

int main();
and
int main(int argc, char *argv[])

First one is used in normal programs. Second signature is used when you want to access and process command line arguments.

So do not use void main() in your code, even if your compiler does not throw any errors.

Online learning - C++

2016-05-12T04:38:00.003-07:00

Today's generation has no patience. No patience to read books (or attend classes :) ). They learn stuff through youtube. How effective is that? And how reliable are the videos?

But there are online courses available from various sites like Coursera, Edx, Udemy etc. These are reasonably better, I think.

When I was browsing through online courses for C++, I came across sololearn and visited their C++ course. I was impressed. The course was concise but really good. And the best part is each descriptive page is followed by a quiz. What is needed for us - who have the attention span of a two year old :)

Should I give a disclaimer here? I am not a paid advertiser for that course. The reason behind this post is - I am eager to share the information with others as always.

And by the way, sololearn has android apps for courses, which are good too.

By the way MIT has open course ware for C++ complete with downloadable lecture notes and assignments here and here

And there is a course in university of cambridge here.

Before I forget, informit reference guide on C++ has in depth material and is really good (but is not downloadable)

Overloading of [] and ()

2016-05-09T18:07:00.001-07:00

Let us see some unusual operators to overload.

Subscript operator overloading

Let us say you have an array class of some type and you want to access the elements of the array using familiar [] operator, then you can overload this.
So here comes code

  class Array  
 {  
   int *numarray;  
   int size;  
 public:  
   --------  
   int operator [](int index);  
   -----  
 };

The class looks quite straight forward. It is array of ints and subscript operator returns the element of the array. So the function can be

 int Array::operator[](int index)
  {   
   return numarray[index];  
  }

But there is still some problem in this code. Don't you think so? Let us look at its usage

Array obj(5);
cout<<obj[0];
obj[1] = 22;

obj[1] = 22 needs us to be able to place our operator function on LHS. Which means --- we need a reference return type.

So the proper class with operator functions is

#include<iostream>
using std::cout; 
class Array
{ int *element;
 int size; 
 public:
    Array(int n=1);
    int & operator [](int index);
   const int &operator[](int index) const;
    ~Array();
    Array(const Array & obj);
    Array& operator =(const Array &other);
}; 
Array::Array(int n)
{
 size = n; 
 element = new int[n];
 for(int i=0;i<n;i++)
 {
  element[i]=0;
 }
} 
Array::Array(const Array &obj)
{  
 size = obj.size;
 element = new int[size];
 for(int i=0;i<size;i++)
 {
  element[i]=obj.element[i];
 }
} 
Array& Array::operator = (const Array &other)
{
 if(this!=&other){
  delete []element;
   
   size = other.size;
 element = new int[size];
 for(int i=0;i<size;i++)
 {
  element[i]=other.element[i];
 }
 }
 return *this;
}

int &Array ::operator[](int n)
{
 if(n>=0 && n<size)
     return element[n];
  else return 0;
} 
 
const int& Array::operator[](int n) const
{
 if(n>=0 && n<size)
     return element[n];
}
 
Array::~Array()
{
 delete[]element;
}

Now you should ask me why are there two subscript functions. The reason is, if there is a constant object, it can call only const functions. const functions should not modify the state of the object. That is the reason one [] operator function is const and returns const int &

Function call operator

Function call operator should be a member function. It is normally used for function objects such as iterators etc.

Let us look at an example.

class Cube
{
 public:
 int operator ()(int num);
};
int Cube::operator()(int num)
{
 return num*num*num;
}

As we can see the class has an operator function which takes an int and returns its cube. Let us see its usage.

        Cube funobj;
 cout<<funobj(4);

In this case funobj is function object and is also called a functor.

File Handling in C++

2016-05-07T18:37:00.001-07:00

File handling in C++ is not that difficult. All these times, you have been using insertion operator - << and extraction operator >> to write and read data to screen. Insertion operator uses cout object - which is an object of ostream class and extraction operator works on cin - an istream object.

ifstream is a derived class of istream and can be used for files in read mode and ofstream is derived from ostream and is used for writing to files.

This is how you start writing to a file

ofstream obj("myfile.txt");//constructor creates the file and opens it. 
int n;<

If the file can not be created or opened the object will be false.

if(!obj) cout<<"File open error"

Another method of opening a file is a 2 step process

ifstream obj2;   obj2.open("filename");

Both the constructor and open method can take second parameter which is the mode of opening the file.

The mode of opening a file can be
ios::in , ios::out, ios::app, ios::trunc etc.

Writing to file:

Let us write hello world to a file.

 #include<iostream>  
 #include<fstream>  
 using namespace std;  
 int main()  
 {  
      ofstream obj("myfile.txt");  
      if(!obj)  
      {  
        cout<<"could not open file";  
           exit(1);  
      }  
      obj<<"Hello world"<<endl;  
      obj.close();  
 }

Voila! We wrote our first hello world file.

Reading from a file:

To read the same, we need to use an ifstream object and extraction operator

 #include<iostream>  
 #include<fstream>  
 using namespace std;  
 int main()  
 {  
      ifstream obj("myfile.txt");  
      if(!obj)  
      {  
        cout<<"could not open file";  
           exit(1);  
      }  
      char s[100]; 
      while(obj) 
      {  
          obj>>s;  
          cout<<s;
      }
 }

Do you notice anything stranage? There are no format specifiers anywhere and no addressof operator. That is because >> and << are overloaded for all types of data. And C++ uses reference parameters, so no addresses.

Also there are no white spaces. >> operator ignores whitespaces.

Even if you read the string from screen, the similar thing can be expected. To read a string with white spaces and everything, you can use getline function

obj.getline(str,100);

where str is character array - buffer and 100 is size of buffer.

      char str[100];
      while(obj)
      {
           obj>>str;
           cout<<str;
     }

There is a safer version without mentioning the buffer length. This is non-member function.

getline(istream-object,char-array,delimiter)
which reads upto the delimiter character.

You can use this as

getline(obj,str,'\n');

What if you meed to read and write from the same file? That is possible too, using the mode ios::in|ios::out and using an fstream object, like this.

 int main()  
 {  
      fstream obj("myfile.txt",ios::in|ios::out);  
      if(!obj)  
      {  
        cout<<"could not open file";  
           exit(1);  }
      char s[100];
      while(obj)
      {
           obj>>s;
           cout<<s;
     } 
     obj.clear();//clear the errors on object
     obj<<"Now we write again to same file";
     obj.close();}

Do you notice some thing here? Instead of checking for NULL, we just check if the stream is true or false.

bad? fail?

Another method of checking the validity of stream is using bad(), eof() and fail() functions. bad() returns true if any invalid operation is performed on the stream. eof() returns true when end of file is reached. And fail() is true if either bad() or eof() are true.

Seek and you will find it

Remember fseek() and ftell() in C? We have equivalents here. Only we have four functions. seekg(), seekp(), tellg(), tellp(). And you are right. g is for get pointer - for reading and p is put pointer - for writing.

seekg() and seekp() move the file pointer to the required location. They need offset as first parameter and optional seek direction as second parameter.

     obj.clear();//clear the errors on object
     obj.seekp(0); 
     obj<<"Now we write again to same file";
     obj.close();

This code writes the line to the beginning of the file.

tellg() and tellp() give the location of getpointer and putpointer in terms of bytes.

Objects to a file

So far we wrote and read PODs . But we can write entire objects to the file by overloading << and extraction operators for these classes as shown below.

   class NumString
{
 int num;
 char str[40];
public:
 NumString(int n=0):num(n),str("nothing"){}
 int getNum()
 {
  return num;
 }
 void setNum(int n)
 {
  num = n;
 }
 void setstr(char *s)
 {
  strcpy(str,s);
 }
 char * getstr()
 {
  return str;
 }
};

ostream& operator << (ostream &out,NumString &obj)
{
 out<<obj.getNum()<<" "<<obj.getstr()<<"\n";
 return out;
}
 int main()  
 {  
      fstream obj("myfile.txt",ios::out);
      NumString nobj(100);
   nobj.setstr("Some string");
   obj<<nobj;
      return 0;
 }

And now we wrote our object to the file. You want to read objects from the file? Overload extraction operator!

To learn basic and advanced topics in C++ and solve quiz and write programs, you may want to download my app c++ notes

Exceptional situation

2016-04-27T23:58:00.001-07:00

As part of my C++ journey (not for the first time), I embarked upon "exception handling". After reading the first few paragraphs, I wanted to get my hands dirty by a code which catches an exception and shots howzzat.

Which exception is easily conceivable that divide by zero? So I cinned two numbers, divided them and waited with bated breath. And was sadly disappointed. Instead of catching the error, my program crashed. I tried "exception", "Exception", "std::exception". All IDEs are not android studios to give the correct version and its needed header file. Incidentally I am using Codelite with mingw compiler it suggested - not bad for a windows gcc IDE.

So I had an idea - use catch(...) - which can not fail. It is supposed to catch all exceptions. I thought stupid Windows system is unable to handle exceptions. So rewrote the code in ubuntu. With exactly same results.

So there must be some thing wrong with the code? What can be wrong with 3 line code - try - divide n1 by n2 followed by catch?

Again my memory said I had been here before. So let me just throw an int error

try

{
     if (n2==0)

          throw 5;

return n1/n2;

catch (int e)

 cout<<"Exception";

And voila, the program worked. So the problem is not with exception handling. It is with floating point exception or divide by zero error.

Little googling told me that Stroustrup wanted divide by zero to be handled by low level code like Assembly language, not be exception handling.

Why don't any books mention that? Don't they know that we code - enthusiasts first try with division by zero error.

So now I am telling you. Don't expect, an exception to be thrown or caught when you divide by zero.

Another thing. Instead of throwing int, if you want to throw an exception object, the method is to say throw exception();

     try{  
           if(n2==0) throw exception();  
           return n1/n2;  
      }catch( exception e)  
      {  
           cout<<"there was an error in divide";  
           cout<<e.what();  
      }

In a few days, I will add another post - this time a serious one, about exception handling.

Template Specialization

2016-04-27T23:23:00.000-07:00

Sometimes template classes are not just right for a particular data type. In order to redefine such specialized template classes you need to use template with empty angular brackets followed by class name and type name in angle brackets.

Like this

 template <class T>  
 class Number  
 {  
      T n;  
 public:  
   Number(T n1):n(n1){}  
      T getNumber();  
      void setNumber(T n);  
 };  
 template <class T>  
 T Number<T>::getNumber()  
 {  
      return n;  
 }  
 template<class T>  
 void Number<T>::setNumber(T n1)  
 {  
      n = n1;  
 }  
 template<>  
 class Number<char>  
 {  
      int n;  
      public:  
      Number(char n1);  
      void setNumber(char n1);  
      char getNumber();  
 };  
 Number<char>::Number(char n1)  
      {  
           n = (int)n1;  
      }  
   void Number<char>::setNumber(char n1)        
      {  
           n = (int)n1;  
      }  
   char Number<char>::getNumber()        
      {  
           return (char)n;  
      }

For the Number template class, specialization is done for char type using

 template<>  
 class Number<char>  
 {

-----------

};

Do you notice something here? When defining member functions of specialized template class- Number<char> outside the body of class, template keyword is not used. Instead, just class name with data type in angle brackets is used.

 Number<char>::Number(char n1)  
      {  
           n = (int)n1;  
      }

When instantiated with int, float etc, generic Number class is used. When instantiated with char, specialized class is used.

         Number<int> nobj(10);//uses generic Number
  cout<<"int number is "<<nobj.getNumber()<<"\n";   
  Number<char> nobjchar('A');//uses Number<char> class
  cout<<"char number is "<<nobjchar.getNumber()<<"\n";

Template specialization for function templates

We can write a function with same name as template function. Then this explicit function overrides template function for that data-type.

In this example, print function is defined explicitly for string type.

template <class T>
void print(T val){
 cout<<"Value is "<<val<<endl;
}
void print(std::string s)
{
 cout<<"String is"<<s;
}
int main(int argc, char **argv)
{
   print(10.2);//uses template function
   string s = "Hello C++ developer";
   print(s);//uses non-template print function
}

It is also possible to overload a template function with another template function.

template <class T>
void print(T val){
 cout<<"Value is "<<val<<endl;
}

template <class T,class U>

void print(T val1,U val2)

    cout<<"First value is "<<val1<<"Second value is "<<val2;

int main()

     int a,b;

     a=b=12;

     float c = 88.8;

     print(a);//first template function

     print(a,c);//second template function

A sample C++ question for you to ponder

2016-03-28T06:39:00.000-07:00

I am collecting C++ questions. And I really don't want to ask the much used what is inheritance? what is polymorphism?

And I don't want to ctrl C and ctrl V either. So I am making up my own questions. I can see a smirk on your faces.

OK, OK. Let us see if you can predict the output of the program. Do predict without compiling and running the program please.

#include<iostream>
using namespace std;
class A
{
int n;
public:
   A(int);
   ~A();
   void print();
}
A::A(int m):n(m)
   {
   cout<<"Constructor";
   }
A::~A()
{
   cout<<"Destructor";
}
void A::print()
{
    cout<<m;
}

int main()
{
      A obj1(10);
      obj1.print();
      A obj2[3];
      obj2[0].print();
}

Again, I see the smirk on your face. If you say the output is
ConstructorConstructorConstructorConstructorDestructorDestructorDestructorDestructor

If you say that, now you can compile and run the program.

:)