malloc1

Copy the following program into malloc1.c. Study the program carefully before you compile and run it. Then run the program and make sure you can see why each line of output is generated.

#include <stdio.h>
#include <stdlib.h> /* needed to use malloc and free */
main()
{
     int *p1;  /* address of 1st integer */
     int *p2;  /* address of 2nd integer */
     
     p1 = (int *) malloc(sizeof(int));      /* allocate space for 1st integer */
     printf("p1 allocated memory at address %p\n",p1);
     p2 = (int *) malloc(sizeof(int));      /* allocate space for 2nd integer */
     printf("p2 allocated memory at address %p\n",p2);
     printf("1st no? ");
     scanf(" %i",p1);                 /* store input as 'value at address p1' */
     printf("2nd no? ");
     scanf(" %i",p2);                 /* store input as 'value at address p2' */
     printf("sum of %d and %d is %d\n",*p1,*p2,*p1+*p2);

     /* print 'value at address p1', 'value at address p2' and
      * 'value at address p1' plus 'value at address p2'
      */
     free(p1);                        /* free up dynamic memory at address p1 */
     free(p2);                        /* free up dynamic memory at address p1 */
}

Look closely at the scanf statements. Why is it correct to write p1 and not &p1 (and similar argument for p2)?

sumInts

Copy the following program into sumInts.c. The program calculates the sum of a set of integers, where the number of integers is not known in advance, and demonstrates that the data at the address pointed to by p can be treated as an array of integers - notice the use of index p[i].

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

main()
{
     int *p;
     int howMany;
     int i, sum=0;
     
     printf("how many numbers? "); 
     scanf(" %i", &howMany);
     p = (int *) malloc(howMany*sizeof(int));
     if (p == 0)
     {
        printf("no memory allocated\n"); return -1;
     }
     for (i=0;i<howMany;i++)
     {
           printf("number %d ",i);
           scanf(" %i", &p[i]);
     }
     for (i=0;i<howMany;i++)
     {
           sum=sum+p[i];
     }     
     printf("average of the %d numbers is %d\n",howMany,sum/howMany);
     free(p);
}

malloc2

Write a program malloc2.c that

• asks the user how many numbers they want to enter;
• mallocs enough space to store these numbers;
• uses a loop to read in these numbers and store them;
• prints out the numbers and the address at which they are stored;
• releases the memory allocated.

malloc3

Write a program malloc3.c that

• asks the user to specify how many letters (chars) they want to enter
• dynamically allocates just enough memory for these;
• uses a while loop to read that many characters from the keyboard and store them;
• prints the characters entered by the user in the reverse order to which they were entered;
• frees up the memory allocated.

copy4Strings

Copy the following program into copy4Strings.c. The program reads in four strings from the user, copies each string into a memory allocation just big enough to hold it and the prints all of the strings entered. Complete the program so that it does this.

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

int strlength(char * s)
{
     int max = 0;
     while (s[max] != '\0')
     {
          max++;
     }
     return max;
}

int strcopy(char * s, char * t)
{
     int i=0;
     while (s[i] != '\0')
     {
          t[i]=s[i];
          i++;
     }
     t[i]='\0';
}

main()
{
     char string[256];  /* to store the input from user */
     char *p[4];       /* space for 4 string addresses */
     int i;
     int length;
     
     for (i=0; i < 4 ; i++)
     {
          printf("string? ");
          scanf("%[^\n]", string);
          
          /* calculate length of the input string
          *  length = 
          */
          
          /* allocate memory to hold a string of this length
          *      (remembering space for the null at the end)
          *  p[i] = 
          */
          
          /* copy the input string to this newly allocated
          *  address
          */
     }
     for (i=0; i < 4 ; i++)
     {
         /* print the ith copy                              */
         printf("%d: %s\n",i,p[i]);
         /* free the space for the ith copy                 */
     }
 }

words

1. • Create a program words.c that defines a function called words with the following function header:

            int words(char * str, char ** wds, int max);
            

     The function copies each word from the input string (str) into the array of words (wds) provided up to a maximum of max words. Thus the first word would be stored in wds[0], and so on. You will need to allocate sufficient memory to store each word as you go along. The function returns the number of words stored.
   • Define a main program that will test the words function is working properly.
   • A variation on this problem requires the words function to count the number of words initially and then allocate an array of words that is just the right length for the number of words.

            int words(char * str, char *** wds);
            

     Once again, the function returns the number of words stored. Modify your program to incorporate this new version of the words function and test it.

malloc4

Create a program malloc4.c that

• defines a struct type called idType which contains an int field called number and a char *     field called name;
• declares a variable of this type
• gets a value for the number field from the user;
• gets a length for the name field from the user;
• allocates space for this name dynamically and stores the address in the name field;
• gets the name string from the user and stores it;
• prints the name and number;
• frees the memory allocated.

intstack

Copy the following code into a header definition file called intstack.h

#ifndef INTSTACK
#define INTSTACK

typedef struct node { int           item;
                      struct node * next;
                    } Node;
typedef struct      { Node * top;
                      int   size;
                    } Stack;

void initialise(Stack * s);
int  isEmptyStack(Stack * s);
int  push(Stack * s, int x);
int  pop(Stack * s, int * x);
void printStack(Stack * s);

#endif

Copy the following code into a file called intStack.c.

#include <stdio.h>
#include <stdlib.h>
#include "intstack.h"

void initialise(Stack * s)
{
    s->top = NULL;
    s->size = 0;
}

int isEmptyStack(Stack * s)
{
    return s->top == NULL;
}

int push(Stack * s, int x)
{
    Node * np;
    np = malloc(sizeof(Node));
    if (np == NULL)
        return 0;
    np->item = x;
    np->next = s->top;
    s->top   = np;
    (s->size)++;
    return 1;
}

int pop(Stack * s, int * x)
{
    Node * np;
    if (isEmptyStack(s))
       return 0;
    else
    { 
         np     = s->top;
         *x     = s->top->item;
         s->top = s->top->next;
         free(np);
         (s->size)--;
         return 1;
    }
}

void printStack(Stack * s)
{
    Node * tmp;
    
    tmp = s->top;
    while (tmp != NULL)
    {
        printf("%d\n",tmp->item);
        tmp = tmp->next;
    }       
}

Compile intstack.c to produce an object file intstack.o

gcc -c intstack.c

Using the operations declared in intstack.c, write a program called stack1.c which reads in characters one by one until a dot is entered and then prints them out in reverse order. Remember that you will need to

#include "intstack.h"

Produce an executable progam:

gcc intstack.o stack1.c -o stack1

queue1

Copy the following code into a header definition file called intQueue.h

#ifndef _INT_QUEUE
#define _INT_QUEUE

typedef struct node { int           item;
                      struct node * next;
                    } Node;

typedef struct      { Node * front;
                      Node * back;
                      int   size;
                    } Queue;

void initialiseQueue(Queue * q);
int  isEmptyQueue(Queue * q);
void join(Queue * q, int x);
void leave(Queue * q, int * x);
int  length(Queue * q);
void printQueue(Queue * q);

#endif

Copy the following code into a file called intQueue.c.

#include <stdio.h>
#include <stdlib.h>
#include "intQueue.h"

void initialiseQueue(Queue * q)
{
    q->front = NULL;
    q->back  = NULL;
    q->size = 0;
}

int isEmptyQueue(Queue * q)
{
    return q->front == NULL;
}

void join(Queue * q, int x)
{
    Node * np;
    np = malloc(sizeof(Node));
    np->item = x;
    np->next = NULL;    /* ie at back of the queue */
    if (isEmptyQueue(q))
       { q->front = np; }
    else
       { q->back->next = np; }
    q->back = np;
    (q->size)++;
}

void leave(Queue * q, int * x)
{
    Node * np;
    if (isEmptyQueue(q))
       { printf("Remove error: empty queue\n");
         exit(1);
       }
    else
       { *x = q->front->item;
         np = q->front;
         q->front = q->front->next;
         free(np);
         (q->size)--;
       }
}

int length(Queue * q)
{
    return q->size;
}

void printQueue(Queue * q)
{
    Node * np = q->front;
    printf("< ");
    while (np != NULL)
    {
       printf("%d ",np->item);
       np = np->next;
    }
    printf("<");
}

Using the operations declared in intQueue.c, write a program called queue1.c that

1. reads in numbers one by one until -1 is entered and joins them onto a queue;
2. prints out all the entries in the current queue after each number is entered;
3. empties the queue after -1 has been entered.

Compile queue1.c with intQueue.o to produce an executable program.

gcc queue1.c intQueue.o -o queue1