Pointers are just variables like any other variables we declare, the only difference is that, the so called normal variables store some sort of data like an integer,a character,a floating point number, on the other hand a pointer stores a logical address belonging to the data or stack segment (at which some data is stored or is to be stored).

A pointer provides us the ability to access and modify data from anywhere. Pointers allow faster access to memory.

Pointer declaration:

The ‘*’ operator is used to declare a pointer for e.g. int *ptr or char *ptr

In the former case ptr is a pointer which would hold the memory location of an integer similarly in the latter ptr is a pointer which would store the memory location of a character. Its important to note that the datatype preceding the identifier is not the datatype of the identifier its the datatype of the value that would be stored or is already present at the location ptr is pointing to.

Pointer Initialization:

Its important to remember that a pointer when declared does not store a valid logical address, rather it holds a garbage value and such pointers are called wild pointers and are very dangerous as they may be pointing to a location where some data is already stored and you might end up overwriting it. So its essential to give a valid address to the pointer (You shouldn’t worry too much about this as the compiler would give you a segmentation fault at run time if you try to access a wild pointer, but its a good habit to initialize the pointer as soon as you declare it).

There are many ways to initialize a pointer:

• Suppose you declare a pointer which points to an integer value, like

int *ptr, now this pointer doesn’t have a valid address. We can use the

address of another variable and assign this address to our pointer like

int variable1;

ptr = &variable1;

‘&’ ampersand is used to get memory location of the integer variable.

• Another way is dynamic memory allocation. In this technique pointer is

  assigned a valid address at run time from the heap segment. This is the best way to assign addresses to pointers as it gives us the flexibility of deciding the amount of memory we want our pointer to access and the type of data we will store in the block of memory. Dynamic allocation of memory is done using malloc(), calloc(),and realloc() system calls.

  For e.g. lets assign an address to ptr

  ptr = (int*)malloc(sizeof(int) * 10);

Here, we type cast malloc to tell the compiler that we want a memory block

that stores integers and we use the sizeof() function to find the size of ‘int’ in

our system and multiply it by the no. of integers we want to store in this

block.

ptr would store the starting address of this block of memory.

• This last method is specific to character arrays

  for e.g. char *ptr = “Hello world”

  ‘ptr’ is a pointer which would store the address at which a character is to be stored. In our e.g. ptr would hold the address at which ‘H’ is stored using this

  address we access the entire string. Note that the string will be automatically terminated by ‘\0′.

Reading Complicated Pointer Declarations:

We’ll use an e.g. to understand how we should interpret complicated pointer

declarations.

int*(*(*ptr[]) () )[]

We should start from the identifier(and the innermost brace) and move right

then left until we reach

end brace so we start from ptr:

• ptr is the identifier we can straight away conclude that ptr is an array

  (on moving right) of (on moving left)pointers, after square brackets the innermost braces close. So we’re at *ptr[]

• Next on moving right ptr is an array of pointers to a function (then moving left) that returns pointer. At this point we’re at

  (int*(*ptr[])() )

• Finally the outermost braces ptr is an array of pointers to a function returning pointer to (on moving right) an array of integer pointers(on moving left).

Although the term “embedded” is often also used in kernel discussions, there is no special form of the Linux kernel targeted at embedded applications. Instead, the same Linux kernel source code is intended to be built for the widest range of devices, workstations, and servers imaginable, although obviously it is possible to configure a variety of optional features according to the intended use of the kernel.

In the context of embedded development, you will typically encounter embedded Linux systems—devices that use the Linux kernel and a variety of other software—and embedded Linux distributions—a prepackaged set of applications tailored for embedded systems and development tools to build a complete system. It is the latter that you are paying for when you go to an embedded Linux vendor. They provide development tools such as cross-compilers, debuggers, project management software, boot image builders, and so on. A growing number of vendors have chosen to integrate much of this functionality into customized plug-ins for their own versions of the community developed Eclipse graphical IDE framework.

fork()  creates  a new process by duplicating the calling process.  The new process, referred to as the child, is an  exact  duplicate  of  the calling  process,  referred  to as the parent, except for the following points:

• The child has its own unique process ID, and this PID does not match the ID of any existing process group.
• The  child’s  parent  process ID is the same as the parent’s processID.
• The child does not inherit  its  parent’s  memory  locks.
• Process  resource  utilizations and CPU time counters are reset to zero in the child.
• The child’s set of pending  signals  is  initially  empty.
• The  child  does  not  inherit semaphore adjustments from its parent.
• The child does not inherit record locks from its parent.
• The  child  does  not  inherit timers from its parent.
• The child does not inherit outstanding asynchronous  I/O  operations from its parent.

Compression

Data compression is often referred to as coding, where coding is a very general term encompassing any special representation of data which satisfies a given need.

A simple characterization of data compression is that it involves transforming a string of characters in some representation (such as ASCII) into a new string (of bits, for example) which contains the same information but whose length is as small as possible. Data compression has important application in the areas of data transmission and data storage. Many data processing applications require storage of large volumes of data, and the number of such applications is constantly increasing as the use of computers extends to new disciplines.