PROGRAMMING WITH C AND C++ STUDY

GUIDE

UNIT I

SHORT ANSWERS

Q1. History of C
• History of C: Developer: Developed by Dennis Ritchie in 1972 at AT&T's Bell Laboratories located in Murray
Hill, New Jersey, USA.
• Evolution: It was derived directly from earlier languages like BCPL and B (developed by Ken Thompson). C
was created to overcome the limitations of these languages by adding powerful data typing features.
• Purpose: It was originally created to write and implement the core architecture of the UNIX Operating System.
Today, it remains highly influential because almost all modern operating systems and compiled languages are
rooted in C syntax.

Q2. Basic Structure of C Language

A standard C program follows a precise structural layout to execute properly:
• 1. Documentation Section: Contains comments specifying the program's purpose, author name, and date.
• 2. Link Section: Contains preprocessor directives that include standard library header files (e.g., #include
<stdio.h>).
• 3. Global Declaration: Declaring variables or function blueprints that can be accessed globally across the
code.
• 4. main() Function: The mandatory starting block where program execution begins. It contains a local
declaration part and executable statements enclosed within opening and closing curly braces { }.

Q3. Sizeof() Operator

• Definition: It is a compile-time unary operator used to compute the exact amount of memory (allocated in
bytes) that a specific data type or variable occupies on a system.
• Syntax: sizeof(data_type); or sizeof(variable_name);
• Additional Details: Because the size of data types can vary across different hardware architectures (like 16-bit,
32-bit, or 64-bit systems), sizeof() ensures portability by evaluating size dynamically during compilation. It
returns an unsigned integer value and is highly useful when allocating memory dynamically using functions like
malloc().
• Example: sizeof(int) generally evaluates to 4 bytes on standard modern computers.

Q4. Pre-processor Directive

• Definition: These are source code instructions given directly to the compiler before the actual translation or
compilation process begins.

Programming with C and C++ 1

 • Identifier: They always begin with a hash symbol (#) and do not require a terminating semicolon at the end of
the line.
• Additional Details: The preprocessor scans the program file first, expanding macro definitions and substituting
header files into the code. This mechanism allows programmers to create highly modular, readable, and easily
modifiable software configurations.
• Example: #include <stdio.h> directs the compiler to load the standard input/output library, while #define PI
3.14 tells it to substitute the value 3.14 wherever PI appears.

Q5. Comments in C
• Definition: Comments are non-executable explanatory notes and text lines written inside the source code to
improve human readability. The C compiler completely ignores them during compilation.
• Additional Details: They serve as internal documentation to help other developers understand complex logic or
functions. Writing clean comments is a fundamental practice in software engineering to make code maintainable
over long periods.
• Types:
◦ 1. Single-line comment: Starts with double forward slashes // and applies only to that specific line.
◦ 2. Multi-line comment: Enclosed between a starting /* and an ending */, allowing notes to span across
multiple lines or paragraphs.

Q6. Keywords
• Definition: Keywords are pre-defined, reserved words whose internal semantic meaning is permanently fixed
and hardcoded within the C compiler.
• Rules: They cannot be repurposed or used as user-defined variables, functions, or identifiers. They must
always be written strictly in lowercase characters.
• Additional Details: If a programmer attempts to use a keyword as a variable name, the compiler will generate a
syntax error. Standard ANSI C consists of exactly 32 keywords that form the fundamental vocabulary of the
language.
• Examples: int, float, char, if, else, while, for, switch, and return.

Q7. Type Conversion

• Definition: The process of changing a value or variable from one data type into another completely different
data type during evaluation.
• Additional Details: Type conversion ensures that operations involving mixed data types can execute without
compatibility conflicts. It helps balance processing precision and memory consumption.
• Types:
◦ 1. Implicit (Type Promotion): Performed automatically by the compiler to upgrade a lower data type to a
higher data type to prevent data loss (e.g., automatically converting an int to a float during addition).
◦ 2. Explicit (Type Casting): Performed manually by the programmer using a casting operator to force
conversion. Syntax: (target_type) variable; (e.g., converting a float value to an int to drop its decimal
places).

Q8. Scope & Lifetime of a Variable

• Scope: Defines the exact visibility or structural boundary of a program where a variable can be accessed
directly. For example, a Local Scope variable is accessible only within its declaring block, while a Global Scope
variable is visible across all blocks and functions.

Programming with C and C++ 2

 • Lifetime: The total time duration during which a variable remains actively alive and retains its allocated physical
memory space in RAM during program execution.
• Additional Details: Scope dictates where you can use a variable, whereas lifetime dictates when that variable
exists. Properly managing both prevents runtime memory bugs and variable shadowing issues.

Q9. Flowchart & Algorithm

• Algorithm: A step-by-step, finite textual procedure written in plain English to solve a logical or mathematical
problem. It serves as the logical plan or recipe before writing actual code.
• Flowchart: The pictorial, schematic, or graphical representation of an algorithm using standard geometric
shapes connected by arrows called flow lines.
• Additional Details: Ovals are used for start/stop boundaries, rectangles represent processing steps, and
diamonds are used for decision-making steps. Both flowcharts and algorithms act as universal blueprints that
help programmers analyze code complexity regardless of the programming language used.

Q10. Conditional Operator (Ternary Operator)

• Definition: A shorthand, compact alternative used to replace simple if-else conditional statements. It is
explicitly called a ternary operator because it operates on exactly three operands.
• Syntax:
Condition ? Expression1 : Expression2;
• Working: The program first evaluates the Condition. If it proves true, Expression1 is executed and returned; if
the condition evaluates to false, Expression2 is executed instead.
• Additional Details: It is highly efficient for writing clean, single-line data assignments based on a state toggle.
However, nesting multiple ternary operators is generally discouraged because it makes the source code difficult
to read.

LONG ANSWERS

Q1. Explain about the features of C language.

• Introduction to C: C is a robust, structured, and general-purpose programming language developed by Dennis
Ritchie in 1972 at AT&T's Bell Laboratories. It serves as the foundational language for modern software
engineering because it combines the power of low-level assembly code with the readability of high-level
programming languages.
• Core Features of C:
◦ 1. Simple and Efficient: C provides a clean, syntax-driven approach that makes it exceptionally fast to write
and execute. It breaks down complex system processes into straightforward expressions.
◦ 2. Middle-Level Language: It bridges the gap between low-level languages (hardware manipulation) and
high-level languages (user application development). It supports direct memory allocation through pointers
while maintaining abstract data types.
◦ 3. Structured Programming Language: Programs can be divided into smaller, manageable, and self-
contained logical units called functions. This structure prevents messy debugging sessions and encourages
code reusability.
◦ 4. Rich Library Support: It comes packed with built-in functions via standard libraries to handle complex
tasks like standard input-output operations, mathematical computations, dynamic memory allocations, and
string manipulation.

Programming with C and C++ 3

 ◦ 5. Highly Portable: A C program written on one operating system or machine architecture can run
seamlessly on another machine with little to no modification, making it a globally accepted platform.
◦ 6. Pointer Implementation: C explicitly allows programmers to interact directly with physical computer
memory. Pointers optimize memory performance, facilitate the creation of complex data structures like linked
lists, and speed up overall execution.
◦ 7. Extensible Architecture: C permits the continuous addition of new features, custom user-defined
operations, and external library modules into an existing code base without breaking core operations.

Q2. Explain different types of programming languages.

• Introduction: A programming language is a structured set of instructions, symbols, and grammatical rules used
to write computer programs, enabling humans to communicate effectively with computer hardware.
Programming languages are broadly classified into three major generations based on their closeness to human
language and machine execution.
• Types of Programming Languages:
◦ 1. Low-Level Language (Machine Language / 1GL):
▪ This is the lowest, most fundamental language understood directly by the computer's Central Processing
Unit (CPU) without any translation.
▪ It consists entirely of binary digits—0s and 1s.
▪ Characteristics: It executes at blindingly fast speeds and consumes minimal memory. However, it is
incredibly difficult for humans to read, write, or debug, and it is strictly machine-dependent.
◦ 2. Middle-Level Language (Assembly Language / 2GL):
▪ This language introduces a layer of human-readable symbols called mnemonics (such as ADD, SUB, MOV,
PUSH) to replace complex binary strings.
▪ Characteristics: It requires a dedicated translator utility called an Assembler to convert mnemonics
back into machine-executable binary code. It provides exceptional low-level control over internal registers
and hardware, making it suitable for developing drivers and operating system kernels.
◦ 3. High-Level Language (3GL, 4GL, 5GL):
▪ These languages are designed using plain English words, mathematical symbols, and familiar logical
structures, making them highly intuitive for human programmers.
▪ Characteristics: They are strictly machine-independent, meaning the same program code can be moved
and executed across diverse hardware platforms. They require translation tools like Compilers or
Interpreters to run. Examples include C, C++, Java, Python, and COBOL.

Q3. Write about various datatypes in C language.

• Introduction: Data types in C define the nature, specific properties, operational constraints, and the exact
volume of memory space allocated to hold a variable's value during execution. They ensure the compiler
interprets the raw binary values stored in RAM accurately.
• Detailed Classification of Data Types:
◦ 1. Primary (Primitive / Basic) Data Types:
▪ char: Used to store a single character enclosed in single quotes. It occupies 1 byte of memory space and
operates using ASCII numerical values.
▪ int: Used to store whole numbers without fractional elements. It typically allocates 2 or 4 bytes of
memory depending on whether it runs on a 16-bit or 32/64-bit architecture.

Programming with C and C++ 4

 ▪ float: Used to handle real numbers containing fractional decimal points. It allocates 4 bytes of memory
and provides up to 6 digits of precision.
▪ double: Provides double-precision for larger decimal computations. It allocates 8 bytes of memory space
and supports up to 14 digits of precision.
▪ void: Represents an empty or non-existent value data type. It is widely applied to define functions that do
not return any value to the caller.
◦ 2. Derived Data Types:
▪ These types are constructed by extending or combining the primary data types.
▪ Examples: Arrays (ordered sequences of homogeneous elements), Pointers (variables storing memory
addresses), and Functions (modular blocks returning calculated outputs).
◦ 3. User-Defined Data Types:
▪ C allows programmers to construct customized data frameworks to cleanly map real-world records.
▪ Examples: Structures (struct), Unions (union), and Enumerations (enum).

Q4. Briefly discuss about operators in C with examples.

• Introduction: An operator is a special symbol that instructs the C compiler to perform specific mathematical,
logical, or relational transformations on data values called operands. Operands can be plain variables or
constant values. C contains a highly comprehensive suite of operators.
• Categories of Operators in C:
◦ 1. Arithmetic Operators: Used to execute core mathematical equations.
▪ Includes: + (Addition), - (Subtraction), * (Multiplication), / (Division), and % (Modulus—returns the integer
remainder of a division).
▪ Example: 10 % 3 evaluates to 1.
◦ 2. Relational Operators: Used to compare two operands to establish their relative relationship, returning
either True (1) or False (0).
▪ Includes: == (Equal to), != (Not equal to), >, <, >=, and <=.
▪ Example: 5 > 3 evaluates to 1 (True).
◦ 3. Logical Operators: Used to combine or negate multiple conditional expressions.
▪ Includes: && (Logical AND—returns true only if both conditions are true), || (Logical OR—returns true if
at least one condition is true), and ! (Logical NOT—inverts the logical state).
◦ 4. Assignment Operators: Used to store a calculated value into a targeted variable.
▪ Includes the standard assignment = and compound shorthand variants like +=, -=, *=, and /=.
▪ Example: x += 5 is structurally identical to writing x = x + 5.
◦ 5. Increment and Decrement Operators: Unary operators used to alter an integer value by exactly one.
▪ Includes: ++ (Increment) and -- (Decrement). These can be used as prefix (++x) or postfix (x++)
statements.
◦ 6. Conditional (Ternary) Operator: A shorthand operational substitute for standard if-else loops.
▪ Syntax: Condition ? Expression1 : Expression2;
◦ 7. Bitwise Operators: Used to perform calculations directly at the binary level on individual bits.
▪ Includes: & (Bitwise AND), | (Bitwise OR), ^ (Bitwise XOR), ~ (Bitwise NOT), << (Left Shift), and >>
(Right Shift).

Programming with C and C++ 5

Q5. Explain the process of creating, compiling, linking, and executing a C program.
• Introduction: Transforming raw human-readable C source code into a functional, standalone machine-
executable program involves a multi-stage software build pipeline. Each step is handled by distinct development
tools.
• The Step-by-Step Execution Lifecycle:
◦ 1. Creating (Editing): The programmer writes the human-readable source code using an editor or
Integrated Development Environment (IDE) and saves the document with a .c extension (e.g., program.c).
◦ 2. Preprocessing: Before compilation starts, the Preprocessor utility scans the source file. It strips out all
comments, expands macro values defined via #define, and injects the actual system code from requested
header files specified via #include. This outputs an expanded intermediate code file with an .i extension.
◦ 3. Compilation: The Compiler takes the intermediate .i file, validates its structural syntax against language
rules, and translates it into an optimized low-level machine-specific language called Assembly Language,
saving it as a .s file.
◦ 4. Assembly: The Assembler converts the assembly code .s file into pure binary machine language
instructions. This file is called an Object File and is saved with a .obj or .o file extension.
◦ 5. Linking: A system tool called the Linker takes the generated .obj file and combines it with pre-compiled
system library object codes (like [Link]). It resolves all functional references and bundles the modules
into a single standalone file called an Executable File, saved with an .exe extension.
◦ 6. Execution (Loading): The Loader subsystem pulls the .exe file from permanent secondary storage into
the computer's primary RAM. The CPU then begins executing the instructions sequentially starting at the
main() function.

Q6. Write about Formatted I/O operations with suitable example.

• Introduction: Formatted Input/Output operations are functions that allow data to be read from the keyboard or
displayed on the monitor in a highly controlled, specific arrangement or layout. Unlike unformatted functions,
formatted operations utilize custom characters called Format Specifiers to dictate how distinct data types (like
integers, floats, or characters) are parsed and formatted.
• Primary Formatted Functions:
◦ 1. printf() (Formatted Output): Displays formatted text strings and variable values onto the standard
console screen. It processes a control string embedded with format codes along with a list of arguments.
◦ 2. scanf() (Formatted Input): Reads user characters entered via the keyboard, automatically converts them
into specified internal data formats, and maps them to memory addresses using the address-of operator (&).
• Common Format Specifiers:
◦ %d or %i for signed integers.
◦ %f for floating-point decimal values.
◦ %c for individual characters.
◦ %s for character array strings.
• Code Implementation Example:

#include <stdio.h>

int main() {
int age;
float gpa;

Programming with C and C++ 6

 // Formatted Output asking for data
printf("Enter your age and GPA: ");

// Formatted Input receiving two distinct values

scanf("%d %f", &age, &gpa);

// Formatted Output printing structured results

printf("Age: %d years old | GPA: %.2f
", age, gpa);

return 0;
}

UNIT II

SHORT ANSWERS

Q11. If-statement
• Definition: The simplest conditional decision-making control structure used to execute a specific block of code
only if a given test condition evaluates to true.
• Syntax:

if (condition) {
// statements run only if the condition is true
}

• Additional Details: If the condition evaluates to false, the program completely skips over the inner block of
statements and resumes with the next line of code. It forms the foundational building block for adding basic logic
and conditional branching to a software application.

Q12. Nested if
• Definition: A conditional structure where an entire if statement is placed inside the body of another existing if
or else statement block.
• Purpose: Used when multiple, sequential dependent conditions must be evaluated before a specific piece of
code can run.
• Additional Details: In a nested setup, the inner if condition is tested only after the outer if condition has
already evaluated to true. While powerful for validating multi-layered rules, excessive nesting should be avoided
as it leads to complex, hard-to-read code.

Q13. Default Statement

• Definition: A catch-all control keyword used exclusively inside a switch-case block.
• Working: The default block executes automatically when none of the defined explicit case constants match
the value of the switch expression.

Programming with C and C++ 7

 • Additional Details: It operates similarly to the final else statement in an if-else-if ladder. Placing a default
case is a good practice because it handles unexpected or invalid user inputs gracefully, ensuring the program
does not fail silently.

Q14. Goto
• Definition: An unconditional jump statement used to transfer control instantly to a targeted line of code tagged
with a specific identifier name known as a label.
• Syntax: goto label_name;
• Additional Details: The destination line must be marked with a corresponding label_name: followed by a
colon. Using goto is generally discouraged in modern programming because it disrupts the natural top-down
flow of execution, creating complex "spaghetti code" that is difficult to trace, debug, and maintain.

Q15. Break
• Definition: A control jump keyword used to immediately terminate the execution of the nearest enclosing loop
(for, while, do-while) or a switch-case statement.
• Control Flow: It breaks the flow of execution and forces the program pointer to jump straight to the first line of
code immediately following the terminated block.
• Additional Details: In loops, it is typically paired with an if statement to exit early when a specific condition is
met, such as finding a target element during a search operation.

Q16. Continue
• Definition: A control jump statement that skips the remaining executable lines inside the current iteration of a
loop and forces the program to instantly jump to the next loop cycle test condition.
• Contrast: Unlike the break statement, continue does not exit or terminate the loop entirely. It simply bypasses
the rest of the statements in the current turn and forces the loop to proceed with its next update and evaluation
phase.
• Additional Details: It is useful when you want to skip processing specific invalid data points or exceptions
within a looping cycle without stopping the entire operation.

Q17. Switch Case

• Definition: A multi-way branch selection control structure used to test the value of a single variable or
expression against a predefined list of unique integer or character constants called cases.
• Working: When a matching case constant is found, the program executes that case's specific block of code.
• Additional Details: Every individual case block should typically conclude with a break statement to prevent
execution from accidentally falling through into the next case. A switch statement provides a much cleaner,
more organized, and faster alternative to long, complex if-else-if ladders.

Q18. For Loop

• Definition: A deterministic, entry-controlled loop structure used to execute a block of statements repeatedly for
a fixed number of iterations.
• Syntax:

for (initialization; condition; increment/decrement) {

// loop body statements
}

Programming with C and C++ 8

 • Additional Details: It groups the three critical loop management steps—counter initialization, conditional
testing, and loop counter updating—into a single line. It is best suited for scenarios where the exact total number
of loops is known in advance before execution begins.

Q19. Do-while Loop

• Definition: A post-test, exit-controlled loop structure that always executes its inner body of statements at least
once before evaluating its check condition.
• Syntax Note: Unlike other loops, the do-while loop ends with a trailing semicolon right after the condition: do
{ ... } while (condition);
• Additional Details: Because the condition check happens at the bottom of the loop body rather than the top,
the block runs unconditionally on its very first pass. This makes it ideal for menu-driven programs where a user
must see options at least once before choice validation occurs.

Q20. While Loop

• Definition: A pre-test, entry-controlled loop structure that evaluates its conditional expression before allowing
execution of the loop body.
• Working: If the condition evaluates to false at the very beginning, the inner loop body is completely bypassed
and never runs.
• Additional Details: It is primarily utilized when the exact total number of execution iterations is not known
beforehand, and the loop needs to run continuously until a specific condition dynamically changes to false.

Q21. Nested Loop

• Definition: A structural programming layout where a complete loop statement is embedded entirely inside the
body of another outer loop statement.
• Working: For every single iteration of the outer loop, the inner loop executes its entire cycle from start to finish.
• Additional Details: You can nest any loop type inside any other loop type (e.g., a while loop inside a for
loop). This technique is essential for processing multi-layered data structures, generating multidimensional grid
tables, or handling coordinate matrices.

LONG ANSWERS

Q7. What are decision-making statements? Explain them with suitable examples.
• Introduction: Decision-making (or selection) statements allow a program to alter its linear path of execution
based on specific conditions. They evaluate one or more conditions and execute a distinct block of statements if
the condition is True, or skip it if the condition evaluates to False.
• Types of Decision-Making Statements:
◦ 1. Simple if Statement: Evaluates a single test condition. If true, the code block runs; otherwise, it is
skipped.
◦ 2. if-else Statement: Provides a dual-path execution flow. If the test condition matches True, the if block
executes; if false, the else block runs.
◦ 3. Nested if-else Statement: Involves placing an entire if-else block inside another if or else block to
evaluate multiple dependent conditions sequentially.
◦ 4. if-else-if Ladder: A multi-path decision-making structure used when a program needs to check
multiple independent conditions sequentially until a valid one matches.

Programming with C and C++ 9

 • Code Implementation Example (if-else structure):

#include <stdio.h>

int main() {
int score = 75;

if (score >= 50) {

printf("Result: Passed
");
} else {
printf("Result: Failed
");
}

return 0;
}

Q8. What is meant by Loop? Explain about various looping statements in C.

• Introduction: A loop is a control structure that repeatedly executes a specific block of code as long as a defined
conditional expression remains true. Loops automate repetitive operations, reducing code duplication. Every
loop contains four essential components: initialization, a test condition, a loop body, and an update expression.
• Types of Loops in C:
◦ 1. while Loop (Entry-Controlled Loop): Evaluates the condition before executing the loop body. If the
condition is false initially, the loop body never runs.
▪ Syntax: while(condition) { // body }
◦ 2. for Loop (Entry-Controlled Loop): It is a compact loop structure that groups initialization, the test
condition, and the update expression into a single line. It is best suited when the exact number of iterations is
known in advance.
▪ Syntax: for(initialization; condition; update) { // body }
◦ 3. do-while Loop (Exit-Controlled Loop): Evaluates the test condition at the bottom of the loop body. This
guarantees that the loop body executes at least once, regardless of whether the condition is true or false
initially.
▪ Syntax: do { // body } while(condition);
• Code Implementation Example (for loop):

#include <stdio.h>

int main() {
int i;
for (i = 1; i <= 5; i++) {
printf("Iteration: %d
", i);
}
return 0;
}

Programming with C and C++ 10

Q9. What is a switch statement? Explain it with a suitable example.
• Introduction: A switch statement is a multi-way decision-making control structure that provides a clean
alternative to a long, complex if-else-if ladder. It tests the value of a single variable or expression against a
predefined list of unique integer or character values called cases.
• Key Execution Rules:
◦ When a match is found, the program transfers control to that specific case block and executes its
statements.
◦ break statement: Every case block typically ends with a break keyword. Execution will fall through to
subsequent cases, running them unintentionally, if break is omitted.
◦ default statement: An optional catch-all block positioned at the bottom that executes automatically if none
of the explicit cases match the evaluated expression.
• Code Implementation Example:

#include <stdio.h>

int main() {
char grade = 'B';

switch(grade) {
case 'A':
printf("Excellent Performance!
");
break;
case 'B':
printf("Good Performance
");
break;
case 'C':
printf("Average Performance
");
break;
default:
printf("Invalid Grade Entered
");
}
return 0;
}

Q10. What are conditional statements? Briefly explain them.

• Introduction: Conditional statements are control structures that direct the execution flow of a program based on
logical evaluations. Instead of executing code line-by-line sequentially from top to bottom, these statements
analyze boolean conditions to determine which blocks of code should run and which should be skipped.
• Overview of Conditional Structures:
◦ 1. if Structures: Direct execution based on standard boolean conditions. This includes simple if, dual-
path if-else, and multi-path if-else-if ladders.
◦ 2. switch-case Structures: Evaluate a single integer or character expression to branch to a matching
constant case label.

Programming with C and C++ 11

 ◦ 3. Ternary Operator (? :): An inline, compact conditional operator that takes three operands to evaluate
simple assignments efficiently in a single line.
• Purpose in Software: Conditional statements enable software to exhibit intelligent behavior, respond
dynamically to varying user inputs, manage data validation checks, and handle exceptional error states
gracefully.

Q11. Explain about Goto, Break and Continue with suitable examples.
• Introduction: goto, break, and continue are unconditional jump statements used to alter the normal linear
path of execution based on specific runtime conditions. They allow a program to jump sequentially or
immediately to a completely different line of code without waiting for conditions to evaluate normally.
• Detailed Explanations and Conditions:
◦ 1. break Statement: Immediately terminates the execution of the nearest enclosing loop or switch
statement, passing control straight to the next line of code outside that block. Example: Exiting a loop early
as soon as a target element is found.
◦ 2. continue Statement: Skips the remaining executable statements inside the current iteration of a loop and
immediately advances control to the next loop update and condition evaluation check.
◦ 3. goto Statement: Unconditionally jumps control to a line marked by a specific text identifier called a label.
Its use is generally discouraged in structured programming because it can create confusing, unmaintainable
"spaghetti code."
• Code Implementation Example (break and continue):

#include <stdio.h>

int main() {
int i;
for (i = 1; i <= 5; i++) {
if (i == 2) {
continue; // Skips printing 2
}
if (i == 4) {
break; // Exits the loop entirely at 4
}
printf("Number: %d
", i);
}
return 0; // Output will be: Number: 1, Number: 3
}

Programming with C and C++ 12

 UNIT III

SHORT ANSWERS

Q22. String.h
• Definition: A standard C library header file that contains pre-built function definitions designed specifically to
manipulate and manage null-terminated character arrays (strings).
• Common Functions: Includes strlen() to calculate length, strcpy() to copy a string, strcat() to
concatenate (join) strings, and strcmp() to compare two strings alphabetically.
• Additional Details: Including #include <string.h> at the top of your program gives you access to optimized,
safe string handling routines, eliminating the need to write complex character-by-character loops manually.

Q23. Math.h
• Definition: A standard C library header file that provides declarations and definitions for performing core
mathematical and trigonometric computations.
• Common Functions: Includes sqrt(x) for square roots, pow(x, y) to calculate x raised to power y, abs(x) for
absolute integer values, sin(), cos(), ceil(), and floor().
• Additional Details: Most mathematical functions defined within this header return double-precision floating-
point values. When compiling programs using math.h on Linux environments, developers often need to link the
math library explicitly using the -lm flag.

Q24. Recursion
• Definition: A functional programming technique where a function calls an instance of itself either directly or
indirectly to solve a complex problem broken down into smaller sub-problems.
• Requirement: Must contain a clearly defined terminating base condition to stop the self-calling process.
• Additional Details: Without a proper base condition, a recursive function will cause infinite loops, rapidly
consuming memory until a stack overflow crash occurs. It is highly useful for solving problems that have
naturally repetitive structures, such as calculating factorials, generating the Fibonacci series, or traversing tree
structures.

Q25. Return Statement

• Definition: A jump statement used to terminate execution of a function immediately and pass execution control
back to the original calling function block.
• Value Passing: It can optionally return a single data value back to the caller, provided that value matches the
function's declared return type.
• Additional Details: If a function is declared with a void return type, the return; statement is optional and does
not pass a value. Once a return statement executes, any lines of code written after it within that function block
are completely ignored.

Q26. Actual Parameters Vs. Formal Parameters

• Actual Parameters: The actual variables, constants, or expressions passed inside the parentheses into a
function during its invocation/call inside main().
• Formal Parameters: The local variables declared inside the function definition header designed to receive
those incoming values.

Programming with C and C++ 13

 • Additional Details: Formal parameters exist only while the function is executing and are destroyed when the
function exits. Actual parameters supply the initial values that initialize these formal parameters at runtime.

Q27. Multi-dimensional Array (Two-dimensional)

• Definition: An organized array of arrays structured as a grid matrix containing horizontal rows and vertical
columns.
• Declaration Syntax:
data_type array_name[row_size][column_size];

• Additional Details: In memory, a two-dimensional array is stored sequentially in a continuous, linear row-major
order. To access or modify any specific element in a 2D array, you must specify two indices: the first index for
the row number and the second for the column number (e.g., matrix[0][1]).
• Example: int matrix[3][3]; allocates room for a 3x3 table containing 9 total integer elements.

Q28. Function Prototype

• Definition: A forward declaration of a function that provides the compiler with essential structural information
about the function's name, return type, and expected parameters before it is used.
• Syntax Example:
int add(int a, int b); (Note that it always terminates with a semicolon).
• Additional Details: It acts as an interface blueprint. The prototype allows the compiler to perform type checking
on function calls throughout the file, ensuring that the arguments passed match the expected types, even if the
actual function body is defined later in the file or in an external file.

Q29. Function Call

• Definition: An expression statement used to invoke a function, transferring execution control and data from the
current block over to the targeted function.
• Syntax Example:
result = add(10, 20);
• Additional Details: When a function call occurs, the current state of execution is paused on the system stack,
control jumps to the function code block, executes it completely, and then returns to the exact spot where the
call was made to resume normal operations.

Q30. Call by Value

• Definition: A parameter-passing mechanism where a duplicate copy of the actual argument's data value is
passed into the function's formal parameters.
• Safety: Any changes or modifications made to the formal parameters inside the function block do not alter the
original actual parameters.
• Additional Details: This is the default parameter passing method in C. It provides excellent data protection
because the function cannot accidentally modify variables in the calling block, though it can incur minor memory
overhead when copying large data structures.

Q31. Call by Reference

• Definition: A parameter-passing mechanism where the direct memory address of the actual parameters is
passed into the function using pointer variables.
• Behavior: Because the function operates directly on the memory address, any modifications made to the
parameters inside the function permanently alter the original variables in the calling block.

Programming with C and C++ 14

 • Additional Details: This method allows a function to effectively return multiple modified values to the caller. It is
highly efficient for handling large structures because it passes a lightweight address rather than copying a large
block of data.

LONG ANSWERS

Q12. What is an Array? Explain different types of Arrays.

• Introduction: An array is a derived, structured data type that stores a fixed-size, ordered sequence of elements
belonging to the same homogeneous data type. Array elements are stored in continuous, sequential memory
locations under a single shared name. Individual elements are accessed using a unique integer index value that
begins at 0.
• Types of Arrays:
◦ 1. One-Dimensional (1D) Array:
▪ Represents a single row or linear list of elements. It requires only a single index bracket to access any
specific item.
▪ Syntax: data_type array_name[size];
▪ Example: int marks[5]; allocates memory for 5 separate integer values.
◦ 2. Two-Dimensional (2D) Array:
▪ Arranges data elements as a grid layout structured into horizontal rows and vertical columns. It requires
two sets of index brackets: the first for the row index and the second for the column index.
▪ Syntax: data_type array_name[rows][columns];
▪ Example: int matrix[3][4]; defines a table grid with 3 rows and 4 columns.
◦ 3. Multi-Dimensional Array:
▪ Extends arrays beyond two dimensions to represent multi-layered mathematical spaces (such as 3D
matrices). It uses three or more index brackets (e.g., int hypercube[2][3][4];).

Q13. What is a String? Explain about different string handling functions.

• Introduction: In C, a string is a sequential sequence of characters treated as a single data unit. It is
implemented as an array of characters that always concludes with a unique hidden character called the Null
Character (). The null character indicates the boundary end of the string text in memory. C provides a
comprehensive suite of built-in functions inside the <string.h> library.
• Core String Handling Functions:
◦ 1. strlen(str) (String Length): Computes and returns the total number of characters present in a string,
excluding the terminal null character.
◦ 2. strcpy(dest, src) (String Copy): Copies the text contents of a source string into a destination character
array, including the trailing null character.
◦ 3. strcat(dest, src) (String Concatenation): Appends or joins a copy of the source string onto the end of
the destination string.
◦ 4. strcmp(str1, str2) (String Compare): Compares two strings character by character based on their ASCII
values. It returns 0 if both strings are identical, a positive value if str1 > str2, or a negative value if str1 < str2.
• Code Implementation Example:

Programming with C and C++ 15

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

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

// Copying string
strcpy(destination, source);
printf("Copied String: %s
", destination);

// Finding length
printf("Length of string: %d
", (int)strlen(source));

return 0;
}

Q14. What is a Function? Explain about different types of functions in C.

• Introduction: A function is a self-contained, modular block of code designed to execute a specific, well-defined
task. Functions allow complex monolithic programs to be broken down into smaller, logical sub-units. This
practice makes code clean, easier to debug, highly readable, and reusable without duplication. Every complete
function lifecycle involves a function prototype declaration, a function call, and a formal function definition block.
• Classification of Functions:
◦ 1. Library (Built-in) Functions:
▪ Pre-compiled functions provided by the C development environment that are stored inside standard
system header libraries.
▪ Examples: printf(), scanf(), sqrt(), pow(), and exit().
◦ 2. User-Defined Functions:
▪ Custom functions created, structured, and named by the programmer to address specific logical needs
within an application.
▪ Examples: int calculateTax(int income);
• Functional Configurations based on Arguments and Returns:
◦ Category 1: Functions with no arguments passed and no return value.
◦ Category 2: Functions with arguments passed but no return value.
◦ Category 3: Functions with no arguments passed but returning a calculated value.
◦ Category 4: Functions with arguments passed and returning a calculated value.

Q15. What are Built-in functions? Explain about any 3 types of built-in functions.
• Introduction: Built-in (or library) functions are standard pre-compiled routines included with the C compiler
environment. Programmers can invoke these functions instantly to perform common tasks without needing to
write the underlying operational code from scratch. To use them, you must include their corresponding header
file at the top of the program.

Programming with C and C++ 16

 • Three Primary Subcategories of Built-in Functions:
◦ 1. Standard Input/Output Functions (<stdio.h>): Used to handle data exchange between the application,
keyboard hardware, and console monitor. Examples: printf() (writes formatted output text) and scanf()
(reads formatted input keys).
◦ 2. Mathematical Computation Functions (<math.h>): Used to execute complex arithmetic calculations.
Examples: sqrt(x) (computes the square root of a double value) and pow(base, exp) (raises a base
number to a specific exponent power).
◦ 3. Character Utility Functions (<ctype.h>): Used to analyze and test individual character attributes or
perform type transformations. Examples: isalpha(c) (checks if a character is an alphabet letter) and
toupper(c) (converts a lowercase character to uppercase).

Q16. What is User-defined functions? Explain how to create them with suitable example.
• Introduction: A user-defined function is a custom, programmer-created block of code designed to perform a
specific task within an application. These functions allow developers to extend C's capabilities by building
modular, reusable blocks tailored to their program's logic.
• Three Essential Steps to Create a User-Defined Function:
◦ 1. Function Declaration (Prototype): Declares the function's name, return type, and parameter list at the
top of the file, informing the compiler about its signature.
◦ 2. Function Call: Invokes the function from another part of the program (like main()), passing actual values
called arguments into it.
◦ 3. Function Definition: The actual block of code containing the local statements that execute when the
function is called.
• Code Implementation Example:

#include <stdio.h>

// 1. Function Prototype Declaration

int computeSquare(int num);

int main() {
int input = 5;
int result;

// 2. Function Invocation / Call

result = computeSquare(input);

printf("The square of %d is: %d

", input, result);
return 0;
}

// 3. Function Definition Block

int computeSquare(int num) {
int output;
output = num * num;
return output; // Returns calculated value
}

Programming with C and C++ 17

Q17. Write a C program to add two given matrices.
• Introduction: Matrix addition is performed using two-dimensional arrays. To add two matrices, both must have
the same dimensions (the same number of rows and columns). The addition is performed by adding
corresponding elements at each position (i.e., C[i][j] = A[i][j] + B[i][j]).
• Complete Code Implementation:

#include <stdio.h>

int main() {
int rows = 2, cols = 2;
int matrixA[2][2] = {{1, 2}, {3, 4}};
int matrixB[2][2] = {{5, 6}, {7, 8}};
int sumMatrix[2][2];
int i, j;

// Outer loop iterates through rows

for(i = 0; i < rows; i++) {
// Inner loop iterates through columns
for(j = 0; j < cols; j++) {
sumMatrix[i][j] = matrixA[i][j] + matrixB[i][j];
}
}

// Displaying the resulting sum matrix

printf("Resulting Matrix Sum:
");
for(i = 0; i < rows; i++) {
for(j = 0; j < cols; j++) {
printf("%d ", sumMatrix[i][j]);
}
printf("
"); // Newline after each row
}

return 0;
}

Q18. What is Recursion? Explain it with suitable example.

• Introduction: Recursion is a programming technique where a function calls itself directly or indirectly to solve a
problem. It works by breaking down a complex problem into smaller, repeating sub-problems of the same type.
• Critical Requirements for Recursion:
◦ Base Case (Termination Condition): A defined condition where the function stops calling itself and returns
a fixed value. Without a base case, the function will execute infinitely, causing a stack overflow crash.
◦ Recursive Step: The part of the function where it calls itself with modified arguments, gradually moving
closer to the base case.
• Code Implementation Example (Factorial Calculation):

#include <stdio.h>

// Recursive function definition

Programming with C and C++ 18

 int findFactorial(int n) {
// Base Case to terminate recursion
if (n == 0 || n == 1) {
return 1;
}
// Recursive Step
return n * findFactorial(n - 1);
}

int main() {
int number = 4;
int result = findFactorial(number);
printf("Factorial of %d is: %d
", number, result);
return 0;
}

Q19. Write about different ways to use a function in C language.

• Introduction: Functions process data by accepting parameters from the calling block and returning results.
Depending on how variables are passed into the function, C supports two primary data interaction mechanisms.
• The Two Parameter-Passing Mechanisms:
◦ 1. Call by Value:
▪ The compiler passes a duplicate copy of the actual argument's value into the function's formal
parameters.
▪ Characteristics: The function operates entirely on this separate duplicate copy in a separate memory
location. Any modifications made to the parameters inside the function do not alter the original variables
in the calling block. This is C's default passing method, providing excellent data security.
◦ 2. Call by Reference:
▪ The program passes the actual memory address of the variables into the function using pointers.
▪ Characteristics: Because the function has direct access to the variables' memory addresses, any
changes made to the parameters inside the function permanently modify the original values in the
calling block. This mechanism is highly efficient for modifying variables directly or passing large data
structures without copying them.

UNIT IV

SHORT ANSWERS

Q32. Pointer
• Definition: A special variable that stores the raw memory address of another variable as its data value rather
than storing a standard data literal.
• Operators: Uses the reference operator & (address-of) to fetch a variable's address, and the dereference
operator * (value-at-address) to access the content stored at that address.

Programming with C and C++ 19

 • Additional Details: Pointers provide powerful capabilities such as dynamic memory allocation, efficient array
processing, and the ability to implement reference passing in functions. Mismanaging pointers can lead to
serious system errors, such as dangling pointers or memory leaks.

Q33. Structure
• Definition: A user-defined data type that groups related variables of different data types together under a
single, unified name.
• Memory Allocation: The total memory space allocated for a structure is equal to the sum of the individual
memory footprints of all its internal members combined.
• Additional Details: It uses the struct keyword for declaration, and its individual internal data fields are
accessed using the dot operator (.). Structures are essential for managing real-world record systems, such as
grouping a student's name, roll number, and marks into a single unit.

Q34. Union
• Definition: A user-defined data type that allows grouping multiple variables of different data types under a
single name, where all members share the exact same memory location.
• Memory Allocation: The total memory allocated for a union is limited to the size of its single largest internal
member.
• Additional Details: It uses the union keyword. Because all internal fields share the same memory space, a
union can hold only one valid member value at any given time. Modifying one member will overwrite the shared
space, corrupting the values of the other members. It is primarily used to save memory in embedded systems.

Q35. enum
• Definition: An abbreviation for enumeration, enum is a user-defined data type used to assign human-readable
text names to a finite set of internal integer constants.
• Purpose: It makes a program cleaner, more readable, and easier to maintain by replacing obscure numeric
codes with clear text words.
• Additional Details: By default, the C compiler automatically assigns the integer value 0 to the first identifier, 1 to
the second, 2 to the third, and so on. Developers can also explicitly assign custom values to any of the
identifiers if needed.
• Example: enum Weekday {Sun, Mon, Tue}; (Automatically sets Sun=0, Mon=1, Tue=2).

Q36. typedef
• Definition: A compiler keyword used to define an alternative, user-friendly nickname or alias for an existing
standard or user-defined data type.
• Syntax Example:
typedef unsigned long ulong; allows you to declare variables using ulong x; instead of writing out the full
type.
• Additional Details: It does not create a new data type; it simply establishes a synonym for an existing one. It is
frequently used with complex structure declarations to make the code shorter and easier to read by eliminating
the need to repeatedly type the struct keyword.

Programming with C and C++ 20

LONG ANSWERS

Q20. Define Structure. Explain how do you initialize and access structure members in C?
• Introduction: A structure (struct) is a user-defined data type that allows you to group related variables of
different data types together under a single name. Unlike arrays, which store only homogeneous elements,
structures enable developers to manage heterogeneous records, such as combining a student's name (char[]),
roll number (int), and GPA (float) into a single cohesive unit.
• Syntax, Initialization, and Access Operations:
◦ Declaration Syntax:

struct Student {
int rollNo;
float gpa;
};

◦ Initialization: A structure variable can be initialized by providing a comma-separated list of values enclosed
in curly braces matching its member order.
◦ Accessing Members: Individual structure fields are accessed using the dot operator (.) between the
structure variable name and the member field name.
• Code Implementation Example:

#include <stdio.h>

struct Student {
int rollNo;
float gpa;
};

int main() {
// Initializing structure variable
struct Student s1 = {101, 3.85};

// Accessing structure variables using dot operator

printf("Student Roll No: %d
", [Link]);
printf("Student GPA: %.2f
", [Link]);

return 0;
}

Q21. Explain Array of Structure with suitable example.

• Introduction: An array of structures is a composite data structure used when a program needs to store and
manage multiple records of the same structure type. While a single structure variable represents a single record
(e.g., one student), an array of structures acts as a mini-database table capable of holding rows of data records
(e.g., details for an entire classroom of students).

Programming with C and C++ 21

 • Syntax and Practical Behavior:
◦ Declaration Syntax:
struct StructureName arrayName[size];
◦ Access Layout: Individual records are accessed via an array index number, and specific fields within that
record are accessed using the trailing dot operator. (e.g., studentList[i].gpa).
• Code Implementation Example:

#include <stdio.h>

struct Book {
int bookId;
float price;
};

int main() {
// Declaring an Array of Structures
struct Book library[2];
int i;

// Populating data manually

library[0].bookId = 501; library[0].price = 450.50;
library[1].bookId = 502; library[1].price = 299.00;

// Displaying Array data using a for loop

for(i = 0; i < 2; i++) {
printf("Book ID: %d | Price: %.2f
", library[i].bookId, library[i].price);
}
return 0;
}

Q22. Define Union. Explain how do you initialize and access union members in C?
• Introduction: A union is a user-defined data type that allows grouping multiple variables of different data types
under a single name, where all members share the exact same memory location. While a structure allocates
separate memory blocks for each member, a union allocates a single memory sized to match its largest
member.
• Initialization and Access Constraints:
◦ Shared Memory Constraint: Because memory is shared, a union can store only one valid member value at
any given time. Assigning a value to one member overwrites the shared memory, corrupting any previously
stored data in other members.
◦ Accessing Members: Like structures, union members are accessed using the dot operator (.).
• Code Implementation Example:

#include <stdio.h>

union Data {
int intVal;
float floatVal;
};

Programming with C and C++ 22

 int main() {
union Data d;

// Correct initialization pattern: One at a time

[Link] = 10;
printf("Stored Integer Value: %d
", [Link]);

[Link] = 22.5; // Overwrites intVal space

printf("Stored Float Value: %.2f
", [Link]);

return 0;
}

Q23. Explain the differences between structure and union.

• Introduction: Structures and unions are both user-defined data types in C used to group variables of different
types under a unified name. However, they manage memory allocation and internal data storage differently.
• Comparative Summary Table:

Feature Structure (struct) Union (union)

Keyword Declared using the struct keyword. Declared using the union keyword.

Memory Allocates distinct, unique memory slots for Allocates a single shared space, sized to match
Allocation each member variable. the single largest member variable.

Total Memory Equal to the sum of the sizes of its Equal to the size of its single largest member.
Size individual members.

Member All member variables can be accessed Only one member variable can be accessed
Access simultaneously at any time. reliably at a time.

Data Integrity Modifying one member has no effect on Modifying one member overwrites the shared
the other members. space, destroying other members' data.

Q24. Explain about Enumerated Data Types.

• Introduction: An enumeration (enum) is a user-defined data type used to assign human-readable text names to
a finite set of internal integer constants. Enums make code much cleaner, more readable, and easier to
maintain by replacing abstract numbers or magic flags with explicit descriptive words.
• Internal Compilation Rules:
◦ Enums are declared using the enum keyword.
◦ By default, the compiler automatically assigns the integer value 0 to the first item in the list, 1 to the second,
2 to the third, and so on.
◦ Programmers can explicitly override these default values by assigning custom integer values during
declaration.
• Code Implementation Example:

Programming with C and C++ 23

 #include <stdio.h>

// Defining an enumeration for traffic lights

enum TrafficLight { RED, YELLOW, GREEN };

int main() {
// Automatically sets RED = 0, YELLOW = 1, GREEN = 2
enum TrafficLight signal = GREEN;

if (signal == GREEN) {
printf("Signal Status: Go! (Value: %d)
", signal);
}
return 0;
}

Q25. What is a Pointer. Explain about pointer arithmetic with suitable example.
• Introduction: A pointer is a special variable that stores the memory address of another variable. Pointer
arithmetic refers to performing operations like addition or subtraction on pointer variables to interact directly with
memory locations. C supports specific arithmetic operations on pointers, which are highly useful when working
with arrays.
• Core Pointer Arithmetic Rules:
◦ When you increment a pointer (e.g., ptr++), the pointer does not simply add 1 to its address value. Instead,
it advances by the size of the data type it points to (e.g., adding 4 bytes for an integer pointer on standard
systems).
◦ Valid operations include adding or subtracting an integer to/from a pointer, or subtracting one pointer from
another of the same type to find the distance between them.
• Code Implementation Example:

#include <stdio.h>

int main() {
int arr[3] = {10, 20, 30};
int *ptr = arr; // Points to arr[0]

printf("Initial Address: %p | Value: %d

", (void*)ptr, *ptr);

ptr++; // Advances by 4 bytes (size of int) to point to arr[1]

printf("Updated Address: %p | Value: %d
", (void*)ptr, *ptr);

return 0;
}

Programming with C and C++ 24

 UNIT V

SHORT ANSWERS

Q37. Class
• Definition: A user-defined data type that acts as a blueprint, template, or prototype from which individual
objects are created in Object-Oriented Programming (OOP).
• Composition: It encapsulates member variables (data) and member functions (methods) into a single structural
block.
• Additional Details: A class serves as a logical design definition and does not occupy any physical memory
space in RAM when it is declared. Memory is allocated only when an instance of that class—an object—is
created.

Q38. Object
• Definition: A real-world identifiable entity that represents a concrete, runtime instance of a defined Class.
• Memory: Unlike a class, an object allocates physical memory space in RAM when it is instantiated.
• Additional Details: Objects possess specific states (stored in data variables) and behaviors (executed through
member functions). In an object-oriented program, system tasks are accomplished by objects communicating
and interacting with one another via their public methods.

Q39. Encapsulation
• Definition: The foundational OOP mechanism of wrapping data variables and the member functions that
manipulate them together into a single, cohesive structural unit called a Class.
• Purpose: It achieves data hiding by restricting direct outside manipulation of internal variables.
• Additional Details: Encapsulation shields an object's internal state from unauthorized modification by external
code, forcing all access to go through authorized public methods. This helps maintain data integrity and security
within the application.

Q40. Data Abstraction

• Definition: The design principle of hiding complex internal implementation details from the user and displaying
only the essential high-level operational features.
• Purpose: It reduces system complexity by separating what an object does from how it does it.
• Additional Details: In C++, abstraction is achieved using classes and access specifiers (public, private). For
example, when you use a public method like calculateInterest(), you interact with the essential interface
without needing to understand the underlying mathematical algorithms or background mechanics.

Programming with C and C++ 25

Q41. Inheritance
• Definition: An object-oriented programming mechanism that allows a newly created class (known as the
Derived Class or Subclass) to inherit attributes, properties, and behaviors from an existing class (known as the
Base Class or Superclass).
• Main Advantage: It promotes code reusability and establishes a clear hierarchical relationship between
classes.
• Additional Details: It allows developers to reuse tested code, minimizing duplication and making the software
architecture much easier to expand and maintain over time.

Q42. Polymorphism
• Definition: Derived from Greek words meaning "many forms," polymorphism is the capability of an operation,
function, or message to exhibit different behaviors depending on the context or data types provided.
• Types:
◦ 1. Compile-time (Static): Achieved using function overloading or operator overloading, where the correct
function is selected during compilation.
◦ 2. Runtime (Dynamic): Achieved using inheritance and virtual functions, where the correct function is
determined dynamically while the program is running.
• Additional Details: It allows a single interface to be defined for a general class of actions, with the specific
action determined by the nature of the object involved.

Q43. C vs. C++

• Paradigm Difference: C is a structured, procedural programming language focused primarily on step-by-step
algorithms, whereas C++ is a hybrid language that supports Object-Oriented Programming (OOP) focused on
data objects.
• Design Approach: C follows a Top-Down design approach, where a problem is broken down into smaller sub-
procedures. C++ follows a Bottom-Up approach, building upward from basic object interactions.
• Data Security: C does not feature access specifiers, leaving data vulnerable to accidental modification. C++
introduces access specifiers like public, private, and protected to secure data members and enforce data
hiding.

LONG ANSWERS

Q26. Write about structure of C++ program.

• Introduction: A C++ program follows a structured, modular layout designed to support both object-oriented
features and procedural logic. It relies on class definitions, namespace declarations, and standard input-output
streams.
• Core Structural Sections of a C++ Program:
◦ 1. Headers and Include Files: Contains preprocessor directives like #include <iostream> to load
standard input/output stream components.
◦ 2. Namespace Declaration: The statement using namespace std; informs the compiler to search the
standard namespace repository for identifiers like cout and cin, avoiding name conflicts.
◦ 3. Class Definition and Methods: Encapsulates member variables and functions within user-defined
classes, serving as blueprints for objects.

Programming with C and C++ 26

 ◦ 4. The main() Function: The mandatory entry point where program execution begins, initializing objects
and driving application logic.
• Code Implementation Example:

#include <iostream> // Header section

using namespace std; // Namespace section

int main() { // Execution block

cout << "Hello C++ Object-Oriented Program
";
return 0;
}

Q27. Explain the features of C++.

• Introduction: C++ is an advanced, multi-paradigm programming language developed by Bjarne Stroustrup in
1979 at Bell Laboratories. It was designed as an extension of the C language, combining C's low-level efficiency
with modern Object-Oriented Programming (OOP) concepts.
• Key Features of C++:
◦ 1. Object-Oriented Programming (OOP): Supports core OOP principles like classes, objects,
encapsulation, abstraction, inheritance, and polymorphism to model real-world problems cleanly.
◦ 2. Rich Performance & Speed: Like C, C++ provides low-level memory manipulation and fast execution
speeds, making it ideal for developing game engines, flight simulators, and operating systems.
◦ 3. Multi-Paradigm Support: It is a hybrid language that allows programmers to write procedural code (like
C) or object-oriented code within the same application.
◦ 4. Advanced Memory Management: Provides precise control over memory allocation using the new and
delete operators for dynamic memory management.
◦ 5. Strong Type Safety: Enforces strict compile-time type checking to minimize runtime errors and
unhandled exceptions.
◦ 6. Templates (Generic Programming): Supports templates, enabling developers to write generic classes
and functions that operate seamlessly across different data types.

Q28. What is Object-oriented Programming? Write about OOPs concepts in C++.

• Introduction: Object-Oriented Programming (OOP) is a software design paradigm centered around Objects
rather than functions or procedural steps. It binds data and the methods that manipulate that data closely
together, protecting it from unauthorized external modification.
• Core OOP Concepts:
◦ 1. Class: A user-defined data type that serves as a blueprint or template for creating objects.
◦ 2. Object: A concrete runtime instance of a class that allocates memory and exhibits state and behavior.
◦ 3. Encapsulation: Wrapping data members and member functions together within a class to hide internal
details and protect data integrity.
◦ 4. Data Abstraction: Hiding complex implementation details and displaying only essential high-level
operational features to the user.
◦ 5. Inheritance: The mechanism by which a derived class adopts the properties, attributes, and behaviors of
an existing base class, promoting code reusability.

Programming with C and C++ 27

 ◦ 6. Polymorphism: The capability of an operation, function, or message to take on multiple forms depending
on the context (e.g., function overloading or overriding).

Q29. Explain different Storage Classes in C++.

• Introduction: Storage classes define the scope (visibility), lifetime (duration in memory), and storage
location (RAM or CPU register) of a variable during program execution.
• The Four Primary Storage Classes:
◦ 1. auto Storage Class: The default storage class for local variables declared inside a block or function.
They are created automatically when entering the block and destroyed upon exit.
◦ 2. register Storage Class: Directs the compiler to store the local variable inside a high-speed CPU
register rather than standard RAM, providing faster access for performance-critical counters.
◦ 3. static Storage Class: Instructs the compiler to preserve a local variable's value even after its declaring
function exits, maintaining its memory throughout the entire runtime of the program.
◦ 4. extern Storage Class: Used to declare a global variable or function reference that is visible and
accessible across multiple files within the project.

Q30. Explain about Data Members and Member Functions.

• Introduction: A class encapsulates data and behavior into a single cohesive unit. The variables declared inside
a class are called Data Members, and the functions declared inside the class that operate on those variables
are called Member Functions.
• Key Properties and Interaction:
◦ Data Members: Define the state, properties, or attributes of an object. They can be of any primary or user-
defined data type.
◦ Member Functions: Define the behavior or operations an object can perform. They provide the interface
through which external code interacts with an object's protected data members.
◦ Access Specifiers: Access to data members and member functions is controlled using access keywords
like private, protected, and public.
• Code Implementation Example:

#include <iostream>
using namespace std;

class Account {
public:
// Data Member defining object state
int balance;

// Member Function defining object behavior

void displayBalance() {
cout << "Current Account Balance: " << balance << endl;
}
};

int main() {
Account myAcc;
[Link] = 5000; // Accessing Data Member
[Link](); // Invoking Member Function

Programming with C and C++ 28

 return 0;
}

Q31. Define a Class and Explain how to create a class in C++.

• Introduction: A class is a user-defined data type that serves as an abstract blueprint or template for creating
objects. It encapsulates data members (variables) and member functions (methods) into a single logical unit. A
class definition outlines a structure but does not allocate physical memory until an object of that class is
instantiated.
• Creating a Class:
◦ Declared using the class keyword, followed by a custom class name and a body enclosed in curly braces.
◦ Semicolon Requirement: The closing curly brace of a class definition must terminate with a trailing
semicolon (;).
◦ Access specifiers (public, private) are used inside the class body to regulate access permissions for its
members.
• Code Implementation Example:

#include <iostream>
using namespace std;

// Defining the class layout

class Room {
public:
double length;
double breadth;

void calculateArea() {
cout << "Total Room Area: " << length * breadth << endl;
}
}; // Must terminate with a semicolon

int main() {
Room myRoom; // Instantiating an object
[Link] = 12.0;
[Link] = 10.0;
[Link](); // Invoking member function
return 0;
}

Q32. What is Inheritance? Explain about different types of Inheritance.

• Introduction: Inheritance is a core mechanism of Object-Oriented Programming (OOP) that allows a newly
created class (known as the Derived Class or Subclass) to inherit and adopt the data members and member
functions of an existing class (known as the Base Class or Superclass). Inheritance minimizes code duplication
and promotes reusability.
• Types of Inheritance Supported in C++:
◦ 1. Single Inheritance: A derived class inherits directly from a single base class.
◦ 2. Multiple Inheritance: A single derived class inherits properties from two or more independent base
classes simultaneously.

Programming with C and C++ 29

 ◦ 3. Multilevel Inheritance: A class is derived from another derived class, forming a sequential inheritance
chain (e.g., Class C inherits from Class B, which inherits from Class A).
◦ 4. Hierarchical Inheritance: Multiple separate derived classes inherit directly from a single shared base
class.
◦ 5. Hybrid Inheritance: A complex inheritance structure that combines two or more of the inheritance types
described above (often leading to a diamond hierarchy pattern resolved using virtual base classes).

Programming with C and C++ 30