Yantrix - the power to empower!

About Yantrix

2012-02-07T12:59:00.000+05:30

Yantrix is a product development and consultancy company.

Yantrix products are based on simple ideas with a high utility potential to make life a little easier. Yantrix consultancy helps those involved in developing higher end products to get the right technical architecture around which their inhouse teams can build the product.

In terms of the value delivered, Yantrix products and consultancy services are highly cost effective in terms of time, energy as well as money saved.

A simple shell script to handle signals

2011-04-19T17:05:00.002+05:30

#! /bin/bash
handle () {
     echo "received signal:$1"
}
term () {
     echo 'will terminate in 5 seconds ...'
     sleep 5
     exit
}
echo "pid: $$"
trap "handle HUP" HUP
trap "handle USR1" USR1
trap "term" TERM

while true
do
    sleep 3
done
kill -SIGHUP

kill -SIGUSR1

kill - SIGTERM

Funny fact about a C/C++ array!

2011-03-25T09:46:00.000+05:30

An array element is normally accessed as A[n] where A is the array var name and n is the subscript. But the following works with most C/C++ compilers!

#include
using namespace std;
int main()
{
    int A[3]={0,1,2};
   cout << 0[A] << ":" << 1[A] << ":" << 2[A] << endl;
    return 0L;
}

output: 0:1: 2

Use of Typename keyword

2011-03-22T14:06:00.003+05:30

When your code uses a type from a templatized class, the compiler must be made aware of it. This is where typename comes in:

#include
using namespace std;

int iter=10; //global int variable
class Test1
{
    public:
         static int iterator; //public static variable - can be used for calculation
};
int Test1::iterator=0;
class Test
{
    public:
        class iterator //public nested class can - declare variable with it
        {};
        iterator it;
};
template <class T>
void func()
{
       typename T::iterator * iter;
       //do we mean use Test::iterator - the static var
       //or Test1::iterator - user defined type
     //typename indicates we mean the type Test1::iterator
       //else Test::iterator static var would have been used
}
int main()
{
   func<Test>();
//   func<Test1>();   //unmarking this gives compile time error
}

Invoke an object's private method using external pointer

2011-03-18T10:36:00.002+05:30

#include <iostream>

using namespace std;

class Person;

typedef void(Person::*mptr)(); //define a pointer to function UDT

class Person

{

private:

void testMe()

{cout << "Person::testMe - INVOKED A PRIVATE FUNCTION USING POINTER" << endl;}

public:

int ctr;

Person():ctr(10){}

void speak()

{cout << "Person::speak - INVOKED BY POINTER" << endl;}

void test(mptr * in)

{*in=&Person::testMe;}

};

int main()

{

int Person::*pctr; //pointer to int member

Person p, q;

mptr pmtd=&Person::speak;

(p.*pmtd)();

(q.*pmtd)();

pctr=&Person::ctr;

cout << "value of p.ctr using pointer:" << p.*pctr << endl;

cout << "value of q.ctr using pointer:" << q.*pctr << endl;

//pmtd=&Person::testMe; //cannot point directly to private func

p.test(&pmtd); //member func ptr reassigned in

(p.*pmtd)(); //another func and invoked!

}

output:

[root@localhost ~]# ./a.out
Person::speak - INVOKED BY POINTER
Person::speak - INVOKED BY POINTER
value of p.ctr using pointer:10
value of q.ctr using pointer:10
Person::testMe - INVOKED A PRIVATE FUNCTION USING POINTER
[root@localhost ~]#

Specify size of array on stack while instantiating a Object

2011-03-12T19:52:00.001+05:30

A stack based array in a class can only be of specific size. If you want to specify the size while instantiating an object of the class, you have to use a heap allocated array. Using template parameters we can specify the array size on instantiation! Here's how ...

#include

using namespace std;

template < int sz=1 > //hold atleast one element

class Integer

{

public:

int & operator[](const int in)

{return ints[in];}

protected:

int ints[sz];

};

int main()

{

Integer <3> ints;

ints[0]=0;

ints[1]=1;

ints[2]=2;

for(int i=0; i<3; i++)

cout << ints[i] << endl;

return 0L;

}

output: 1

C/C++ never ceases to amaze me!

Select Parent Class To Inherit At Runtime!

2011-02-23T08:52:00.005+05:30

Sometimes its useful to decide which parent class to inherit from while instantiating an object. This can be done easily in C/C++ as the following code shows:

#include
using namespace std;

class Animal
{
   public:
virtual void speak()=0;
};

class Dog : public Animal
{
   public:
virtual void speak()
{cout << "BOW NOW" << endl; }
};

class Cat : public Animal
{
   public:
virtual void speak()
{cout << "Meow Meow" << endl; }
};

template
class Pet : public T
{};

int main()
{
   Animal * a=new Pet<Dog> ; //Inheritance decided at timeof instantiation
   a->speak(); // bow bow!
   delete a, a=0;
    Pet<Cat> p; p.speak(); //meow meow
}

Instant C/C++ Tutorial

2011-02-22T23:27:00.001+05:30

Its easy to learn C/C++! All you need to remember is:

All classes should have

a default constructor (or one will be created under the hood!)
a copy constructor
an overloaded assignment operator
a virtual destructor

While creating a pointer

choose the right data type
understand its lifetime
make sure the path of execution arrives at the deletion point
delete it at the end of its lifetime (this releases the memory pointed to)
deinitialize a deleted pointer with NULL (this ensures the pointer does not hold an address)

How A C Program Works

2011-02-22T19:20:00.009+05:30

A program written in C/C++, is compiled into a binary or executable file and stored on the hard disk. To do anything useful this executable file has to be loaded into a process by the operating system from where the microprocessor can execute it.

Once an executable has been loaded into a process, the processor will start executing its code from a well known entry point usually written as the one and only main function in our program. The process is given resources by the operating system which among other things consists of:

Stack Memory - To hold auto variables, function parameters and return values. When your code invokes a function, its parameters are pushed on to the stack, its return value is implicitly pushed on to the stack and its variables are also pushed on to the stack. The called function is now logically on top of the stack. When the function ends its local variables are popped of the stack and hence local variables are also called auto variable. The size of stack memory is limited and to hold larger collections of data, we use the heap.

Heap Memory - This memory can be allocated on demandfrom our program and used to the extent of RAM limit available in the system. A reference of the address location of memory allocated to our program has to be held and later passed on explicitly for deallocation to the runtime system. This is done through a mechanism called pointers.

File Handles - This memory is used to hold file handles of open files in our program in a file handle table.

Variables in our program may be classified as data variables and pointers. Data variables are created on the stack and their address is represented in our program as a variable name. The data is stored starting from the first byte of the location. The range of bytes used to store the data depends on the type of the variable.

Pointer variables are also created on the stack but they can only hold addresses of other variables which may be on the stack or on the heap. The data held at the location indicated by the pointer can be indirectly accessed using the pointer this is known as de-referencing the pointer.

Memory can be dynamically allocated to a pointer on the heap. The size of memory allocated depends on the data type of the pointer. the pointer will hold the address of the location as long as we require. When we finish with the memory allocated, we have to explicitly deallocate the pointer which results in the pointer holding an address at which our program no longer controls memory. We have to deinitialize the pointer by setting its contents to zero or NULL.

This has been the trend with most C/C++ runtimes so far, but it may change given that now we are at the threshold of 64 bit computing and embedded computing on more powerful devices.