C language Stuff

Comparing Username Stored in File in C

2015-06-24T10:47:00.000-07:00

I got a request to read the username from file and compare the same .
Here is the code for the same :

#include<stdio.h>
#include<conio.h>
void main()
{
char ch;
char user_name[128];
char line[128];
char str[128];
char *ptr;
int i=0;
FILE *fp;

//Saving username in file
printf("Enter the username to write in a file:");
ch=getch();
while(ch!=13)
{
if(ch==8)
{
printf("\b");
putch(NULL);
printf("\b");
user_name[i]='\0';
--i;
}
else
{
printf("%c",ch);
user_name[i++]=ch;
}
ch=getch();
}
user_name[i]='\0';
ptr=user_name;
fp=fopen("d:\\user.txt","w+");
while(*ptr!='\0')
{
fputc(*ptr,fp);
ptr++;
}
printf("\nUsername successfully saved in the file");

//Reading username from file and saving to string .
fseek( fp, 0, SEEK_SET );
while(fgets(line,sizeof(line),fp)!=NULL)
   {
   char *nwln=strchr(line,'\n');
   if(nwln!=NULL)
   *nwln='\0';
   }
printf("\nUsername in file is :%s",line);
fp=NULL;

//take username from user to compare.
printf("\nEnter username to confirm:");
fgets(str,sizeof(str),stdin);
str[strlen(str)-1] = '\0';
if(!strcmp(line,str))
{
    printf("\nyou are right");
}
else
{
    printf("\nyou are wrong");
}

getch();
}

Format Specifiers in C

2015-01-27T05:44:00.000-08:00

Let us take a look at some format specifiers used in printf which are necessary to format the output.....

%x--> prints an int in hexadecimal.
%4x--> prints a hex int, right-justified to 4 places. If it's less than 4 digits, it's preceded by spaces. If it's more than 4 digits, you get the full number.
%04x--> prints a hex int, right-justified to 4 places. If it's less than 4 digits, it's preceded by zeroes. If it's more than 4 digits, you get the full number, but no leading zeroes.

example:
void main()
{
int i=98;
printf("%x\n",i);
printf("%4x\n",i);
printf("%04x",i);
getch();
}

output:
62
       62
00062

Similary with %d
void main()
{
int i=5;
printf("%d\n",i);
printf("%4d\n",i);
printf("%04d",i);
getch();
}

output:
5
         5
00005

Similary with %c..
void main()
{
char c='a';
printf("%c\n",c);
printf("%4c\n",c);
printf("%04c",c);
getch();
}

output:
a
         a

0000a

Calling conventions in C

2015-01-27T05:41:00.002-08:00

What is the calling convention?
When a function is called, the arguments are typically passed to it, and the return value is retrieved.

A calling convention describes:
-->how the arguments are passed and values returned by functions.

Two calling Conventions:
1.)cdecl
2.)pascal

1.)cdecl
-->This convention is the default for C/C++ programs..
-->Arguments are passed from right to left, and placed on the stack.
-->Only the code that calls these functions knows for certain what it has placed on the stack.
So,stack cleanup is performed by the caller...
-->Support the variable argument functionality.

2.)pascal
-->Arguments are passed form left to right ,and placed on stack.
-->Stack cleanup is performed by the called function.
-->Does not support variable argument functionality.

Example:
#include<stdio.h>
#include<conio.h>
void pascal f(int i,int j,int k)
{
printf(“i=%d j=%d k=%d”,i, j, k);
}
void cdecl f1(int i,int j,int k)
{
printf(“i=%d j=%d k=%d”,i, j, k);
}

int main()
{
int i=50;
f1(i++,i++,i++);
printf("-->%d\n",i);
i=50;
f(i++,i++,i++);
printf("-->%d",i);
getch();
return 0;
}

output:
i=52 j=51 k=50-->53
i=50 j=51 k=52-->53

Explanation:
Strictly speaking the result is undefined , Read about the Sequence Points and Undefined Behavior .
now if we talk about a particular compiler implementation ,if that compiler produces "i=52 j=51 k=50" for cdecl convention(default for C) then it willl certainly give the output "i=50 j=51 k=52" for the pascal convention because they are opposite to each other..

How to translate C source code into assembly instruction for a function

2013-12-18T07:51:00.000-08:00

Converting the function source code into the assembly is not a big deal , it is just a matter of 3 simple steps:

1.) Identifying the non-executable statements within a function.

2.)Create a function symbol table and resolve all the non-executable instructions.

3.)Translate C source into assembly source.

These steps sounds to be tough but if you have basic knowledge of c language these are very easy . let us take the steps one by one considering the follwing example of small code:

view plainprint?
int main()  
{  
int a = 100;  
int b = 100;  
int c;  
c = a+b;  
}  

Step1: Identifying the non-executable statements within a function

To understand this step we have to know what are the non-executable statements ??
Whenever you write a program you always write them at the very beginning of you function body.yes you guessed it right the variable declarations are the ones.
we can define the non-executable statements as:

Non-executable statements are those which are not converted to the instructions to be executed by the processor. It means that they are just the memory allocation instruction which are processed by the compilers.

So, in our example we have three non-executable statements shown in the figure below.

Step2: Creating the function symbol and resolving all non-executable statements.

Function Symbol table consists of 4 values:
1.)Symbol Name
2.)Type
3.)Composition (size of data type of symbol)
4.)Offset Address

You can easily fill the symbol table as shown below for our example.

As you can see in the above table , we have taken the variable names as symbols and added their type and size in the respective columns.

After filling the table we have calculate the total size which comes out to be 12 . Basically this 12 is the size of the stackfor the function main which will be allocated when the main function will be called.

Now the last column is the offset address . Offest Addresses are allocated by the compiler. let us see how we will fill that column.

Let us take the base pointer to the stack as ebp and assume that stack grows downwards (which happens most of the tym ).

As the size of the stack is 12 and a is the first variable declared in the function so,

Variable 'a' will get the memory at -12(%ebp) that is -12 from ebp (stack base pointer)
Variable 'b' will get the memory at -8(%ebp) because 'a' is of 4 bytes.
Variable 'c' will get the memory ar -4(%ebp) because 'b' is also of 4 bytes.

So, The final function symbol will be:

Step3: Translating C code to assembly language.

In this process whenever we have to access the variable we will replace that by the offset address given in the functionsymbol table.

To convert the function C source code into assembly we need to know one thing that is GNU compilers follows a standard which says that:

"Every function consist of 4 parts which are:
1.) Function name
2.)Pre-amble (the opening brace of function)
3.)Function-body
4.)Post-amble (the closing brace of function)"

And the same is written as the following:

Function name :

pre-amble

function-body

post-amble.

Here pre-amble defines the code for the opening curly brace and
post-amble defines the code for the closing curly brace.

Let us take a look at the both the pre-amble ,function body and post-amble small piece of code:

Pre-amble code:

view plainprint?
Pushl %ebp  
Movl %esp,%ebp  

Function-body code:

view plainprint?
Subl $12, %esp  
Movl $100, -12(%ebp)  
Movl $100, -8(%ebp)  
Movl -8(%ebp), %eax  
Addl -12(%ebp) , %eax  
Movl %eax, -4(%ebp)  

Post-amble code:

view plainprint?
movl %ebp, %esp  
popl %ebp  
popl %eip  

pre-amble and post-amble are the most important part to understand how the stack flow works in function in c language,
what is the ebp ,esp and eip ?
ebp is the pointer to base address of the stack and
esp is the pointer to top address of the stack.
eip is the pointer to the current instruction to be executed .

Now let us take the instruction one by one and see what it means:

pushl %ebp :--> This instruction means push the content/value of the ebp to the top of the stack.
movl %esp,%ebp :--> This instruction means copy the content/value of the esp to the ebp that is now both the pointers points to the same location.
subl $12, %esp :-->This the first instruction of the function body and it does the job of allocating the space for the function on the stack by subtracting the total amount of space required for the function from the esp so that esp points to the top of the stack as it is defined to be.
Note:
you can also note that now there will be a difference of 12 bytes in the ebp and esp as per our example which is nothing but the space required by the function to allocate its local variables.

movl $100 , -12(%ebp) :--> This instruction means that move the value 100 at the location 12 less than the location of ebp. that is if ebp is pointing to 1012 address location put the value 100 at 1000(1012-12).
popl %ebp --> This instruction means that pop out the contents at the top of the stack that is value at the address pointed by the esp pointer.

Rest the instruction meanings are self explanatory in corresponding to these instructions.

Full code:

view plainprint?
Main:  
Pushl %ebp  
Movl %esp,%ebp  
Subl $12, %esp  
Movl $100, -12(%ebp)  
Movl $100, -8(%ebp)  
Movl -8(%ebp), %eax  
Addl -12(%ebp) , %eax  
Movl %eax, -4(%ebp)  
movl %ebp, %esp  
popl %ebp  
popl %eip  

This is how we can convert the C code of a function to the assembly source code. The main thing to understand is the pre-amble and the post-amble .

Stack Flow in function calls in C

2013-10-13T00:07:00.001-07:00

Today I am going to start a topic on how the stack works when we call a functions in c , how the function calls are executed internally. There are some questions which are very general in intervaiew like:

How the stack is allocated for a function ?
How the calling a function works internally ?
How stack grows when we call a function within a function ?

There are lot more questions on the same stuff. So, we will able to answer all those question after going through the full topic series of this which will be covered in consecutive posts.

So, To understand how the function call works we have to know little bit of assembly programming. Don't be afraid if you don't know the same. we don't require the expertise in that , we just require very basic knowledge.

So to start with we will first learn:

How to translate C source code into assembly instruction for a function :

Converting the function source code into the assembly is not a big deal , it is just a matter of 3 simple steps:

1.) Identifying the non-executable statements within a function.

2.)Create a function symbol table and resolve all the non-executable instructions.

3.)Translate C source into assembly source.

These steps sounds to be tough but if you have basic knowledge of c language these are very easy . let us take the steps one by one considering the follwing example of small code:

int main()
{
int a = 100;
int b = 100;
int c;
c = a+b;
}

Step1: Identifying the non-executable statements within a function

Step2: Creating the function symbol and resolving all non-executable statements.

Function Symbol table consists of 4 values:
1.)Symbol Name
2.)Type
3.)Composition (size of data type of symbol)
4.)Offset Address

You can easily fill the symbol table as shown below for our example.

As you can see in the above table , we have taken the variable names as symbols and added their type and size in the respective columns.

After filling the table we have calculate the total size which comes out to be 12 . Basically this 12 is the size of the stack for the function main which will be allocated when the main function will be called.

Now the last column is the offset address . Offest Addresses are allocated by the compiler. let us see how we will fill that column.

Let us take the base pointer to the stack as ebp and assume that stack grows downwards (which happens most of the tym ).

As the size of the stack is 12 and a is the first variable declared in the function so,

Variable 'a' will get the memory at -12(%ebp) that is -12 from ebp (stack base pointer)
Variable 'b' will get the memory at -8(%ebp) because 'a' is of 4 bytes.
Variable 'c' will get the memory ar -4(%ebp) because 'b' is also of 4 bytes.

So, The final function symbol will be:

Step3: Translating C code to assembly language.

In this process whenever we have to access the variable we will replace that by the offset address given in the function symbol table.

To convert the function C source code into assembly we need to know one thing that is GNU compilers follows a standard which says that:

"Every function consist of 4 parts which are:
1.) Function name
2.)Pre-amble (the opening brace of function)
3.)Function-body
4.)Post-amble (the closing brace of function)"

And the same is written as the following:

Function name :

pre-amble

function-body

post-amble.

Pushl %ebp
Movl %esp,%ebp

Function-body code:

Subl $12, %esp
Movl $100, -12(%ebp)
Movl $100, -8(%ebp)
Movl -8(%ebp), %eax
Addl -12(%ebp) , %eax
Movl %eax, -4(%ebp)

Post-amble code:

movl %ebp, %esp
popl %ebp
popl %eip

Main:
Pushl %ebp
Movl %esp,%ebp
Subl $12, %esp
Movl $100, -12(%ebp)
Movl $100, -8(%ebp)
Movl -8(%ebp), %eax
Addl -12(%ebp) , %eax
Movl %eax, -4(%ebp)
movl %ebp, %esp
popl %ebp
popl %eip

This is how we can convert the C code of a function to the assembly source code. The main thing to understand is the pre-amble and the post-amble .

I will explain the significance with the example in the next post with step by step change in the stack when we execute these instruction. then it will be cleared why we are using these instruction, so stay tuned for the next post.

If you have any doubt in this , feel free to comment.

Have Fun !!!!

C Language Basic Quiz

2013-10-02T08:33:00.001-07:00

Please Comment feedback and Queries about the questions after completing.

C Language Basic Quiz » Online Exam maker

Tower Of Hanoi Continued...

2013-09-29T01:09:00.001-07:00

As I have described in the previous post , Here is the Recursion Tree of the Tower. If you are able to draw the recursion tree of a a problem you will be able to code that too very easily.

This Tree is self explanatory , In this we have Decomposed the 3 Disc problem into 3 steps and recursively solved the same.

So, Now we can write the Program for the same , It does not depend which programming language you use to code , the algorithm will be the same.

Tower Of Hanoi Algorithm Implementation.

#include<stdio.h>
int main()
{
int number_of_discs;
printf("Enter the Number of discs:");
scanf("%d",&number_of_discs);
printf("\n");
Towers(number_of_discs,'A','B','C');
}

void Towers(int N,char From, char To, char Via)
{
   if(N==1)
{
printf("Moving %c to %c\n ", From , To);
}
else
{
  Towers(N-1,From,Via,To);                     //(N-1,A,C,B)
  printf("Moving %c to %c\n" , From , To);    //(1,A,B,C)
  Towers(N-1,Via, To,From);                   //(N-1,C,B,A)
}

}

Tower Of Hanoi

2013-09-29T00:50:00.000-07:00

Today I will try to explain the Tower Of Hanoi Algorithm in Full detail. I don’t want you to just mug up the 3 lines of code and pass an exam . I want you to learn How we reach to the solution. How we decompose the problem and recompose it again to get the solution which is very important to solve a problem like this. You will also learn how to apply the recursion to get the desired solution.

Tower Of Hanoi:- The problem description is as follows:

We have Three pillars/pegs and N discs of different size on One pillar/peg such that They are in Incresing order of size from top to bottom.

What we have to do?

We have to move the Discs from Source Peg to Destination Peg keeping the following constraints in Mind.

Constraints:

1.)We can take one peg out at a time.

2.)We can’t place small disc below the larger one during the task.

3.)We can only use one more pillar for help to complete the solution.

Problem:

Solution:

We have described the problem the solution above. Now we have to think how to solve the same.

Let Us decompose the problem and try to solve it

Let us Assume that we have only one Disc On peg A and We have to move the same to the Peg B.The solution is obvious , We will just pick the disc and put it on B and the problem is solved , let us see the same in Picture.

Solution of 1 disc Problem

(1,A,B,C) denotes that we have moved 1 disc from A to B using C.

SO, (1,A,B,C) solves the One Disc Problem.

Now , Let Us Assume that We have Two Disc and We have to move both disc from A to B. Let us see the solution of Two Disc Problem in Picture.

Solution Of 2 Discs problem

So, To solve 2 Disc problem we have followed the following 3 steps:

1.) (1,A,C,B)

2.) (1,A,B,C)

3.) (1,C,B,A)

Now Let us Take the 3 Disc Problem, Now we have to move the 3 discs from A to B.

Solution of 3 Disc Problem:

Now if We see The solution of 2 Disc Problem(2,A,B,C) is :

1) (1,A,C,B)

2.) (1,A,B,C)

3.) 1(C,B,A)

So,The First 3 steps:

1.) (1,A,B,C)

2.) (1,A,C,B)

3.) (1,B,C,A)

of the 3 disc problem is the solution of Problem (2,A,C,B)

And,The 4th Step:

4.) (1,A,B,C)

is the solution of Problem(1,A,B,C)

And the last 3 steps:

5.) (1,C,A,B)

6.) (1,C,B,A)

7.) (1,A,B,C)

is the solution of Problem(2,C,B,A)

So the solution of 3 disc problem(3,A,B,C) can be written as:

1.) (2,A,C,B)

2.) (1,A,B,C)

3.) (2,C,B,A).

and Similarly the solution of N disc problem(n,A,B,C) can be written as:

1.) (n-1,A,C,B)

2.) (1,A,B,C)

3.) (n-1,C,B,A).

So, In this way we have decomposed the problem into three parts to solve it.

Now let us say

A-->From

B-->To

C-->Via

So the Tower of hanoid problem is (N,From,To,Via) which can be solved in three steps:

1.) (n-1,From,Via,To) -- first solve the problem of moving n-1 discs From to Via .

2.) (1,From,To,Via) -- Then solve the problem of moving 1 disc From to To.

3.) (n-1,Via,To,From) -- Then Solve the problem of moving n-1 disc from Via to To back.

We can also draw the Recursion Tree of the problem Here.

Storage Classes in C

2013-09-23T11:06:00.000-07:00

Today I am going to explain the most important concept of C language.
If you have gone through any interview , It is quite possible that you came across the questions like:

What do you mean by storage class in C?
How many storage classes are there in C?
Explain the different storage classes in C ?

So, I will be explaining the storage class concept in full detail with all its types.

Let us start by understanding What it means by a Storage class?

We know that Every variable posses the following property:

Lifetime: Lifetime of a variable defines "till what time we can access a particular variable".
Scope: Scope of a variable defined "Where we can access a variable in our hundred and thousands lines of code".
Default value: what is the default value of the variable when it is only declared that is programmer has not assigned any value to it explicitly.
Storage place: Storage of a variable defined Where the variable is getting the memory to be accessed.

All the above properties are tied to the variables , and the specifiers consisting of these properties specify the storage class of a variable...

So, We can say that Storage class is an attribute/specifier which defines Lifetime,scope,storage and default value of a variable.

For defining different lifetime,scope,storage and default value the storage classes are categorized into 4 categories:
1.)Auto
2.)Static
3.)Extern
4.)Register

So, just by saying that this is an auto variable, a static variable , a extern variable or a register variable we are
telling about all the four properties of a variable.

Explanation of all the classes coming soon one by one.

gettid() vs pthread_self()

2013-08-13T06:57:00.002-07:00

So we have looked at both gettid(getting the id of the thread) and the pthread_self(),Now let us join then as see the output...so the difference between then is clear...

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<linux/unistd.h>
#include<sys/syscall.h>
void* printid(void *ptr)
{
printf("The id of %s is %u\n",(char*)ptr,syscall( __NR_gettid ));
printf("The id of %s is %u\n",(char*)ptr,(unsigned int)pthread_self());
}
int main()
{
    pthread_t thread[5];
    char *msg[]={"thread1","thread2","thread3","thread4","thread5"};
    int i;
    for(i=0;i<5;i++)
    {
        pthread_create(&thread[i],NULL,printid,(void*)msg[i]);
        pthread_join(thread[i],NULL);
    }
    return 0;
}

output:

The id of thread1 is 18799

The id of thread1 is 3086543760

The id of thread2 is 18800

The id of thread2 is 3086543760

The id of thread3 is 18801

The id of thread3 is 3086543760

The id of thread4 is 18802

The id of thread4 is 3086543760

The id of thread5 is 18803

The id of thread5 is 3086543760

Explanation:

As you can see the ID generated by pthread_self() is reused by the threading implementation after the thread completion which have achieved using the join in the for loop..and the ID assigned by the kernel is unique one...

So the difference between gettid() and the pthread_self() is:

1.)POSIX thread IDs are assigned and maintained by the threading implementation. The thread ID returned by gettid() is a number (similar to a process ID) that is assigned by the kernel.

2.)ID generated by the pthread_self() can be used after the completion of the thread but the ID genereated by the kernel can't be used even after the completion of the thread..

Getting the Thread ID In C

2013-08-13T06:57:00.000-07:00

As we have see in the pthread_self(),the ID is implemented or maintained by threading implementation not by the kernel,so for getting the unique ID assiged by the kernel we have to use the system call...

Take a look at the example...

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<linux/unistd.h>
#include<sys/syscall.h>
void* printid(void *ptr)
{
printf("The id of %s is %u\n",(char*)ptr,syscall( __NR_gettid ));
}
int main()
{
    pthread_t thread[5];
    char *msg[]={"thread1","thread2","thread3","thread4","thread5"};
    int i;
    for(i=0;i<5;i++)
    {
        pthread_create(&thread[i],NULL,printid,(void*)msg[i]);
        pthread_join(thread[i],NULL);
    }
    return 0;
}

output:

On my system the output is:

The id of thread1 is 18622

The id of thread2 is 18623

The id of thread3 is 18624

The id of thread4 is 18625

The id of thread5 is 18626

As you can see now the IDs are different because they are assigned by the kernel not by the threading implementation...

Also look at :gettid() vs pthread_self()

pthread_self()

2013-08-13T06:56:00.001-07:00

Getting the Thread ID..

We can get the ID of the thread by using the funciton pthread_self() on the running thread.

The main point about this function is :It uniquely identifies EXISTING threads,Here EXISTINGhas a special meaning..The meaning is pthread_self() return the value which can be reused across the program that means if you have created a thread and it completed its execution then the id of that thread can be used as the id of another thread..

Let us prove the statement that is a thread completes then the id of that thread(returned by pthread_self) can be used as the id of another thread...

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<linux/unistd.h>
#include<sys/syscall.h>
void* printid(void *ptr)
{
printf("The id of %s is %u\n",(char*)ptr,(unsigned int)pthread_self());
}
int main()
{
    pthread_t thread[5];
    char *msg[]={"thread1","thread2","thread3","thread4","thread5"};
    int i;
    for(i=0;i<5;i++)
    {
        pthread_create(&thread[i],NULL,printid,(void*)msg[i]);
        pthread_join(thread[i],NULL);
    }
    return 0;
}

output:

On my system the output is:

The id of thread1 is 3086285712

The id of thread2 is 3086285712

The id of thread3 is 3086285712

The id of thread4 is 3086285712

The id of thread5 is 3086285712

As you can see the ID's of all the thread is equal...

Explanation:I need to explain only one thing that is how to make sure that a thread completes before the execution of the next thread the answer is simple joining the thread solves our purpose..so in the for loop we create a thread then call a join so the main program waits for the thread to complete for the next iteration of the for loop..In this way we can make sure that the thread starts after the completion of the previous thread...

As the thread completes so the program can use the same ID of thread1 for the thread2 and so on....

Why so???

POSIX thread IDs are assigned and maintained by the threading implementation not by the kernel,to get the ID assigned by the kernel see here...

Thread Specific Data Example

2013-08-13T06:55:00.001-07:00

Here is the Example to using Thread Specific Data..

In this example I am using File pointer as the TSD,setting the value of the key and then getting the correspoding file pointer for the particular thread...

Each Thread creates its log file and writes its name in the file....

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
static pthread_key_t key;
void write_to_file(void *ptr)
{
    FILE *fp= (FILE*)pthread_getspecific(key);
    fprintf(fp,"%s",(char*)ptr);
        fclose(fp);
}
void* perform(void *ptr)
{
    FILE *fp;
    char *filename=malloc(strlen((char*)ptr)+8 );
    sprintf(filename,"%slog.log",(char*)ptr);
    fp=fopen(filename,"w");
    pthread_setspecific(key,fp);
    write_to_file(ptr);
}
int main()
{
    pthread_t thread[5];
    char *msg[]={"thread1","thread2","thread3","thread4","thread5"};
    int i;
    pthread_key_create(&key,NULL);
    for(i=0;i<5;i++)
    {
        pthread_create(&thread[i],NULL,perform,(void*)msg[i]);
        pthread_join(thread[i],NULL);
    }
    printf("Now main ends");
    return 0;
}

Thread Specific Data

2013-08-13T06:54:00.001-07:00

Thread Specific Data

Thread Specific Data means data related to a particular thread,Think of a pool of different data for different threads that each thread can access with a public key...

All things revolves around a key to get the particular data..

what to do--

1.)Create a key

2.)set the specific data for the thread using the key

3.)get the specific data using the key only for a specific thread

Example:suppose there are 4 Threads running and every threads has to create a log file of the task that is performing,so each thread wants a file pointer specific to that thread so we can keep those file pointers as the TSD and can use a key to access the TSD for each thread..

For creating a key use the following function:

int pthread_key_create(pthread_key_t *key, void (*destructor) (void *));

first argument-The key which you have defined...

second argument-The function which you want to run after the completion of the thread,generally for cleanup,descrutor kind of thing.

Note-If you pass a function pointer here, GNU/Linux automatically calls that function when each thread exits, passing the thread-specific value corresponding to that key. This is particularly handy because the cleanup function is called even if the thread is canceled at some arbitrary point in its execution. If the thread-specific value is null, the thread cleanup function is not called. If you don't need a cleanup function, you may pass NULL instead of a function pointer.

For setting the value use the following function:

pthread_setspecific(key, value);

For getting the value use the following function:

pthread_getspecific(key);

Return Value From Thread

2013-08-13T06:53:00.001-07:00

As we have seen in the examples the return type of the functions that runs as the threads is the void*,it means we can return a value from the thread,but the point is how to capture that returned value in the main function...

The answer is the join again,as we have seen in the join the function prototype is

int pthread_join(pthread_t,void **)

Here the 2nd argument is the pointer to the value returned by the thread...

In the main funtion we can capture and use the value returned by the thread using the pthread_join.

Let us capture the return value...

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
void* myfunc1(void *ptr)
{
    char *msg;
    int i=0;
    msg=(char*)ptr;
    while(1)
    {
        sleep(1);
        if(i>5)
            break;
        else
        {
            printf("i in thread1=%d\n",i);i++;
        }
    }
    printf("Thread1 completed\n");
    return "hello";
}
void *myfunc2(void *ptr)
{
    char *msg;
    int i=0;
    msg=(char*)ptr;
    while(1)
    {
        sleep(1);
        if(i>10)
            break;
        else
        {
            printf("i in thread2=%d\n",i);i++;
        }
    }
    printf("Thread2 completed\n");
    return "Hi";
}
int main()
{
    pthread_t thread1,thread2;
    int val1,val2;
    int status;
    char *msg1="Thread1";
    char *msg2="Thread2";
    void **ret_val1=malloc(sizeof(void*));
    void **ret_val2=malloc(sizeof(void*));
    printf("In the main funciton\n");
    pthread_create(&thread1,NULL,myfunc1,(void*)msg1);
    pthread_create(&thread2,NULL,myfunc2,(void*)msg2);
    pthread_join(thread1,ret_val1);
    pthread_join(thread2,ret_val2);
    printf("return value from thread1  is:%s\n",*ret_val1);
    printf("return value from thread2 is:%s\n",*ret_val2);
    printf("Now main ends");
    return 0;
}

Thread Join In C

2013-08-13T06:52:00.001-07:00

Why thread Join??

As we have seen in the first multithreaded program that we have the while(1) loop in the main function ,that is to ensure that the application/program keeps runnning because if main ends the program ends...

Now if we dun want to waste the time in the main program and only want to run the threads we can use the thread join to achieve this task.

what is a join??

Join means we are telling the thread to join with the other thread that is we are telling that wait for the other thread to finish..

So two threads are included in the join

first thread -to whom we are saying to join

second thread-the thread to join with

suppose there is Thread1 and Thread2,and we require the Thread2 must complete before Thread1 so we have to tell the Thread1 to join with the Thread2..

So in our Example,We have to say main to join with the Thread1 and Thread2 ,that is telling main to wait for both the Threads to complete,

So, By using join we need not to worry about the main,the main will end only after the completion of the both threads..

Funtion prototype:

int pthread_join(pthread_t tid, void **status);

The first argument is the thread ID.

The second argument is a pointer to the data your thread function returned,keep it as NULL for now.

Example:

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
void* myfunc1(void *ptr)
{
    char *msg;
    int i=0;
    msg= (char*)ptr;
    while(1)
    {
        printf("In the %s\n",msg);
        sleep(1);
    if(i++> 7)
    break;
    }
printf("Thread1 completed\n");
}
void *myfunc2(void *ptr)
{
    char *msg;
    int i=0;
    msg= (char*)ptr;
    while(1)
    {
        printf("In the %s\n",msg);
        sleep(1);
    if(i++>10 )
    break;
    }
printf("Thread2 completed\n");
}
int main()
{
    pthread_t thread1,thread2;
    int val1,val2;
    int status;
    char *msg1="Thread1";
    char *msg2="Thread2";
    void **ret_val;
    printf("In the main funciton\n");
    val1=pthread_create(&thread1,NULL,myfunc1,(void*)msg1);
    val2=pthread_create(&thread2,NULL,myfunc2,(void*)msg2);
    printf("the value returned by thread1=%d\n",val1);
    printf("the value returned by thread2=%d\n",val2);
    pthread_join(thread1,NULL);//telling main to join with thread1
    pthread_join(thread2,NULL);//telling main to join with thread2
        printf("Now main ends:\n");
    return 0;
}

First Multi Threaded Program in C

2013-08-13T06:50:00.001-07:00

Today i have written my first multithreaded program in C on linux,

It is very easy to write multithreded program using the pthread library..

Let us take a look which function we need to create a multithreded program in c...

The function to create the thread:

int pthread_create(pthread_t *tid,const pthread_attr_t *attr,void *(*func)(void *), void *arg)

Note-Each thread will have its own unique thread ID.

The first argument is the variable where its thread ID will be stored.

The second argument contains attributes describing the thread. Keep this as NULL now,will explain later.

The third argument is a pointer to the function you want to run as a thread.

The final argument is a pointer to data you want to pass to the function.

Having this information in mind you can write a simple multithreaded program in C...

Let us take a look at a example:

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
void* myfunc1(void *ptr)
{
char *msg;
msg= (char*)ptr;
printf("%s started\n",msg);
while(1)
{
printf("In the %s\n",msg);
sleep(1);
}
}
void *myfunc2(void *ptr)
{
char *msg;
msg= (char*)ptr;
printf("%s started\n",msg);
while(1)
{
printf("In the %s\n",msg);
sleep(1);
}
}
int main()
{
pthread_t thread1,thread2;
int val1,val2;
char *msg1="Thread1";
char *msg2="Thread2";
printf("In the main funciton\n");
printf("My first thread program\n");
val1= pthread_create(&thread1,NULL,myfunc1,(void*)msg1);
val2= pthread_create(&thread2,NULL,myfunc2,(void*)msg2);
printf("The value returned by thread1=%d\n",val1);
printf("The value returned by thread2=%d\n",val2);
while(1)
{
printf("in the main function\n");
sleep(1);
}
return 0;
}

Deleting a File in C

2011-09-16T05:54:00.000-07:00

Here is the program to delete a file in C......

#include <stdio.h>
#include<stdio.h>
#include<errno.h>
int main(void)
{
   char file[80];
   int i;
   clrscr();
   printf("File to delete: ");
   gets(file);
   i=remove(file);
   if(i==0)
   {
   printf("file removed");
   }
   else
   {
   if(errno==ENOENT)
   printf("\nNo such file exists");
   if(errno==EACCES)
   printf("\nPermission denied");
   }
   getch();
   return 0;
}

Feel Free to Comment if any point is not clear.........

Renaming a file in c

2011-09-13T20:44:00.000-07:00

In this post we will find how to rename and move a file in the same drive using c language....
This can be done in c using the rename() function..The prototype of rename is:

int rename(const *char oldname,const *char newname);

On sucess--it returns 0,

On error---it returns -1;

Let us take an example:

#include <stdio.h>
#include<conio.h>
#include<errno.h>
int main(void)
{
   char oldname[80], newname[80];
   int i;
   clrscr();
   printf("Enter File to rename: ");
   gets(oldname);
   printf("\nEnter New name: ");
   gets(newname);
   i=rename(oldname, newname);
     if(i==0)
     {
     printf("rename done");
     }
     else
     {
     if(errno==ENOENT){printf("no such file/directory exists");}
     if(errno==EACCES){printf("access denied");}
     if(errno==ENOTSAM){printf("Drive is not same");}
     }
getch();
   return 0;
}

Let us find the output for different inputs

output:

Enter File to rename:c:\test.txt

Enter New name:c:\go.txt

rename done

Explanation:it will sucessfully rename the file test to go in the c drive

output:

Enter File to rename:d:\test.txt

Enter New name:c:\go.txt

Drive is not same

Explanation:Using rename function u can only work within a drive

output:

Enter File to rename:d:\test.txt

Enter New name:d:\moveinthis\go.txt

rename done

Explanation:You can move the file from one directory to another directory using rename but the condition is that the directories must be in the same drive......

output:

Enter File to rename:d:\ex.txt

Enter New name:d:\moveinthis\go.txt

no such file/directory exists

Explanation:This message will come if there is no file named as ex.txt present in the d drive......

output:

Enter File to rename:c:\temp

Enter New name:c:\check

rename done

Explanation:We can rename also a directory using the rename function,but still the condition is we must work in the same drive.....

The difference between pointer to array and pointer to its first element

2011-09-08T06:29:00.000-07:00

In the previous Post,We have seen that the address of array and the address of its first element is same,so,the question was what is the difference between Pointer to array and the Pointer to the first element of array while both contains the same address as proved in this Post....
That is if write something like this--
int (*ptr)[5];
ptr=&a;
and a pointer to first element of the array that is....
int *ptr1;

ptr1=a;

Then,What's the Difference between ptr and ptr1??????

To Get the difference between we have just to recall the concept of pointer arithmetic that is what happens if we add some number to a pointer??...
As we know whenever we add any number to the pointer the pointer appends to the memory location which is equal to the sizeof datatype*number....
For example:if a pointer is pointing to an int and its value is 65588 then if we add 1 to the pointer then it goes to 65590 that is (sizeof int *num) that is 2*1=2,so 2 gets added to the pointer and now it points to 65590 memory location...

So,Having the concept of pointer arithmetic in mind when we declare a pointer to an array and increments it the value of the pointer get incremented by sizeof array*datatype size*number...

For example:
if we write int a[5]={1,2,3,4,5};
the sizrof array is 5,
datatype size is 2 for int(16-bit assumed),
and number is 1,
int(*ptr)[5];
ptr=&a;
ptr=ptr+1;or ptr++;
if in address of array is 65516 that is ptr is 65516 in the beginning then after ptr=ptr+1 or ptr++;
The value of ptr is 65516+(5*2*1)=65516+10=65526
This is what happens if ptr is the pointer to array and if the ptr is the pointer to the first elements of the array then as the first element is an int so when we increments the ptr the value get incremented by sizeof int that is it points to the next element...
let us write a program

#include<stdio.h>
#include<conio.h>
void main()
{
int arr[5]={1,2,3,4,5};
int(*ptr1)[5];
int *ptr2;
ptr1=&a;//pointer to an array
ptr2=&a[0];//pointer to first element of array
printf("The address of array is:%u",ptr1);
printf("\nThe address of first element of array is:%u",ptr2);
ptr1++;
printf("\nNow the value of ptr1 is:%u",ptr1);
ptr2++;
printf("\nNow the value of ptr2 is:%u"",ptr2);
}

output:

The address of array is:65516

The address of first element of array is:65516

Now the value of ptr1 is:65526

Now the value of ptr2 is:65518

I explained to the best of my knowledge,Correct me if there is anything wrong by commenting ,your comments,query and suggestions are invited to raise the level of this blog......
Have a nice time.....

Address of array and Address of first element of array

2011-09-07T20:58:00.000-07:00

Today we will explore the address of array and the Address of First Element of the same array....
let us first create an array of int containing the 5 elements.
int a[5]={1,2,3,4,5};
Here a is the array of the 5 int data type elements...
As we know we can find the address of the array by applying the & operator with the array name that is "a",so the address of the aray is "&a"...we can print this address using the %u format specifier in the printf..
printf("address of array is:%u",&a);//address of the array
let us write a program..

#include<stdio.h>
#include<conio.h>
void main()
{
int a[5]={1,2,3,4,5};
clrscr();
printf("The address of array is:%u",&a);
getch();
}

The output is the address of the array...let us say it prints

The address of array is:65516

Now let us find the address the first element of the array,as ww know we can get the first element by a[0],and its address by &a[0]..
so the statement printf("The address of first element is:%u",&a[0]); gives the address of the first element of the array...it prints.

The address of first element is:65516

Further,we also know that the a(the name of the array) is nothing but the pointer to the first element of the array so printing the a will also give the same value....

#include<stdio.h>
#include<conio.h>
void main()
{
int a[5]={1,2,3,4,5};
printf("The address of array is:%u",&a);
printf("The address of first element is:%u",&a[0]);
printf("The value of a is:%u",a);
}

output:

The address of array is:65516

The address of first element is:65516

The value of a is:65516

As we can see the result the,The conclusion is...

"The Address of Array and the Address of its first element is Same........".

As for the explanation we can say that array starts from the first element so the address of its first elements is same as the address of itself........

So,the Question arises--

"What's the Difference Between Pointer to array and the pointer to the first element of array if both contains the same address????"

that is:
if we declare int a[5];
and a pointer to array that is...
int (*ptr)[5];
ptr=&a;
and a pointer to first element of the array that is....
int *ptr1;

ptr1=a;

so,What's the Difference between ptr and ptr1??????
Get Answer here.

MAC address using c

2011-09-04T01:31:00.000-07:00

Mac Address-->from Wikipedia
A Media Access Control address (MAC address) is a unique identifier assigned to network interfaces for communications on the physical network segment. MAC addresses are used for numerous network technologies and most IEEE 802 network technologies including Ethernet. Logically, MAC addresses are used in the Media Access Control protocol sub-layer of the OSI reference model.
MAC addresses are most often assigned by the manufacturer of a network interface card (NIC) and are stored in its hardware, the card's read-only memory, or some other firmware mechanism. If assigned by the manufacturer, a MAC address usually encodes the manufacturer's registered identification number and may be referred to as the burned-in address. It may also be known as an Ethernet hardware address (EHA), hardware address or physical address. A network node may have multiple NICs and will then have one unique MAC address per NIC.

Now the question is How can we find the Mac Address using C language....
There may be many methods to do that but i am using the sytem() function which is used to run the DOS command using C and the FILE handling to get the MAC address or pghysical address of the pc...

As we know we can get the physical or MAC address using the DOS command "ipconfig/all" ..u can get the mac address using this command from the dos prompt as shown in the figure below..

As you can se in the figure the Physical Address is 00-1C-C0-1A-6E-C0
Now mout ask is only to show this address as theoutput of our C program....
What firstly Strike in the mind,the idea is :

"To get the ipconfig/all command executed using sytem funtion and redirecting the output to the string or taking the output to the string and then getting the substring form that main string starting from the Physical Address that will be easy and simple....."

I also look for that and tried but was not able to do the same....any help in this regard will be appriciated
now what i have done to get the only MAC address or the physical addres,i just rediredced the output of the system funtion() with the inconfig/all command to a file ,read that file back line by line which is very necessary then search for the substring starting with Physical Address or containg the Physical Address,get that printed and get out of the loop using break....
You can see the code below...

#include <stdio.h>
#include<conio.h>
int main ()
{
  FILE *fp;
  clrscr();
  system ("ipconfig/all>f:\macid.txt");
   fp=fopen("f:\macid.txt","r");
   if(fp!=NULL)
   {
   char line[128];
   while(fgets(line,sizeof line,fp)!=NULL)
   {
   char *nwln=strchr(line,'\n');
   char *ptr;
   if(nwln!=NULL)
   *nwln='\0';
   ptr=strstr(line,"Physical Address");
   if(ptr!=NULL)
   {
   printf("%s\n",ptr);
   break;
   }
  }
   }
  getch();
  return 0;
}

NOTE:Run the program using DOS Prompt instead of turboc ide....
Your comments and query are invited .....

Dos Command in C

2011-09-04T00:47:00.000-07:00

This example will show how to use the DOS command in C and rediret its output to a file..

#include <stdio.h>
#include<conio.h>
void main ()
{
  FILE *fp;
  clrscr();
  printf ("Checking if processor is available...");
  if (system(NULL))
  {
  puts ("Ok");
  }
  else
  {
  printf("Processor is not available");
  getch();
  exit (1);
  }
  system ("dir>c:\dirlist.txt");
  printf("Done!!File created");
getch();
}

output:will create the file with name dirlist in the "c:\" drive..........

Check whether the processor is available or not

2011-08-30T23:36:00.000-07:00

This program will check whether the processor is available or not..

#include<stdio.h>
#include<conio.h>
void main()
{
printf ("Checking if processor is available...");
if (system(NULL))
printf("Processor is available");
else
printf("Processor is not available");
getch();
}

Running a DOS command using C

2011-08-30T23:00:00.000-07:00

To Run a DOS command using C we use the system() function present in process.h and stdlib.h
The prototype of the function is:

int system(const char *command);

On Success returns 0

On Error returns -1
Example:

#include<stdio.h>
#include<conio.h>
void main()
{
clrscr();
int i;
printf("This program will execute the DOS command");
i=system("dir");
if(i==0)
printf("completed successfully");
else
printf("error in executing the command");
getch();
}

If you are using turboc3 and run this using Ctrl+F9 you will not see the error , to run this go to cmd prompt and then execute the exe file created after compiling the program form the DOS prompt.you will easily get the output..if you are having any problem...just mail me at milankmr2011@gmail.com