How will you override an existing macro in C?

#ifdef pre-processor directive checks whether particular macro is defined or not in a C program.

• memcpy() function is used to copy a specified number of bytes from one memory to another. Whereas, strcpy() function is used to copy the contents of one string into another string.
• memcpy() function acts on memory rather than value. Whereas, strcpy() function acts on value rather than memory.

• memcpy()  function is is used to copy a specified number of bytes from one memory to another.
• memmove() function is used to copy a specified number of bytes from one memory to another or to overlap on same memory.
• Difference between memmove() and memcpy() is, overlap can happen on memmove(). Whereas, memory overlap won’t happen in memcpy() and it should be done in non-destructive way.

• There is no inbuilt function to remove leading and trailing spaces from a string in C. We need to write our own function to remove them.
• We need to check first non-space character in given string. Then, we can copy that string from where non space character is found. Then, we can check whether any spaces are available in copied string from the end of the string. If space is found, we can copy ‘\0’ in that space until any character is found. Because, ‘\0’indicates the end of the string. Now, we have removed leading and trailing spaces in a given string.

• strcpy( ) function copies whole content of one string into another string. Whereas, strncpy( ) function copies portion of contents of one string into another string.
• If destination string length is less than source string, entire/specified source string value won’t be copied into destination string in both cases.

Here's a comparison between the strcpy() and strncpy() functions in C:

In summary, the main differences between strcpy() and strncpy() are that strcpy() copies the entire string until the null terminator, whereas strncpy() allows specifying the maximum number of characters to copy. Additionally, strcpy() always adds a null terminator, while strncpy() only adds a null terminator if the number of characters copied is less than the specified length. However, it's important to note that strncpy() does not automatically null-terminate the destination string if the specified length is equal to or greater than the length of the source string. Care should be taken to handle null termination correctly when using strncpy().

The strcpy() function in C is used to copy a string from one character array (source) to another (destination). It stands for "string copy." Here is the general syntax of the strcpy() function:

char* strcpy(char* destination, const char* source);

Parameters:

• destination: A pointer to the destination character array where the string will be copied.
• source: A pointer to the source character array, which contains the string to be copied.

Return Value:

• The strcpy() function returns a pointer to the destination character array (destination).

Example Usage:

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

int main() {
    char source[] = "Hello, World!";
    char destination[20];

    strcpy(destination, source);

    printf("Copied string: %s\n", destination);

    return 0;
}

In the above example, the strcpy() function is used to copy the contents of the source array to the destination array. After the strcpy() function is called, the destination array will contain the same string as the source array, "Hello, World!". The resulting string is then printed using printf().

It's important to note that when using strcpy(), you need to ensure that the destination array is large enough to accommodate the copied string to avoid buffer overflow and memory corruption.

No. Array subscripts should not have a negative value. Always, it should be positive.

No, array subscripts cannot have negative values in C. Array subscripts are used to access individual elements of an array by specifying their position or index. In C, array indexing starts from zero, so the first element of an array has an index of 0, the second element has an index of 1, and so on.

Attempting to use a negative value as an array subscript would result in undefined behavior. It can lead to memory access errors, data corruption, or program crashes. It is important to ensure that array subscripts are within the valid range of the array size to access elements correctly and avoid unintended consequences.

• Array can hold any of the data types. But, string can hold only char data type.
• Array size must be a constant value. So, array size can’t be changed once declared. But, string size can be modified using char pointer.
• Array is not ended with null character by default. But, string is ended with null (‘\0’) character by default.

Here's a comparison between arrays and strings in C:

In summary, an array in C is a collection of elements of the same data type, while a string is a sequence of characters terminated by a null character. Arrays can store elements of any data type, whereas strings specifically store characters or arrays of characters. Strings have a special termination character ('\0') to indicate the end of the string. Arrays are accessed and modified using array indexing, while strings can be manipulated using string-specific functions from the C standard library.

Null pointer is a pointer which is pointing to nothing. Null pointer points to empty location in memory. Value of null pointer is 0. We can make a pointer to point to null as below.

int *p =  NULL;
char *p = NULL;

In C, a null pointer is a special value that represents the absence of a valid memory address. It is commonly denoted by the macro NULL, which expands to an implementation-defined null pointer constant.

A null pointer does not point to any valid memory location. It is used to indicate that a pointer variable does not currently point to an object or has not been assigned a valid memory address yet.

Null pointers are often used in conditional statements to check if a pointer is valid or uninitialized before dereferencing it. Attempting to dereference a null pointer can result in undefined behavior, such as program crashes or accessing invalid memory.

Here's an example illustrating the use of null pointers:

#include <stdio.h>

int main() {
    int* ptr = NULL;  // Assigning a null pointer

    if (ptr == NULL) {
        printf("The pointer is currently null.\n");
    } else {
        printf("The pointer is not null.\n");
    }

    return 0;
}

In the above example, a pointer variable ptr is initialized with a null pointer by assigning the NULL macro. The code then checks if ptr is equal to NULL using an if statement. Since ptr is a null pointer, the message "The pointer is currently null." is printed.

NULL is a macro which is defined in C header files. The value of NULL macro is 0. It is defined in C header files as below.

#define NULL (void *) 0;

NULL is used for pointers only as it is defined as (void *) 0. It should not be used other than pointers. If NULL is assigned to a pointer, then pointer is pointing to nothing.

• Void pointer is a generic pointer that can be used to point another variable of any data type.
• Void pointer can store the address of variable belonging to any of the data type. So, void pointer is also called as general purpose pointer.

Note:
int pointer can be used to point a variable of int data type and char pointer can be used to point a variable of char data type.

In C, a void pointer, also known as a generic pointer, is a special pointer type that can hold the address of an object of any data type. It is declared using the void * type.

The void * type is considered "generic" because it lacks a specific data type. It allows a pointer to be assigned and manipulated without specifying the data type of the object it points to. However, you cannot directly dereference a void pointer or perform pointer arithmetic on it, as the compiler does not know the size or type of the object being pointed to.

Here's an example illustrating the use of a void pointer:

#include <stdio.h>

int main() {
    int num = 42;
    float pi = 3.14159;
    char letter = 'A';

    void* ptr;

    ptr = &num;
    printf("Value pointed by ptr: %d\n", *(int*)ptr);

    ptr = &pi;
    printf("Value pointed by ptr: %.5f\n", *(float*)ptr);

    ptr = &letter;
    printf("Value pointed by ptr: %c\n", *(char*)ptr);

    return 0;
}

In the above example, a void pointer ptr is declared. It is then assigned the address of different variables (num, pi, and letter) successively. By explicitly casting ptr to the appropriate type (int*, float*, or char*) before dereferencing it, we can access the values pointed to by the void pointer.

Note that when using void pointers, you need to ensure proper type casting and handle them with caution, as there is no type checking at compile-time. It is crucial to cast the void pointer to the correct type before dereferencing it to avoid errors and maintain type safety.