Technology Corner

Home » C- Language

Category Archives: C- Language

Follow Technology Corner on

Code Snippet: string split in c++ (c syntax)

Below code snippet useful while splitting string (char*) .


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

int split (const char *str, char c, char ***arr)
 int count = 1;
 int token_len = 1;
 int i = 0;
 char *p;
 char *t;

 p = str;
 while (*p != '\0')
 if (*p == c)

 *arr = (char**) malloc(sizeof(char*) * count);
 if (*arr == NULL)

 p = str;
 while (*p != '\0')
 if (*p == c)
 (*arr)[i] = (char*) malloc( sizeof(char) * token_len );
 if ((*arr)[i] == NULL)

 token_len = 0;
 (*arr)[i] = (char*) malloc( sizeof(char) * token_len );
 if ((*arr)[i] == NULL)

 i = 0;
 p = str;
 t = ((*arr)[i]);
 while (*p != '\0')
 if (*p != c && *p != '\0')
 *t = *p;
 *t = '\0';
 t = ((*arr)[i]);
 return count;

int main(void) {
 char* strToSplit ="REPLY id, login, cmd, volume, symbol, price, bid/ask, rate-id, status, message";
 int i;
 int c = 0;
 char **splittedarr = NULL;
 c = split(strToSplit, ',', ;&splittedarr)

 printf("found %d occurrence.\n", c);

 for (i = 0; i < c; i++)
 printf("string #%d:%s\n", i, splittedarr[i]);
 return 0;

found 10 occurence.
string #0:REPLY id
string #1: login
string #2: cmd
string #3: volume
string #4: symbol
string #5: price
string #6: bid/ask
string #7: rate-id
string #8: status
string #9: message

Process Synchronization (Part 1)

We can divide processes in two Categories

1) Co-operative Processes

2) Independent Processes

Co-operative processes are those where the execution of one process affects or affected by other process and if they are not dependent than they are independent processes.

In this tutorial we will study :-

1) problems

2) Conditions to achieve synchronization

3) Solutions to achieve synchronization (which will cover both wrong & right solutions)

Lets Start with Problems which we faced during implementing  Co-operative processes

Producer- Consumer Problem :

The problem describes two processes, the producer and the consumer, who share a common, fixed-size buffer used as a queue. The producer’s job is to generate a piece of data, put it into the buffer and start again. At the same time, the consumer is consuming the data (i.e., removing it from the buffer) one piece at a time. The problem is to make sure that the producer won’t try to add data into the buffer if it’s full and that the consumer won’t try to remove data from an empty buffer.

Consider the Following Program

Producer Code

Int Count =0;

Void producer(void){

int temp;





in=(in + 1)mod n ;




Consumer Code

void consumer(void){

int itemc;





out=(out+1)mod n;


process.item(item c);



can you find any error in the above programs?

when we see these programs individually than these programs works fine but if both of these programs have to work on same data , same resources than they fail to achieve synchronization  which results in inconsistency , loss of data and sometimes can cause DEADLOCK.

Now before continuing to  the next Topic lets know some important terms

Critical Section :-  The portion of program where shared resource or the shared variables is placed

Non Critical Section :- The portion of program which is independent to respective processes

Race Condition :- The condition in which the output of the process depends on execution sequence of statements

Conditions which are important to achieve Synchronization :

1) Mutual Exclusion :- No two processes may be simultaneously present inside the Critical Section at any point of time.

2) Progress :- No process running outside the critical section should block the other interested processes from entring into critical section when critical section is free.

3) Bounded waiting :- No process should have to wait forever to enter into critical section .i.e. their should  be a bound on getting chance to enter into critical section .

(note : – if any solution which is not following bounded waiting than their is a possibility of starvation.)

4) No assumption related to hardware of the process or speed should be taken .

Continued …

Creating linked list Dynamically ( Dynamic Memory Allocation) part – 1

We have seen representation of linear data structures by using sequential allocation method of storage ,as in arrays. But sometimes linear memory allocation is unacceptable in a program ,this can be due to various reason like  Unpredictable storage requirements for the program and can be due to extensive data manipulation takes .To satisfy these requirements linked list came which allocates memory dynamically  .

There is a huge difference between how data is stored in a Array and Linked list. In arrays the memory allocation is continuous . Consider the below figure which represents memory allocation through arrays.

Where as in Linked list the memory allocation is not continuous .  A linked list consists of nodes and that contains data and address of the next node in the list

Now lets write a simple program to implement linked list through structures ..



Struct node {

int data;

struct node *next ;


struct node *p;

P=(struct node *)malloc(4); /* malloc() will allocate continuous memory and than return the address of the memory location of the data where memory is allocated

(*p).data = 10;



This is how memory will be allocated to this program —– >

Now consider the following c program to display data present in every node of the given linked list :

Programe :

display(struct node *s)


if (s==null){



else {

while (s!=Null)







output of the above program will be : a b c d e f

continued …