Unit 5: Dynamic Memory Allocation

Dynamic Memory Allocation in C

Dynamic Memory Allocation (DMA) means:

Allocating memory during program execution (runtime) instead of compile-time.
Memory is taken from a special area called Heap Memory.
Used when the size of data is not known in advance.

Why do we need DMA?

For handling large data that may change (user input, arrays, strings).
Efficient memory utilization.
Flexibility in programs.

DMA Library Required

All DMA functions are available in:


#include <stdlib.h>

malloc() – Memory Allocation

malloc() allocates memory in bytes.

Syntax


ptr = (type*) malloc(size_in_bytes);

Features

Allocates continuous block of memory.
Memory contains garbage values.
Returns a void pointer, so typecasting is required.

Example


int *p;
p = (int*) malloc(5 * sizeof(int));    // memory for 5 integers

calloc() – Continuous Allocation

calloc() stands for Contiguous Allocation.

Syntax


ptr = (type*) calloc(num_of_blocks, size_of_each_block);

Features

Allocates multiple blocks, each of equal size.
Initializes memory with 0 (unlike malloc).
Memory is contiguous.

Example


int *p;
p = (int*) calloc(5, sizeof(int));  // memory for 5 integers initialized to 0

malloc vs calloc

Feature	malloc	calloc
Initialization	Garbage	Initializes to 0
Parameters	Single	Two
Speed	Faster	Slightly slower
Use case	When initialization not needed	When initialization needed

realloc() – Re-allocation

realloc() changes the size of already allocated memory.

Syntax


ptr = (type*) realloc(ptr, new_size);

Features

Used to increase or decrease memory size.
Useful when size is decided later during program.
Keeps old data intact (as much as fits in new size).

Example


p = (int*) malloc(3 * sizeof(int));
p = (int*) realloc(p, 5 * sizeof(int));  // increase size

free() – Release Memory

free() is used to deallocate memory taken by malloc, calloc, or realloc.

Syntax


free(ptr);

Features

Prevents memory leakage.
Should always be used when memory is no longer needed.

Example: free(p); // frees memory from heap

Example Program Using All DMA Functions


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

int main() {
    int *p;

    // allocate memory using malloc
    p = (int*) malloc(3 * sizeof(int));

    // reallocate memory
    p = (int*) realloc(p, 5 * sizeof(int));

    // use allocated memory
    for(int i = 0; i < 5; i++) {
        p[i] = i + 1;
        printf("%d ", p[i]);
    }

    // free memory
    free(p);

    return 0;
}

Quick Summary (For Exams)

Function	Use	Initialization	Memory From
malloc()	Allocate memory	Garbage values	Heap
calloc()	Allocate multiple blocks	0	Heap
realloc()	Change size of allocated memory	Depends on old values	Heap
free()	Release memory	—	Heap

FILE HANDLING IN C

Normally, data stored in variables disappears when program finishes.
File handling allows us to store data permanently on secondary storage (like hard disk).

Basics of File Handling

File handling means:

Creating files
Reading from files
Writing into files
Closing files

Files allow persistent storage of data beyond program execution.

File Types in C

C supports two types of files:

Type	Description
Text Files (.txt)	Human readable, characters stored using ASCII
Binary Files (.bin)	Not human readable, faster and more efficient, used for structured data

File Operations

C provides these major file operations:

Create a file
Open a file
Read from a file
Write to a file
Append data to existing file
Close a file
Update / modify
Delete a file (using remove function)

File Pointer in C

A file is controlled using a file pointer, a special pointer of type:


FILE *fp;

It stores:

Address of file information
Current position in file

All file operations use this pointer.

File Opening Modes

Mode	Meaning	File must exist?	Pointer position
`"r"`	Open for reading	Yes	Beginning
`"w"`	Open for writing (overwrite)	No	Beginning
`"a"`	Open for appending	No	End of file
`"r+"`	Read + write	Yes	Beginning
`"w+"`	Read + write (overwrite)	No	Beginning
`"a+"`	Read + write	No	End of file
`"rb"`	Read binary	Yes	Beginning
`"wb"`	Write binary	No	Beginning
`"ab"`	Append binary	No	End
`"rb+"`	Read + write binary	Yes	Beginning
`"wb+"`	Read + write binary	No	Beginning

Example:


FILE *fp;
fp = fopen("data.txt", "r");

File Handling Functions

1. fopen() – open a file


fp = fopen("file.txt", "r");

2. fclose() – close a file


fclose(fp);

3. fgetc() – read a single character


char ch = fgetc(fp);

4. fputc() – write a single character


fputc('A', fp);

5. fgets() – read a string


fgets(str, 50, fp);

6. fputs() – write a string


fputs("Hello", fp);

7. fscanf() – formatted read


fscanf(fp, "%d %s", &id, name);

8. fprintf() – formatted write


fprintf(fp, "%d %s\n", id, name);

9. fread() & fwrite() – binary file operations


fread(&emp, sizeof(emp), 1, fp);
fwrite(&emp, sizeof(emp), 1, fp);

10. fseek() – move file pointer


fseek(fp, 0, SEEK_SET);   // move to beginning

11. ftell() – position of file pointer


long int pos = ftell(fp);

12. rewind() – move pointer to beginning


rewind(fp);

File Handling Through Command Line Arguments

Command line arguments allow the program to accept file names through terminal.

Example:


program.exe input.txt output.txt

C program syntax:


int main(int argc, char *argv[]) {
    FILE *fp1, *fp2;

    fp1 = fopen(argv[1], "r");   // input file
    fp2 = fopen(argv[2], "w");   // output file

    // Copy content...
}

Meaning:

argc = number of arguments
argv = array of strings (arguments)

Record I/O in Files (Structure Files)

Used when storing records (like student details, employee details).

Writing a record (binary file)


struct student {
    int roll;
    char name[20];
    float marks;
};

struct student s;

FILE *fp = fopen("stud.dat", "wb");
fwrite(&s, sizeof(s), 1, fp);

Reading a record


FILE *fp = fopen("stud.dat", "rb");
fread(&s, sizeof(s), 1, fp);

Example: Writing & Reading a Text File

Write


FILE *fp = fopen("test.txt", "w");
fputs("Hello MCA Students", fp);
fclose(fp);

Read


FILE *fp = fopen("test.txt", "r");
char str[50];
fgets(str, 50, fp);
printf("%s", str);
fclose(fp);

SUMMARY TABLE (FOR EXAMS)

Topic	Key Points
File Pointer	`FILE *fp` used for all file operations
fopen()	Opens a file
fclose()	Closes a file
fgetc()/fputc()	Character I/O
fgets()/fputs()	String I/O
fprintf()/fscanf()	Formatted I/O
fread()/fwrite()	Binary I/O
fseek(), ftell()	Pointer movement
Command line	`argc`, `argv[]`
Record I/O	Use of structures with binary files

GRAPHICS IN C

C graphics is usually implemented using BGI (Borland Graphics Interface) in the <graphics.h> library.
It is used to draw shapes, lines, text, images and interactive GUI programs.

Introduction to Graphics

Graphics programming in C means using library functions to draw:

Lines
Circles
Rectangles
Arcs
Polygons
Pixels
Text

This is done with the help of a special library:


#include <graphics.h>

The functions convert commands into pixel-based drawing on the screen.

Graphics Initialization

Before drawing anything, graphics mode must be initialized.


int gd = DETECT, gm;
initgraph(&gd, &gm, "C:\\Turboc3\\BGI");

initgraph()

Loads graphics driver
Switches screen to graphics mode

Constants Used in Graphics

These constants are predefined in <graphics.h>.

Color Constants

Constant	Color
BLACK	0
BLUE	1
GREEN	2
RED	4
WHITE	15
YELLOW	14
CYAN	3

Line Style Constants

Constant	Meaning
SOLID_LINE	continuous line
DOTTED_LINE	dotted
DASHED_LINE	dashed
THICK_WIDTH	thick

Fill Style Constants

Constant	Pattern
SOLID_FILL	solid color
LINE_FILL	diagonal lines
HATCH_FILL	cross-hatch
XHATCH_FILL	criss-cross

Data Types and Global Variables in Graphics

Global Variables

Some graphics programs use:

Variable	Meaning
`gd`, `gm`	graphics driver and mode
`MAXCOLOR`	maximum number of colors
`graphresult()`	stores error code
`currentcolor()`	current drawing color

Important Data Types

int → for coordinates (x,y)
unsigned int → colors & patterns
char* → font names, file paths

Library Functions Used in Drawing

Below are the most important drawing functions:

1. line()

Draws a straight line.


line(x1, y1, x2, y2);

2. rectangle()


rectangle(left, top, right, bottom);

3. circle()


circle(x, y, radius);

4. arc()


arc(x, y, start_angle, end_angle, radius);

5. ellipse()


ellipse(x, y, start_angle, end_angle, x_radius, y_radius);

6. putpixel()


putpixel(x, y, color);

7. drawpoly()


drawpoly(number_of_points, array_of_coordinates);

Filling Shapes (Coloring)

1. setfillstyle()

Selects pattern & color.


setfillstyle(SOLID_FILL, RED);

2. floodfill()

Used to fill a closed shape.


floodfill(x, y, boundary_color);

3. bar()

Draws & fills rectangle.


bar(left, top, right, bottom);

4. setcolor()

Sets current color.


setcolor(YELLOW);

Drawing and Filling Example


#include <graphics.h>
#include <conio.h>

int main() {
    int gd = DETECT, gm;
    initgraph(&gd, &gm, "");

    setcolor(RED);
    rectangle(100, 100, 300, 200);

    setfillstyle(SOLID_FILL, BLUE);
    floodfill(150, 150, RED);

    getch();
    closegraph();
    return 0;
}

GUI Interaction Within the Program

Graphics allows user interaction such as:

1. Detecting Mouse Click


int x = mousex();
int y = mousey();

2. getmouseclick()


getmouseclick(WM_LBUTTONDOWN, x, y);

3. Keyboard Interaction


char ch = getch();

4. Button Design

You can draw simple GUI components:

Buttons (rectangles with text)
Input boxes
Menus
Sliders
Simple games (car racing, bouncing ball)

Example: Simple Clickable Button


rectangle(100, 100, 200, 150);
outtextxy(120, 120, "OK");

You monitor whether the mouse click occurs inside the rectangle.

SUMMARY (FOR EXAMS)

Topic	Key Points
Graphics library	`<graphics.h>`
Important functions	line, circle, arc, rectangle, putpixel, bar
Fill functions	setfillstyle, floodfill, bar
Constants	colors, line styles, fill patterns
Global variables	gd, gm
User interaction	mouse clicks, keyboard input