1.

Difference between while and do while loop:

 While Loop: The condition is checked before executing the loop body. If the
condition is false initially, the loop may not execute at all.

cpp
Copy code
while (condition) {
// loop body
}

 Do While Loop: The loop body is executed first, and then the condition is checked.
This guarantees that the loop runs at least once.

cpp
Copy code
do {
// loop body
} while (condition);

2. Can you execute more than one statement in an if statement? If yes, elaborate it with
an example.

Yes, you can execute more than one statement within an if statement by using braces {} to
group the statements together.

Example:

cpp
Copy code
if (condition) {
statement1;
statement2;
}

3. What is the need for type conversion? Discuss different types of type conversion in
C++.

 Type Conversion is necessary to ensure that operations are performed with

compatible data types. It helps in preventing errors during computation.
 Implicit Type Conversion (or type casting) is done automatically by the compiler.
Example:

cpp
Copy code
int x = 10;
float y = 5.5;
float result = x + y; // Implicit conversion from int to float

 Explicit Type Conversion requires the programmer to specify the conversion using a
cast operator. Example:
 cpp
Copy code
double x = 5.6;
int y = (int) x; // Explicit conversion from double to int

4. What are control statements? Explain all in details.

Control statements allow you to control the flow of execution in a program:

 Conditional Statements: if, else, else if, switch

o These are used to make decisions based on conditions.
 Looping Statements: for, while, do while
o Used to repeat a block of code multiple times based on a condition.
 Jump Statements: break, continue, return
o Used to control the flow of loops or functions.

5. Enlist the rules for creation of variable names:

 A variable name must begin with a letter (A-Z or a-z) or an underscore (_).
 The remaining characters can be letters, numbers (0-9), or underscores.
 Variable names are case-sensitive (myVar is different from myvar).
 Keywords and reserved words cannot be used as variable names (e.g., int, for).
 Variable names should be descriptive to indicate their purpose (e.g., count instead of
c).

6. Justify why while loop is called Entry Control loop and do while is called Exit control
loop.

 While Loop (Entry Control): The condition is checked before the execution of the
loop body, so the loop may not execute at all if the condition is false.
 Do While Loop (Exit Control): The loop body is executed first, and the condition is
checked after the loop body, ensuring that the loop executes at least once.

7. Write and explain the Applications of arrays.

Arrays are used in situations where multiple values of the same type need to be stored and
processed together. Some common applications:

 Storing a list of values (e.g., a list of student marks).

 Representing matrices or multidimensional data.
 Implementing algorithms like sorting and searching.
 Storing results of repetitive calculations to be accessed later.
8. Describe the various types of functions in C++ language.

 Standard Library Functions: Predefined functions available in C++ libraries (e.g.,

printf, scanf).
 User-defined Functions: Functions created by the programmer to perform specific
tasks.
o Void Functions: Functions that do not return a value.
o Function with Return Value: Functions that return a value after execution.

9. Explain pointer to pointer with the help of a suitable example.

A pointer to a pointer is a variable that holds the address of another pointer variable. It allows
indirect access to the value that the first pointer points to.

Example:

cpp
Copy code
int num = 5;
int* ptr1 = # // Pointer to int
int** ptr2 = &ptr1; // Pointer to pointer

cout << **ptr2; // Outputs 5

In this example, ptr2 is a pointer to ptr1, and ptr1 points to the value num.

10. Explain the process of accessing array elements with the help of pointer.

Array elements can be accessed using pointers by treating the array name as a pointer to the
first element. Pointers can then be used to traverse the array.

Example:

cpp
Copy code
int arr[] = {10, 20, 30};
int* ptr = arr; // Pointer to the first element

cout << *ptr; // Outputs 10 (first element)

cout << *(ptr + 1); // Outputs 20 (second element)

Here, ptr acts as a pointer to the first element of the array, and pointer arithmetic (ptr + 1)
is used to access subsequent elements.

11. Explain call by value and call by reference using an example.

  Call by Value: A copy of the argument is passed to the function, so changes made
inside the function do not affect the original variable. Example:

cpp
Copy code
void func(int x) {
x = 10; // Changes the copy, not the original variable
}

int main() {
int a = 5;
func(a);
cout << a; // Outputs 5
}

 Call by Reference: The address of the argument is passed, so changes made inside
the function affect the original variable. Example:

cpp
Copy code
void func(int &x) {
x = 10; // Modifies the original variable
}

int main() {
int a = 5;
func(a);
cout << a; // Outputs 10
}

12. What is structure? Explain with the help of a suitable example.

A structure is a user-defined data type in C++ that allows grouping variables of different
types under a single name.

Example:

cpp
Copy code
struct Person {
string name;
int age;
};

int main() {
Person p1;
p1.name = "John";
p1.age = 30;

cout << p1.name << " is " << p1.age << " years old.";
}

In this example, the structure Person contains two members: name and age, which are of
different data types.
13. What is 1-D array initialization? Explain with syntax and example.

A 1-D array is a collection of variables of the same type, indexed by a single index.

 Syntax:

cpp
Copy code
data_type array_name[size] = {value1, value2, ..., valueN};

 Example:

cpp
Copy code
int arr[5] = {1, 2, 3, 4, 5};

Here, arr is a 1-D array of size 5, initialized with values 1, 2, 3, 4, and 5.

14. List any five string library functions with syntax and example.

1. strlen(): Returns the length of a string.

cpp
Copy code
int len = strlen("Hello"); // len = 5

2. strcpy(): Copies one string to another.

cpp
Copy code
char src[] = "Hello";
char dest[10];
strcpy(dest, src); // dest = "Hello"

3. strcat(): Concatenates two strings.

cpp
Copy code
char str1[20] = "Hello";
char str2[] = " World";
strcat(str1, str2); // str1 = "Hello World"

4. strcmp(): Compares two strings.

cpp
Copy code
int result = strcmp("abc", "def"); // result < 0 (since 'a' < 'd')

5. strstr(): Finds the first occurrence of a substring.

cpp
Copy code
 char str[] = "Hello, world";
char *sub = strstr(str, "world"); // sub points to "world"

15. Differentiate between actual parameter and formal parameter with example.

 Actual Parameter: The actual value or variable passed to the function when calling
it.
 Formal Parameter: The variable declared in the function definition to receive the
value of the actual parameter.

Example:

cpp
Copy code
void display(int x) { // 'x' is the formal parameter
cout << x;
}

int main() {
int num = 5;
display(num); // 'num' is the actual parameter
}

16. Define recursion with a suitable example.

Recursion is a process where a function calls itself to solve a smaller instance of the same
problem.

Example (Factorial of a number):

cpp
Copy code
int factorial(int n) {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1); // Function calls itself
}
}

int main() {
cout << factorial(5); // Outputs 120
}

17. Define structure. How members of the structure can be accessed using a structure
variable.

A structure is a user-defined data type that groups variables of different types.

 Accessing Members: Members of a structure are accessed using the dot (.) operator.
Example:

cpp
Copy code
struct Student {
string name;
int age;
};

int main() {
Student s1; // Structure variable
s1.name = "Alice"; // Accessing the 'name' member
s1.age = 20; // Accessing the 'age' member

cout << s1.name << " is " << s1.age << " years old.";
}

18. What is a pointer variable? How it is different from a normal variable.

 A pointer is a variable that stores the memory address of another variable, rather than
the data itself.
 A normal variable stores a value directly.

Example:

cpp
Copy code
int x = 10; // Normal variable
int* ptr = &x; // Pointer variable that stores the address of 'x'

19. Difference between arrays, references, and pointers.

 Arrays: Fixed-size data structures that store multiple elements of the same type.
Example:

cpp
Copy code
int arr[3] = {1, 2, 3};

 References: An alias for another variable. Once set, a reference cannot be changed to
refer to a different variable. Example:

cpp
Copy code
int x = 10;
int& ref = x; // 'ref' is a reference to 'x'

 Pointers: Variables that store the memory address of another variable. Pointers can be
changed to point to different variables. Example:

cpp
Copy code
int x = 10;
 int* ptr = &x; // 'ptr' points to 'x'

20. What do you mean by default arguments? Explain with an example.

Default Arguments are values assigned to function parameters when the caller doesn't
provide them.

Example:

cpp
Copy code
void greet(string name = "Guest") {
cout << "Hello, " << name << "!";
}

int main() {
greet(); // Outputs: Hello, Guest!
greet("John"); // Outputs: Hello, John!
}

21. What is the difference between actual and formal parameters?

This question is similar to question 15. The explanation remains the same:

 Actual Parameter: The value passed to the function when calling it.
 Formal Parameter: The variable that receives the value of the actual parameter in
the function definition.

22. How do you define an array of structures? Elaborate with an example.

An array of structures is a collection of structure variables, where each element in the array
is a structure.

 Syntax:

cpp
Copy code
struct StructureName {
data_type member1;
data_type member2;
};
StructureName array_name[size];

 Example:

cpp
Copy code
struct Student {
string name;
int age;
};

int main() {
 Student students[3]; // Array of 3 students
students[0].name = "Alice";
students[0].age = 20;
students[1].name = "Bob";
students[1].age = 22;
students[2].name = "Charlie";
students[2].age = 23;

for (int i = 0; i < 3; i++) {

cout << students[i].name << " is " << students[i].age << "
years old.\n";
}
}

23. How to access structure elements?

To access the elements of a structure, you use the dot (.) operator with the structure variable.
If you have a pointer to a structure, use the arrow (->) operator.

 Example (Accessing with a structure variable):

cpp
Copy code
struct Person {
string name;
int age;
};

int main() {
Person p;
p.name = "John";
p.age = 30;
cout << p.name << " is " << p.age << " years old.";
}

 Example (Accessing with a pointer):

cpp
Copy code
Person *p = &person;
cout << p->name << " is " << p->age << " years old."; // Use -> for
pointers

24. How many ways can you initialize a 1D array?

A 1D array in C++ can be initialized in several ways:

1. Static Initialization (All elements initialized explicitly):

cpp
Copy code
int arr[3] = {1, 2, 3};

2. Partial Initialization (Some elements initialized, the rest are set to 0):
 cpp
Copy code
int arr[5] = {1, 2}; // arr[2], arr[3], arr[4] will be 0

3. Implicit Initialization (Array size deduced from the number of elements):

cpp
Copy code
int arr[] = {1, 2, 3, 4}; // Compiler infers size = 4

4. Default Initialization (All elements set to 0 for basic types):

cpp
Copy code
int arr[5] = {}; // All elements are initialized to 0

25. Mention the limitations of inline functions.

While inline functions can improve performance by avoiding function call overhead, they
come with some limitations:

1. Increased Code Size: If a function is large and used many times, inlining it can
increase the size of the executable.
2. Limited to Small Functions: Inline functions are usually limited to small, frequently
called functions.
3. Compiler's Decision: The compiler may ignore the inline request if it deems inlining
inefficient.
4. Recursive Functions: Recursion is not supported in inline functions.

26. What is a string? Explain with an example to find a character from a string.

A string is a sequence of characters. In C++, strings are represented using either character
arrays or the string class from the C++ Standard Library.

 Example (Using a character array to find a character):

cpp
Copy code
char str[] = "Hello, World!";
char target = 'o';

for (int i = 0; str[i] != '\0'; i++) {

if (str[i] == target) {
cout << "Found character '" << target << "' at position " <<
i << endl;
}
}

 Example (Using string class to find a character):

cpp
 Copy code
string str = "Hello, World!";
size_t pos = str.find('o');

if (pos != string::npos) {
cout << "Found 'o' at position " << pos << endl;
}

27. Classification of user-defined function's components (elements).

A user-defined function in C++ consists of the following components:

1. Function Definition: Contains the function header, body, and return type.
o Return Type: Specifies the type of value the function will return.
o Function Name: The name of the function to call it.
o Parameters (Optional): Variables passed into the function for use.
o Function Body: The block of code that defines what the function does.
2. Function Declaration (or Prototype): Provides the compiler with information about
the function’s return type, name, and parameters (without the body).

cpp
Copy code
int add(int a, int b); // Function prototype

3. Function Call: Invoking the function from the main or other functions.

cpp
Copy code
int result = add(2, 3); // Calling the function

28. List any five string library functions with syntax and example.

This question has already been answered in question 14.

29. Explain function overloading.

Function overloading allows defining multiple functions with the same name but different
parameter types or numbers of parameters.

 Example:

cpp
Copy code
int add(int a, int b) {
return a + b;
}

double add(double a, double b) {

return a + b;
}
 int main() {
cout << add(5, 3) << endl; // Calls the int version
cout << add(5.5, 3.3) << endl; // Calls the double version
}

In this example, add is overloaded to handle both integer and double types.

30. Short note on array of structures.

An array of structures is used when you need to store multiple records of data, where each
record has different types of data. It allows you to access all members of a structure for
multiple instances.

 Example:

cpp
Copy code
struct Student {
string name;
int age;
};

int main() {
Student students[2] = {{"John", 20}, {"Jane", 22}};

cout << students[0].name << " is " << students[0].age << " years
old." << endl;
cout << students[1].name << " is " << students[1].age << " years
old." << endl;
}

31. What is the need of array? Discuss different types of arrays.

Arrays are used to store multiple values of the same type in a single variable. They simplify
the process of managing data, especially when the number of data items is large and known
in advance.

Types of Arrays:

1. One-Dimensional Array (1D Array): A linear collection of elements, accessed by a

single index.
o Example:

cpp
Copy code
int arr[5] = {1, 2, 3, 4, 5};

2. Two-Dimensional Array (2D Array): An array of arrays, often used to represent

matrices. Accessed by two indices.
o Example:
 cpp
Copy code
int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};

3. Multi-Dimensional Array: Arrays with more than two dimensions, used for more
complex data structures (e.g., 3D arrays).
o Example:

cpp
Copy code
int arr[2][3][4] = {{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11,
12}}, {{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}};

32. Explain various data types in detail.

C++ provides several data types for defining variables that hold different kinds of data.

1. Basic Data Types:

o int: Stores integer values (e.g., 1, -100).
o float: Stores floating-point numbers (e.g., 3.14, -7.5).
o double: Stores double-precision floating-point numbers (more precision than
float).
o char: Stores a single character (e.g., 'a', '1').
o bool: Stores boolean values (true or false).
2. Derived Data Types:
o Array: A collection of elements of the same type.
o Pointer: A variable that holds the memory address of another variable.
o Reference: An alias for another variable.
3. User-Defined Data Types:
o struct: A custom data type that groups variables of different types.
o enum: A user-defined type that consists of named integer constants.
o union: A data type that can hold variables of different types but only one at a
time.
o class: A blueprint for creating objects that contain data and functions.

33. Explain break, continue, with syntax.

 break: Exits the loop or switch statement prematurely.

o Syntax:

cpp
Copy code
break;

o Example:

cpp
Copy code
for (int i = 0; i < 10; i++) {
 if (i == 5) {
break; // Exits the loop when i equals 5
}
}

 continue: Skips the current iteration of a loop and moves to the next iteration.
o Syntax:

cpp
Copy code
continue;

o Example:

cpp
Copy code
for (int i = 0; i < 10; i++) {
if (i == 5) {
continue; // Skips the current iteration when i equals
5
}
}

34. Discuss the difference between 1-D array and 2-D array.

 1-D Array: A simple linear array with one index. It is used to store elements in a
single row.
o Example:

cpp
Copy code
int arr[5] = {1, 2, 3, 4, 5};

 2-D Array: An array with two indices, typically used to represent a matrix or table
with rows and columns.
o Example:

cpp
Copy code
int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

Key Differences:

 Size: 1-D array is a single row of elements, while 2-D array consists of multiple rows
and columns.
 Access: In a 1-D array, elements are accessed using a single index. In a 2-D array,
elements require two indices (row and column).

35. Explain call by value and call by reference in function with syntax.
  Call by Value: The function receives a copy of the argument's value. Changes made
inside the function do not affect the original argument.
o Syntax:

cpp
Copy code
void func(int x) {
x = 10; // Modifies the copy
}

o Example:

cpp
Copy code
int a = 5;
func(a); // a remains 5 after function call

 Call by Reference: The function receives the address of the argument. Changes made
inside the function affect the original argument.
o Syntax:

cpp
Copy code
void func(int &x) {
x = 10; // Modifies the original variable
}

o Example:

cpp
Copy code
int a = 5;
func(a); // a becomes 10 after function call

36. Explain structure with syntax.

A structure is a user-defined data type that allows grouping variables of different types
under a single name.

 Syntax:

cpp
Copy code
struct StructureName {
data_type member1;
data_type member2;
// Other members
};

 Example:

cpp
Copy code
struct Student {
 string name;
int age;
float grade;
};

int main() {
Student s1;
s1.name = "John";
s1.age = 20;
s1.grade = 85.5;

cout << s1.name << " is " << s1.age << " years old and scored "
<< s1.grade << ".";
}

37. Write a short note on 1-D and 2-D arrays and explain with the help of a real-time
example.

 1-D Array: A one-dimensional array stores a list of values in a single row. A real-
time example of a 1-D array could be storing the scores of students in a class.
o Example:

cpp
Copy code
int scores[5] = {85, 90, 78, 88, 92};

 2-D Array: A two-dimensional array stores values in a table format (rows and
columns). A real-time example of a 2-D array could be a seating arrangement in a
classroom.
o Example:

cpp
Copy code
int seating[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

38. Define an inline function. Give an appropriate example.

An inline function is a function for which the compiler generates code directly at the point of
function call, rather than performing a traditional function call. This can improve
performance by eliminating the function call overhead, especially for small functions.

 Syntax:

cpp
Copy code
inline return_type function_name(parameters) {
// function body
}

 Example:

cpp
Copy code
inline int add(int a, int b) {
 return a + b;
}

int main() {
int result = add(5, 3); // Compiler replaces this with: return 5
+ 3;
cout << result; // Outputs 8
}

39. Explain the process of passing a structure value to a function.

To pass a structure to a function, you can either pass it by value or by reference.

 Passing by Value: A copy of the structure is passed to the function, so changes made
inside the function do not affect the original structure.
o Example (Pass by Value):

cpp
Copy code
struct Person {
string name;
int age;
};

void display(Person p) {
cout << p.name << " is " << p.age << " years old.\n";
}

int main() {
Person p1 = {"John", 30};
display(p1); // Passes a copy of p1
}

 Passing by Reference: The address of the structure is passed to the function, so

changes made inside the function will affect the original structure.
o Example (Pass by Reference):

cpp
Copy code
struct Person {
string name;
int age;
};

void updateAge(Person &p) {

p.age = 35;
}

int main() {
Person p1 = {"John", 30};
updateAge(p1); // Modifies p1's age to 35
cout << p1.name << " is now " << p1.age << " years old.";
}
40. "Array can be preferred over singular variables for searching a number in the list"
– Justify this answer with a proposed solution accordingly.

Arrays are preferred over singular variables when dealing with a list of values because they
allow efficient and organized storage of multiple elements. Searching for a number in an
array is more efficient than using individual variables because:

1. Arrays can store multiple related data items, making it easier to handle a group of
values.
2. Arrays enable the use of loop-based search algorithms (e.g., linear search or binary
search) for more efficient searches.
3. Searching a number in a list of individual variables requires manually checking each
variable, which is time-consuming and error-prone.

 Example:

cpp
Copy code
int arr[] = {5, 10, 15, 20, 25};
int target = 15;
bool found = false;

for (int i = 0; i < 5; i++) {

if (arr[i] == target) {
found = true;
break;
}
}
if (found) {
cout << "Found " << target;
} else {
cout << target << " not found";
}

41. "Modularization is useful to implement the concept of reusability" – Justify it in

terms of using functions in programming.

Modularization refers to breaking down a large program into smaller, manageable, and
reusable functions or modules. This approach helps in achieving the concept of reusability,
where functions can be used across different programs or in various parts of the same
program without rewriting code.

 Advantages:
1. Code Reusability: Once a function is written, it can be called multiple times,
reducing the need to repeat the same code.
2. Easier Maintenance: Modular code is easier to test, debug, and maintain. If a
bug is found in a function, you only need to fix it in one place.
3. Organized Code: Modularization helps in organizing code logically into
smaller blocks, improving readability and structure.
 Example:

cpp
 Copy code
int add(int a, int b) {
return a + b; // This function can be reused in different parts
of the program
}

int main() {
int sum1 = add(5, 3); // Reusing the add function
int sum2 = add(10, 7); // Reusing the add function
cout << sum1 << " " << sum2;
}

42. "Structure can be used for creating records of data items with different data types"
– Justify this with an example.

A structure in C++ allows grouping variables of different data types under a single name.
This makes it ideal for creating records of data items that might have different data types
(e.g., a record of a student with a name, age, and grades).

 Example:

cpp
Copy code
struct Student {
string name;
int age;
float grade;
};

int main() {
Student s1 = {"John", 20, 85.5}; // Creating a record
cout << "Name: " << s1.name << ", Age: " << s1.age << ", Grade: "
<< s1.grade;
}

In this example, the Student structure contains different types of data (a string, an int, and
a float) within a single record. This makes structures useful for representing complex data
that needs to be treated as a unit.

43. What are various string handling functions? Explain any 5 with example.

The answer to this question was already provided in question 14, so feel free to refer to it!

44. How 1D and 2D arrays are initialized? Explain with examples.

1. 1D Array Initialization:
o Example:

cpp
 Copy code
int arr[5] = {1, 2, 3, 4, 5}; // 1D array with 5 elements

2. 2D Array Initialization:
o Example:

cpp
Copy code
int arr[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 2D array with 2
rows and 3 columns

45. How recursion is different from iteration? Explain.

Recursion and iteration are both techniques for repeating a block of code, but they differ in
their approach.

 Recursion: A function calls itself to solve a smaller instance of the problem. It

involves function calls and utilizes the call stack.
o Example (Factorial of a number):

cpp
Copy code
int factorial(int n) {
if (n == 0) return 1;
return n * factorial(n - 1);
}

 Iteration: A loop is used to repeat the code block until a condition is met. It doesn’t
use the function call stack and is usually more efficient in terms of memory.
o Example:

cpp
Copy code
int factorial(int n) {
int result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}

Difference:

 Recursion is often more elegant and natural for certain problems but can be less
efficient due to the overhead of function calls.
 Iteration is generally more efficient in terms of memory, as it doesn’t use the call
stack.

46. Write short note on inline and macros functions.

  Inline Functions: A function defined with the inline keyword is directly inserted
into the code at the point of call, which can reduce function call overhead. However, it
increases code size.
 Macros: Macros are preprocessor directives that are replaced with a value or code at
compile time. They don't have type checking and are more error-prone than inline
functions.

Example:

cpp
Copy code
#define SQUARE(x) ((x) * (x)) // Macro
inline int square(int x) { return x * x; } // Inline function

47. Differentiate between array and structure.

 Array:
o An array is a collection of variables of the same data type, stored in
contiguous memory locations.
o Arrays can only store elements of the same type (e.g., all integers or all floats).
o Accessing array elements is done via an index.

Example:

cpp
Copy code
int arr[5] = {10, 20, 30, 40, 50}; // Array of integers
cout << arr[2]; // Outputs 30

 Structure:
o A structure is a user-defined data type that groups variables of different types
under a single name.
o Structures allow different types of data to be stored together.
o Members of a structure can be accessed using the dot (.) operator.

Example:

cpp
Copy code
struct Student {
string name;
int age;
float grade;
};

Student s1 = {"John", 20, 85.5}; // Structure to store a student's

information
cout << s1.name << " is " << s1.age << " years old and scored " <<
s1.grade;

Key Differences:
  Arrays store multiple values of the same type, while structures store values of
different types.
 Arrays are accessed using indices, while structures are accessed using member names.

48. What is pointer? What are its operators? Explain.

A pointer is a variable that stores the memory address of another variable. It allows for direct
manipulation of memory and efficient handling of large data.

 Pointer Declaration:

cpp
Copy code
int* ptr; // Pointer to an integer

 Pointer Initialization:

cpp
Copy code
int x = 5;
int* ptr = &x; // ptr stores the address of x

 Operators used with Pointers:

1. Address-of operator (&): This operator is used to get the memory address of
a variable.

cpp
Copy code
int x = 5;
int* ptr = &x; // &x gives the address of x

2. Dereference operator (*): This operator is used to access the value at the
address stored in the pointer.

cpp
Copy code
int x = 5;
int* ptr = &x;
cout << *ptr; // Outputs 5 (the value stored at the address of
x)

49. What is 1D array and how we can declare, initialize and print it? Explain with the
help of a program.

A 1D array is a linear collection of elements, all of the same data type, stored in contiguous
memory locations. It can be declared, initialized, and accessed using an index.

 Declaration:

cpp
 Copy code
int arr[5]; // Declare an array of 5 integers

 Initialization:

cpp
Copy code
int arr[5] = {1, 2, 3, 4, 5}; // Initialize the array with values

 Accessing and Printing Elements:

cpp
Copy code
#include <iostream>
using namespace std;

int main() {
int arr[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
cout << arr[i] << " "; // Printing each element of the array
}
return 0;
}

Output:

Copy code
1 2 3 4 5

50. Differentiate the working of the 1D array and Character 1D Array.

 1D Array: A 1D array stores elements of any data type (e.g., int, float, etc.) in
contiguous memory locations, accessed by a single index.

Example:

cpp
Copy code
int arr[3] = {10, 20, 30}; // Array of integers

 Character 1D Array: A 1D array of characters is essentially a string, where each

element is a character (of type char). It stores a sequence of characters, often
terminated by a null character ('\0') to signify the end of the string.

Example:

cpp
Copy code
char name[5] = {'J', 'o', 'h', 'n', '\0'}; // Array of characters (a
string)

Key Differences:
  A character array stores individual characters, while a regular 1D array can store
elements of any data type.
 Character arrays are often used for strings, where the null character '\0' marks the
end of the string.

51. Differentiate between Inline and Macro Function.

 Inline Function:
o An inline function is a function whose code is directly inserted into the calling
location by the compiler, eliminating the function call overhead.
o It is type-safe and can handle parameters like regular functions.
o Example:

cpp
Copy code
inline int add(int a, int b) {
return a + b;
}

 Macro Function:
o A macro function is a preprocessor directive that replaces the code with its
definition before the program is compiled. Macros are not type-safe.
o Example:

cpp
Copy code
#define ADD(a, b) ((a) + (b))

Key Differences:

 Inline functions are type-safe, while macros are not.

 Inline functions are evaluated at runtime, while macros are expanded during
preprocessing.

52. What is recursion and how its working is different from the loop?

 Recursion: A process where a function calls itself to solve a problem in smaller

subproblems, often breaking down a complex task into simpler tasks.
o Example (Factorial):

cpp
Copy code
int factorial(int n) {
if (n == 0) return 1;
return n * factorial(n - 1); // Recursive call
}
  Loop: A loop repeats a block of code as long as a condition is true. It doesn’t involve
function calls and is generally more memory-efficient.
o Example:

cpp
Copy code
int factorial(int n) {
int result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}

Key Differences:

 Recursion uses function calls and a call stack, while loops use iterative control
structures.
 Recursion is often more elegant but less efficient in terms of memory.

53. How Structure is declared, initialized, and printed in C++?

 Declaration:

cpp
Copy code
struct Person {
string name;
int age;
};

 Initialization:

cpp
Copy code
Person p1 = {"Alice", 25}; // Initialize structure with values

 Printing:

cpp
Copy code
cout << "Name: " << p1.name << ", Age: " << p1.age;

Full Example:

cpp
Copy code
#include <iostream>
using namespace std;

struct Person {
string name;
int age;
};

int main() {
Person p1 = {"Alice", 25};
cout << "Name: " << p1.name << ", Age: " << p1.age;
return 0;
}

54. With the help of a diagram explain the memory allocation and the working of
pointers.

When a pointer is declared, memory is allocated to it, and it stores the address of another
variable. The memory address is stored in the pointer variable, and dereferencing the pointer
allows access to the value stored at that address.

 Memory Allocation:
o When you declare a pointer, it points to a memory address. Dereferencing the
pointer (*ptr) gives you access to the value stored at that address.

Diagram:

arduino
Copy code
int x = 10; // Variable x stores the value 10
int* ptr = &x; // Pointer ptr stores the address of x

Memory Representation:
+------+ +-------+
| x | | ptr |
+------+ +-------+
| 10 | → | 0x123|
+------+ +-------+
↑
Dereferencing ptr gives 10