Programs in C & C++ with Example

Promoting our new page

2015-04-16T04:54:00.002-07:00

updated by api call

Ways to pass variables to functions in C

2014-10-31T10:13:00.000-07:00

There seems to be a confusion among people (even authors of Many books) about ways of passing values to a function.
Question: How many ways are there to pass a variable to a function in C ?
Ans: proposed by most people (authors) :

Passing variables by values
Passing variables by references

My Reaction : Wrong !!!!!!!
To make thing even worse, the example most writer put up for passing values by references is this :

#include<stdio.>

void swap(int *x, int *y)
{
     int* t;
     *t=*x;
     *x=*y;
     *y=*t;
}

int main()
{
    int x,y;
    x=100;
    y=200;
    swap(&x,&y);
    printf("%d,%d",x,y);
}

I don't know if you get this example or not, But this example is wrong.

This example is using pointers, and pointers are not references.
So again:
Question: How many ways are actually there to pass variables to functions in C ?
Well there is only one way: Passing variables by value.

Question: But What about books claiming that variables can be passed to functions by references?
Ans: Well I don't know what other authors are writing or why they are writing such information and feeding it to students. I think many writer confuse pointers and references to be same, they are not.
There is a good article on Wikipedia about this : c++ references
To simplify pointers and references : Always remember
Pointers can be created without initializing them (meaning they can have garbage) while references can't. References are to be initialized as soon as you create them. But funny thing is C doesn't have references !!. This can be easily proven by using gcc compiler, declare a reference variable and watch gcc complaint during compilation(easy).
Question: So what about the example above?
Well technically the example is not using references (cause C don't have them). But passing values by reference is a good feature to have (unfortunately C doesn't have this feature). So how will you simulate this behavior in C? Well by using pointers.
By explicitly passing the address of variable, our function can do anything with that variable. But it should be noted that these addresses are again passed by value ( since addresses are nothing but integers and C can only pass variables by value only). This is the reason why we can't modify the address we have passed in C to a function (cause it was passed by value).
Comment if you didn't or did get what I was trying to convey.

Linked list using C

2012-08-21T07:48:00.000-07:00

This is a Program for Linked List using C. The Code contains enough comments to make your life easy.

#include <stdio.h>


// structure to hold our data
// we call it node
// has a int 'value'
// also has a pointer that points to next node
struct node
{
    int value;
    struct node * next;
};
//typdef will save our time
//from now onwards 'struct node' will be replaced by NODE
typedef struct node NODE;


// you can notice that we are passing NODE** to insert
// Why????
// The answer is simple
// since we will be passing the head pointer to the function
// and head pointer can be modified in insertion operation
// so we must pass a NODE**
// reason being if we pass a NODE* to function
// its value will be restored after function has returned
// hence even if have modified head pointer, it will be restored
// so we pass NODE**
//------------------
// v is the value to be inserted

void insert(NODE** base, int v)
{
    NODE* BASE=*base;    // get pointer of head
    NODE* k;    // k will be used for allocation
    NODE* p=BASE; // p will be used like a temp pointer
    
    
    // if head pointer is NULL
    // means list is empty
    // so we will make a new node
    // attach head pointer to the new node
    if(*base==NULL)
    {
        printf("\nNo nodes in list, Adding first node with value=%d ",v);
        
        // alloc memory to k
        k=(NODE*)malloc(sizeof(NODE));
        
        // set values in node k
        k->value=v;
        // make its next pointer null
        k->next=NULL;
        //attach k to head node
        // notice since we have passed NODE**
        // we will use *base to get the value of the head node
        *base=k;
        // this is the only portion where head gets modified
        
    }
    else
    {
        // if head is not null
        // loop through list till we reach last node
        // last node can be checked by checking p->next value
        // if its not null we continue moving
        while(p->next!=NULL)
        {
            p=p->next;    
        }
        // ok now we are at last node
        printf("\n Adding another node with value=%d ",v);
        // create a new node on k
        k=(NODE*)malloc(sizeof(NODE));
        // do the usual stuff
        
        k->value=v;
        k->next=NULL;    
        // attach k to last node i.e. p
        
        p->next=k;
    }
    
    
    
}

//--- this function shows us the list
// we pass the head pointer to it and it shows us the list
void show(NODE* base)
{
    printf("\n List is= ");
    
    // if head node is NULL
    // means list is empty
    if(base==NULL)
    {
        printf("\nEmpty List");
    }
    else
    {
        // else loop through and print values along the way
        while(base!=NULL)
        {
            printf("%d,",base->value);
            base=base->next;
        }
    }
}

// del node can delete any value that is found first
// you can also see , we pass the NODE** to it 
// thats because deletion can even cause the head to be removed/ modified
// so address of the head is passsed to it
void del(NODE** base, int v)
{
    NODE* BASE=*base;// for our head pointer copy
    NODE* PRE=BASE;// another tmp pointer
    NODE* tmp; // one more tmp pointer
    
    // if head is empty 
    // we cant delete anything
    if(*base==NULL)
    {
        printf("\n Cant delete anything, List is empty");
    }
    // just in case the value to be deleted is on head !!
    // we move the head on to next node and free head
    else if((*base)->value==v)
    {
        printf("head node found, deleting");
        // copy head pointer to tmp
        tmp=*base;
        // move head to next node
        // notice the use of *base
        (*base)=(*base)->next;
        // free the previous head node
        free(tmp);
        
            
    }
    else
    {
        // node is somewhere along the way
        // lets find it
        // loop till you find the value
        // or we reach the last node
        while((BASE!=NULL) && (BASE->value!=v))
        {
            // copy BASE ptr value to pre
            // this is done so that we have a pointer to the last node
            // why we need previous node???
            // so that previous node can be linked to next node of the 'victim' node
            PRE=BASE;
            BASE=BASE->next;
        }
        // did we find the node??
        // if BASe is null , that means 
        // we failed to find the node
        if(BASE==NULL)
        {
            printf("\nNode Not Found !!");
        }
        else
        {
            // if base was not NULL that means we found the node
            printf("Deleting node......");
            // attach PRE's next pointer to BASE's next pointer
            // this will eliminate the link    
            PRE->next=BASE->next;
            // free the unlinked node
            free(BASE);
        }
        
    }
    
}

// our main
int main()
{
    // declare a head pointer
    NODE* base=NULL;// its NULL initially
    
    // insert some values
    // notice we pass the address of the head node
    insert(&base,5);
    insert(&base,6);
    insert(&base,7);
    insert(&base,8);
    // lets see what we have :)
    show(base);
    // now lets delete a value
    del(&base,9);
    // now lets see the list again
    show(base);
}

constructor overloading in c++

2012-02-15T19:18:00.000-08:00

Constructor play an important part in c++. They can initialize the values of a given object to some known values. This is important as constructor will be able to set some values in objects which otherwise may have some garbage values. Most uninitialized value in objects are main cause of the bugs.
But the concept of constructor can allow us to do just anything beside initializing values. Constructor are always called when an object is created. This property of constructor is very useful in situation when you need to perform some task as soon as an object is created.
So constructor is a special function that gets called automatically when an object is created. This function can like any other function do anything (like initializing values).
Overloading Constructor :
This process is very similar to the overloading of simple functions. Since constructor are also function , they can be overloaded like any other functions. This allows user to create many constructor, which can help user to create (and set) objects differently. In most cases objects have data member set to private (so user can't directly change the values of the objects). Different constructor can allow creation of objects with desired type of values.
Method :
Overloading a constructor is very similar to function overloading. Just change the signature (no. of args and type of args) of the constructor.
Overloaded Constructor Usage::
<class name> <objectname>(args);
like Box b; or Box b2(9);

Code:

#include<iostream>

using namespace std;

class box
{
    //data member  are private
    int width,height,length;
    
    public:
    
    box()
    {
        //default constructor 
        //initializes values to 0;
        width=height=length=0;
    }
    box(int k)
    {
        //overloaded constructor with one argument
        //will initialize all 3 data member to value 'k'
        width=height=length=k;
    }
    box(int x,int y,int z)
    {
        //overloaded constructor with 3 argument
        //will initialize data member differently
        width=x;
        height=y;
        length=z;
    }
    void show()
    {
        //function to show these values
        cout<<"\n Width="<<width;
        cout<<"\n Height="<<height;
        cout<<"\n Length="<<length;
    }
    
};

int main()
{
    box b;//using default constructor
    box b2(9);//using 1st overloaded constructor
    box b3(1,2,3);//using 2nd overloaded constructor
    
    b.show();
    b2.show();
    b3.show();
}

Bubble Sort in C++ with improvements

2012-01-11T01:39:00.000-08:00

Here is an example of Bubble sort in C++. The example will perform bubble sort on a set of 10 integers. The example is a OO example . So everything is in a class called bubble. The class it self has following methods in it.

set() This will allow to set the values in the array.
show() This will display the given array.
sort1() normal bubble sorting.
sort2() improved bubble sorting.

Bubble sort : The sort is a very easy to implement sort method that compares the element to its next element. If the element is bigger then the first element then it is swapped with next element. The name bubble sort comes from the fact, the method is similar to bubble rising in water. As lighter bubble come up and heavy bubble fall down. So if you have numbers like
41,13,53,6
first 41 will be checked against 13. Since its bigger then 13 so it will be replaced with 13.
13,41,53,6
Now 2nd element which happens to be 41 will be compared to 53. since its smaller then 53 so we do nothing.
13,41,53,6
Next compare the next element 53 with 6. Since it is bigger then 6, it will be replaced by 6..
13,41,6,53
This is over result after First pass. Notice how the biggest element is at last position already. So we won't bother about it . Next we will repeat the process for the other elements.
After second pass
13,6,41,53
after 3rd pass
6,13,41,53
Hence the array gets sorted.
Improvement : So how can bubble sorting be improved. Well the improvement can only happen if in between the passes the array gets sorted out. So when this happens we don't need to proceed checking the whole passes. How to detect if the array was sorted ?? well if there are no exchange of variables in any pass that means the array elements are already sorted out. We can use a variable "swap" , we will set it to 0 just before any pass. and we will set it to 1 if any exchange happens. after the pass we will check its value, if its 0 that means no exchange happened so the array is already sorted by bubble sort. and we can break from there.
code:

#include<iostream>

using namespace std;

class bubble
{
    // 10 element of type int
    int a[10];
    
    public:
    bubble()
    {
        //default constructor sets all elements to 0
        for(int x=0;x<10;x++)
        {
            a[x]=0;
        }
    }
    void set()
    {
        cout<<"\n Enter Elements of Array=";
        for(int x=0;x<10;x++)
        {
            cout<<"\nEnter"<<x+1<<" Item=";
            cin>>a[x];
        }
    }
    void show()
    {
        cout<<"\n Printing Array=";
        for(int x=0;x<10;x++)
        {
            cout<<"\n"<<a[x];
        }
    }
    void sort1()
    {
        int moves=0;
        
        for(int x=0;x<10;x++)
        {
            for(int y=0;y<10-x-1;y++)
            {
                //compare the 2 near values
                // move the bigger one down by swapping
                if(a[y]>a[y+1])
                {
                    //swapping by a third variable
                    int t=a[y];
                    a[y]=a[y+1];
                    a[y+1]=t;    
                    
                }
                //count moves
                    moves++;
                
            }
        }
        cout<<"\n array sorted with "<<moves<<" moves";
    }
    void sort2()
    {
        int moves=0;
        int swap=0;
        for(int x=0;x<10;x++)
        {
            //set variable swap to 0
            swap=0;
            for(int y=0;y<10-x-1;y++)
            {
                //compare the 2 near values
                // move the bigger one down by swapping
                if(a[y]>a[y+1])
                {
                    //swapping by a third variable
                    int t=a[y];
                    a[y]=a[y+1];
                    a[y+1]=t;    
                    //if swapping is done set swap to 1
                    swap=1;
                    
                }
                //count moves
                    moves++;
                    
                
            }
            if(swap==0)
            {
                // break the loop if no swapping were done 
                // this will only happen if the array was sorted already
                break;
            }
        }
        cout<<"\n array sorted with "<<moves<<" moves";
    }
};

int main()
{
    bubble b;
    b.set();
    b.show();
    b.sort2();
    b.show();
}

Find Armstrong Number in C

2012-01-08T01:09:00.000-08:00

Finding Armstrong number is again a great exercise for students The exercise involves clever use of modulus operator to extract the digits and then using those digits to perform calculations.

Armstrong Number : These are the special numbers which is equal to the sum of the cube of their own digits.
like 153. since 153= 1³+5³+3³=1+125+27=153 cool isn't it. So how can you find them? Here is the logic.
Logic: use modulus operator to get the last digit of the number. so 153%10=3 (last digit). cube this number, 3*3*3=27, then save it to a variable. again now reduce the number 153. 153/10=15 (see the last digit will be removed :) ). repeat the process till this number becomes 0.
Code:

#include<stdio.h>

int armstrong(int x)
{
    //copy x to k
    int k=x;
    
    //start extracting its digit, 
    // cube the digit and start saving it
    // we will use sum to save the total.
    int sum=0;
    int r=0;
    //r will be used for remainder
    while(k>0)
    {
        r=k%10;
        //now cude the remainder and add it to sum
        sum+=r*r*r;
        //reduce k by 10
        k=k/10;    
    }
    if(x==sum)
    {
        return(1);
    }
    else
    {
        return(0);
    }
}

int main()
{
    int k=0;
    //n will be used how far we want to calculate
    int n;
    printf("\n Enter a number=");
    scanf("%d",&n);
    for(k=0;k<=n;k++)
    {
        if(armstrong(k))
        {
            printf("\n Armstring number=%d",k);
        }
    }
    
}

Overloading Unary Operator in C++

2012-01-03T19:50:00.000-08:00

In this Example I will demonstrate overloading a unary operator. The overloading is done in similar way as we did for binary operator. In this example I will be using a Vector Class. The operator we are going to over load is the unary "~" (tilde) operator. although you can use any unary overloadable operator.
Method: In this example the overloaded operator will be the part of the class i.e. the over loaded definition will be a member function. (As we know overloading can be done using non member functions too). So the unary operator will not have any arguments in it.
We will overload ~ operator so that it will reflect the vector so that its z component becomes x component and vice versa. So input vector will be 2i+3j+5k and its output vector will be 5i+3j+2k. although you can do anything you like.

Code:

#include<iostream>

using namespace std;


class vector
{
    int x,y,z;
    public:
    vector()
    {
        x=y=z=0;
        //default constructor
    }
    vector(int a, int b,int c)
    {
        x=a;y=b;z=c;
    }
    void show()// to show vector
    {
        cout<<"\n Vector="<<x<<"i+"<<y<<"j+"<<z<<"k";
    }
    //the operator overloading returns a vector
    //although return type can be anything
    vector operator~()
    {
        //notice how the ans object is being created
        // we are passing it the value by our constructor
        vector ans(z,y,x);
        return(ans);
    }
};

int main()
{
    //create 2 vector
    // one has value i+2j+3k other is 0
    vector v(1,2,3),c;
    //use ~ operator to reflect the vector and pas it to c
    c=~v;
    v.show();
    c.show();
    
}

Counting Words in a String using C

2011-12-08T21:01:00.001-08:00

Counting words in a String using C:
This is very good exercise to test new programmers pointer skills. The task is to count the words in a given string using C. Well there might be many ways you can do it, I will demonstrate mine way.
Note that mine solution might not be the optimal one, but it gets the job done.

Logic:
How to calculate words in a given string using C. Well I generally use two pointers, one pointer pointers to first char of the string, second point to next char. Then we compare the content on the two pointers. There will be 3 cases:

Both pointers are blank chars (space), so that means we are in between words
First pointer is blank, other is not. This is denote beginning of the Word.
Rest cases will be when either in the middle of the words or at the ending of the words.

Check this image for clarity.

The two Orange dots represent the two pointers in the middle of words.
The two Green dots represent when first char is blank and other is not. this marks the beginning of the word and here we count the word.
The two red dots represent the case when pointers are in the middle of the words, we don't do anything.
Why are we using 2 pointers?
This will allow our function to count the words that are separated by more then one space (which is very handy, when user puts too many spaces in the string)

Code:

#include<stdio.h>
#include<conio.h>
#include<string.h>// for strlen function

int countWord(const char* str)
{
    int c=0,l,i;
    char* p1;//first pointer
    char* p2;//second pointer
    p1=str;//assing first pointer to first char of string
    p2=p1+1;//assign 2nd pointer to next of first
    l=strlen(str);
    printf("\n String has  %d length",l);
    
    
    if(p1==NULL)
    {
        return(0);
    }
    else
    {
        //check if first char is space or not, if not then its the first word
        if(*p1!=' ')
        {
            c=1;
        }
    }
    
    for(i=0;i<l;i++)
    {
        
        if((*p1==' ')&&(*p2==' '))
        {
            //both p1 and p2 are blank , so do nothing
        }
        else if((*p1==' ') && (*p2!=' '))
        {
            //first pointer is blank but second is not, means a word is there
            c++;    
        }
        else
        {
            // rest dont need to worry
            
        }
        //increment both pointers
        p1++;
        p2++;
    }
    
    
    return(c);
}

int main()
{
    char *name;
    printf("\n Enter a string= ");
    gets(name);
    printf("%s",name);
    printf("number of words=%d",countWord(name));
}

Operator Overloading using Friend Functions with Complex Numbers

2011-12-08T00:38:00.001-08:00

Operator overloading using friend functions:

Operators can be overloaded in c++ with friend functions also. The procedure is same as we discussed earlier. Here I will demonstrate operator overloading with "+" operator which is a binary operator. I will be using a complex number class (called complex). The class will have 2 data types, real and imaginary.
Operator overloading will not be a part of class complex, but we will declare that this function is a friend of class complex.

Note that since overloaded function is not part of class , so will require 2 args (overloading with member function require 1 arg for binary operator, as the first arg is the object itself.)
Use:
Most student wonder why we need to use operator overloading in such manner? The answer is simple, this will allow you to manipulate operator for predefined objects that you mat not have access. (Like cout or cin)

Code:

#include<iostream>


using namespace std;
// complex class with real and imaginary part
class complex
{
    public:
    int real;
    int img;
    //default constructor
    complex()
    {
        real=img=0;    
    }
    //overloaded constructor with 2 args
    complex(int x,int y)
    {
        real=x;
        img=y;    
    }
    //show function to display complex number
    void show()
    {
        cout<<"\n"<<real<<"+"<<img<<"i";
    }
    //declaring that "opeartor+" is friend of class complex
    friend complex operator+(complex c,complex d);
};

//operator+ is not part of complex class so have 2 args for + operator overload.
complex operator+(complex c, complex f)
{
    complex ans;
    ans.real=c.real+f.real;
    ans.img=c.img+f.img;
    return(ans);
}
int main()
{
    complex x(1,2), y(0,7);
    complex c=x+y;//overloaded + is called here
    //note that compiler will convert this to
    // c=operator+(x,y)
    c.show();
}

Find nth Prime Number in C++

2011-11-29T01:58:00.001-08:00

c++ program to find prime numbers:

The problem of finding prime number can be solved by checking all numbers, testing them for prime and then moving ahead. If you want to calculate nth prime. Then this can be done in a brutal way by checking the number one by one. This may sound odd, by there is no easy way then this for prime numbers (Well Actually there are like Pollard's Rho Algorithm, Number Sieves or Shor's Quantum Algorithm, but we are talking about the one that most people may understand easily). There may be way to pre-calculate the prime numbers but that again is not sufficient. So how can we use c++ to create a program to find prime numbers.

Method:
The method is pretty similar to what i have discussed in my other post.
http://programs-in-c-plus-plus.blogspot.com/2011/09/program-to-find-nth-prime-number-in-c.html
To convert it into a c++ program , we will just encapsulate the main functions into one single class. That class will serve us for calculations. The class has a member variable "n" , which can be used to calculate "nth" prime. There will be 2 methods to set this "n" variable. One is an overloaded constructor, other is a member function. Choice is yours.

Code:

#include <iostream>
using namespace std;


class prime
{
    int n;// this will be used to find the nth prime
    public:
    prime()
    {
        n=1;//default value 1
    }
    prime(int t)
    {
        n=t;//set n by using constructor
    }
    void setGoal(int k)
    {
        n=k;//set n by function
    }
    void find()// find the prime
    {
        int count=0;
        long a = 2;
            
        while(count<n)
        {
            
            long b = 2;
            int prime = 1;
            while(b * b <= a)
            {
                if(a % b == 0)
                {
                    prime = 0;
                    break;
                }
                b++;
            }
            if(prime)
            {
                count++;
            }
            a++;
        }
        cout<<"\n The "<<n<<" th prime="<<--a;
    }
};
int main()
{
    prime p;
    p.setGoal(10);
    p.find();

}

Program for Multi Level Inheritance and Function Overriding

2011-11-28T20:44:00.001-08:00

Program for Multi Level Inheritance and Function Overriding:
Function overriding is a very key programming feature in OOP system. This allows programmers to create objects which has similar function ( with same name) but having different implementations. Such technique is really helpful in situations where each object has a common function but implementations ( games for example).

Multi Level Inheritance:
In this type of inheritance one class inherits B inherits a base class A. After that B acts as a base class for next class C. So B inherits A, C inherits B.
in this example we have a base class "animal".
The next class "Tiger" inherits "animal".
Then "SaberTooth" inherits "Tiger".
Both Tiger and SaberTooth get the functionality of Base class Animal.
Function Overriding:

This is the feature that can change the behaviour of inherited function in derived class. Here we will change the inherited function "attack()". Note that overridden function may have completely different functioning then original

Code:

#include<iostream>

using namespace std;

//--Our base class
class animal
{
    public:
    int life;// base class has an attribute that will get passed to derived classes
    animal()
    {
        life=100;        
    }
    void say()
    {
        cout<<"\n This is Animal Class with Health="<<life;
    }
    void showHealth()
    {
        cout<<"\n Health="<<life;
    }
};

//---Tiger class inherits animal class so gets all his public members:
//---life
//--say()
//---showHealth()
class Tiger : public animal
{
    public:
    Tiger()
    {
        
    }
    void attack()
    {
        cout<<"\n This class can Attack !!";
    }
};
//--this class inherits tiger class also gets his public members:
//--attack()
//--this class has its own member data bigFangs
//--this also overrrides the inherited attack function
class SaberTooth : public Tiger
{
    public:
    int bigFangs;
    SaberTooth()
    {
        bigFangs=10;
    }
    // redefining inherited method will overrride it
    void attack()
    {
        cout<<"\n this class can attack with "<<bigFangs<<" inch Jawz\n";
    }
    
};

int main()
{
    animal a;
    a.say();
    a.showHealth();
    
    cout<<"\n---- Tiger Class-----\n";
    Tiger t;
    t.showHealth();// <--gets it from animal class
    t.attack();//<--its own
    cout<<"\n---- SaberTooth Class-----\n";
    SaberTooth s;
    s.showHealth();//<--from base class to tiger then to this
    s.attack();//<--Overrrided method
}

output:

News: All Code now have color highlighting

2011-11-27T23:58:00.001-08:00

I have updated my codes to now have color highlighting, This will make code look a little better :)
Cheers

Program for Matrix Multiplication in C++ using Operator Overloading

2011-11-27T23:13:00.001-08:00

Program for Matrix Multiplication in C++ using Operator Overloading :
We will now try to multiply two matrix by using the concept of operator overloading. The described way is very very easy to understand. We will be overloading "*" operator for this purpose. Although this can be done by any binary operator.

We will start with a basic class Matrix. In this example we will take a 3x3 matrix.
Description:

class Matrix has a constructor that will initialize its element to 0.
also has a set() function that can be used to set values in the Matrix.
A show() function shows the matrix.
operator overloading definition for "*" operator.

Code:

#include<iostream>

using namespace std;

class matrix
{
    
    public:
    int a[3][3];
    
    matrix()//default constructor
    {
        for(int i=0;i<3;i++)
        {
            for(int j=0;j<3;j++)
            {
                a[i][j]=0;
            }
        }
    }
    void set()// to set matrix elements
    {
        for(int i=0;i<3;i++)
        {
            for(int j=0;j<3;j++)
            {
                cout<<"\n Enter "<<i<<","<<j<<" element=";
                cin>>a[i][j];
            }
        }
    }
    void show()// to show matrix elements
    {
        cout<<"\n Matrix is=\n";
        for(int i=0;i<3;i++)
        {
            for(int j=0;j<3;j++)
            {
                
                cout<<a[i][j]<<",";
            }
            cout<<"\n";
        }
    }
    /*
    binary * operator will require one more arg, since it is a binary operator
    one arg is the object itself that will call it, other will be passed as arg(in this case x). also this will return a matrix object
    */
    matrix operator*(matrix x)// overloading * for multiplication
    {
        matrix c;// this will hold our result
        for(int i=0;i<3;i++)
        {
            for(int j=0;j<3;j++)
            {
                c.a[i][j]=0;
                for(int k=0;k<3;k++)
                {
                    c.a[i][j]=c.a[i][j]+a[i][k]*x.a[k][j];        
                }
            }
        }
        return(c);
        
    }
};

int main()
{
    matrix a,b,c;
    a.set();
    b.set();
    c=a*b;
    /*
    note that compiler will break this statement as 
    c=a.operator*(b);
    this is how 2nd arg is passed.
    and this is how object "a" acts as the calling object
    */
    
    a.show();
    b.show();
    c.show();
}

Stack in C using functions

2011-11-21T02:01:00.001-08:00

Stack in C: Stack is a very useful data structure in C, It is used in many situations. Implementing stack can be done using a global array and a global pointer of the stack. although this implementation reveals how good OOP is for such situations. There will be three basic functions of the stack. One will be push() operation, which will push the given element to the stack. Pop() function will pop out the element from the top. A show function to show the content of the stack.

The size of the stack will be controlled by a preprocessor called SIZE. we will always check for boundaries of the stack. Modular approach for such situation is not safe. A better OO way is there, that I will discuss later.
The code to implement Stack in C using functions is as follows :-

Code :

#include<stdio.h>
#include<dos.h>

#define SIZE 5
int cursor=0;//global
int stack[SIZE];
void initstack()
{
        int i=0;
        for(i=0;i<SIZE;i++)
       {
            stack[i]=0;//set all element of the stack to 0
         }
}
void show()
{
       int i=0;
       for(i=0;i<SIZE;i++)
       {
           printf("\n %d",stack[i]);
        }
}
void push(int v)
{
       if(cursor==SIZE)
        {
             printf("\n -----Stack is full------");
         }
         else
         {

           stack[cursor]=v;
           cursor++;
          }

}
int pop()
{
        int t;
         if(cursor==0)
         {
            printf("\n Stack is empty");
         }
        else
        {
               cursor--;
                t=stack[cursor];
              stack[cursor]=0;
          return(t);
        }
}


int main()
{
           char c='a';
           int v,k;
             k=1;

while(k)
{
               printf("\n Enter your choice: 1:Push\n 2:Pop \n3:Show \n4:Exit\nyour choice::");
               scanf("%c",&c);
               switch(c)
               {
                   case '1':
                   printf("\n enter a value:");
                  scanf("%d",&v);
                      push(v);
                      break;
                  case '2':
                  pop();
                  break;
                  case '3':
                  show();
                  break;
                  case '4':
                     k=0;//will break the while loop
                     break;
                 }



   }
}

Pointers in C for starters

2011-11-05T23:05:00.000-07:00

Ask any new computer science student ,"What is the most dreaded topic in C language?". They will reply ,"Still having nightmares about pointers !!!". And I don't blame them. In fact pointers become even more dreaded as the learning curve is really steep for beginner.

So what makes pointers so "evil" ? I personally think its not the pointers but its lack of knowledge about memory that actually kills a new student. Hence I claim "Pointers are innocent ".

Pointers can be easily mastered by any new student, they just need to work with them. It is said that a good programmer will always avoid any type of programming error except that of pointers. Even the mightiest fail with pointers. So don't take it hard on your self , we all make mistakes (specially with pointers and then laugh about it later ).

So whats the deal about these strange looking creatures (pointers that is :P ). To understand it, lets look at the memory in detail.

If you want to visualize memory, its more like a huge set of boxes with a numbers on it. These boxes contain your data and the number on the box helps us getting to these boxes. These "numbers" are called "memory addresses". So everything you create in a C program will be stored in these boxes. every data type require a particular amount of boxes for storage. Like int requires 2 boxes each of 1 Byte in size (assuming int is 2 Byte long)

X	Y	Z
1	2	3
100	102	104

here we see 3 int variables X,Y,Z. with values 1,2,3 and they are stored at memory locations 100,102,104 respectively. As we can see these int require 2 Byte of memory. Easy right?

Q: So where are the pointers?

Ans : In Simple words the pointers will store these Addresses. That's the whole purpose of a pointer,to store the address of other variable (int in this case).

Q: Can Pointers store values?

Ans : Well if the value is an address, YES.

Q : How do I create a pointer?

Ans :Well its very easy, you have to just mention that what data type the pointer will be "pointing".

int* ptr;

Read this statement from right to left. "ptr is a pointer to data type int".

so my ptr pointer will store the address of a int.

But i don't know where my variables are stored. :(

Yeah we know that that's why we use a special operator to get the address of your variable. this operator is "&" operator.

so i can write :-

ptr=&X;

read this statement from right to left. "Address of X gets assigned to pointer ptr". easy right?

Q: So &X gives me the address of X. Will &Y give me address of Y?

Ans : of course it will.

Q : But what is pointer itself?

Ans: Technically speaking pointer itself acts as an special integer that stores addresses.

Q: Pointer is Integer?

Ans : Yes it is.

Q: You mean the pointer itself is stored in memory too?

Ans: Of course like any other variable.

X	Y	Z	PTR
1	2	3	100
100	102	104	200

You can see that the pointer itself is stored at address 200. and we can see that pointer contains the value 100 which is the address of variable X. and we say that ptr points to X.

Q: Fine. What can do with pointers now?

Ans : actually u can access the values "pointed" by the pointers.

Q: I can? how?

Ans: its very easy , we use a special operator "*" called "value at pointer".

So if I say *ptr , I mean "value at ptr".

pointer contains address 100, and the value AT 100 is =1 which is the value of X. (So basically we get the value of the data type we were pointing ).

Summary:-

Pointers points to data types.
Pointers only contain addresses.
"&;" operators is used to get the memory address of a data type.
"*" is used by pointers to read value it is pointing.

I hope it helps new C programmers.

Understanding Constructors in C++

2011-11-05T21:48:00.000-07:00

What are Contructors in C++?
Ans: Constructor are special function that can help initialize an object.
Do we really need contructors in C++?
Well, Its a good feature and really helps programmer.
I am a good programmer and I don't Need contructors.
LOL !!!!!
Ok enough of chit chat, lets get to the point. Why contructors were included in C++. The answer lies in very nature of programmers. Programmer frequently get messy with code and allow mistakes to happen ( LOL :P). How? Lets have a look on following code :

#include<iostream>

using namespace std;

int main()

{

int k;

cout<<k;

}

This is a classical example of programmer forgetting to initialize the variable. Hence causing unexpected errors. This problem gets more complicated as we start creating objects. Since objects may have many data, its a very common mistake to forget to initialize the data portions of objects. This is where construcors come handy. The contructors have a property that they get called automatically when objects gets created.

#include<iostream>

using namespace std;

class Me

{

     int x,y;

    public:

   Me()

{

      x=y=0; 

}

   void show()

{

       cout<<x<<","y;

}

};

int main()

{

  Me x;

x.show();

}

Declaring a Constructors will ensure that whatever initialization are put into the contructors to execute always whenever object gets created. Hence objects data will always will be in initialize state.
How to declare Contructors in C++?
Its really easy, just follow the following rules :

Contructors are public.
Constructors don't have any return type.
Constructors name is always as that of the Class.
Constructors with no arguments are called default constructors.
Constructors can be overloaded.

So next time you put some initialization code in a contructors, your object won't have garbage values in them.
Happy coding.

Calculate Factorial in python

2011-10-16T06:05:00.000-07:00

Objective : Using python calculate factorial of a number.

Logic : the logic is exactly the same as we do it in C language. so we use loops.

Code:

def factorial(number):

    ans=1;

    for i in range(2,number+1):

        ans=ans*i;

    print(ans)

    return

What are the benefits of this code in python over the same in C? well on the first you won't see much advantages, but that's where you overlook Python !!! Python utilizes a heavy bit integers (128 bit integers), so 200! can be easily calculated without using decimal representation. Isn't that cool !!!

Program to check if a number is palindrome or not in C

2011-10-14T11:13:00.000-07:00

Objective : To check if given number is palindrome or not in C.

Programming logic : This is a very easy program if you know how to reverse a number. Once you have found the reverse of number just compare it with original, if both are same then the number is palindrome.

Code:

#include<stdio.h>
int main()
{
    int k;
    printf("\n enter number =");
    scanf("%d",&k);
    if(palindrome(k))
    {
        printf("\n The number is palindrome");
    }
    else
    {
        printf("\n The number is not palindrome");
    }
    return(0);
}
int palindrome(int x)
{
    int rev=0;//to calculate reverse of number
    int k=x;
    while(k>0)
    {
        rev=rev*10+k%10;
        k=k/10;
    }
    if(x==rev)// check if reverse is equal to given number
    {
        return(1);//if yes then return 1
    }
    else
    {
        return(0);//else return 0
    }
}

Fibonacci series in C non recursive

2011-10-14T10:56:00.000-07:00

Objective : To print given numbers of Fibonacci series. (1,1,2,3,5.....) non recursively.
Programming Logic: Its easy to print the above Fibonacci series in C. the number is always sum of previous 2 terms. This series starts with numbers 1,1. so next term is 1+1=2. Then next term is 1+2=3 and so on.
(It may be noted that series 1,3,4,7,11,18.... is also a Fibonacci series, but it starts with 1,3 )

Code :

#include<stdio.h>
int main()
{
    int k;
    printf("\n enter number of terms to print=");
    scanf("%d",&k);
    fic(k);
    return(0);
}
void fic(int x)// x are number of terms to print
{
    int a,b,sum,i;
    a=b=1;
    printf("1,1,",sum);//first 2  terms
    for(i=0;i<x-2;i++)
    {
        sum=a+b;
        printf("%d,",sum);
        a=b;
        b=sum;    
    }
}

It may be noted that using a non recursive way to calculate Fibonacci series in C provides faster calculations as compared with recursive method. As recursive program have a large overhead of function calls. Also the recursive way is very unoptimised since it doesn't uses the last 2 values that have been calculated already..

Reversing a Number in C

2011-10-13T23:45:00.000-07:00

Objective : You are given a number and you have to find the reverse of the given number in C. reverse of 1234 will be 4321.

Programming logic: The logic lies in constructing the reverse numbers from the digits of the given number. So we extract each digit with % modulus operator and then build the number up.To build the number we simply multiply the reverse number by 10 and then add the next remainder to it.
Like 1234:
1234%10=4 (remainder). rev=4.
123%10= 3. rev=4x10+3=43.
12%10=2 rev=43x10+2=432.
1%10=1 rev=432x10+1=4321.

Code:

#include<stdio.h>
int main()
{
    int k;
   printf("\n enter a number=");
   scanf("%d",&k);
   printf("\n Reverse of the number is=%d",reverse(k));
   return 0;
}
int reverse(int x)
{
    int ans=0,r;
    while( x > 0 )
    {
        r=x%10;//extract last digit
        ans=ans*10+r;// multiply by 10 and then add the remainder
          x=x/10;//reduce number
    }
   return(ans);

}

Integer to Binary in c

2011-10-13T23:10:00.000-07:00

Objective : To convert the given integer to binary in C language.

Programming technique : The conversion of integer to binary can be done in many ways. I will demonstrate a very simple (possibly very unoptimised ) way which it is easy to understand.
This way involves using an array to store the remainder of the number when we divide it by 2. The remainder will be saved in array. We will start filling the array from the last and at last we will print the array.
This technique will convert integer number to binary using array, it may not be a true solution but you will get the picture.
we will use % modules operator to extract remainder. Then will reduce the number till it reaches 0. The array will be initialized to 0.

Code :

#include<stdio.h>
int main()
{
    int p;
    printf("\n Enter a number=");
    scanf("%d",&p);
    bin(p);
}

void bin(int x)
{
    long b=0;
    int binary[20],i;
    for(i=0;i<20;i++)
    {
        binary[i]=0;//setting array to 0
    }
    i=19;// starting from last of array
    while(x>0)
    {

        binary[i]=x%2;//save remainder to array
        x=x/2; //reduce number
        i--;//moving index 
    }
    printf("\n Printing Binary=");
    for(i=0;i<20;i++)
    {
        printf("%d",binary[i]);
    }
}

one possible drawback of this technique is that you cant use the binary number directly in calculations.
Note : The above method will store only 20 digits of binary.

Find Sum of Digits of a Number in C

2011-10-12T23:31:00.000-07:00

Objective: Your are given a number and you have to find the sum of its digits. Like 1234 so its digits sum 1+2+3+4=10.

Programming technique : This problem can be solved using the fact that modulus operator (%) gives the last digit when divided by 10. So we successively Divide it , till all numbers are exhausted.
so The program runs like this >>
1234%10 gives last digit. that is 4. (we save it ) then divide the number by 10 to reduce it.
1234/10=123. and repeat the process till the number becomes 0.
First run : 1234%10 gives 4, 1234/10=123.
Second run: 123%10 gives 3 , 123/10=12.
Third Run :12%10 gives 2 , 12/10=1
Fourth run: 1%10 gives 1, 1/10=0 (we stop here).
pretty easy stuff.

Code :-
#include<stdio.h>

int main()
{
    int k;
    printf("\n enter any number=");
    scanf("%d",&k);
    printf("\n sum of digit=%d",sumdigit(k));
          return(0);
}

int sumdigit(int x)
{
    int sum=0;// will save sum
    int r=0; // for remainder
    while(x>0)
    {
        r=x%10;//get remainder
        sum+=r;//sum it
        x=x/10;    //reduce number
    }
    return(sum);
}

Program to find nth Prime number in C

2011-09-22T19:36:00.000-07:00

Objective: To print any Prime number in C.

This task may sound easy but is a very good exercise to help optimize CPU intensive programs. Finding Prime number is a very CPU hogging task and it becomes even more dreaded as the number starts to grow. Lets say we want to find 30001th prime. how will we find it?? Here is the program.

Programming logic: The easiest method is to check if the given number N is divisible by any number from 2 to N-1.
But it may be noted that we don't need to go beyond the number that is square root of N. why??
lets have a look.
Say we are testing number 49 for prime number. Our objective is to find any number that may divide it. so we start from 2,3,4 etc. As soon as we cross 7 there will be no number that will divide 49, if there was we have got it earlier since it will be smaller then 7. Get it?
another example 64 :
2x32
4x16
8x8
16x4
32x2
as you can see when we pass number 8 we don't need to test as the number that will come , we have tested them already. (clever right ?)

Code:

#include <stdio.h>
int main()
{
int count=0;
long a = 2;
while(count<30001)
{
    long b = 2;
    int prime = 1;// to check if found a prime
    while(b * b <= a)
    {
        if(a % b == 0)
        {
            prime = 0;
            break;
        }
        b++;
    }
    if(prime)
    count++;
    a++;
}
printf("%d st prime no. : %ld\n",count,--a);
return 0;
}

It may be noted that this program can be further optimized in several ways. One possible way is to consider only odd terms ( since even terms cant be prime, except 2)

calculating leap year in c using if else

2011-07-13T08:01:00.000-07:00

Most new students get really confused when it comes to calculating Leap year in C. It is given as an exercise to enhance their knowledge about using if else usages. This can be calculated using Logical operators too. But using if else provides clearer ways to calculate it. Both of the methods can be implemented in C/C++ program. Here we will discuss the if else method in C/C++

Leap year : A year is Leap year if

It is not a century and gets divided by 4.
It is a century and gets divided by 400.

it is clear that a year will either be century (like 1600,1700,1800,1900) or it will not be a century (like 1988,1999 etc). You get the picture right.
So the first step is to check if the given year is a century or not? it can be easily checked using modulus operator % . (Modulus operator calculates remainder) . So if the modulus gives us 0, that means the given number is divided exactly.
So 1700,1800,1900 are not Leap Years (as they all are centuries but not divided by 400).
Years like 1600,2000,2400 are Leap Years (they all are divided exactly vy 400).
On the other hand Years like 1946,1950,1950 are not Leap year (they are not centuries and are not divided exactly by 4).
While years like 1944,1948,1952 are Leap years (as they are not centuries and are divided by 4 exactly ).
How can we calculate leap year in c/ c++? well its easy:

Program:

#include<stdio.h>
int leapyear(int);// protyping function

int main()
{
    int x;
    printf("Enter a number=");
    scanf("%d",&x);
    if(leapyear(x))
    {
        printf("The %d year is Leap year",x);
    }
    else
    {
        printf("The %d year is not Leap year",x);
    }
}
int leapyear(int year)
{
    int iscentury=0;// to test if year is century or not
    if(year%100==0)
    {
        iscentury=1;//yes its a century
    }
    if(iscentury)
    {
        if(year%400==0)//century must be divided by 400
        {
            //yes?
            return(1);// you have leap year... return 1
        }
        else
        {
            return(0);// no leap year return 0
        }
    }
    else
    {
        if(year%4==0)// normal year must be divided by 4
        {
            return(1);// you have leap year return 1;    
        }
        else
        {
            return(0);// you don't have leap year return 0
        }       
    }  
}

The above C program returns 1 if it finds a Leap year otherwise returns 0 if it doesn't. easy right?

Tools for C/C++ development

2011-05-08T10:23:00.000-07:00

C/C++ development can be done in variety of ways. If you are comfortable using the compiler and command prompt, you can just download the compiler and start working. But most of developer will prefer some sort of Integrated development environment (IDE) for C/C++ development.

Most new developer get confused when it comes to choosing a IDE. Actually there are many options available in Internet for development purposes. Some of them may cost a little while others may be free.
But sticking to one IDE will probably what makes an IDE great. A new developer who is starting his way with c/c++ programming can start with old IDE like turboC. I personally have worked with many IDE myself. Some of them are "codelite", "code blocks" , DevCPP, Visual studio etc.
I think codelite and devcpp are really good way to start. If you are comfortable with Eclipse IDE then there is a plugin for c/c++ development. Visual studio express edition is also a great tool available.
Cfree is has a free version that can be used.
My personnel choice for bigger projects has been DevCPP and Visual Studio, due to their great project support.
For starters just get an IDE and work with it for like one month. This will get you going with that IDE and once you get familiar with it , you will start to like it. As far as IDE for c/c++ goes no one is perfect, everyone has their own pros and cons.
"PEACE TO ALL"