A C Pre-processor: What Is It?

The compiler does not include the C Pre-processor. The C Pre-processor is merely a text replacement tool that tells the compiler to perform any necessary pre-processing prior to the compilation process. The C Pre-processor is referred to as CPP.

The block structure of the programme is unimportant; pre-processor directives like #include take effect as soon as they are noticed and continue to function until the end of the file that includes them. Pre-processing instructions in a C programme are lines that begin with the hash symbol “#.” The directive name is immediately followed by the hash symbol “#”. For instance, “#include.” ‘ The hash symbol “#” may be placed before or after whitespace.

The pre-processor, a kind of automatic editor that alters our source code before sending it to the compiler to translate into machine language code, is the first step in compiling the C programme. The pre-job processor’s includes removing all comments, which the compiler would otherwise disregard. Additionally, the pre-processor reacts to code directives like #define, #include, or #elif, which instruct the pre-processor on how to modify the source code before handing it off to the compiler.

The post C Pre-processor first appeared on Student Projects.

The variable’s accessibility in these contexts is referred to as scope. Both the initial default value and the lifetime of a variable relate to the value that was there by default before the variable was initialised.

Let’s move on to its types now that we are familiar with the fundamental idea of storage classes. Depending on the kind of variables they hold, there are four different sorts of storage classes. The various storage classes are as follows. Their names give away the stored variables:

• Automatic Variables
• External Variables
• Static Variables
• Register Variables

Auto Storage Class:

This category applies automatically to variables that are created as part of a function but whose storage class has not yet been defined. As it can only be accessed within the function it is initialised in, its scope is minimal. Nothing else can access it. The variable initially holds a trash value until a value is assigned to it. Their lifespan is the amount of time till the function block ends, hence it depends on the duration of the function block.

int a;
auto int a;
//Both are the same.

External Storage Class:

Because these variables are defined externally to the function, they can be used anywhere inside the function, making them universally applicable. Their starting value is zero. Their lifetime is equivalent to the duration of the programme because they can be used at any moment. It’s not usually a good idea to have too many global variables in a programme because they can compromise security.

Extern Keyword:

Use of the extern keyword tells the compiler that the variable has previously been defined somewhere else. By doing this, we may access the same variable in another file without allocating new memory and use it with the same space. Since we must use the extern keyword and it will automatically access it from the other file, its syntax is straightforward.

Syntax:

extern int a;

Static Storage Class:

Static variables are a little more technical because they are only valid for the function they are initialised in throughout the entire programme. It is useful when we modify the program’s value since the new value will be stored and overwritten by the old one. Their syntax is relatively simple because we just need to apply the Static keyword during initialization, and their initial default value is 0.

Syntax:

static int a;

Register Storage Class:

As its scope is restricted to the function it is defined in, its initial default value is 0, and its lifetime is limited to the end of the function block, the Register Storage Class is very similar to the Auto Storage Class. Now, the main distinction between it and the others is that it seeks rapid access to the CPU’s register memory rather than the local memory. It is typically used for programmes that must be accessed more quickly than others or that are frequently used.

Syntax:

register int a;

The post Storage classes first appeared on Student Projects.

• Malloc
• Calloc
• Realloc
• Free

malloc():

• Memory allocation is referred to as malloc. It asks memory from the heap and returns a reference to the memory, as implied by its name. We can typecast the pointer for any variables because it is of the void type. At the time of allocation, all values are initialised to null values. Its syntax is straightforward because we only need to specify the memory space and the desired size in bytes.

Syntax:

ptr = (ptr-type*) malloc(size_in_bytes)

Example:

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

calloc():

• Contiguous allocation is referred to as calloc. The two key distinctions are that it also asks for memory from the heap, returns a pointer to the memory, and has the same functionality as malloc(). The required number and size of blocks must be sent as parameters. The second distinction is a significant one. In other words, calloc() initialises the variables to 0 rather than a trash value at the moment of allocation.

Syntax:

ptr = (ptr-type*) calloc(n,size_in_bytes) ptr = (ptr-type*) calloc(n,size_in_bytes)

Example:

int *ptr;
ptr = (int*) malloc (10, sizeof(int))

realloc():

• Reallocation is the definition of realloc. It is employed when dynamic memory is insufficient or when extra memory needs to be allocated in order to hold more data. Its syntax is straightforward because all we have to do is provide the information relating to the pointer while overwriting the memory that has already been allocated as a function parameter.

Syntax:

ptr = (ptr-type*) realloc(ptr,new_size_in_bytes)

Example:

ptr = (int*) realloc (ptr, 5* sizeof(int))

Free():

• As was said earlier when discussing the drawbacks of dynamic memory allocation, there is no automatic method for releasing the memory space that has been allocated. Therefore, the allocated memory’s space is released using the free function. Since we must send the pointer as a parameter inside the function, its syntax is the simplest of all.

Syntax:

free(ptr)

The post Allocation of memory using the heap first appeared on Student Projects.

“Void pointers are uninitialized pointers.”

Example:

int *ptr;

In the example above, a pointer was generated but left empty, turning it into a wild pointer.

Its drawback is that it will hold any garbage value, which means it will hold any random portion of memory. Numerous faults in the software may result from the storage of data in an arbitrary location, and occasionally the programmer will not even be able to determine the source.

Solution: We would rather convert a void pointer to a NULL pointer in order to prevent the flaws and errors it may introduce into a programme. As a result, our pointer will always point to 0 or NULL instead of any memory location. Simply setting a wild pointer equal to NULL will make it a NULL pointer. Let’s look at it using C syntax.

Syntax:

int *ptr = NULL;

Therefore, if we are not utilising our pointer to point at a specific memory region, we will use this way.The pointer can now be initialised as a second option for preventing similar issues.

Example:

int x = 3;
int *ptr;
ptr = &3;

It will be a wild pointer if we simply run the first two lines of the aforementioned section of code because no value has been initialised to it. However, if we run the third line as well, it will point to a specific address and become a normal pointer.

Dereferencing:

We are unable to dereference a wild pointer because we are unsure of the data that it is pointing to in memory. Dereferencing a wild pointer can result in several problems as well as programme failure.

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int a =4354;
    int *ptr; // This is a wild pointer
    // *ptr = 34; // This is not a good thing to do
    ptr = &a; // ptr is no longer a wild pointer
    printf("The value of a is %d\n", *ptr);
    return 0;
}

The post Wild pointers first appeared on Student Projects.

• The process of allocating memory at runtime is known as dynamic memory allocation. The idea of dynamic memory allocation is used to minimise memory waste and is the best method of memory allocation. We’ll look at the C programming language’s memory structure to fully understand the idea.

Memory Allocation in C:

• There are four different parts to memory allocation in C. Because understanding each of them is essential for understanding memory layout, we shall go into detail about each of them.

Code:

• All of our program’s text segments are composed of code. Since we are already familiar with this section, we won’t go into more depth about it.

Variable

• We refer to both global and static variables as variables. While static variables have restrictions inside the function, global variables can be utilised elsewhere in the programme. Depending on the amount of data they can store, the variable section is further separated into two segments.

Data segment:

• Stores data that has already been initialised, or whose value has been determined.

Example:

int i = 0;

The bss segment stores uninitialized data, or data whose variables have not yet been initialised.

Example:

int i = 0;

Stack:

• A LIFO data structure is the stack. It grows in size as the programme progresses.
• The stack initially resembles a bucket, where the last item entered will be the first one to emerge. Because of this, it is known as a LIFO data structure, or last in, first out, structure.Consider adding function A to the stack. The execution of Function A will begin. As it continues to run, function A is now calling function B. The programme will begin executing Function B after pushing B into the stack. If B now calls a different function C, the programme will add C to the stack and begin C’s execution.Now that C has finished running through its whole, the programme will remove C from the stack (because it was the last one to enter) and begin running B. After B has finished running entirely, it will be pushed out, and A will then begin running until the stack is empty.

Stack overflow:

• Stack Overflow is a phenomena that occurs when a stack runs out of space due to poor programming or a logical mistake.

Heap:

• Heap is a data structure that is built on trees. When we allocate memory dynamically, its size grows. We must establish a pointer in our main function that points to a memory block in a heap in order to use the heap data structure. The drawback of using heap is that when the pointer is rewritten, the memory does not immediately free itself.

#include <stdio.h>
#include <string.h>
int i;
int main()
{
    int id;
    return 0;
}
 

The post Dynamic memory allocation first appeared on Student Projects.

• Variables declared within a function or a block of code are referred to as local variables. These variables are only accessible within the function in which they were declared. Local variables have a function-specific scope since they can only be accessed by statements that are included within that function or code block.

B. Worldwide Variables

• Global variables are those that have definitions separate from any and all functions. We can access global variables within any of the program’s declared functions to retrieve their values. The system initialises global variables when they are defined. When a name is defined for both local and global variables, the local variable is given preference.

C. Static Variables

• One definition of a static variable is one that keeps its value even after the programme leaves the scope in which it was declared. Static variables don’t need to be initialised afresh in the new scope; they keep their value. Static variables retain their memory until the program’s end, but regular variables are deleted when the function they were declared in is exited. Both inside and outside of the function they can be declared. The block is the local area for static variables. A static variable’s default value is zero. A static variable is declared with the word static.

Output:

static datatype variable_name = variable_value;

Static global variables differ from static local variables.

Static global variable

• Static global variables are any variables with the static keyword specified outside of a function. Any method in the application will allow access to this variable.

Static local variable

• Static local variables are any variables that are declared with the static keyword inside of a function. A static local variable has the same scope as a local variable, but its memory is accessible for the duration of the program’s execution.

The characteristics of static variables

• A static variable’s value will remain after the programme leaves the scope in which it was declared.
• A static variable’s allotted memory is accessible for the duration of the program’s execution.
• A static variable’s default value is 0 if we don’t initialise it.

The post C Static Variables first appeared on Student Projects.

For instance:

int *ptr;

A pointer called ptr is generated in this example, but it is empty. The pointer ptr is now a wild pointer as a result. Declaring a pointer without initialising it has drawbacks of its own. One such drawback is that it will save any worthless information in it. It will hold in it arbitrarily a position in memory. This random allocation frequently becomes difficult for a programmer to debug, leading to several issues with the program’s operation.

A. Avoiding problems due to WILD pointers

In order to avoid problems that can arise while dereferencing a wild reference, we frequently opt to change a void pointer to a NULL pointer. By doing this, our pointer will instead point to a NULL position rather than any trash memory location. Simply setting a wild pointer equal to NULL will make it a NULL pointer.

B. Dereferencing

A wild pointer cannot be dereferenced since we are unsure of the data it is pointing at in memory. Dereferencing a wild pointer can result in numerous problems as well as a software crash.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
   int *arr;
   for(int i=0; i<5 ; i++)
   cout << arr[i] << ” “;
   return 0;
}

Output:1 0 -426634956 32764 0

The post Wild Pointer first appeared on Student Projects.

Releasing or deleting temporary memory

• The pointer continues to point to freed space even after memory is deallocated. Here’s an illustration to show how that occurs:

#include <stdio.h>
int main()
{
    int a = 80;
    int *ptr = (int *)malloc(sizeof(int));
    ptr = &a;
    free(ptr);
    return 0;
}

The code shown above shows how to construct a variable pointer *ptr and an integer variable a with the value 80. The malloc() function is used to generate the pointer variable *ptr. Given that we are aware that the malloc() function produces a void, we type-convert the void pointer into an int pointer using the int * function.

Function Call

• We will now examine how the function call causes the pointer to become dangling.

#include <stdio.h>
int *myvalue()
{
    int a = 10;
    return &a;
}

int main()
{
    int *ptr = myvalue();
    printf(“%d”, *ptr);
    return 0;
}

Output: Segmentation Fault!

The func() method’s return value is contained in the pointer ptr, which is declared in the main() function of the code above. The programme control is transferred to the context of the int *func when the function func() is called (). The address of the integer variable an is then returned by the method func().

The integer variable an is no longer accessible for the remainder of the program’s execution at this point, and programme control returns to the main() function. And because it points to a memory location that has been removed or freed from the stack, the pointer ptr becomes dangling. The application consequently causes a segmentation fault.

The outcome would have been 10 had the code been modified and the integer variable, which is static and is declared globally, been local rather than global.

The best way to prevent dangling pointer errors

Our applications get unpleasant defects from the hanging pointer, and these issues frequently lead to security flaws. These errors that result from the generation of a dangling pointer can be prevented by simply initialising the pointer value to NULL. The pointer won’t then point to the space in memory that was freed. While the purpose of giving the pointer the NULL value was to prevent it from pointing to any previously or arbitrarily designated memory location.

The post Dangling Pointer first appeared on Student Projects.

int *ptr = NULL;

Simply put, no memory is allocated to a NULL pointer because it often corresponds to the NULL or 0th memory location.

Defeating a reference to NULL

• A NULL pointer behaves very similarly to a void pointer when dereferencing. Since a NULL pointer is really a VOID pointer in and of itself, we must typecast it into any data type before dereferencing. Failure to do so causes a compile-time error.

Uninitialized pointer versus NULL pointer

• Null pointers are distinct from uninitialized pointers since they take up no memory space. In other words, it only points to the zeroth position. An uninitialized pointer, on the other hand, signifies that the pointer resides at a garbage value address. Since the garbage value address still refers to a legitimate memory location, it is not a NULL value. Therefore, NULL pointers are chosen to be on the safe side.

Void pointer versus NULL pointer

• Due to their similar names, NULL pointers and void pointers may appear to be quite similar; nevertheless, a NULL pointer is a pointer with a NULL value address, and a void pointer is a pointer of void data type. Their respective meanings diverge.

example of a NULL pointer :  

 int *ptr = NULL;

example of a VOID pointer:

    void *ptr;

Benefits of using a NULL pointer

• A pointer variable can be initialised without having a specific memory location assigned to it.
• It can be used to determine whether a pointer is genuine or not. Making the pointer NULL, which prevents dereference, allows us to verify that.
• When comparing two pointers, a NULL pointer is used to determine whether the other pointer is actually pointing to a memory address or not.
• In the case of C programming, we employ it for error management.
• When passing a pointer with a valid memory location is not desired, we can give a NULL pointer instead.

The post NULL Pointer in C first appeared on Student Projects.

    int var = 1;

    void *voidPointer = &var;

Since we have stored the address of an integer value in the void pointer, its data type is typecast here into int.

    char x = ‘a’;

    void *voidPointer = &x;

As we have saved the address of a character value in the void pointer in this example, the data type of the pointer is typecast to char. You must also be reminded of how we used to type cast void pointers provided by the calloc() and malloc() routines while doing dynamic memory allocation. The heap also returns a void pointer to the requested memory there. A void pointer is useful in this situation since we could type cast the object to any other data type.

Two important features of a VOID pointer are:

Pointers that are void cannot be dereferenced. An illustration of this is possible with the aid of an example.

int a = 10;
    void *voidPointer;
    voidPointer = &a;
    printf("%d", *voidPointer);

OUTPUT: Compiler Error!

The fact that we cannot dereference a void pointer, which would require us to typecast the pointer each time it is used, causes his programme to crash at compilation time. This is the right way to do things.

    int a = 8;
    void *voidPointer;
    voidPointer = &a;
    printf("%d", *(int *)voidPointer);

Output:8

Due to the use of the type and the pointer, the compiler won’t produce any errors and will output the result immediately.

Since void pointers don’t retain any addresses, they can’t be utilised with pointer arithmetic to increase or decrease their value.

The post C VOID Pointer first appeared on Student Projects.