They are set to one

They are automatically initialized to zero

They are left undefined

They are initialized to null

Single-dimensional arrays store data in rows and columns

Two-dimensional arrays store data in a linear sequence

Single-dimensional arrays store data in a linear sequence

Two-dimensional arrays store data in a single line

data_type array_name[size];

array_name[size] data_type;

data_type[size] array_name;

array_name data_type[size];

Using a loop

Using a string literal

Using a pointer

Using a function

printf(), scanf()

strlen(), strcpy()

malloc(), free()

fopen(), fclose()

strcpy

strcat

strcmp

strlen

A function is a block of statements that performs a specific task. Syntax: int add(int x, int y);

A function is a variable that stores data. Syntax: int add = 5;

A function is a loop that iterates over a block of code. Syntax: for(int i=0; i<10; i++);

A function is a conditional statement. Syntax: if(x > y)

Actual parameters are used in function definition; formal parameters are used in function call.

Actual parameters are stored in the called function; formal parameters are stored in the calling function.

Actual parameters are stored in the calling function; formal parameters are stored in the called function.

Actual parameters are variables; formal parameters are constants.

Increase the source code

Difficult to maintain and modify

Reduce the source code

Cannot be called from anywhere in the program

Functions with arguments and no return values

Functions with no arguments and no return values

Functions with arguments and with return values

All of the above

A structure is a single variable of one data type. Example: int number;

A structure is a collection of variables of different data types. Example: struct student { char name[20]; int ID; }

A structure is a loop that iterates over a block of code. Example: for(int i=0; i<10; i++);

A structure is a conditional statement. Example: if(x > y)

Structures have shared memory; unions have separate memory.

Structures and unions both have shared memory.

Structures have separate memory; unions have shared memory.

Structures and unions both have separate memory.

The arrow operator (->) for normal variables and dot operator (.) for pointers.

The dot operator (.) for normal variables and arrow operator (->) for pointers.

The dot operator (.) for pointers and arrow operator (->) for normal variables.

The arrow operator (->) for both normal variables and pointers.

A pointer is a variable that stores the value of another variable.

A pointer is a variable that stores the address of another variable.

A pointer is a variable that stores the type of another variable.

A pointer is a variable that stores the size of another variable.

By using the address of the pointer variable.

By using the value of the pointer variable.

By using the dereference operator (*) on the pointer variable.

By using the increment operator on the pointer variable.

A pointer that points to a valid memory location.

A pointer that points to the address of a variable.

A pointer that does not point to any memory location (value is NULL).

A pointer that points to the value of a variable.

It represents the address of the pointer.

It represents the value of the pointer.

It is the indirection/dereference operator used to access the value stored at the pointer’s address.

It is the operator used to increment the pointer’s address.

A void pointer can store the address of any type of variable and has a specific data type.

A void pointer cannot store the address of any type of variable.

A void pointer can store the address of any type of variable and does not have any data type associated with it.

A void pointer can only store the address of integer variables.

A collection of integers stored in an array

A collection of memory addresses stored in an array

A collection of strings stored in an array

A collection of characters stored in an array

A pointer to a variable

A pointer to a function's return value

A pointer variable that stores the address of a function

A pointer to a memory location

strcpy()

strcat()

strlen()

strcmp()

A function calling another function

A function calling itself

A loop within a function

A function with no return value

120

24

60

100

Simplifies code

Reduces memory usage

Increases speed

Decreases complexity

More memory usage (stack)

Slower execution

Less accurate

Harder to understand

A copy of the variable

The address of the variable

A reference to the variable

The variable's type

The address of the variable

A copy of the variable

The variable's type

A constant value

Reads a string

Prints a string with newline

Reads an integer

Prints an integer

Prints a string with newline

Reads a string

Prints an integer

Reads an integer

Structures can store different data types, unions cannot.

Unions can store different data types, structures cannot.

Structures allocate memory for all members, unions share memory.

Unions allocate memory for all members, structures share memory.

User-defined functions are pre-written, built-in functions are written by the user.

Built-in functions are pre-written, user-defined functions are written by the user.

Both are written by the user.

Both are pre-written.

Formal arguments are used in function calls, actual arguments are used in function definitions.

Actual arguments are used in function calls, formal arguments are used in function definitions.

Both are used in function calls.

Both are used in function definitions.

‘&’ is used to access the value, ‘*’ is used to access the address.

‘*’ is used to access the value, ‘&’ is used to access the address.

Both are used to access the value.

Both are used to access the address.

To point to a valid memory location.

To indicate that a pointer does not point to any valid memory location.

To point to the first element of an array.

To point to the last element of an array.

Open, Close, Read, Write, Append

Start, Stop, Read, Write, Delete

Open, Close, Start, Stop, Delete

Read, Write, Start, Stop, Append

int array[5] = {1, 2, 3, 4, 5};

array int[5] = {1, 2, 3, 4, 5};

int array = {1, 2, 3, 4, 5};

array int = {1, 2, 3, 4, 5};

Single-dimensional: int array[5]; Two-dimensional: int array[5][5];

Single-dimensional: int array[5][5]; Two-dimensional: int array[5];

Both are declared as int array[5];

Both are declared as int array[5][5];

gets() reads a line, puts() prints a line.

puts() reads a line, gets() prints a line.

Both gets() and puts() read a line.

Both gets() and puts() print a line.

strcpy()

strcat()

strlen()

strcmp()

They reduce code redundancy.

They increase code redundancy.

They make code harder to understand.

They slow down program execution.

Actual parameters are used in function definitions, formal parameters are used in function calls.

Formal parameters are used in function definitions, actual parameters are used in function calls.

Both are used in function definitions.

Both are used in function calls.

struct Student { int id; char name[50]; };

struct Student { int id; char name; };

struct Student { id; name[50]; };

struct Student { int id; name[50]; };

Using the ‘&’ operator.

Using the ‘*’ operator.

Using the ‘%’ operator.

Using the ‘#’ operator.

int *array[5];

int array[5];

int *array;

int array;