'==' is used to declare variables while '=' is for comparison.

The difference is that '=' is for assignment and '==' is for comparison.

Both '=' and '==' are used for assignment.

'==' is for assignment and '=' is for comparison.

A pointer in C is a variable that stores the address of another variable. It is declared using the syntax 'type *pointerName;'. For example, 'int *ptr;'.

A pointer in C is a variable that stores a string.

A pointer in C is a type of function that returns a variable.

A pointer in C is declared using 'pointerName *type;'.

Use 'malloc', 'calloc', or 'realloc' functions.

Use 'new' operator for memory allocation.

Use 'free' to allocate memory.

Use 'printf' to allocate memory.

The 'main' function is where all the functions are declared.

The 'main' function is used for defining global variables.

The 'main' function is the entry point of a C program.

The 'main' function handles memory allocation in a C program.

'printf' formats input data, while 'scanf' displays output.

'printf' and 'scanf' are both used for file operations.

'printf' is used for reading input, while 'scanf' outputs text.

'printf' outputs formatted text, while 'scanf' reads formatted input.

dynamic

auto, register, static, extern

shared

local

StructName struct { dataType member1; dataType member2; };

struct StructName { member1, member2; };

struct StructName { dataType member1; dataType member2; ... };

struct { member1: dataType; member2: dataType; } StructName;

The 'return' statement is used to declare a variable.

The 'return' statement pauses the function's execution.

The 'return' statement is only used in loops.

The 'return' statement signifies the end of a function's execution and provides a value to the function caller.

Recursion is a method where a function calls itself to solve smaller instances of the same problem.

Recursion is a method where a function runs in parallel to solve problems.

Recursion is a technique that involves using loops to repeat a function.

Recursion is when a function is executed only once without any repetition.

An array can change size dynamically, while a pointer cannot.

A pointer is a collection of elements, while an array is a single memory address.

An array holds a single value, while a pointer can hold multiple values.

An array is a fixed-size collection of elements, while a pointer is a variable that holds the address of a memory location.

Arrays cannot be passed to functions in C; you must use pointers instead.

You can pass an array to a function by using the syntax 'functionName(dataType arrayName[], int size)'.

You can pass an array by using 'functionName(arrayName, size)' without specifying the data type.

You can only pass arrays by copying their elements into individual parameters.

loop until condition

foreach loop

for loop, while loop, do while loop

repeat until loop

A preprocessor directive is a type of variable in C.

A preprocessor directive is a function that executes at runtime.

A preprocessor directive is a command that starts with '@' for error handling.

A preprocessor directive in C is a command that begins with '#' and is used for tasks like including files or defining macros.

Handle errors by checking return values, using errno, implementing error handling functions, and using setjmp/longjmp for critical errors.

Ignore errors completely

Use global variables to track errors

Always print error messages to the console

'sizeof' is a function that calculates the total memory used by a program.

'sizeof' returns the size of a variable or data type in bytes.

'sizeof' is used to allocate memory dynamically.

'sizeof' is used to declare the size of an array.

Use the syntax 'dataType arrayName[size1][size2];'.

Declare it as 'dataType arrayName[size1, size2];'.

Multi-dimensional arrays cannot be created in C.

Use 'dataType arrayName[size1] = { {value1, value2}, {value3, value4} };'.

'break' is used to exit a loop or switch statement prematurely.

'break' pauses the execution of a loop for a specified time.

'break' is used to skip the current iteration of a loop.

'break' is used to continue the next iteration of a loop.

'const' is a storage class that defines the lifetime of a variable.

'const' is used to define a variable that can be modified.

'const' is used to declare a function that cannot return a value.

'const' indicates that the value of a variable cannot be changed after initialization.

union UnionName { dataType member1; dataType member2; } = {value1, value2};

UnionName union { dataType member1; dataType member2; };

union { member1: dataType; member2: dataType; } UnionName;

union UnionName { dataType member1; dataType member2; ... };

'malloc' and 'calloc' are identical in functionality.

'malloc' is used for allocating memory for arrays, while 'calloc' is for single variables.

'malloc' allocates memory without initializing it, while 'calloc' allocates memory and initializes it to zero.

'malloc' is used for dynamic memory allocation, while 'calloc' is for static memory allocation.

'static' is used to declare global variables only.

'static' is used to allocate memory dynamically.

'static' makes a variable retain its value between function calls.

'static' limits the visibility of a variable to the file it is declared in.

type (functionName)();

type *functionName;

type (*functionName)();

functionName type();

'volatile' indicates that a variable may be changed unexpectedly, preventing the compiler from optimizing it.

'volatile' is used to declare a variable that cannot be modified.

'volatile' is a storage class that defines the lifetime of a variable.

'volatile' is used to declare a function that cannot return a value.

The 'return' type is only relevant for void functions.

The 'return' type specifies the type of value the function will return.

The 'return' type is used to declare global variables.

The 'return' type indicates the function will not return any value.

'break' is used to exit the switch statement and prevent fall-through.

'break' is used to pause the execution of the switch statement.

'break' is not applicable in switch statements.

'break' is used to skip the current case in a switch statement.

dataType variableName = const value;

dataType const variableName;

constant dataType variableName;

const dataType variableName;

'enum' is used to define a set of named integer constants.

'enum' is a function that returns a value based on conditions.

'enum' is used to declare a variable that can hold multiple values.

'enum' is a data type that allows for dynamic memory allocation.

pointerType pointerName = &functionName;

dataType (*pointerName)(parameterTypes);

dataType pointerName(parameterTypes);

functionType pointerName = (dataType *)functionName;

'continue' skips the current iteration and proceeds to the next iteration of the loop.

'continue' exits the loop entirely.

'continue' is used to break out of nested loops.

'continue' pauses the loop for a specified time.

'extern' is used to allocate memory dynamically.

'extern' is used to declare a variable that is defined in another file.

'extern' limits the visibility of a variable to the file it is declared in.

'extern' is used to declare local variables only.

'const' indicates that a variable's value cannot be changed after initialization.

'const' is used to declare a variable that can be modified.

'const' is a storage class that defines the lifetime of a variable.

'const' is used to declare a function that cannot return a value.

union UnionName { member1, member2; };

UnionName union { dataType member1; dataType member2; };

union { member1: dataType; member2: dataType; } UnionName;

union UnionName { dataType member1; dataType member2; ... };

'typedef' is used to define a new data type from scratch.

'typedef' is used to declare a function that cannot return a value.

'typedef' is used to create an alias for an existing data type.

'typedef' is a storage class that limits variable visibility.

'&&' is a logical AND operator that returns true if both operands are true.

'&&' is a bitwise AND operator.

'&&' is used to concatenate two strings.

'&&' is a comparison operator that checks for equality.

'volatile' is a storage class that defines the lifetime of a variable.

'volatile' is used to declare a variable that cannot be modified.

'volatile' indicates that a variable may be changed unexpectedly, preventing the compiler from optimizing it.

'volatile' is used to declare a function that cannot return a value.

'sizeof' is used to declare the size of a structure.

'sizeof' returns the size of a variable in bytes.

'sizeof' is used to allocate memory dynamically.

'sizeof' is a function that counts the number of elements in an array.

'struct' is used for function declarations, while 'union' is for variable declarations.

'struct' is a type of pointer, while 'union' is a type of array.

'struct' allocates memory for all members, while 'union' shares memory among its members.

'struct' can only hold integers, while 'union' can hold any data type.

'extern' is used to define a variable with local scope.

'extern' is used to declare a variable that is defined in another file.

'extern' is used to declare a function that cannot return a value.

'extern' is a storage class that limits variable visibility to the function it is declared in.

'static' is a storage class that defines the lifetime of a variable only within a function.

'static' restricts the visibility of a variable to the file it is declared in.

'static' allows a variable to retain its value between function calls.

'static' is used to declare a variable that can be modified.

'sizeof' returns the size of the first element in the array.

'sizeof' cannot be used with arrays.

'sizeof' returns the number of elements in the array.

'sizeof' returns the total size of the array in bytes.

pointerName = new StructName();

struct *pointerName = &StructName;

pointerName struct StructName;

StructName *pointerName;

'volatile' is used to declare a function that cannot return a value.

'volatile' is used to declare a variable that can be modified by external factors, preventing compiler optimizations.

'volatile' indicates that a variable's value can change at any time, such as in multi-threaded applications.

'volatile' is a storage class that limits the visibility of a variable to the file it is declared in.

Use 'arrayName = new dataType[size];'.

Use the syntax 'arrayName = malloc(size * sizeof(dataType));'.

Dynamic memory allocation is not possible for arrays in C.

Use 'arrayName = allocate(size);'.

'malloc' allocates memory without initializing it, while 'calloc' allocates memory and initializes it to zero.

'malloc' is used for allocating memory for structures, while 'calloc' is for arrays.

'malloc' requires the size of each element, while 'calloc' requires the total size.

There is no difference; both functions serve the same purpose.

'break' is used to pause the loop for a specified time.

'break' skips the current iteration and continues with the next one.

'break' exits the loop immediately.

'break' is used to terminate the program.

'||' is a logical OR operator that returns true if at least one operand is true.

'||' is a bitwise OR operator.

'||' is used to concatenate two strings.

'||' is a comparison operator that checks for inequality.

'sizeof' returns the size of the pointer type, not the size of the data it points to.

'sizeof' cannot be used with pointers.

'sizeof' returns the size of the data type pointed to by the pointer.

'sizeof' is used to allocate memory for pointers.

'static' is used for dynamic memory allocation.

'static' limits the visibility of a variable to the file it is declared in.

'static' is only applicable to global variables.

'static' is used to declare variables that retain their value between function calls.

struct StructName *pointerName;

struct *pointerName = StructName;

pointerName struct StructName;

struct StructName pointerName*;

'continue' is used to break out of nested loops.

'continue' pauses the loop for a specified time.

'continue' exits the loop entirely.

'continue' skips the current iteration and proceeds to the next iteration of the loop.

'typedef' is a function that returns a new data type.

'typedef' is used to create an alias for an existing data type.

'typedef' is used to define a variable's scope.

'typedef' is a storage class that limits variable visibility.

'continue' skips the current iteration and proceeds to the next iteration of the loop.

'continue' is used to terminate the program.

'continue' exits the loop immediately.

'continue' pauses the loop for a specified time.

'volatile' is used to declare a function that cannot return a value.

'volatile' is a storage class that defines the lifetime of a variable.

'volatile' ensures that a variable is always read from memory, preventing compiler optimizations that could lead to stale data.

'volatile' is used to declare a variable that cannot be modified.

'typedef' is a storage class that defines the lifetime of a variable.

'typedef' is used to declare global variables.

'typedef' is a function that returns a new data type.

'typedef' is used to create an alias for existing data types.

'++i' is used for floating-point numbers, while 'i++' is for integers.

'++i' and 'i++' are identical in functionality.

'++i' increments the value before it is used, while 'i++' increments it after.

'++i' is a preprocessor directive, while 'i++' is a function.

The 'switch' statement is used for looping through arrays.

The 'switch' statement is used to execute a block of code based on a specific condition.

The 'switch' statement is a way to declare multiple variables at once.

The 'switch' statement is used to handle exceptions in C.

'typedef' is used to define new functions.

'typedef' is used to create an alias for existing data types.

'typedef' is used to declare global variables only.

'typedef' is a storage class that limits variable visibility.

'++i' increments the value before it is used, while 'i++' increments it after.

'++i' and 'i++' are identical in functionality.

'++i' is used for floating-point numbers, while 'i++' is for integers.

'++i' is a preprocessor directive, while 'i++' is a function.

macro define MACRO_NAME(value);

#define MACRO_NAME value

define MACRO_NAME(value)

macro MACRO_NAME = value;

'extern' is a storage class that defines the lifetime of a variable only within a function.

'extern' is used to allocate memory dynamically.

'extern' is used to declare a variable that is defined in another file.

'extern' restricts the visibility of a variable to the file it is declared in.

struct StructName { dataType member1; dataType member2; };

structure StructName { member1, member2; };

struct StructName { member1, member2; ... };

struct { member1: dataType; member2: dataType; } StructName;

'sizeof' cannot be used with arrays.

'sizeof' is used to allocate memory for variables.

'sizeof' returns the number of elements in an array.

'sizeof' returns the size of a variable or data type in bytes.

Use 'delete arrayName;'.

Use 'dispose(arrayName);'.

Use 'free(arrayName);'.

Memory cannot be freed in C.

'volatile' indicates that a variable may be changed unexpectedly.

'volatile' is used to declare a variable that cannot be modified.

'volatile' is a storage class that limits variable visibility.

'volatile' is used to optimize memory allocation.

dataType *pointerName(parameterTypes);

pointerName dataType(parameterTypes);

dataType pointerName(parameterTypes);

dataType (*pointerName)(parameterTypes);

'volatile' tells the compiler that a variable may be changed unexpectedly.

'volatile' is used to declare a variable that cannot be modified.

'volatile' is used to optimize memory usage.

'volatile' is a storage class that limits variable visibility.

There is no difference; both serve the same purpose.

'struct' can only contain primitive data types, while 'union' can contain any data type.

'struct' is used for dynamic memory allocation, while 'union' is not.

'struct' allocates memory for all members, while 'union' shares memory among its members.

dataType *arrayName[size1];

dataType arrayName[size1][size2];

dataType *arrayName[size1][size2];

dataType **arrayName;

'enum' is used to declare a variable that can hold multiple data types.

'enum' is a function that returns the size of an array.

'enum' is a data type that allows for dynamic memory allocation.

'enum' is used to define a set of named integer constants.

'struct' is used for dynamic memory allocation, while 'union' is for static memory allocation.

'struct' allocates memory for all members, while 'union' shares memory among its members.

'struct' is a type of function, while 'union' is a variable type.

'struct' can only hold integers, while 'union' can hold any data type.

#define MACRO_NAME value

macro MACRO_NAME = value;

macro = #define MACRO_NAME value;

define MACRO_NAME(value)

'const' is used to define a constant function.

'const' is used to declare a variable whose value cannot be changed after initialization.

'const' is used to declare a variable that can be modified by external factors.

'const' is a storage class that limits the visibility of a variable.

'errno' is used to allocate memory dynamically.

Check the value of 'errno' after a function call to determine if an error occurred.

'errno' is a function that returns the last error code.

'errno' is set to zero by default and indicates no error.

'malloc' is faster than 'calloc' because it does not initialize memory.

'malloc' and 'calloc' are identical in functionality.

'malloc' is used for allocating memory for arrays, while 'calloc' is for single variables.

'malloc' allocates memory without initializing it, while 'calloc' allocates memory and initializes it to zero.

'extern' is used to allocate memory dynamically.

'extern' is a storage class that limits the visibility of a variable to the file it is declared in.

'extern' is used to define a variable that cannot be modified.

'extern' is used to declare a variable that is defined in another file.

Use the syntax 'dataType arrayName[size1][size2];'.

Multi-dimensional arrays are not supported in C.

Declare multiple arrays of the same type to simulate a multi-dimensional array.

Use the syntax 'dataType arrayName[size1, size2];'.

'goto' is used to jump to a specific label in the code.

'goto' is used to exit a loop.

'goto' is a function that executes a block of code.

'goto' is used to define a variable scope.

'typedef' is a storage class that limits variable visibility.

'typedef' is used to define new data types only.

'typedef' is used to create an alias for existing data types.

'typedef' is used to declare functions in C.

There is no difference; both serve the same purpose.

'struct' allocates memory for all members, while 'union' allocates memory for the largest member only.

'struct' is used for dynamic memory allocation, while 'union' is for static memory allocation.

'struct' can only contain primitive data types, while 'union' can contain any data type.

constant dataType variableName;

dataType variableName = constantValue;

const dataType variableName;

dataType const variableName;

'static' limits the visibility of a variable to the file it is declared in.

'static' indicates that a variable retains its value between function calls.

'static' is used to declare a variable that cannot be modified.

'static' is a storage class that defines the lifetime of a variable only within a function.

'malloc' allocates memory without initializing it, while 'calloc' allocates memory and initializes it to zero.

'malloc' is used for allocating memory for arrays, while 'calloc' is for single variables.

'malloc' requires the size in bytes, while 'calloc' requires the number of elements and size of each element.

'malloc' can only allocate memory for integers, while 'calloc' can allocate for any data type.

'typedef' is used to create an alias for an existing data type.

'typedef' is used to define a new data type from scratch.

'typedef' is used to declare a function that cannot return a value.

'typedef' is a storage class that limits the visibility of a variable.