Underworld Coders

Static Variable in Class

2013-07-11T16:15:00.002-07:00

This is a very simple example differentiating static member variables and regular member variables of the class.

I will be updating this post later with more examples on static variables and functions

#include <iostream>
using namespace std;
class staticExample{
      int mydata;
      static int count; // Declaration
public:

      staticExample( ){
      mydata = 50; // static variable cannot be initialized
      count +=1;     // inside the class becoz d variable is SAME
      mydata++;      // for each class object. However, mydata
}                    // is unique for each class object.
                     // As we know, obj1->mydata is different   from obj2->mydata

// but, obj1->count is equal to obj2->count ... all the time

                  void getData(){
               cout<<"mydata : "<<mydata<<" count : "<<count<<endl;
          }

};

int staticExample :: count = 50; // Initialization, out side the class

int main(){
staticExample john;
john.getData();

staticExample alex;
alex.getData();
}

Defining Macros

2013-07-10T15:23:00.000-07:00

Example 1
#include <stdio.h>

#define SUM a+b    // Macros used just to replace values .
                                        // Whenever compiler see 'SUM' keyword in the program
                                       // it will replaced with a+b .

                                       //  It works on the principal of function, so you don't have to
                                       //  write same long particular statement every where in the program


int main (){

   int a = 5,
       b = 3,
       c;

   c = SUM - 1;     // this statement is same as c = a + b - 1;
   printf("%d", c);

   return 0;

}

　

Example 2
#include <stdio.h>

#define SUM(a,b) (a+b)  // Macros look for each and every word or symbol
                        // So, here SUMa,b would not work.

#define MAX(a,b) (((a)>(b))?(a):(b)) // Also, it is not different than..
                        // MAX(a,b) (a>b ) ? (a:b)
                   // However, they are placed in brackets to
                   // avoid mathematical errors in complex equations

int main (){

int x = 5,
      y = 3,
      z, h;

  z = SUM(x,y) - 1;    // same as functions.. x => a and y => b
                       // SUM(x --> a, y--> b) = SUM (a,b)..
                       // replace with a + b ==> x + y
printf("%d",z);

h = MAX(x+y,z*x);    //i.e. MAX (x + y --> a, z * x --> b)
                              MAX (8, 35) ==> (8>35) ? (8:35)
printf("%d",h);     // of course statement is false so .. 35 is returned

return 0;

}

Dynamic Array Example

2013-07-09T16:01:00.002-07:00

#include <iostream.h>

class IntArray{
int *p, junk;
int size;

public:

IntArray(int size){
    p = new int[size];
    this->size = size;
}

int length(void)const{
    return size;
}

void resize(int newsize){
    int *temp = new int[newsize];
    for(int i=0; i<newsize && i < size;i++){
      temp[i]=p[i];
    }

    delete[] p;
    p = temp;
    size = newsize;
}

int &operator[](int ix){
    if(ix>=size || ix < 0){
      return junk;
    }
    else{
      //return p[ix];
    return *(p+ix);
    }
  }

~IntArray(void){
     delete[] p;
   }

};

int main(void){
   IntArray a(5);
   int i;
   for(i=0;i<5;i++){
     a[i] = i*2;
   }

   for(i=0;i<10;i++){
     cout<<a[i]<<endl;
   }

   a.resize(10);
   for(i=5;i<10;i++){
     a[i] = i * 100;
   }

   for(i=0;i<10;i++){
     cout<<a[i]<<endl;
   }

return 0;
}

Some addressing fundamentals for C beginners

2013-07-02T16:41:00.003-07:00

The following program explains how properly addressed variable don't loose their correct values

#include<iostream>
using namespace std;

void func_widout_address(int a, int b){
a = 10;
b = 30;
}

void func_wid_address(int &x, int &y){
x = 100;
y = 200;
}
int main(){
int a = 20;
int b = 40;

func_widout_address(a,b);
cout<<"a: "<<a<<", b: "<<b<<endl;

func_wid_address(a,b);
cout<<"a: "<<a<<", b: "<<b<<endl;
return 0;
}
// ** Output **
// a: 20, b: 40
// a: 100, b: 200

Passing number of Vairable Arguments in function

2013-07-02T16:31:00.000-07:00

Passing number of Variable Arguments in function

#include <stdio.h>
#include <stdarg.h>

int sum(int num, ...); /* Function which takes n number of arguments */

int main(void){
int s1;
s1 = sum(4, 100,200,300,400);/* Lets put some numbers to add up       */
  s2 = sum(6,6,6,6,6);        /* which can be changed on each function */
                               /* call, but calling the same function   */
printf("The sum S1 is: %d\n",s1);
printf("The sum S2 is: %d\n",s2);
return 0;
}

int sum(int num,...){
int S = 0, i;
va_list L; /* 'va_list' - structure defined in 'stdarg.h' header file */

va_start(L,num); /* 'va_start' -function taking object 'L'(of Structure
                       va_list) and 'num' -total number of arguments
                       passed when 'sum' function is called */
                   /* Object 'L' will hold all the values when sum is
                       called */

for(i=0;i<num;i++){
   S += va_arg(L, int); /* va_arg will convert current value is L into
                          'int' (function argument) and return an 'int' */
}

va_end(L);        /* destructing Object 'L' */
return S;           /* returning 'S' to command line */
}

COUT Class code

2011-06-05T13:56:00.000-07:00

#include <stdio.h>
#include<iostream>
using namespace std;
#define endl '\n'
class syp{
ostream* ost; // output stream pointer
public:
syp(ostream* is){ // accepting 'cout' as constructor argument
ost = is; // assigning 'cout' to output stream ost
}
friend syp operator<<(const syp&, const char*); //(lft operand -> class obj,rht operand -> char*/int /double)
friend syp operator<<(const syp&, const int); // e.g. syp<<8;
friend syp operator<<(const syp& s, const double x);
friend syp operator<<(const syp& s, const char c);
};

syp operator<<(const syp& s, const char c){
s.ost->put(c); // put (const char) is a function of ostream class
return s; // return class syp object 's'
}
syp operator<<(const syp& s, const char* os){
s.ost->write(os,strlen(os)); // write (const char*, length) is a function of ostream class
return s;
}
syp operator<<(const syp& s, const int x){
s.ost->operator<<(x); // operator<<(const int) is an operator of ostream class
return s;
}
syp operator<<(const syp& s, const double x){
s.ost->operator<<(x); //operator<<(const double) is an operator of ostream class
return s;
}

int main(){
double d1 = 12.3;
int i1 = 45;
syp s(&cout);
spy << "abc" << endl; // #define endl '\n' -> i.e. char '\n', this uses operator<<(class object, const char )
// Cascading
// As a compiler calculating e.g. --> 1 + 2 + 3 => (1 + 2) + 3 => 3 + 3
// In the same way --> s<<'a'<<2<<"hello" ; returns class syp object s
// o/p on screen => a
// => s << 2<<"hello" ; returns class object s
// o/p => 2
// => s<<"hello" ;
// o/p => hello

s << "d1=" << d1 << " i1=" << i1 << 'z' << endl;
return 0;
}

Linked List in C++

2011-05-07T06:45:00.000-07:00

A good Doubly linked list functionality class with template.

Enjoy people !! 

template <class T>
class node {
   private:
      T data;
      node *prev, *next;
   public:
      node(T);
      void setnext(node<T> *);
      void setprev(node<T> *);
      node<T>* getnext( );
      node<T>* getprev( );
      T showdata( );
};

template <class T>
node<T>::node(T in) {
   data = in;
   next = prev = NULL;
}
template <class T>
void node<T>::setnext(node<T> *n) { next = n; }

template <class T>
void node<T>::setprev(node<T> *p) { prev = p; }

template <class T>
node<T>* node<T>::getnext( ) { return next; }

template <class T>
node<T>* node<T>::getprev( ) { return prev; }

template <class T>
T node<T>::showdata( ) {
   return data;
}

template <class L>
class lnklist {
   private:
      node<L> *start, *curr;
      int node_count;
   public:
      lnklist( );
      void insertnode(L);
      bool gonext( );
      bool goprev( );
      void ins_at_front(node<L> *);
      void between_post(node<L> *);
      void between_pre(node<L> *);
      void ins_at_end(node<L> *);
      void removenode(L);
      void dsplist( );
   void sort( );
   int numofnodes();
   void writeinfile(FILE*& );
   node<L>* top();
   bool search(char*,node<L>*, bool);
   ~lnklist( );
   
      void info(node<L> *); 
};
template <class L>
int lnklist<L>::numofnodes( ){
 return node_count;
}

template <class L>
void lnklist<L>::writeinfile(FILE*& f){
 node<L>* temp = start;
 while(temp){
  strcat(temp->showdata(),"\n");
  fputs(temp->showdata(),f);
   temp = temp->getnext();
 }
}

template <class L>
void lnklist<L>::sort(){   // quick sort
 node<L>* left = start; // set left value to the start of the list
 node<L>* temp = start; // maintaing a temp value to swap nodes
 while(temp->getnext()) temp = temp->getnext(); // getting to end of the list
 node<L>* right = temp;   // set right value to the end of the list
 int pivot = node_count / 2; // pivot value , exactly to the middle of the list
 node<L>* pivot_n = start;   
 while(pivot >= 1){
  pivot_n = pivot_n->getnext(); // setting pivot node as the middle node of the list
  pivot--;
 } 
 while(strcmp(left->showdata(),right->showdata()) <= 0 ){ // comparing the left node to be smaller then right node 
  while(strcmp(left->showdata(),pivot_n->showdata()) < 0) // reaching to the pivot value.
   left = left->getnext(); 
  while(strcmp(right->showdata(),pivot_n->showdata()) > 0)
   right = right->getprev();
  if(strcmp(left->showdata(),right->showdata()) <= 0){
   temp = left;
   left = right;
   right = temp;
   left = left->getnext();
   right = right->getprev();
  }
 }
 
 
}

template <class L>
node<L>* lnklist<L>::top(){
 return start;
}
template <class L>
lnklist<L>::lnklist( ) {
   start = curr = NULL;
   node_count = 0;
}
template <class L>
void lnklist<L>::insertnode(L in) {
   bool oktogo = true;
   node<L> *temp = new node<L>(in);
   if(start == NULL) {     // empty list (no nodes)
      start = curr = temp; // temp's 'next' and 'prev' nodes set to NULL
  // cout<<"At the first node:"<<in<<endl;
   //cout << "inserting node in a brand new list (empty)"  << endl;

   }                       // in node constructor
   else {                  // at least 1 node in list to which 'curr' is
      // pointing to
    //cout<<" Data : "<<match(in,curr->showdata())<<endl;
    if(strcmp(in,curr->showdata()) < 0) {
   while(oktogo && (strcmp(in,curr->showdata()) < 0)) {
   oktogo = goprev();
   }
      }
      else {
  while(oktogo && (strcmp(in,curr->showdata()) > 0)) {
   oktogo = gonext( );
  }
      }
      // now check to see if the node to insert is the last, first, or
      // somewhere in the middle
      if(   strcmp(in,curr->showdata()) < 0   ) {
   if(curr == start) {
    ins_at_front(temp);
    //cout << "inserting node at top of the list"  << endl;
   }
   else {
    between_pre(temp);
    //cout << "inserting node between pre"  << endl;
   }
      }
      else {
   if(curr->getnext( ) == NULL) {
    ins_at_end(temp);
    //cout << "inserting node at end of the list"  << endl;
   }
   else {
    between_post(temp);
    //cout << "inserting node between post"  << endl;
   }
      }
   }
   // info(temp);
   node_count++;
   //dsplist( );
}
template <class L>
bool lnklist<L>::gonext( ) {
   bool rc;
   if(curr && curr->getnext( )) {
      curr = curr->getnext( );
   }
   rc = (curr && curr->getnext( )) ? true : false;
     // must first check 'curr' in the
   return rc;                    // event of an empty list
}
template <class L>
bool lnklist<L>::goprev( ) {
   bool rc;
   if(curr && curr->getprev( )) {
      curr = curr->getprev( );
   }
   rc = (curr && curr->getprev( )) ? true : false;
   return rc;
}
template <class L>
void lnklist<L>::ins_at_front(node<L> *tmp) {
   tmp->setnext(curr);
   curr->setprev(tmp);
   curr = start = tmp;
}
template <class L>
void lnklist<L>::between_pre(node<L> *tmp) {
   tmp->setnext(curr);
   tmp->setprev(curr->getprev( ));
   curr->getprev( )->setnext(tmp);
   curr->setprev(tmp);
   curr = tmp;
}
template <class L>
void lnklist<L>::between_post(node<L> *tmp) {
   tmp->setnext(curr->getnext( ));
   tmp->setprev(curr);
   curr->getnext( )->setprev(tmp);
   curr->setnext(tmp);
   curr = tmp;
}
template <class L>
void lnklist<L>::ins_at_end(node<L> *tmp) {
   tmp->setprev(curr);
   curr->setnext(tmp);
   curr = tmp;
}
template <class L>
void lnklist<L>::dsplist( ) {
   node<L> *temp = start;
   while(temp) {
      cout << "[" << temp->showdata( ) << "]"<<endl;
      temp = temp->getnext( );
   }
   cout << "tnodes: "<< node_count << endl;
}

template <class L>
void lnklist<L>::removenode(L n) {
   bool rc = true;
   if(curr) { // at least 1 node in list to remove
    if(    strcmp( n,curr->showdata() ) < 0    ) 
   while(rc && (  strcmp(n,curr->showdata()  ) < 0 )  ) rc = goprev( );     
       else 
   while(rc && (  strcmp(n,curr->showdata()  ) > 0 )  ) rc = gonext( );   
      
       if(strcmp(n,curr->showdata()) == 0) { // node to remove was found
   node_count--;
   node<L> *tmp = curr;
   if(curr == start) {       // node to remove is first node
    if(curr->getnext( )) { // next node exists
     curr->getnext( )->setprev(NULL);
    }
    start = curr = curr->getnext( );
   }
   else if(curr->getnext( ) == NULL) { // node to remove is last node
    if(curr->getprev( )) {           // previous node exists
     curr->getprev( )->setnext(NULL);
    }
    curr = curr->getprev( );
   }  
   else { // node to remove is between 2 nodes
    curr->getprev( )->setnext(curr->getnext( ));
    curr->getnext( )->setprev(curr->getprev( ));
    curr = start;
   }
   delete tmp;
      }
      else {
  cout << "Node: [" << n << "] not found in list!" << endl;
      }
   }
   //dsplist( );
}
template <class L>
lnklist<L>::~lnklist( ) {
  node<L> *temp;
   while(start) {     // proceed provided there is at least 1 node
      temp = start;
      //cout << "deleting node: [" << temp->showdata( ) << "]" << endl;
      start = start->getnext( );
      delete temp;
   }
}

template <class L>
void lnklist<L>::info(node<L> *t) {
   cout << "sn:   [" << (void *) start << "] : [" << start->showdata( ) << "]\n";
   cout << "curr: [" << (void *) curr  << "] : [" << curr->showdata( ) << "]\n";
   cout << "temp: [" << (void *) t     << "] : [" << t->showdata( ) << "]\n";
}



template <class T>
bool lnklist<T>::search(char* data,node<T>* n,bool fnd){ 

 //** recursive solution **
 /*if(n && !fnd){
  if(strcmp(n->showdata(), data) == 0) fnd = true;
  search(data,n->getnext(),fnd);
 }*/
 node<T>* temp = n;
 while(temp && !fnd){
  if(strcmp(temp->showdata(), data) == 0) fnd = true;
  temp = temp->getnext();
 } 
 return fnd;
}

Swap Objects with Reference

2011-05-06T12:33:00.000-07:00

SWAP EXAMPLE

In the following example we are swapping objects. Java only allows the exchange or swapping values between two objects with reference.

There are two functions created demonstrating proper and improper exchange of data.

public class swap{
 private int num;
 private String name;
 public swap(){
  num = 0;
  name = null;
 } 
 
 public swap(int n, String name){
  num = n;
  this.name = name; 
 }
 public  void improperSwap(swap a, swap b){
  swap t;
  t = a;
  a = b;
  b = t;
  System.out.println("InSide ImproperSwap");
  System.out.println(a);
  System.out.println(b); 
  System.out.println("*** Bye Swap ****\n"); 
 }
 public String toString(){
  String t;
  t = "The number is :" + num + "\n" + 
      "The name is: " + name;
     return t;
 }
 public static void main(String args[]){
  swap one , two, swapper;
  one = new swap(10,"Ashu");
  two = new swap(45,"Dennis");
  swapper = new swap();
  swapper.improperSwap(one, two);
  System.out.println(one);
  System.out.println(two);
 }
}