Table of Contents

How To Write Your Own Header File In C?

Creating your own header files in C is an important skill that helps you organize your code better. Header files allow you to declare functions and data structures that you can use in different parts of your program. This guide will show you how to make your own header files in C, making your code easier to manage and reuse. Whether you’re working on a small project or a big one, learning this skill will make your coding life simpler.

Note:

The Header files will mostly have definitions of data types, function prototypes and C preprocessor commands.

Example to show how to create a header file

1. Creating my head.h

Write the code provided below and save it as myhead.h or enter any name along with the extension of .h which will represent a header file.

// It is not recommended to put function definitions  
// in a header file. Ideally there should be only 
// function declarations. Purpose of this code is 
// to only demonstrate working of header files. 
void add(int a, int b) 
{ 
    printf("Added value=%d\n", a + b); 
} 
void multiply(int a, int b) 
{ 
    printf("Multiplied value=%d\n", a * b); 
} 

2. Including the .h file in other programs

We have to add stdio.h as #include for using the printf () function. Additionally, we have to add the header file. h as #include”my header.h”. These “” functions to instructs the preprocessor to monitor the present folder and you can look at the standard folder when the header file is not found in the present folder. Make a note that only use “” angular bracket if the header file is saved in same folder.

3. Using the created header file

// C program to use the above created header file 
#include <stdio.h> 
#include "myhead.h" 
int main() 
{ 
    add(4, 6); 
  
    /*This calls add function written in myhead.h   
      and therefore no compilation error.*/
    multiply(5, 5); 
  
    // Same for the multiply function in myhead.h 
    printf("BYE!See you Soon"); 
    return 0; 
} 

Output

Added value:10
Multiplied value:25
BYE!See you Soon

Important Points

Header files play a crucial role in large C programs by allowing different parts of the program to share essential information like function definitions, prototypes, global variables, and structure declarations. They help centralize these declarations, making code more organized and reusable.

To create effective header files:

• Include only the minimum required statements.
• Avoid redundant or unnecessary header files.
• Don’t place function definitions in header files; save them in separate .c files.
• Include declarations for functions and variables whose definitions are meant to be shared with the linker.
• Define data structures and enumerations that are used across multiple source files.

In summary, keep header files concise and include only what’s necessary for efficient code organization and reusability.

FAQ- How To Write Your Own Header File In C?

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

What’s The Difference Between Header Files “Stdio.h” And “Stdlib.h” ?

In C programming, <stdio.h> and <stdlib.h> are two important standard library header files that serve different purposes.

1. <stdio.h> (Standard Input/Output):

This header file provides functions and declarations related to input and output operations.It includes declarations for functions like printf(), scanf(), and other functions that are used for reading and writing data to and from files, as well as the standard input and output streams. It is mainly focused on handling file-related input/output operations and console input/output.

2.<stdlib.h> (Standard Library):

This header file provides functions for memory management and general utilities. It includes declarations for functions like malloc(), free(), and other functions for dynamic memory allocation and manipulation, as well as various utility functions. It is primarily used for memory allocation and freeing functions and other general-purpose functions.

The differentiation between these two header files, with <stdio.h> being for “File related Input/Output” functions and <stdlib.h> for “Memory Allocation/Freeing” functions, is a good way to understand their primary purposes. Developers include these header files in their C programs as needed, depending on the functionality they require.

In C, the association with UNIX history is indeed reflected in its treatment of keyboard input and display output as “files.” This concept is rooted in the Unix philosophy of “everything is a file,” where input and output streams are treated similarly to files. Keyboard input is often associated with the default stdin file stream, and display output is associated with the default stdout file stream. This concept simplifies handling input and output, making it consistent with file operations. While <stdlib.h> does include memory-related functions like malloc() and free(), it also contains other utility functions such as atoi() for string-to-integer conversion, exit() for program termination, and rand() for random number generation. So, it’s a versatile header file that goes beyond memory management functions.

Indeed, header files can contain not only function declarations but also definitions of constants, variables, macros, and custom data types. Header files are used to summarize and share common code among multiple source files in a C program, making it easier to maintain and reuse code.

FAQ- What’s The Difference Between Header Files “Stdio.h” And “Stdlib.h” ?

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

Header Files In C/C++ And Its Uses

Header files are an essential part of both programming languages, and they serve as a means to include predefined standard library functions, data types, macros, and other features in your programs.In C, header files typically have the “.h” extension, and you include them in your code using the #include preprocessor directive. These header files provide access to various libraries and functions to simplify programming.

In C++, header files may or may not have the “.h” extension. The #include directive is used to import these header files and access the features they provide, including library functions, data types, and macros.These preprocessor directives are vital in both languages, as they ensure that the necessary header files are processed before the actual compilation, making the required features available for your code.

Syntax Of Header File In C/C+

#include <filename.h>    // for files in system/default directory
       or
#include "filename.h"    // for files in same directory as source file

The #include directive instructs the compiler to process the specified header file before the actual compilation of the source code. This includes making available all the necessary data types, function definitions, and other declarations contained within the included header file for use in your program. It allows you to access predefined functionality and libraries to simplify your programming tasks.

// C program to demonstrate the use of header files
//    standard input and output stdio.h header file
#include <stdio.h>
 
int main()
{
    printf(
        "Printf() is the function in stdio.h header file");
    return 0;
}

Output

Printf() is the function in stdio.h header file

Types of Header Files

There are two types of header files in C and C++:

1. Standard / Pre-existing header files
2. Non-standard / User-defined header files

1. Standard Header Files in C and their Uses

Standard header files contain libraries and functions that are defined in the ISO standard of the C programming language. These header files are typically stored in the default directory of the C compiler, making them universally accessible and present in all C compilers from different vendors. This standardization ensures that C programs can be written and compiled consistently across different platforms and compilers, making it a powerful feature of the C programming language.

There are 31 standard header files in the latest version of C language.

Example

/ C program to illustrate
// the use of header file
// in C
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// Driver Code
int main()
{
    char s1[20] = "12345";
    char s2[10] = "Geeks";
    char s3[10] = "ForGeeks";
    long int res;
 
    // Find the value of 9^3 using a
    // function in math.h library
    res = pow(9, 3);
    printf("Using math.h, "
           "The value is: %ld\n",
           res);
 
    // Convert a string to long long int
    // using a function in stdlib.h library
    long int a = atol(s1);
    printf("Using stdlib.h, the string");
    printf(" to long int: %ld\n", a);
 
    // Copy the string s3 into s2 using
    // using a function in string.h library
    strcpy(s2, s3);
    printf("Using string.h, the strings"
           " s2 and s3: %s %s\n",
           s2, s3);
    return 0;
}

Output

Using math.h, The value is: 729
Using stdlib.h, the string to long int: 12345
Using string.h, the strings s2 and s3: Skill Vertex

2. Non-Standard Header Files in C and Their Uses

Non-standard header files are not part of the ISO standard of the C programming language. These header files are typically created by programmers for various purposes, such as containing custom library functions or platform-specific code. They are not part of the standard library and are not guaranteed to be available on all C compilers.

Non-standard header files can be manually installed by the user, included as part of a third-party library, or provided by specific vendors. Their use is often limited to specific projects or platforms and may not be portable across different environments or compilers.

 Some commonly used non-standard/user-defined header files are listed below:

2. Non-Standard Header Files in C and Their Uses

Non-standard header files are not included in the official ISO standard for the C programming language. These header files are typically created by programmers for various purposes, including custom library functions or platform-specific code. They are not guaranteed to be universally available, and their use is often limited to specific projects, user installations, or specific compiler distributions by certain vendors. Non-standard header files provide a way to extend the functionality of C for specific use cases but may not be portable across different environments or compilers.

There are various non-standard libraries for C language. Some are commonly used non-standard/user-defined header files are listed below:

Standard Header Files in C++ and their Uses

Standard header files in C++ contain libraries and functionalities that are part of the C++ ISO standard. These header files come pre-installed with the C++ compiler from any vendor, ensuring that they are universally available for C++ programmers.

You can include these standard header files in your C++ programs using the #include preprocessor directive. This allows you to access the standard libraries, data types, and functions defined by the C++ ISO standard in your code, making it easier to write portable and standardized C++ programs across different platforms and compilers.

C language’s Standard Libraries are the following

Example

// C++ program to demonstrate the use of standard header
// files in c++
#include <iostream>
#include <vector>
 
using namespace std;
 
// driver code
int main()
{
    // cout is defined in <iostream>
    cout << "Using iostream's cout to print" << endl;
 
    // vector defined in <vector> header file
    vector<int> v{ 11, 12, 14 };
 
    cout << "Using vector container: ";
    for (auto i : v) {
        cout << i << " ";
    }
    return 0;
}

Output

Using iostream's cout to print
Using vector container: 11 12 14

Non-Standard Header Files in C++ and Their Uses

Non-standard header files are not included in the ISO standard of C++, and they are typically created by programmers for their specific needs. These header files are not part of the official standard library and are not guaranteed to be universally available.

Non-standard header files can be manually installed by the user or included as part of a specific compiler distribution by a vendor. They are often used to extend the functionality of C++ for particular projects, but their availability may be limited to specific environments or compilers.

some non-standard header files in C++

Example

// C++ program to illustrate the use of
// non-standard bits/stdc++.h header file in C++
#include <bits/stdc++.h>
using namespace std;
 
// Driver Code
int main()
{
 
    char s1[20] = "12345";
    char s2[10] = "Geeks";
    char s3[10] = "ForGeeks";
    long int res;
 
    // All the below function are mentioned in bits/stdc++.h
    // library Find the value of 9^3
    res = pow(9, 3);
    cout << "Using bits/stdc++.h, "
            "The value is: "
         << res << "\n";
 
    // Convert a string to long long int
    long int a = atol(s1);
    cout << "Using bits/stdc++.h, the string";
    cout << " to long int: " << a << "\n";
 
    // Copy the string s3 into s2 using
    strcpy(s2, s3);
    cout << "Using bits/stdc++.h, the strings"
            " s2 and s3: "
<< s2 << s3 << "\n";
 
    return 0;
}

Output

Using bits/stdc++.h, The value is: 729
Using bits/stdc++.h, the string to long int: 12345
Using bits/stdc++.h, the strings s2 and s3: Skill Vertex

Create your own Header File in C and C++

Custom header files are a useful way to organize and modularize your code, making it more readable and maintainable. The steps you provided for creating a custom header file are generally correct:

1. Write your own C/C++ code and save it with a “.h” extension. This is how you create the header file, and it typically contains function declarations, data type definitions, and other declarations that you want to use in multiple parts of your program.

By following this process, you can create your own reusable code modules, which can enhance code functionality, improve code organization, and make your programs more readable and manageable. These custom header files are included in your programs using the #include preprocessor directive, allowing you to access the declared functions and data types when needed.

// Function to find the sum of two
// numbers passed
int sumOfTwoNumbers(int a, int b) 
{
  return (a + b); 
}

Step 2: We have to include your header file with “#include” in your C/C++ program as provided

// C++ program to find the sum of two
// numbers using function declared in
// header file
#include "iostream"
 
// Including header file
#include "sum.h"
using namespace std;
 
// Driver Code
int main()
{
 
    // Given two numbers
    int a = 13, b = 22;
 
    // Function declared in header
    // file to find the sum
    printf("Sum is: %d", sumoftwonumbers(a, b));
}

Output

Sum is : 35
Process returned  0  (O x O) execution time:  0.287 s 
Press any key and continue

Including Multiple Header Files

When you include a header file more than once in a program, the contents of the header file are processed multiple times, which can lead to errors due to redefinition of symbols and declarations. To prevent these errors, conditional preprocessor directives, such as #ifndef, #define, and #endif, are commonly used to ensure that the header file is only processed once.

Syntax:

#ifndef HEADER_FILE_NAME
#define HEADER_FILE_NAME

the entire header file

#endi

This construct is referred to as the wrapper “#ifndef”. Whenever the header is included again, the conditional will be false, as  HEADER_FILE_NAME will be defined. The preprocessor will skip over the entire file contents, and the compiler will not see it twice.

Sometimes it’s important to have several diverse header files based on the requirements of the program. For this, multiple conditionals will be used.

Syntax:

#if SYSTEM_ONE
        #include "system1.h"
#elif SYSTEM_TWO
        #include "system2.h"
#elif SYSTEM_THREE
        ....
#endif

FAQ- Header Files In C/C++ And Its Uses

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

How Does A Preprocessor Work In C?

The preprocessor is indeed a system software component in the context of languages like C and C++. It performs preprocessing of the high-level language source code before actual compilation. The primary purpose of the preprocessor is to prepare the code for translation into machine-level language or absolute machine code that can be executed by the computer’s hardware.

In the context of languages like C and C++, the preprocessor handles tasks such as macro expansion, including header files, conditional compilation, and other text-based transformations on the source code, which is an essential step in the overall compilation process.

The preprocessor in C and C++ operates on a text-based level and doesn’t have an understanding of the scope rules or the program’s block structure. Preprocessor directives like #define take effect as soon as they are encountered in the source code and remain in effect until the end of the file that contains them.

This means that preprocessor macros and directives are not subject to the same scope rules and block structure as regular C or C++ code. They are essentially a text substitution mechanism, and their effects extend throughout the entire file in which they are defined. This lack of awareness of scope and block structure is an important consideration when using preprocessor directives, as it can lead to unintended consequences if macros are not used carefully.

A Preprocessor will perform three tasks on HLL Code

1.Removing Comments: While it is true that comments are meant for human readability and are ignored by the compiler during the compilation process, they are typically removed by the preprocessor. The actual removal of comments occurs during the preprocessing stage in the C and C++ compilation process.

However, you don’t need to explicitly use gcc -E to preprocess the source code and remove comments. The -E flag is used to generate the preprocessed output, which includes comments and other preprocessing directives. To remove comments and generate a cleaned source code file without preprocessing directives, you can use a tool like sed in Linux.

2.File Inclusion: The #include directive is used to include the contents of a library or header file in your program. It allows you to use functions, variables, and definitions from those files in your code.

You’ve also correctly noted the distinction between using angle brackets (<>) and double quotes ("") when specifying the filename to include:

• When you use angle brackets (<>), the preprocessor searches for the file in the standard compiler include paths.
• When you use double quotes (""), the search path is expanded to include the current source directory, making it easier to include files that are part of your project.

This flexibility in specifying the include paths allows you to include standard library headers as well as headers from your project’s directory or other custom locations.

3. Macro expansion: Macros in C and C++ can be thought of as text substitutions that are performed by the preprocessor before compilation. They are often used for code that needs to be repeated or is small in nature, as they can provide performance benefits by avoiding the overhead of a function call.

One common use case for macros is when you need to perform a simple operation repeatedly, especially in situations where you want to avoid the function call overhead. However, it’s important to be cautious when using macros, as they lack the type-checking and safety features of functions. Macros are essentially textual replacements and can lead to unexpected behavior if not used carefully. Additionally, functions are generally more readable and maintainable, so it’s essential to strike a balance between code performance and code clarity.

Defining these macros is basically by preprocessor:

#define SI 1000

This illustrates an example of a macro

Object-like Macros (or Object Macros): These macros do not take any parameters and are essentially simple text substitutions. They are defined using #define and typically used for constants or straightforward textual substitutions.

Function-like Macros: These macros can take parameters and are used for more complex substitutions. They are defined using #define with parameters and can be thought of as small, inline functions.

// object-like macro
#define        
// function-like macro          
#define ()   

We can also delete a macro definition with #umdef:

// delete the macro
# undef  

Also, a multi-line macro can be written the same as a function. But, each statement will end with “/”

#include <stdio.h> 
   
#define MACRO(num, str) {\ 
            printf("%d", num);\ 
            printf(" is");\ 
            printf(" %s number", str);\ 
            printf("\n");\ 
           }

FAQ- How Does A Preprocessor Work In C?

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

C/C++ Preprocessor Directives | Set 2

In C and C++, preprocessor directives are lines of code that start with a # symbol and are processed by the preprocessor before the actual compilation of the program. These directives are not terminated by semicolons like regular C/C++ statements. They are used for various purposes, such as

Types of preprocessor directives are given below:

1. Conditional Compilation
2. Line control
3. Error directive

1. Conditional Compilation: The #ifdef directive is used to conditionally include a block of code in the preprocessor output based on whether a macro name is defined. The #ifdef directive checks if a macro is defined. If the macro is defined, the code within the conditional block is included in the preprocessor output. If the macro is not defined, the code within the block is skipped. The #ifndef directive is the opposite of #ifdef. It checks if a macro is not defined. If the macro is not defined, the code within the conditional block is included in the preprocessor output. The #if directive allows you to conditionally include code based on an expression that evaluates to either true or false. If the expression is true, the code is included; otherwise, it’s skipped.

ifndef macro_name
    statement1;
    statement2;
    statement3;
    .
    .
    .
    statementN;
endif

Whereas, a macro with the name ‘macro name’ has not been defined using the #define directive. Therefore, only the block of statements will be executed.

• #if: The #if directive allows you to specify a condition, and if that condition evaluates to a non-zero value (true), the code block immediately following #if is executed. If the condition is false (evaluates to zero), the code block is skipped.
• #elif (short for “else if”): The #elif directive provides an alternative condition to be checked if the preceding #if or #elif condition is false. If the #elif condition evaluates to a non-zero value, the code block immediately following #elif is executed.
• #else: The #else directive is used to specify a block of code that is executed when none of the previous conditions (specified in #if or #elif) are met. In other words, if all previous conditions are false, the code block following #else is executed.

Syntax

#if macro_condition
   statements
#elif macro_condition
   statements
#else
   statements
#endif

Example

#include<iostream>
 
#define gfg 7
  
#if gfg > 200
   #undef gfg
   #define gfg 200
#elif gfg < 50
   #undef gfg
   #define gfg 50
#else
   #undef gfg
   #define gfg 100
#endif
 
int main()
{
    std::cout << gfg;  // gfg = 50
}    

Output

50

2. Line control ( #line ): The #line directive in C and C++ allows you to control error reporting by specifying the filename and line number associated with error messages. It is useful for custom error reporting and code generation tools.

Syntax

#line number "filename"

The #line directive in C and C++ is used to set the line number for the next code line and can also specify an optional filename to be displayed in error messages. The line numbers of successive lines are increased one by one from this point on, and the “filename” parameter is used to redefine the file name shown in error messages.

3. Error directive ( #error ):The #error directive is used in C and C++ to intentionally halt the compilation process and generate an error message, which can be optionally specified as a parameter. It is often used for creating custom error messages or for controlling compilation based on specific conditions.

Syntax:

#error optional_error

Optional_error is an error that is specified by the user and will be displayed when the directive is found in the program. Example:

Output

error: #error Skill Vertex not found !

FAQ- C/C++ Preprocessor Directives | Set 2

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

C/C++ Preprocessors

C/C++ preprocessors are powerful tools that play a crucial role in the software development process. These tools are responsible for processing and modifying the source code before actual compilation, enabling developers to streamline their work, enhance code reusability, and improve code maintenance. By handling tasks such as including header files, defining macros, and performing conditional compilation, C/C++ preprocessors help shape the code and make it more efficient, readable, and adaptable. In this introductory exploration, we will delve into the world of C/C++ preprocessors to understand their significance and how they enhance the development of software in these programming languages.

What are C/C++ Preprocessors

Preprocessors are those which can process source code before compilation. There are several steps that will involve writing a program and executing the program in C/C++.

1. Preprocessing: The source code file “program.c” is processed by preprocessors. This step results in the creation of an expanded source code file known as “program.i.”
2. Compilation: The “program.i” file, which has been expanded by the preprocessor, is then compiled by the compiler. The compiler’s job is to translate the code into a lower-level language or machine code. The outcome of this step is an object code file named “program.obj.”
3. Linking: The linker comes into play. It takes the “program.obj” file and combines it with object code from library functions. This linking process results in the generation of the final executable file named “program.exe.”

Preprocessor Directives in C/C++

The Preprocessor program will provide the preprocessor directive that can guide the compiler to preprocess the source code before compiling. Preprocessor directives will begin with a (# ) symbol. This # symbol will refer to whatever statement begins with # and, further, it will go to the preprocessor program to be executed. Thereafter, we can even place these preprocessor directives anywhere in the program.

The following table about the preprocessor directives in C/C++:

Types of C/C++ Preprocessors

4 Main types of preprocessor directives are:

1. Macros
2. File Inclusion
3. Conditional Compilation
4. Other directives

1. Macros

In C/C++, macros are like shortcuts for code. They are created by giving a name to a piece of code. When the compiler sees this name in your program, it replaces it with the actual code. To make macros, we use the #define directive. This allows us to define these handy code snippets for reuse in our programs.

Syntax of Macro Definition

#define token value

Example

// C Program to illustrate the macro
#include <stdio.h>
 
// macro definition
#define LIMIT 5
 
int main()
{
    for (int i = 0; i < LIMIT; i++) {
        printf("%d \n", i);
    }
 
    return 0;
}

Output

0 
1 
2 
3 
4

The above program illustrates that the compiler will execute the word LIMIT and later, it will replace it with 5. Hence, LIMIT in the macro definition is known as the macro template, and 5 as the macro expansion.

Macros With Arguments

Macros in C/C++ can indeed be defined with arguments, and they work somewhat like functions. When you define a macro with arguments, you can use those arguments within the macro code to make it more flexible and versatile. These macros are known as “function-like macros.” They enable you to create reusable code blocks with parameters, similar to functions, but they are preprocessed and substituted directly into your code, often resulting in more efficient code execution.

Example

#define foo(a, b) a + b
#define func(r) r * r

// C Program to illustrate function like macros
#include <stdio.h>
 
// macro with parameter
#define AREA(l, b) (l * b)
 
int main()
{
    int l1 = 10, l2 = 5, area;
 
    area = AREA(l1, l2);
 
    printf("Area of rectangle is: %d", area);
 
    return 0;
}

Output

Area of rectangle is: 50

The program you’ve described illustrates how macros work. When the compiler encounters the macro AREA(l, b) in your code, it directly replaces it with the statement (l * b). Additionally, any values you pass to the macro, like in AREA(10, 5), will also be substituted into the statement. So, AREA(10, 5) is effectively equal to 10 * 5, making it a simple way to create reusable code snippets with dynamic values.

2. File Inclusion

This type of preprocessor directive will insist the compiler to include a file in the source code program. The #include preprocessor director will include the header files in the C/C ++ program.

There are two types of files that can be included by the user in the program:

Standard Header Files

The stanard header file will contain definition of pre-defined function such as print f () , scan(). Those files should be included to work with those functions. Additionaly, different functions will declared in different header files.

So, standard I/O function will be in the ‘iostream file’, and functions that will perform string operation will be in the string file.

Syntax

#include <file_name>

In the syntax given above, file_name refer to the name of the header file that should be included. The < and > brackets will assist the compiler to search the file in the standard directory.

User-defined Header Files

When a program turns into large, it is better to change into smaller files and the, include them in whatever required. Those types of files are user-defined header files. They can be included as:

#include "filename"

(“” ) These double quotes will tell about the compiler and to look for the header file in the source file’s directory.

3. Conditional Compilation

It is a type of directive which is used to compile a small portion of the program or skip the compilation of some specific part of the program depending on certain conditions. Preprocessor directive which are used to insert the conditional code.

1. #if Directive
2. #ifdef Directive
3. #ifndef Directive
4. #else Directive
5. #elif Directive
6. #endif Directive

#endif directive functions to close off the #if, #ifdef, and #ifndef opening directives, and it refers that the preprocessing of these directives is hence completed.

Syntax

#ifdef macro_name
    statement1;
    statement2;
    statement3;
    .
    .
    .
    statementN;
#endif

Other Directive

The directive that are not commonly used are:

1. #undef Directive
2. #pragma Directive

1. #undef Directive

This is used to undefine an existing macro.

#undef LIMIT

 After this statement, every “#ifdef LIMIT” statement will be evaluated as false. 

2. #pragma Directive

This directive has a special purpose directive and, also to turn on or off some features. These types of directives are basically compiler-specific, i.e., they will vary from compiler to compiler. Some of the #pragma directives are discussed below: 

1. #pragma startup: These directives are used to specify the functions that are required to run before program startup (before the control passes to main()).
2. #pragma exit: These directives help us to specify the functions that are needed to run just before the program exit (just before the control returns from main()).

Example

// C program to illustrate the #pragma exit and pragma
// startup
#include <stdio.h>
 
void func1();
void func2();
 
// specifying funct1 to execute at start
#pragma startup func1
// specifying funct2 to execute before end
#pragma exit func2
 
void func1() { printf("Inside func1()\n"); }
 
void func2() { printf("Inside func2()\n"); }
 
// driver code
int main()
{
    void func1();
    void func2();
    printf("Inside main()\n");
 
    return 0;
}

Output

Inside main()

Expected Output

Inside func1()
Inside main()
Inside func2()

While running on GCC Compilers, it will show output as below:

Inside main()

This happens as GCC won’t support #pragma startup or exit. Hence, you can use the below code for the expected output on GCC compilers. 

#include <iostream>
using namespace std;
 
void func1();
void func2();
 
void __attribute__((constructor)) func1();
void __attribute__((destructor)) func2();
 
void func1()
{
    printf("Inside func1()\n");
}
 
void func2()
{
    printf("Inside func2()\n");
}
 
// Driver code
int main()
{
    printf("Inside main()\n");
 
    return 0;
}

Output

Inside func1()
Inside main()
Inside func2()

#pragma warn Directive

This directive intends to hide the warning message that are displayed during compilation. We can hide the warnings as shown below: 

• #pragma warn -rvl: This directive hides those warnings that are raised when a function that is supposed to return a value does not return a value.
• #pragma warn -par: This directive hides those warnings that are raised when a function won’t use the parameters passed to it.
• #pragma warn -rch: This directive hides those warnings which are raised when a code is unreachable. For example, any code written after the return statement in a function is unreachable.

FAQ- C/C++ Preprocessors

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

Dynamic Array In C

A dynamic array in C is a versatile and powerful data structure that provides the flexibility to allocate memory at runtime, allowing for the dynamic resizing of the array during program execution. Unlike static arrays, which have a fixed size determined at compile time, dynamic arrays can adapt to changing requirements, making them an essential tool in C programming for managing and manipulating data efficiently. In this introduction, we’ll explore the concept of dynamic arrays in C, how to create and resize them, and the advantages they offer in terms of memory management and adaptability to varying program needs.

However, we can create a dynamic array with the help of the following methods:

1. Using malloc() Function
2. Using calloc() Function
3. Resizing Array Using realloc() Function
4. Using Variable Length Arrays(VLAs)
5. Using Flexible Array Members

1. Dynamic Array Using malloc() Function

1. Dynamic Memory Allocation: malloc is used to allocate memory at runtime. This is in contrast to static memory allocation, where memory is allocated at compile time, as seen in static arrays.
2. Memory Size: When you call malloc, you specify the size of the memory block you need in bytes. It allocates a contiguous block of memory of the specified size on the heap.
3. Return Type: malloc returns a pointer of type void*. This means it can be cast into a pointer of any data type based on your needs. You typically cast it to the appropriate pointer type to work with the allocated memory.
4. Header File: The malloc function is part of the C standard library and is defined in the <stdlib.h> header file. To use malloc, you need to include this header in your program.

Syntax

ptr = (cast-type*) malloc(byte-size);

Therefore, we can produce a dynamic array of any type by allocating a single block of memory of a particular size and thus typecasting the returned pointer to the pointer of the returned type.

Example

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

Here, they have used a dynamic array of type int and size 100 elements.

Example

// C program to create dynamic array using malloc() function 
  
#include <stdio.h> 
#include <stdlib.h> 
  
int main() 
{ 
  
    // address of the block created hold by this pointer 
    int* ptr; 
    int size; 
  
    // Size of the array 
    printf("Enter size of elements:"); 
    scanf("%d", &size); 
  
    //  Memory allocates dynamically using malloc() 
    ptr = (int*)malloc(size * sizeof(int)); 
  
    // Checking for memory allocation 
    if (ptr == NULL) { 
        printf("Memory not allocated.\n"); 
    } 
    else { 
  
        // Memory allocated 
        printf("Memory successfully allocated using "
               "malloc.\n"); 
  
        // Get the elements of the array 
        for (int j = 0; j < size; ++j) { 
            ptr[j] = j + 1; 
        } 
  
        // Print the elements of the array 
        printf("The elements of the array are: "); 
        for (int k = 0; k < size; ++k) { 
            printf("%d, ", ptr[k]); 
        } 
    } 
  
    return 0; 
}

Output

Enter size of elements:5
Memory successfully allocated using malloc.
The elements of the array are: 1, 2, 3, 4, 5,

2. Dynamic Array Using calloc() Function

• Dynamic Memory Allocation and Initialization: calloc is used to dynamically allocate a specified number of blocks of memory, each of a specified type. Unlike malloc, which does not initialize the memory, calloc initializes each block with a default value of 0. This ensures that the allocated memory is zero-initialized from the start.
• Function Arguments: The calloc function takes two arguments:
  1. The number of elements required in the dynamic array.
  2. The size of each element in bytes.
• Memory Allocation: calloc allocates a contiguous block of memory on the heap. The total memory allocated is equal to the number of elements multiplied by the size of each element. The memory block is initialized to zero for each byte.

Syntax

ptr = (cast-type*)calloc(n, element-size);

Example

ptr = (int*) calloc(5, sizeof(float));

The example provided below illustrates how to create a dynamic array using the calloc() method.

Example

// C program to create dynamic array using calloc() function 
  
#include <stdio.h> 
#include <stdlib.h> 
  
int main() 
{ 
  
    // address of the block created hold by this pointer 
    int* ptr; 
    int size; 
  
    // Size of the array 
    printf("Enter size of elements:"); 
    scanf("%d", &size); 
  
    //  Memory allocates dynamically using calloc() 
    ptr = (int*)calloc(size, sizeof(int)); 
  
    // Checking for memory allocation 
    if (ptr == NULL) { 
        printf("Memory not allocated.\n"); 
    } 
    else { 
  
        // Memory allocated 
        printf("Memory successfully allocated using "
               "malloc.\n");
 // Get the elements of the array 
        for (int j = 0; j < size; ++j) { 
            ptr[j] = j + 1; 
        } 
  
        // Print the elements of the array 
        printf("The elements of the array are: "); 
        for (int k = 0; k < size; ++k) { 
            printf("%d, ", ptr[k]); 
        } 
    } 
  
    return 0; 
}

Output

Enter size of elements:6
Memory successfully allocated using malloc.
The elements of the array are: 1, 2, 3, 4, 5, 6, 

3. Dynamically Resizing Array Using realloc() Function

In C, the realloc function is used to change the size of previously allocated memory. It’s a way to resize an existing array or create a new one with a different size. This allows your program to adapt to changing memory requirements. The function takes a pointer to the old memory block and the new size in bytes as arguments. It automatically copies the data from the old block to the new one if necessary.

Syntax:

ptr = realloc(ptr, newSize);

Example

/ C program to resize dynamic array using realloc() 
// function 
  
#include <stdio.h> 
#include <stdlib.h> 
  
int main() 
{ 
  
    // address of the block created hold by this pointer 
    int* ptr; 
    int size = 5; 
  
  
    //  Memory allocates dynamically using calloc() 
    ptr = (int*)calloc(size, sizeof(int)); 
  
    if (ptr == NULL) { 
        printf("Memory not allocated.\n"); 
        exit(0); 
    } 
    else { 
        printf("Memory successfully allocated using "
               "calloc.\n"); 
    } 
  
    // inserting elements 
    for (int j = 0; j < size; ++j) { 
        ptr[j] = j + 1; 
    } 
  
    printf("The elements of the array are: "); 
    for (int k = 0; k < size; ++k) { 
        printf("%d, ", ptr[k]); 
    } 
  
    printf("\n"); 
  
    size = 10; 
  
    int *temp = ptr; 
  
    //  using realloc 
    ptr = realloc(ptr, size * sizeof(int)); 
    if (!ptr) { 
        printf("Memory Re-allocation failed."); 
        ptr = temp; 
    } 
    else { 
        printf("Memory successfully re-allocated using "
               "realloc.\n"); 
    } 
  
    // inserting new elements 
    for (int j = 5; j < size; ++j) { 
        ptr[j] = j + 10; 
    } 
  
    printf("The new elements of the array are: "); 
    for (int k = 0; k < size; ++k) { 
        printf("%d, ", ptr[k]); 
    } 
    return 0; 
}

Output

Memory successfully allocated using calloc.
The elements of the array are: 1, 2, 3, 4, 5, 
Memory successfully re-allocated using realloc.
The new elements of the array are: 1, 2, 3, 4, 5, 15, 16, 17, 18, 19, 

4. Variable Length Arrays(VLAs)

• Dynamic Sizing: VLAs in C allow you to determine the size of an array at runtime. This dynamic sizing is useful for situations where the array size is not known until the program is running.
• Stack Memory Allocation: VLAs allocate memory on the stack, making them local to the scope in which they are defined. The memory is automatically released when the scope ends, which can be advantageous for memory management.
• Immutable Size: Once you define a VLA with a specific size, you cannot change that size during its lifetime. The size remains fixed.
• Limitations: Using VLAs has some limitations, such as the potential for stack overflow if the array size is too large, limited portability (as VLAs were introduced in C99 and may not be supported in older compilers), and potential inefficiency for very large arrays.

Example

// C program to demonstrate the use of VLAs 
#include <stdio.h> 
  
int main() 
{ 
  
    int n; 
    printf("Enter the size of the array: "); 
    scanf("%d", &n); 
    
    int arr[n]; 
  
    printf("Enter elements: "); 
  
    for (int i = 0; i < n; ++i) { 
  
        scanf("%d", &arr[i]); 
    } 
      
      printf("Elements of VLA of Given Size: "); 
    for (int i = 0; i < n; ++i) { 
  
        printf("%d ", arr[i]); 
    } 
  
    return 0; 
}

Output

Enter the size of the array: 5
Enter elements: 1 2 3 4 5
Elements of VLA of Given Size: 1 2 3 4 5

5. Flexible Array

Flexible array members in C are arrays defined within a structure without a specific size. Introduced in the C99 standard, they allow for variable-sized arrays in structures. You can control their size using malloc(). A few rules apply: the flexible array member is best placed as the last member of the structure, its size can change at runtime, and the structure must have at least one other named member. Flexible array members are valuable for creating dynamic arrays within structures, often used in data structures like queues and stacks.

Refer the structure given below for example

struct student
{
  int len;
  int 
};

Then, we can use the malloc() function to allocate memory:

struct student *s = malloc(sizeof(*s) + 5 * sizeof(int));

Example

// C program to demonstrate the use of Flexible Array Member 
#include <stdio.h> 
#include <stdlib.h> 
  
// defining struct 
typedef struct { 
    int len; 
    int arr[]; 
} fam; 
  
int main() 
{ 
    // creating an array member of size 5 
    fam* fam1 
        = (fam*)malloc(sizeof(fam*) + 5 * sizeof(int)); 
  
    // creating an array mebmer of size 10 
    fam* fam2 
        = (fam*)malloc(sizeof(fam*) + 10 * sizeof(int)); 
      
    // inserting elements 
    for (int i = 0; i < 5; i++) { 
        fam1->arr[i] = i + 1; 
    } 
    for (int i = 0; i < 10; i++) { 
        fam2->arr[i] = i + 10; 
    } 
  
    //  printing elements 
    printf("Array of Size 5:\n"); 
    for (int i = 0; i < 5; i++) { 
        printf("%d, ", fam1->arr[i]); 
    } 
    printf("\n"); 
  
    printf("Array of size 10:\n"); 
    for (int i = 0; i < 10; i++) { 
        printf("%d, ", fam2->arr[i]); 
    } 
    return 0; 
}

Output

Array of Size 5:
1, 2, 3, 4, 5, 
Array of size 10:
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,

Dynamic Allocation of Two-Dimensional Array

Creating a two-dimensional dynamic array in c.  These are the various methods inorder to produce a 2D dynamic array.

1. Using a single pointer and a 1D array with pointer arithmetic
2. Using an array of pointers 
3. Using a pointer to a pointer 
4. Using a double-pointer and one malloc call 
5. Using a pointer to Variable Length Array
6. Using a pointer to the first row of VLA

FAQ- Dynamic Array In C

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

What is a Memory Leak? How can we avoid it?

A memory leak occurs when a program fails to release allocated memory, leading to reduced system performance and potential crashes. This is especially problematic for long-running processes like servers that never restart, as leaks accumulate over time, degrading performance and stability. Preventing memory leaks requires careful memory management in programming, with some languages offering automatic memory handling to reduce this issue.

Example of Memory Leak

/* Function with memory leak */
#include <stdlib.h>
 
void f()
{
    int* ptr = (int*)malloc(sizeof(int));
 
    /* Do some work */
 
    /* Return without freeing ptr*/
    return;
}

How to avoid Memory Leak

In order to avoid the leak, memory should always be free from them, when it is not necessary.

Example: Program to Release Memory Allocated in Heap to Avoid Memory Leak

/* Function without memory leak */
#include <stdlib.h>
 
void f()
{
    int* ptr = (int*)malloc(sizeof(int));
 
    /* Do some work */
 
    /* Memory allocated by malloc is released */
    free(ptr);
    return;
}

Example: Program to Check Whether the Memory is Freed or Not

// C++ Program to check whether the memory is allocated or not 
// if allocated free it
 
#include <iostream>
using namespace std;
 
int main()
{
    int* ptr = new int;
   
    if (ptr == NULL)
        cout << "Memory Is Insuffficient\n";
    else {
        delete ptr;
        cout << "Memory Freed\n";
    }
}

Output

Memory Freed

FAQ- What is a Memory Leak? How can we avoid it?

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

Difference Between malloc() and calloc() with Examples

The two functions such as malloc () and calloc() are library functions that can allocate dynamically. Dynamic refers to the memory that is allocated during the run time(execution of the program) from the heap segment.

Initialization

malloc() will allocate a memory block of the provided size(in bytes) and then it can return a pointer to the beginning of the block. Malloc() won’t initialize the memory. Whereas, if you attempt to read from the allocated memory without even initializing it, then it can show undefined behavior. This meant the value that you read will be garbage values.

The calloc() function in C and C++ is used to allocate memory for an array of elements and initializes all the bytes in the allocated memory to zero. It takes two arguments: the number of elements to allocate memory for and the size of each element in bytes. calloc() then returns a pointer to the allocated memory block.

Because calloc() initializes all the bytes to zero, if you try to read the values from the allocated memory without explicitly assigning values to them, you will indeed get 0 or equivalent representations for the data type you are using. This behavior is different from the malloc() function, which allocates memory but does not initialize it, so the values in the memory block may contain arbitrary data.

Parameters

The malloc() function in C and C++ takes a single argument, which is the number of bytes to allocate. It returns a pointer to a block of memory that is large enough to store the specified number of bytes. malloc() does not initialize the memory it allocates, which means the contents of the allocated memory are undefined, and you need to explicitly initialize it if needed.

calloc() indeed takes two arguments:

1. The number of blocks or elements to be allocated.
2. The size of each block or element in bytes.

Return Value

Both malloc() and calloc() return a pointer to the allocated memory block on successful allocation. If the allocation fails for any reason, they return a NULL pointer to indicate failure. It’s important to check the returned pointer to ensure that the allocation was successful before attempting to use the allocated memory.

Example

// C code that demonstrates the difference
// between calloc and malloc
#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    // Both of these allocate the same number of bytes,
    // which is the amount of bytes that is required to
    // store 5 int values.
 
    // The memory allocated by calloc will be
    // zero-initialized, but the memory allocated with
    // malloc will be uninitialized so reading it would be
    // undefined behavior.
    int* allocated_with_malloc = malloc(5 * sizeof(int));
    int* allocated_with_calloc = calloc(5, sizeof(int));
 
    // As you can see, all of the values are initialized to
    // zero.
    printf("Values of allocated_with_calloc: ");
    for (size_t i = 0; i < 5; ++i) {
        printf("%d ", allocated_with_calloc[i]);
    }
    putchar('\n');

    // This malloc requests 1 terabyte of dynamic memory,
    // which is unavailable in this case, and so the
    // allocation fails and returns NULL.
    int* failed_malloc = malloc(1000000000000);
    if (failed_malloc == NULL) {
        printf("The allocation failed, the value of "
               "failed_malloc is: %p",
               (void*)failed_malloc);
    }
 
    // Remember to always free dynamically allocated memory.
    free(allocated_with_malloc);
    free(allocated_with_calloc);
}

Output

Values of allocated_with_calloc: 0 0 0 0 0 
The allocation failed, the value of failed_malloc is: (nil)

Difference between malloc() and calloc() in C

FAQ- Difference Between malloc() and calloc() with Examples

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together

Table of Contents

Dynamic Memory Allocation In C Using Malloc(), Calloc(), Free() And Realloc()

Dynamic memory allocation is a fundamental concept in the C programming language that allows developers to efficiently manage memory resources during runtime. Unlike static memory allocation, which defines memory usage at compile time, dynamic memory allocation enables programs to request and release memory as needed. This flexibility is particularly valuable when working with data structures of varying sizes or when you need to allocate memory for data structures whose size is not known until runtime. In C, this dynamic memory allocation is achieved through functions like malloc(), calloc(), free(), and realloc(). These functions provide the means to allocate memory, initialize it, release it, and even resize it, empowering programmers to optimize memory usage in their applications. This introductory guide will explore the usage of these functions, offering insights into how to harness their power for efficient memory management in C programming.

Dynamic Memory Allocation in C

Dynamic memory allocation is a fundamental concept that allows developers to adapt the size of data structures, such as arrays, during program execution. This adaptability is especially crucial when the actual size of the data structure cannot be determined at compile time or when it needs to change dynamically based on program requirements.

The four library functions provided by C, namely malloc(), calloc(), free(), and realloc(), are key tools for implementing dynamic memory allocation. They empower programmers to allocate memory, initialize it, release it when no longer needed, and resize data structures, ensuring the efficient use of memory resources.

Dynamic memory allocation is a powerful feature that enhances the flexibility and efficiency of C programming, enabling developers to create more adaptable and resource-efficient applications. It is particularly valuable in scenarios like the ones you’ve described, where the size of an array needs to be adjusted at runtime to prevent memory wastage or accommodate additional data.

C malloc() method

1. Dynamic Memory Allocation: The malloc function in C is used to dynamically allocate a single large block of memory during runtime. This memory allocation is done based on the specified size provided as an argument to malloc.
2. Pointer Return Type: malloc returns a pointer of type void, which means it can be cast into a pointer of any data type. Programmers typically cast this void pointer into the appropriate data type pointer to work with the allocated memory.
3. Uninitialized Memory: One crucial aspect of malloc is that it does not initialize the memory it allocates. The memory block initially contains garbage values, which means the content of the allocated memory is indeterminate until you explicitly write values into it. It’s important for programmers to initialize the memory if necessary to avoid unexpected behavior in their programs.

This function is widely used for dynamic memory allocation in C and is the first step in allocating memory for various data structures, such as arrays, linked lists, and more. To ensure predictable behavior, it’s essential to initialize the allocated memory to the desired values before using it in your program.

Syntax of malloc() in C

ptr = (cast-type*) malloc(byte-size)
For Example:

ptr = (int*) malloc(100 * sizeof(int));
Due  the size of int is 4 bytes, this statement will allocate 400 bytes of memory. Thus, the pointer ptr holds the address of the first byte in the allocated memory.

Example of malloc() in C

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
 
    // This pointer will hold the
    // base address of the block created
    int* ptr;
    int n, i;
 
    // Get the number of elements for the array
    printf("Enter number of elements:");
    scanf("%d",&n);
    printf("Entered number of elements: %d\n", n);
 
    // Dynamically allocate memory using malloc()
    ptr = (int*)malloc(n * sizeof(int));
 
    // Check if the memory has been successfully
    // allocated by malloc or not
    if (ptr == NULL) {
        printf("Memory not allocated.\n");
        exit(0);
    }
    else {
 // Memory has been successfully allocated
        printf("Memory successfully allocated using malloc.\n");
 
        // Get the elements of the array
        for (i = 0; i < n; ++i) {
            ptr[i] = i + 1;
        }
 
        // Print the elements of the array
        printf("The elements of the array are: ");
        for (i = 0; i < n; ++i) {
            printf("%d, ", ptr[i]);
        }
    }
 
    return 0;
}

Output

Enter number of elements: 5
Memory successfully allocated using malloc.
The elements of the array are: 1, 2, 3, 4, 5,

C calloc() method

1. Dynamic Memory Allocation: The calloc function in C is used for dynamic memory allocation, much like the malloc function. It allows you to allocate memory for a specified number of blocks of a specified type during program execution.
2. Initialization to Zero: One significant difference between calloc and malloc is that calloc initializes each block of memory with a default value of ‘0’. This means that the memory allocated by calloc is set to zeros by default. This can be useful when you want to ensure that the allocated memory starts with a known initial state.
3. Two Parameters: calloc takes two parameters or arguments: the number of blocks you want to allocate and the size of each block in bytes. In contrast, malloc typically takes a single argument, which is the total size of memory to allocate.

calloc is often used when you want to allocate and initialize an array of elements, and you want to ensure that all elements start with a default value of zero. This can be helpful in scenarios where you need to work with arrays or matrices and want to avoid any unpredictable values in the allocated memory.

So, while calloc and malloc serve the same general purpose of dynamic memory allocation, they differ in their behavior regarding memory initialization and the number of parameters they accept.

Syntax of calloc() in C

ptr = (cast-type*)calloc(n, element-size);
here, n is the no. of elements and element-size is the size of each element.

Example

ptr = (float*) calloc(25, sizeof(float));
This statement can allocate acontiguous space in memory for 25 elements whereas, each element with the size of the float. 

Example of calloc() in C

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
 
    // This pointer will hold the
    // base address of the block created
    int* ptr;
    int n, i;
 
    // Get the number of elements for the array
    n = 5;
    printf("Enter number of elements: %d\n", n);
 
    // Dynamically allocate memory using calloc()
    ptr = (int*)calloc(n, sizeof(int));
 
    // Check if the memory has been successfully
    // allocated by calloc or not
    if (ptr == NULL) {
        printf("Memory not allocated.\n");
        exit(0);
    }
    else {
     // Memory has been successfully allocated
        printf("Memory successfully allocated using calloc.\n");
 
        // Get the elements of the array
        for (i = 0; i < n; ++i) {
            ptr[i] = i + 1;
        }
 
        // Print the elements of the array
        printf("The elements of the array are: ");
        for (i = 0; i < n; ++i) {
            printf("%d, ", ptr[i]);
        }
    }
 
    return 0;
}

Output

Enter number of elements: 5
Memory successfully allocated using calloc.
The elements of the array are: 1, 2, 3, 4, 5,

C free() method

1. Dynamic Memory Deallocation: The free function in C is used to dynamically deallocate (release) memory that was previously allocated using functions like malloc and calloc.
2. Manual Memory Management: Memory allocated using malloc and calloc is not automatically deallocated by the program; it remains allocated until explicitly released. This manual memory management is a fundamental responsibility of the programmer.
3. Wastage Reduction: One of the primary purposes of the free function is to reduce memory wastage. By releasing memory that is no longer needed, the program can make efficient use of available memory resources.

It’s important to note that not properly freeing memory can lead to memory leaks, where memory is allocated but never released, causing the program’s memory consumption to grow over time. Therefore, it’s a good practice to use free to release memory as soon as it is no longer required within your program to ensure efficient memory management.

Syntax of free() in C

free(ptr);

Example of free() in C

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
 
    // This pointer will hold the
    // base address of the block created
    int *ptr, *ptr1;
    int n, i;
 
    // Get the number of elements for the array
    n = 5;
    printf("Enter number of elements: %d\n", n);
 
    // Dynamically allocate memory using malloc()
    ptr = (int*)malloc(n * sizeof(int));
 
    // Dynamically allocate memory using calloc()
    ptr1 = (int*)calloc(n, sizeof(int));
 
    // Check if the memory has been successfully
    // allocated by malloc or not
    if (ptr == NULL || ptr1 == NULL) {
        printf("Memory not allocated.\n");
        exit(0);
    }
    else {
 
        // Memory has been successfully allocated
        printf("Memory successfully allocated using malloc.\n");
 
        // Free the memory
        free(ptr);
        printf("Malloc Memory successfully freed.\n");
 
        // Memory has been successfully allocated
        printf("\nMemory successfully allocated using calloc.\n");
 
        // Free the memory
        free(ptr1);
        printf("Calloc Memory successfully freed.\n");
    }
 
    return 0;
}

Output

Enter number of elements: 5
Memory successfully allocated using malloc.
Malloc Memory successfully freed.

Memory successfully allocated using calloc.
Calloc Memory successfully freed.

C realloc() method

1. Dynamic Memory Reallocation: The realloc function in C is used to dynamically change the memory allocation of a previously allocated memory block. This allows you to resize the memory block allocated by malloc or calloc during runtime.
2. Insufficient Memory: realloc is particularly useful when the previously allocated memory is insufficient to hold the data or elements you want to store. It enables you to increase or decrease the size of the memory block to accommodate the new requirements.
3. Data Preservation: When you use realloc to increase the size of the memory block, it preserves the data that is already present in the existing memory. In other words, the data from the original memory block is retained in the new, larger memory block. However, any newly allocated memory within the resized block will contain garbage values unless explicitly initialized.
4. Efficient Memory Usage: realloc helps in efficient memory usage by allowing you to adapt the memory allocation to your program’s needs without unnecessary memory wastage or the risk of buffer overflows.

Overall, realloc is a powerful tool for managing memory efficiently in C programs, as it gives you the flexibility to adjust memory sizes dynamically to meet changing requirements while retaining existing data.

Syntax of realloc() in C

ptr = realloc(ptr, newSize);
where ptr is reallocated with new size 'newSize'.

Example of realloc() in C

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
 
    // This pointer will hold the
    // base address of the block created
    int* ptr;
    int n, i;
 
    // Get the number of elements for the array
    n = 5;
    printf("Enter number of elements: %d\n", n);
 
    // Dynamically allocate memory using calloc()
    ptr = (int*)calloc(n, sizeof(int));
 
    // Check if the memory has been successfully
    // allocated by malloc or not
    if (ptr == NULL) {
        printf("Memory not allocated.\n");
        exit(0);
    }
    else {
// Memory has been successfully allocated
        printf("Memory successfully allocated using calloc.\n");
 
        // Get the elements of the array
        for (i = 0; i < n; ++i) {
            ptr[i] = i + 1;
        }
 
        // Print the elements of the array
        printf("The elements of the array are: ");
        for (i = 0; i < n; ++i) {
            printf("%d, ", ptr[i]);
        }
 
        // Get the new size for the array
        n = 10;
        printf("\n\nEnter the new size of the array: %d\n", n);
 
        // Dynamically re-allocate memory using realloc()
        ptr = (int*)realloc(ptr, n * sizeof(int));
 
        // Memory has been successfully allocated
        printf("Memory successfully re-allocated using realloc.\n");
 
        // Get the new elements of the array
        for (i = 5; i < n; ++i) {
            ptr[i] = i + 1;
        }
 
        // Print the elements of the array
        printf("The elements of the array are: ");
        for (i = 0; i < n; ++i) {
            printf("%d, ", ptr[i]);
        }
 
        free(ptr);
    }
 
    return 0;
}

Output

Enter number of elements: 5
Memory successfully allocated using calloc.
The elements of the array are: 1, 2, 3, 4, 5, 

Enter the new size of the array: 10
Memory successfully re-allocated using realloc.
The elements of the array are: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

FAQ- Dynamic Memory Allocation in C using malloc(), calloc(), free() and realloc()

Hridhya Manoj

Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together