https://github.com/ahadalireach/oop.interview.questions
A repository containing fundamentals of programming, OOP, and other related concepts with interview questions and code implementations.
https://github.com/ahadalireach/oop.interview.questions
cpp exceptions interview-questions oop oop-concepts oop-principles pointers strings templates
Last synced: 3 months ago
JSON representation
A repository containing fundamentals of programming, OOP, and other related concepts with interview questions and code implementations.
- Host: GitHub
- URL: https://github.com/ahadalireach/oop.interview.questions
- Owner: ahadalireach
- Created: 2025-01-11T09:20:55.000Z (over 1 year ago)
- Default Branch: master
- Last Pushed: 2025-03-16T13:51:50.000Z (about 1 year ago)
- Last Synced: 2025-08-14T02:21:27.927Z (10 months ago)
- Topics: cpp, exceptions, interview-questions, oop, oop-concepts, oop-principles, pointers, strings, templates
- Language: C++
- Homepage: https://github.com/ahadalireach/oop.concepts.interview.questions
- Size: 547 KB
- Stars: 3
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# C++ Concepts with Interview Questions
| No. | Questions |
| --- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 001. | [What is Programming, and Why is C++ a Preferred Language?](#what-is-programming-and-why-is-c-a-preferred-language) |
| 002. | [What is a Programming Paradigm, and Why is it Important?](#what-is-a-programming-paradigm-and-why-is-it-important) |
| 003. | [How Does C++ Differ from C?](#how-does-c-differ-from-c) |
| 004. | [What is the File Structure in a C++ Program?](#what-is-the-file-structure-in-a-c-program) |
| 005. | [What is the Difference Between Low-Level and High-Level Programming Languages?](#what-is-the-difference-between-low-level-and-high-level-programming-languages) |
| 006. | [What are Variables and Comments, and Why are They Used?](#what-are-variables-and-comments-and-why-are-they-used) |
| 007. | [What is Variable Scope, and How Does it Affect Code Execution?](#what-is-variable-scope-and-how-does-it-affect-code-execution) |
| 008. | [What are Data Types in C++, and How Are They Classified?](#what-are-data-types-in-c-and-how-are-they-classified) |
| 009. | [What Are Reserved Keywords in C++, and Why Are They Restricted?](#what-are-reserved-keywords-in-c-and-why-are-they-restricted) |
| 010. | [What are Operators and Their Different Types?](#what-are-operators-and-their-different-types) |
| 011. | [What is the Difference Between `float`, `double`, and `long double` Literals?](#what-is-the-difference-between-float-double-and-long-double-literals) |
| 012. | [What is Typecasting?](#what-is-typecasting) |
| 013. | [How Do You Use the Scope Resolution Operator?](#how-do-you-use-the-scope-resolution-operator) |
| 014. | [What are Constants, Manipulators, and Operator Precedence?](#what-are-constants-manipulators-and-operator-precedence) |
| 015. | [What are Control Structures?](#what-are-control-structures) |
| 016. | [What is the Differences Between For, While, and Do-While Loops?](#what-is-the-differences-between-for-while-and-do-while-loops) |
| 017. | [What is the Difference Between Break and Continue Statements?](#what-is-the-difference-between-break-and-continue-statements) |
| 018. | [What is a Pointer and How is it Used?](#what-is-a-pointer-and-how-is-it-used) |
| 019. | [What is the concept of Null Pointer?](#what-is-a-null-pointer) |
| 020. | [What is the concept of Garbage Collection](#garbage-collection-in-c) |
| 021. | [What is an Array, and How are Arrays and Pointers Related?](#what-is-an-array-and-how-are-arrays-and-pointers-related-in-c) |
| 022. | [What are Struct, Union, and Enums in C++?](#what-are-struct-union-and-enums-in-c) |
| 023. | [What are Function and Function Prototypes?](#what-are-function-and-function-prototypes) |
| 024. | [What are Actual and Formal Parameters?](#what-are-actual-and-formal-parameters) |
| 025. | [What does it means by Call by Value, Call by Reference, & Call by Pointer?](#call-by-value-call-by-reference-call-by-pointer) |
| 026. | [What are Static Variables & Functions?](#what-are-static-variable--functions) |
| 027. | [What are Inline Functions, Default Arguments, & Constant Arguments?](#inline-functions-default-arguments-constant-arguments) |
| 028. | [What is Recursion and Recursive Functions?](#recursion-and-recursive-functions) |
| 029. | [What is Function Overloading?](#what-is-function-overloading) |
| 030. | [What is OOP?](#what-is-oop) |
| 031. | [Why OOP? Purpose of Implementing OOP?](#why-oop-purpose-of-implementing-oop) |
| 032. | [Why is OOP so Popular?](#why-is-oop-so-popular) |
| 033. | [What are the Pros and Cons of Object-Oriented Programming (OOP)?](#pros-and-cons-of-object-oriented-programming-oop) |
| 034. | [What is the Difference Between Object-Oriented Programming vs Structural Programming?](#difference-between-object-oriented-programming-vs-structural-programming) |
| 035. | [What is the Difference Between Procedure-Oriented Programming (POP) and Object-Oriented Programming (OOP)?](#difference-between-procedure-oriented-programming-pop-and-object-oriented-programming-oop) |
| 036. | [What is a Pure Object-Oriented Language?](#what-is-a-pure-object-oriented-language) |
| 037. | [What is a Struct?](#what-is-a-struct) |
| 038. | [What is a Class and Why Do We Need It in OOP?](#what-is-a-class-and-why-do-we-need-it-in-oop) |
| 039. | [What are Class Attributes & Methods in OOP?](#what-are-class-attributes-and-methods-in-oop) |
| 040. | [Why Use a Class Instead of a Struct?](#why-use-a-class-instead-of-a-struct) |
| 041. | [What is the Difference Between Class and Struct?](#difference-between-class-and-struct) |
| 042. | [What are the Similarities Between Class and Struct?](#similarities-between-class-and-struct) |
| 043. | [What is an Object and Why Do We Need It in OOP?](#what-is-an-object-and-why-do-we-need-it-in-oop) |
| 044. | [What is an Array of Objects?](#what-is-an-array-of-objects) |
| 045. | [How do you Pass Objects as Function Arguments?](#how-do-you-pass-objects-as-function-arguments) |
| 046. | [What is Pointer to Objects in C++? What are its Purpose and Benefits?](#pointer-to-objects-in-c-purpose-and-benefits) |
| 047. | [How is Memory Allocated for Variables, Functions, Member Functions, and Data Members?](#how-is-memory-allocation-for-variables-functions-member-functions-and-data-members) |
| 048. | [What are Access Specifiers in OOP?](#what-are-access-specifiers-in-oop) |
| 049. | [What is the Default Access Modifier in a Class?](#what-is-the-default-access-modifier-in-a-class) |
| 050. | [What is Sealed Modifier?](#what-is-the-sealed-modifier) |
| 051. | [## What is Dynamic Memory Allocation (DMA) and the new Keyword? What are Their Purpose and Benefits?](#what-is-dynamic-memory-allocation-dma-and-the-new-keyword-in-c-purpose-and-benefits) |
| 052. | [What is the `delete` Keyword? What are its Purpose and Benefits?](#what-is-the-delete-keyword-in-c-purpose-and-benefits) |
| 053. | [What is the Arrow (`->`) and Dot (`.`) Operator? What is its Purpose or Benefit?](#what-is-the-arrow--and-dot--operator-in-c) |
| 054. | [What Happens When an Object is Created Without `new` vs With `new`? Where is it stored?](#what-happens-when-an-object-is-created-without-new-vs-with-new-where-is-it-stored) |
| 055. | [What is Shallow Copy? and What’s the Problem with Shallow Copy?](#what-is-shallow-copy-and-whats-the-problem-with-shallow-copy) |
| 056. | [What is Deep Copy?](#what-is-deep-copy) |
| 057. | [What is the Difference Between Shallow and Deep Copy of a Class?](#what-is-the-difference-between-shallow-and-deep-copy-of-a-class) |
| 058. | [Explain the Concept of static in OOP, Including Static Data Members and Static Member Functions?](#explain-the-concept-of-static-in-oop-including-static-data-members-and-static-member-functions) |
| 059. | [How many Types of Variables are there in OOP?](#types-of-variables-in-oop) |
| 060. | [What is `const` in OOP and How is it Used?](#what-is-const-in-oop-and-how-is-it-used) |
| 061. | [What are Friend Functions and Friend Classes?](#what-are-friend-functions-and-friend-classes) |
| 062. | [What are Member Functions & Nesting of Member Functions in OOP?](#what-are-member-functions-and-nesting-of-member-functions-in-oop) |
| 063. | [What is `this` pointer in OOP and its purpose?](what-is-the-purpose-of-this-pointer-in-oop) |
| 064. |[What is a constructor, and what are its rules and types?](#what-is-a-constructor-and-what-are-its-rules-and-types) |
| 065. |[What is the Difference Between Constructor vs Method?](#difference-between-constructor-vs-method) |
| 066. |[Is it possible to overload a constructor? What is constructor overloading, what are its benefits, and what are its conditions or rules?](#is-it-possible-to-overload-a-constructor-what-is-constructor-overloading-what-are-its-benefits-and-what-are-its-condition-or-rules) |
| 067. |[What is a Copy Constructor: Is the Object Passed by Value or Reference, and Why?](#copy-constructor-is-the-object-passed-by-value-or-reference-and-why)|
| 068. |[Where is a Copy Constructor Called Implicitly?](#where-is-a-copy-constructor-called-implicitly)|
| 069. |[What is the Difference Between Copy Constructor vs Assignment Operator?](#difference-between-copy-constructor-vs-assignment-operator)|
| 070. |[What Does It Mean by Constructors with Default Arguments?](#what-does-it-mean-by-constructors-with-default-arguments)|
| 071. |[What is Dynamic Initialization of Objects Using Constructors?](#what-is-dynamic-initialization-of-objects-using-constructors)|
| 072. |[What is Constructor Delegation?](#what-is-constructor-delegation)|
| 073. |[What is a Constructor Initialization List, and Why Do We Use It?](#what-is-a-constructor-initialization-list-and-why-do-we-use-it)|
| 074. |[Can a Constructor be Private or Protected?](#can-a-constructor-be-private-or-protected)|
| 075. |[Can a Constructor be Static or Const? Why or Why Not?](#can-a-constructor-be-static-or-const-why-or-why-not)|
| 076. |[Can We Make a Constructor Private? How Will We Create an Object of Such a Class?](#can-we-make-a-constructor-private-how-will-we-create-an-object-of-such-a-class)|
| 077. |[What is a Destructor? When Do We Need to Define Destructors?](#what-is-a-destructor-when-do-we-need-to-define-destructors)|
| 078. |[Is it Possible to Overload a Destructor?Is it Possible to Overload a Destructor? What is Destructor Overloading, Its Benefits, and Why Is It Not Possible?](#is-it-possible-to-overload-a-destructor-what-is-destructor-overloading-its-benefits-and-why-is-it-not-possible)|
| 079. |[Why Does a Class Have Only One Destructor & Why Do We Need One?](#why-does-a-class-have-only-one-destructor-and-why-do-we-need-one)|
| 080. |[Can a Destructor be Private or Protected?](#can-a-destructor-be-private-or-protected)|
| 081. |[Can a Destructor be Static or Const?](#can-a-destructor-be-static-or-const)|
| 082. |[What is the Order of Constructor and Destructor Calling Sequence?](#order-of-constructor-and-destructor-calling-sequence) |
| 083. | [What is Encapsulation? Why is it important in software development? What are its key features?](#what-is-encapsulation-why-is-it-important-in-software-development-what-are-its-key-features) |
| 084. | [What is the Concept of Setters and Getters? Why Do We Use Them? Provide a Code Example of Encapsulation.](#what-is-the-concept-of-setters-and-getters-and-why-do-we-use-them-provide-a-code-example-of-encapsulation) |
| 085. | [How does Encapsulation promote modular code?](#how-does-encapsulation-promote-modular-code) |
| 086. | [What challenges or pitfalls can you encounter when implementing Encapsulation?](#what-challenges-or-pitfalls-can-you-encounter-when-implementing-encapsulation)|
| 087. | [What is Abstraction? Why is it important in software development? What are its key features?](#what-is-abstraction-why-is-it-important-in-software-development-what-are-its-key-features)|
| 088. | [How does Abstraction differ from Encapsulation?](#how-does-abstraction-differ-from-encapsulation)|
| 089. | [What is Inheritance? Explain Its Different Types.](#what-is-inheritance-explain-its-different-types)|
| 090. | [What are Access Modifiers in Inheritance?](#what-are-access-modifiers-in-inheritance)|
| 091. | [Can a subclass access private members of a superclass? Why or why not?](#can-a-subclass-access-private-members-of-a-superclass-why-or-why-not)|
| 092. | [How does method overriding work in Inheritance?](#how-does-method-overriding-work-in-inheritance)|
| 093. | [What is the difference between Method Overloading and Method Overriding?](#what-is-the-difference-between-method-overloading-and-method-overriding)|
| 094. | [How does Inheritance affect performance?](#how-does-inheritance-affect-performance)|
| 095. | [What happens if a constructor is not defined in a subclass?](#what-happens-if-a-constructor-is-not-defined-in-a-subclass)|
| 096. | [What is Ambiguity in Inheritance? Explain How to Resolve It.](#what-is-ambiguity-in-inheritance-explain-how-to-resolve-it)|
| 097. | [What is a Virtual Base Class in Inheritance and What Problem Does It Solve?](#what-is-a-virtual-base-class-in-inheritance-and-what-problem-does-it-solve)|
| 098. | [What is the Diamond Problem and Its Solution?](#what-is-the-diamond-problem-and-its-solution)|
| 099. | [What is Polymorphism? Why is it important in software development?](#what-is-polymorphism-why-is-it-important-in-software-development)|
| 100. | [What are the Types of Polymorphism?](#what-are-the-types-of-polymorphism)|
| 101. | [What is the Difference between Compile-time vs Run-time Polymorphism](#difference-between-compile-time-vs-run-time-polymorphism)|
| 102. | [What is the Difference between Static Binding (Early Binding) vs Dynamic Binding (Late Binding)](#difference-between-static-binding-vs-dynamic-binding)|
| 103. | [What is Function Overriding?](#what-is-function-overriding)|
| 104. | [How does Polymorphism promote code reusability and flexibility?](#how-does-polymorphism-promote-code-reusability-and-flexibility)|
| 105. | [What method makes classes exhibit different behavior in polymorphism?](#what-method-makes-classes-exhibit-different-behavior-in-polymorphism)|
| 106. | [What is a Pointer to a Derived Class and Its Purpose?](#what-is-a-pointer-to-a-derived-class-and-its-purpose)|
| 107. | [What is the Rule of Three?](#what-is-the-rule-of-three)|
| 108. | [Can we override a static method? Why or why not?](#can-we-override-a-static-method-why-or-why-not)|
| 109. | [What is a Virtual Function and Its Purpose?](#what-is-a-virtual-function-and-its-purpose) |
| 110. | [What are the Rules for Virtual Functions?](#rules-for-virtual-functions) |
| 111. | [Can Virtual Functions be Private?](#can-virtual-functions-be-private) |
| 112. | [What are inline virtual functions? Are inline virtual functions really nonsense?](#what-are-inline-virtual-functions-are-inline-virtual-functions-really-nonsense) |
| 113. | [What is a Pure Virtual Function, Its Purpose, and an Abstract Base Class?](#what-is-a-pure-virtual-function-and-its-purpose) |
| 114. | [What is a Pure Abstract Base Class?](#what-is-a-pure-abstract-base-class) |
| 115. | [Why Does a Pure Virtual Function Require a Function Body?](#why-does-a-pure-virtual-function-require-a-function-body) |
| 116. | [What is the Difference between Virtual vs Pure Virtual Function?](#difference-between-virtual-vs-pure-virtual-function) |
| 117. | [Can a Constructor be Virtual?](#can-a-constructor-be-virtual) |
| 118. | [Can a Constructor be Pure Virtual?](#can-a-constructor-be-pure-virtual) |
| 119. | [What is a Virtual Destructor?](#what-is-a-virtual-destructor) |
| 120. | [What is a Pure Virtual Destructor?](#what-is-a-pure-virtual-destructor) |
| 121. | [Can a Destructor be Virtual? Why and When to use virtual destructors?](#can-a-destructor-be-virtual) |
| 122. | [Can a Destructor be Pure Virtual?](#can-a-destructor-be-pure-virtual) |
| 123. | [Explain the concept of Message Passing.](#explain-the-concept-of-message-passing) |
| 124. | [Explain the concept of a V-Table and what problem it solved?](#explain-the-concept-of-a-v-table-and-what-problem-it-solved) |
| 125. | [What does it mean by Simulating a final class?](#simulating-a-final-class) |
| 126. | [What is an Abstract Class? What is the major thing they don't allow us to do?](#what-is-an-abstract-class-what-is-the-major-thing-they-dont-allow-us-to-do) |
| 127. | [What is the Difference between Abstract Class vs Normal Class vs Concrete Class?](#difference-between-abstract-class-vs-normal-class-vs-concrete-class) |
| 128. | [What is an Interface?](#what-is-an-interface) |
| 129. | [What is the Difference between Interface vs. Abstract Class?](#difference-between-interface-vs-abstract-class) |
| 130. | [Can you call the base class method without creating an instance?](#can-you-call-the-base-class-method-without-creating-instance) |
| 131. | [Can an abstract class have implemented methods?](#can-an-abstract-class-have-implemented-methods) |
| 132. | [What happens if we do not implement all methods of an interface in a class?](#what-happens-if-we-do-not-implement-all-methods-of-an-interface-in-a-class) |
| 133. | [How to avoid the implementation of an abstract function?](#how-to-avoid-the-implementation-of-an-abstract-function) |
| 134. | [How many instances can be created for an abstract class? Explain why.](#number-of-instances-for-an-abstract-class) |
| 135. | [What is Operator Overloading? What main problem does it solve?](#what-is-operator-overloading-what-main-problem-does-it-solve) |
| 136. | [What are templates? Explain the different types of templates with examples](#what-are-templates) |
| 137. | [What Are Threads?](#what-are-threads) |
| 138. | [What is an Exception?](#what-is-an-exception) |
| 139. | [What is the Difference between Error vs Exception?](#difference-between-error-vs-exception) |
| 140. | [What are Objects Relations?](#what-are-objects-relations) |
| 141. | [What is Association?](#what-is-association) |
| 142. | [What is Aggregation (Weak Relationship)?](#what-is-aggregation-weak-relationship) |
| 143. | [What is Composition (Strong Relationship)?](#what-is-composition-strong-relationship) |
| 144. | [What is a Has-a Relationship?](#what-is-a-has-a-relationship) |
| 145. | [What is an Is-a Relationship?](#what-is-an-is-a-relationship) |
| 146. | [What is the Difference between Is-a relationship and Has-a relationship (Aggregation vs. Composition)? Implement examples of each.](#is-a-relationship-vs-has-a-relationship-aggregation-vs-composition-implement-examples-of-each) |
| 147. | [What is the Difference between Generalization, Aggregation, Composition and Association?](#generalization-vs-aggregation-vs-composition-vs-association) |
| 148. | [Explain the concept of Coupling and Cohesion?](#explain-the-concept-of-coupling-and-cohesion) |
| 149. | [Describe the Purpose, Importance, and Use of all the Keywords used in OOP, and what problem they solve:](#describe-the-purpose-importance-and-use-of-all-the-keywords-used-in-oop-and-what-problem-they-solve) |
| | [`Static`](#static) |
| | [`Virtual`](#virtual) |
| | [`Abstract`](#abstract) |
| | [`Final`](#final) |
| | [`Explicit`](#explicit) |
| | [`This`](#this) |
| | [`New`](#new) |
| | [`Const`](#const) |
| | [`Super`](#super) |
| | [`Override`](#override) |
| 150. | [Why do we need all the OOP concepts?](#why-do-we-need-all-the-oop-concepts) |
| 151. | [What problems do OOP concepts like Class, Object, Encapsulation, Abstraction, Inheritance, Polymorphism, and other related concepts solve?](#what-problems-do-oop-concepts-like-class-object-encapsulation-abstraction-inheritance-polymorphism-and-other-related-concepts-solve) |
| 152. | [What problems arise without Static Binding, Dynamic Binding, Function Overloading, Function Overriding, and Inheritance? How do these concepts solve those problems and contribute to Object-Oriented Programming (OOP)?](#what-problems-arise-without-static-binding-dynamic-binding-function-overloading-function-overriding-and-inheritance-how-do-these-concepts-solve-those-problems-and-contribute-to-object-oriented-programming-oop) |
| 153. | [Provide at least 3 Real-World Examples of OOP Concepts](#provide-at-least-3-real-world-examples-of-oop-concepts) |
| | [`Class`](#class) |
| | [`Object`](#object) |
| | [`Encapsulation`](#encapsulation) |
| | [`Abstraction`](#abstraction) |
| | [`Inheritance`](#inheritance) |
| | [`Polymorphism`](#polymorphism) |
| | [`Static vs Dynamic`](#static-vs-dynamic) |
| | [`Function Overloading`](#function-overloading) |
| | [`Function Overriding`](#function-overriding) |
| | [`Inheritance Types`](#inheritance-types) |
| 154. | [How Do OOP Pillars Relate to Real-Life? (Self-Mapped Examples)](#how-do-oop-pillars-relate-to-real-life-self-mapped-examples) |
## What is Programming, and Why is C++ a Preferred Language?
**Programming**
Programming is the process of writing instructions for a computer to execute. These instructions, written in a programming language, enable the computer to perform specific tasks.
**Why C++?**
C++ was created by Bjarne Stroustrup in 1979. It is a powerful, efficient, and widely used programming language because:
- It supports both **procedural** and **object-oriented programming (OOP)**.
- It provides **high performance and memory control**.
- It is used in **system software, game development, embedded systems, and high-performance applications**.
**[⬆ Back to Top](#table-of-contents)**
---
## What is a Programming Paradigm, and Why is it Important?
A **programming paradigm** is a fundamental style of programming that dictates how solutions are structured. Some common paradigms are:
- **Imperative Programming**
- Focuses on **how** to perform tasks by changing the program's state through statements.
- Example:
```cpp
int sum = 0;
for (int i = 1; i <= 5; i++) {
sum += i;
}
```
- **Object-Oriented Programming (OOP)**
- Focuses on using objects and classes to structure programs.
- **Procedural Programming**
- Breaks down tasks into procedures (functions), emphasizing reusable code.
- A subset of imperative programming.
- **Functional Programming**
- Focuses on **what** to do rather than **how** to do it. It treats computation as the evaluation of mathematical functions.
- Example:
```cpp
auto square = [](int x) { return x * x; };
std::cout << square(5); // Output: 25
```
- **Declarative Programming**
- Focuses on **what** needs to be done, not how. It often involves querying data.
- Example:
```sql
SELECT name FROM students WHERE grade > 90;
```
### Why is it Important?
Understanding paradigms helps developers write **better-structured, efficient, and maintainable code**.
**[⬆ Back to Top](#table-of-contents)**
---
## How Does C++ Differ from C?
- **C++** is an extension of **C** that introduces additional features like **Object-Oriented Programming (OOP)**, **function overloading**, **templates**, and **exception handling**.
- While **C** is primarily a **procedural** programming language, **C++** supports both **procedural and object-oriented programming paradigms**.
| Feature | C | C++ |
|------------------------|-----------------------------|-----------------------------------|
| **Programming Paradigm** | Procedural | Procedural + Object-Oriented |
| **Data Encapsulation** | No | Yes (Classes & Objects) |
| **Standard Library** | Limited | Rich Standard Library (STL) |
| **Memory Management** | Manual | Supports RAII (Smart Pointers) |
| **Function Overloading** | No | Yes |
| **Operator Overloading** | No | Yes |
| **Exception Handling** | No | Yes (Try-Catch Blocks) |
| **Templates** | No | Yes (Generic Programming) |
| **Namespace Support** | No | Yes |
| **Usage** | System Programming | System + Application Development |
### Major Enhancements in C++
#### 1. **Object-Oriented Programming (OOP)**
C++ introduces **classes and objects**, allowing encapsulation, inheritance, and polymorphism.
#### 2. **Function Overloading**
C++ allows multiple functions with the same name but different parameters.
#### 3. **Operator Overloading**
C++ allows operators to be overloaded to work with user-defined data types.
#### 4. **Exception Handling**
C++ provides a structured way to handle runtime errors.
**[⬆ Back to Top](#table-of-contents)**
---
## What is the File Structure in a C++ Program?
In C++, the organization of files is crucial for managing and structuring code effectively:
- **Header Files** (`.h` or `.hpp`): These files contain declarations for functions, classes, and other identifiers. `#include` includes the standard library for input and output operations. Header files promote code reuse and modularity by allowing shared declarations across multiple source files.
- **Source Files** (`.cpp`): These files contain the definitions of the functions and classes declared in header files. They provide the implementation details and include the necessary header files.
- **Main Function**: The entry point of a C++ program is the `main` function, where the execution of the program begins.
A typical **C++ program file structure** consists of:
1. **Header Files (`.h`)** – Contain function declarations and macros.
2. **Source Files (`.cpp`)** – Contain the actual implementation of functions and classes.
3. **Main File (`main.cpp`)** – The entry point of a C++ program.
**[⬆ Back to Top](#table-of-contents)**
---
## What is the Difference Between Low-Level and High-Level Programming Languages?
Programming languages can be categorized into **low-level** and **high-level** based on their abstraction from machine code.
### **High-Level Languages (Easy to Use)**
Think of **Google Search** – you type a query and get results without knowing how Google works internally.
High-level languages work similarly – they are **easier to read, write, and understand**, abstracting complex hardware details.
### **Low-Level Languages (More Control)**
Imagine opening a computer and manually controlling its parts instead of just using a search engine.
Low-level languages work **closer to machine code**, giving **direct control** over hardware but requiring a deep understanding of how computers work.
| Feature | Low-Level Languages | High-Level Languages |
|----------------------|----------------------------|----------------------------|
| **Abstraction** | Close to machine code | More human-readable |
| **Ease of Use** | Harder to write & understand | Easier to write & maintain |
| **Performance** | Very fast (direct hardware control) | Slightly slower due to abstraction |
| **Examples** | Assembly, C | C++, Python, Java |
| **Memory Management** | Manual (direct access) | Automatic (Garbage Collection) |
#### Examples of Low & High-Level Languages
```assembly
MOV AX, 05 ; Move value 5 into register AX
ADD AX, 03 ; Add 3 to AX
```
- Directly tells the processor what to do step-by-step.
```python
# High-Level Language (Python)
x = 5
y = 3
print(x + y)
```
- Easier to understand and does not require knowledge of computer hardware.
#### Is C++ Low-Level or High-Level?
**C++ is both!**
- It allows direct memory access like low-level languages.
- It provides abstraction & object-oriented features like high-level languages.
- **Low-level languages** are **fast and powerful**, but **harder to write**.
- **High-level languages** are **easier to use**, but **slightly less efficient**.
- **C++ gives you both speed and simplicity!** 🚀
**[⬆ Back to Top](#table-of-contents)**
---
## What are Variables and Comments, and Why are They Used?
### What are Variables?
- A **variable** is a named storage location used to store data.
- Variables can hold different types of data, such as:
- **int → Whole numbers (e.g., 25)**
- **float → Decimal numbers (e.g., 3.14)**
- **char → Single characters (e.g., 'A')**
- Think of **variables** as **labeled boxes** where you store information.
- For example, if you have a box labeled `age`, you can store a number inside it to represent someone's age.
```cpp
int age = 25; // A variable storing an integer value
```
### What are Comments?
- **Comments** are like sticky notes in your code.
- They don't affect how the program runs but help you (or others) understand the code better.
**Why Use Comments?**
- Improve code readability
- Explain complex logic
- Help with debugging
**Types of Comments:**
#### 1. **Single-Line Comment**
- Used for short explanations.
```cpp
// This is a single-line comment
int x = 10; // Storing the value 10 in x
```
#### 2. **Multi-Line Comment**
- Used for longer explanations.
```cpp
/* This is a
multi-line comment */
int y = 20;
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is Variable Scope, and How Does it Affect Code Execution?
### What is Variable Scope?
- The **scope** of a variable defines **where it can be accessed** in a program.
- Think of it like a **room**: you can only use the items inside that room.
- Similarly, a variable can only be used within the part of the program where it is declared.
### Types of Variable Scope:
#### 1. **Local Variables**
- Declared **inside a function**.
- Can **only be accessed within** that function.
- Like a **key** that only works in one room.
```cpp
void myFunction() {
int localVar = 5; // Local variable
cout << localVar; // ✅ Accessible here
}
cout << localVar; // ❌ ERROR: localVar is not accessible outside
```
#### 2. **Global Variables**
- Declared outside all functions.
- Accessible anywhere in the program.
- Like a master key that opens all rooms.
```cpp
int globalVar = 10; // Global variable
void myFunction() {
cout << globalVar; // ✅ Accessible here
}
int main() {
myFunction();
cout << globalVar; // ✅ Accessible here too
}
```
#### 3. **Block Scope**
- Variables declared inside `{}` only exist within that block.
- Like items inside a drawer—you can’t use them outside.
```cpp
int main() {
{
int blockVar = 20;
cout << blockVar; // ✅ Accessible here
}
cout << blockVar; // ❌ ERROR: blockVar is out of scope
}
```
#### 4. ** Static Scope**
- Variables declared with static inside a function retain their value between function calls.
- Like a notepad that remembers its last written value.
```cpp
void myFunction() {
static int count = 0; // Static variable
count++;
cout << count << endl;
}
int main() {
myFunction(); // Output: 1
myFunction(); // Output: 2
myFunction(); // Output: 3
}
```
- **Local variables** → Limited to a function.
- **Global variables** → Accessible throughout the program.
- **Block scope** → Limited to `{}` blocks.
- **Static variables** → Remember their value between function calls.
- **Use global variables sparingly!** They make debugging harder.
**[⬆ Back to Top](#table-of-contents)**
---
## What are Data Types in C++, and How Are They Classified?
Data types define the kind of data a variable can store. In C++, they are classified into three main groups:
### 1. **Built-in Data Types**
These are the basic types provided by C++.
- `int` → Stores whole numbers (e.g., `int x = 10;`).
- `float` → Stores decimal numbers (e.g., `float y = 3.14;`).
- `char` → Stores single characters (e.g., `char c = 'A';`).
- `double` → Stores large or precise decimal numbers.
- `bool` → Stores `true` or `false` values.
### 2. **User-Defined Data Types**
These allow creating custom data types.
- `struct` → Groups different types together (e.g., name, age, address).
- `union` → Stores different data types, but only one at a time.
- `enum` → Defines named values (e.g., days of the week).
### 3. **Derived Data Types**
These are based on built-in types.
- `array` → Collection of same-type values (e.g., `int arr[5];`).
- `pointer` → Stores the address of another variable (e.g., `int *ptr;`).
- `function` → Block of reusable code performing a specific task.
- **Choosing the right data type helps optimize memory and performance!**
**[⬆ Back to Top](#table-of-contents)**
---
## What Are Reserved Keywords in C++, and Why Are They Restricted?
- Reserved keywords are special words with predefined meanings in C++.
- They **cannot** be used as variable names, function names, or other identifiers because they serve specific purposes in the language.
### Why Are They Restricted?
- They have a **predefined** role in the language.
- Using them incorrectly can **cause errors**.
- They help define variables, control flow, and manage functions.
| Category | Keywords |
|-----------|------------------------------------------------|
| **Data Types** | `int`, `float`, `double`, `char`, `bool`, `void` |
| **Control Flow** | `if`, `else`, `switch`, `case`, `default` |
| **Loops** | `for`, `while`, `do` |
| **Functions** | `return`, `void` |
| **Class & Struct** | `class`, `struct`, `public`, `private`, `protected` |
| **Operators** | `<<` (insertion operator -> used for output in streams (like printing to the screen)), `>>` (extraction operator -> used for input in streams (like reading input from the user)) |
- **❌ You cannot use reserved keywords as variable or function names.**
```cpp
int return = 5; // ❌ Error: "return" is a reserved keyword.
```
- **✅ Use descriptive names instead**
```cpp
int result = 5; // ✅ Correct usage.
```
- Understanding reserved keywords helps in writing error-free and efficient code!
**[⬆ Back to Top](#table-of-contents)**
---
## What are Operators and Their Different Types?
**Operators** are symbols that perform operations on variables and values, such as calculations, comparisons, and logical operations.
### **Different types of operators:**
#### 1. **Arithmetic Operators**:
These are used for basic mathematical operations.
- `+` : Addition (e.g., `a + b` adds `a` and `b`)
- `-` : Subtraction (e.g., `a - b` subtracts `b` from `a`)
- `*` : Multiplication (e.g., `a * b` multiplies `a` by `b`)
- `/` : Division (e.g., `a / b` divides `a` by `b`)
- `%` : Modulus (e.g., `a % b` gives the remainder of `a` divided by `b`)
- `++` : Increment (e.g., `a++` increases `a` by 1)
- `--` : Decrement (e.g., `a--` decreases `a` by 1)
#### 2. **Assignment Operators**:
These operators are used to assign values to variables.
- `=` : Basic assignment (e.g., `a = 10` assigns `10` to `a`)
- `+=` : Add and assign (e.g., `a += 5` is equivalent to `a = a + 5`)
- `-=` : Subtract and assign (e.g., `a -= 3` is equivalent to `a = a - 3`)
- `*=` : Multiply and assign (e.g., `a *= 2` is equivalent to `a = a * 2`)
- `/=` : Divide and assign (e.g., `a /= 4` is equivalent to `a = a / 4`)
- `%=` : Modulus and assign (e.g., `a %= 3` is equivalent to `a = a % 3`)
#### 3. **Comparison Operators**:
These operators are used to compare two values and return a boolean result.
- `==` : Equal to (e.g., `a == b` checks if `a` is equal to `b`)
- `!=` : Not equal to (e.g., `a != b` checks if `a` is not equal to `b`)
- `>` : Greater than (e.g., `a > b` checks if `a` is greater than `b`)
- `<` : Less than (e.g., `a < b` checks if `a` is less than `b`)
- `>=` : Greater than or equal to (e.g., `a >= b` checks if `a` is greater than or equal to `b`)
- `<=` : Less than or equal to (e.g., `a <= b` checks if `a` is less than or equal to `b`)
#### 4. **Logical Operators**:
These operators are used to combine or invert boolean expressions.
- `&&` : Logical AND (e.g., `(a == b) && (a > c)` is true if both conditions are true)
- `||` : Logical OR (e.g., `(a == b) || (a > c)` is true if at least one condition is true)
- `!` : Logical NOT (e.g., `!(a == b)` is true if the condition is false)
**[⬆ Back to Top](#table-of-contents)**
---
## What is the Difference Between `float`, `double`, and `long double` Literals?
**`float`**:
- **Precision**: Holds single-precision floating-point numbers.
- **Memory**: Typically takes up 4 bytes.
- **Use case**: Ideal for storing numbers that do not require high precision.
```cpp
float x = 3.14f; // `3.14f` is a `float` literal (the `f` suffix indicates it's a `float`).
```
**`double`**:
- **Precision**: Holds double-precision floating-point numbers, providing more accuracy than `float`.
- **Memory**: Typically takes up 8 bytes.
- **Use case**: Best for calculations requiring higher precision.
```cpp
double b = 2.718; // 2.718` is a `double` literal (by default, floating-point literals like `3.14` are treated as `double`).
```
`
**`long double`**:
- **Precision**: Holds extended-precision floating-point numbers, offering even more precision and a larger range than `double`.
- **Memory**: Typically uses 12 or 16 bytes, depending on the system.
- **Use case**: Useful for high-precision calculations, especially in scientific computations.
```cpp
long double c = 3.141592653L; // `3.141592653L` (the `L` suffix indicates a `long double`).
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is Typecasting?
**Typecasting** is the process of **converting** a variable from one data type to another. This is useful when:
- Performing operations that require **specific data types**.
- Ensuring **compatibility** between different data types.
### Types of Typecasting
- **Implicit Typecasting (Automatic Conversion)** – Performed by the **compiler** automatically.
- **Explicit Typecasting (Manual Conversion)** – Done using the **(type) operator**.
### Methods of Typecasting
- **C-style cast** → `(float)a` (Converts `a` to a `float`)
- **Functional cast** → `float(a)` (Another way to convert `a` to `float`)
```cpp
int main() {
int a = 10;
double b = a; // Implicit conversion
double c = 3.14;
int d = (int)c; // Explicit conversion
cout << "Implicit: " << b << endl;
cout << "Explicit: " << d << endl;
}
```
### Why Use Typecasting?
- Avoids data loss when converting between types.
- Allows mixed-type operations.
- Ensures precision in calculations.
**[⬆ Back to Top](#table-of-contents)**
---
## How Do You Use the Scope Resolution Operator?
The **scope resolution operator (`::`)** helps access **global** variables, functions, or namespace members when there's a **naming conflict** with local variables or class members.
### When to Use `::`?
- **Access Global Variables** → When a local variable has the **same name**.
- **Define Class Functions Outside the Class** → Helps in organizing code.
- **Access Namespace Members** → Avoids **naming conflicts**.
```cpp
int value = 10; // Global variable
class Example {
public:
int value; // Local variable
void show() {
cout << "Local value: " << value << endl;
cout << "Global value: " << ::value << endl; // Access global variable
}
};
int main() {
Example obj;
obj.show();
}
```
```cpp
class Car {
public:
void show(); // Function declaration
};
// Function definition outside the class using `::`
void Car::show() {
cout << "Car is running!" << endl;
}
int main() {
Car myCar;
myCar.show();
}
```
```cpp
// Define two namespaces with the same function name
namespace English {
void greet() {
std::cout << "Hello!" << std::endl;
}
}
namespace French {
void greet() {
std::cout << "Bonjour!" << std::endl;
}
}
int main() {
English::greet(); // Calls English version
French::greet(); // Calls French version
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are Constants, Manipulators, and Operator Precedence?
### 1. **Constants**
Constants are unchangeable; once a constant variable is initialized in a program, its value cannot be changed afterwards.
```cpp
const int MAX = 100;
// MAX = 200; // This would cause a compile-time error because MAX is a constant
```
### 2. **Manipulators**
Manipulators are used for formatting output:
- `endl`: Moves to the next line.
- `setw`: Specifies the width of the output.
```cpp
#include
#include // For setw
int main() {
std::cout << "Hello";
std::cout << std::endl; // Moves to the next line
std::cout << std::setw(10) << 123 << std::endl; // Sets width for output
}
```
### 3. **Operator Precedence & Operator Associativity**
**Operators** in C++ follow a specific **order of execution** when evaluating expressions.
- Understanding **operator precedence** and **associativity** helps prevent unexpected results in calculations.
#### 1. **Operator Precedence**
- Determines **which operator** is evaluated first in an expression.
In `int result = a * b + c;`, multiplication (`*`) has **higher precedence** than addition (`+`).
```cpp
int main() {
int a = 5, b = 10, c = 15;
int result = a * b + c; // Multiplication happens first: (5 * 10) + 15 = 50 + 15 = 65
cout << "Result: " << result << endl;
}
```
#### 2. **Operator Associativity**
**Defines how operators of the same precedence are evaluated in an expression.
#### Types of Associativity:
##### **Left-to-right → Most operators (like +, -, *, /) follow this rule.**
- `Left-to-right Associativity` Subtraction (-) is left associative, so a - b - c is evaluated as (a - b) - c.
```cpp
int main() {
int a = 10, b = 5, c = 3;
int result = a - b - c; // Evaluated as (10 - 5) - 3 = 5 - 3 = 2
cout << "Result: " << result << endl;
}
```
##### **Right-to-left → Assignment (=) and some unary operators follow this rule.**
- Assignment (=) is right associative, so a = b = c is evaluated as a = (b = c).
```cpp
int main() {
int a, b, c = 10;
a = b = c; // Evaluated as b = c first, then a = b
cout << "a: " << a << ", b: " << b << ", c: " << c << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are Control Structures?
Control structures **manage the flow of execution** within a program.
- They allow decision-making, looping, and altering the normal flow of execution.
### 1. **Sequence Structure**
Executes instructions **sequentially**, one after another.
```cpp
int a = 5;
int b = 10;
int sum = a + b;
cout << "Sum: " << sum << endl;
```
### 2. **Selection Structure**
Controls the flow of execution based on conditions.
- Implemented using if-else statements or switch-case statements.
```cpp
int a = 5;
if (a > 0) {
std::cout << "Positive number" << std::endl;
} else {
std::cout << "Non-positive number" << std::endl;
}
```
```cpp
int day = 3;
switch (day) {
case 1:
std::cout << "Monday" << std::endl;
break;
case 2:
std::cout << "Tuesday" << std::endl;
break;
default:
std::cout << "Weekend" << std::endl;
}
```
### 3. **Iteration Statements (Loops)**
Repeats a block of code until a condition becomes false.
```cpp
int i = 0;
while (i < 5) {
std::cout << i << std::endl;
i++;
}
```
### 4. **Jump Statements**
Alters the normal flow of execution.
#### Break Statement
- Exits the loop.
```cpp
for (int i = 0; i < 5; i++) {
if (i == 3) break;
cout << i << endl;
}
// Output: 0 1 2
```
#### Continue Statement
- Skips the current iteration.
```cpp
for (int i = 0; i < 5; i++) {
if (i == 3) continue;
cout << i << endl;
}
// Output: 0 1 2 4
```
#### Return Statement
- Exits from the function.
```cpp
void greet() {
cout << "Hello!" << endl;
return; // Function ends here
}
```
#### Goto Statement
- Jumps to a labeled statement. (Not recommended in modern C++)
```cpp
int i = 0;
start:
cout << i << endl;
i++;
if (i < 3) goto start; // Jumps back to "start"
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are the differences between for, while, and do-while loops?
### 1. **For Loop**
- Ideal for situations where the number of iterations is known beforehand.
```cpp
for (initialization; condition; increment/decrement) {
// code to be executed
}
```
### 2. **While Loop**
- Useful when the number of iterations is not known and depends on a condition being met.
```cpp
while (condition) {
// code to be executed
}
```
### 3. **Do-While Loop**
- Similar to the while loop, but the condition is evaluated after the code block executes, ensuring that the loop body is executed at least once.
```cpp
do {
// code to be executed
} while (condition);
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is the difference between the break and continue statements?
### 1. **Break Statement**
- Terminates the loop entirely.
```cpp
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // Exits the loop when i is 5
}
std::cout << i << " ";
}
```
### 2. **Continue Statement**
- Skips the current iteration of the loop and proceeds with the next iteration.
```cpp
for (int i = 0; i < 10; i++) {
if (i == 5) {
continue; // Skips the rest of the loop body when i is 5
}
cout << i << " ";
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is a pointer and how is it used?
A pointer is a data type that holds the address of another data type. The `&` operator is called the "address of" operator, and the `*` operator is called the "dereference" operator.
```cpp
// Define a variable and a pointer to it
int a = 3;
int* b = &a; // Pointer b holds the address of a
// Display the address and value of a using pointer b
std::cout << "The address of a is " << &a << std::endl;
std::cout << "The address of a is " << b << std::endl;
std::cout << "The value at address b is " << *b << std::endl;
```
**Benefits:**
1. Dynamic Memory Allocation
Pointers are used to allocate and deallocate memory dynamically.
```cpp
void dynamicMemoryAllocation() {
int* ptr = new int; // Allocating memory dynamically
*ptr = 42; // Assigning a value
cout << "Dynamic Memory Allocation: " << *ptr << endl;
delete ptr; // Deallocating memory
}
```
2. Container Access
Pointers can point to arrays, structs, or other containers, and can pass the address of these containers to functions.
```cpp
void containerAccess(int* arr, int size) {
std::cout << "Container Access: ";
for (int i = 0; i < size; i++) {
std::cout << *(arr + i) << " "; // Accessing array elements using a pointer
}
std::cout << std::endl;
}
```
3. Return Multiple Values
Pointers can be used to return multiple values from a function.
```cpp
void returnMultipleValues(int a, int b, int* sum, int* product) {
*sum = a + b; // Assigning sum to the pointer
*product = a * b; // Assigning product to the pointer
}
```
**Pointer to Pointer**
A pointer to pointer is a variable that stores the address of another pointer. In simple terms, it’s a pointer that points to another pointer, which in turn points to a value.
```cpp
int a = 5; // A normal variable
int* ptr = &a; // A pointer that stores the address of 'a'
int** ptr2 = &ptr; // A pointer to pointer, it stores the address of 'ptr'
// Printing the value of 'a' through ptr and ptr2
cout << "Value of a: " << a << endl; // Direct value of 'a'
cout << "Value of a through ptr: " << *ptr << endl; // Dereferencing ptr to get 'a'
cout << "Value of a through ptr2: " << **ptr2 << endl; // Dereferencing ptr2 twice to get 'a'
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is the concept of Null Pointer?
### What is a Null Pointer?
- A **null pointer** is a pointer that does not point to any valid memory location.
- It is used to indicate that the pointer is not currently holding any object or address.
- It is assigned the value NULL or nullptr (C++11 onwards).
- Helps in avoiding dangling pointers (pointers pointing to invalid memory).
- Used to check if a pointer is valid before dereferencing it.
```cpp
int* ptr = NULL; // Null pointer
if (ptr == NULL) {
cout << "Pointer is NULL!" << endl;
} else {
cout << "Pointer is not NULL!" << endl;
}
// ptr == NULL means the pointer is empty and does not point to valid memory.
```
### Why use nullptr instead of NULL?
- `NULL` is an integer constant (0), while `nullptr` is a true pointer constant.
- `nullptr` is type-safe, making it a better choice.
```cpp
int* ptr = nullptr; // nullptr is preferred over NULL
```
### Common Use Cases of Null Pointers
#### 1. **Avoid Dangling Pointers**
A dangling pointer occurs when a pointer still holds a memory address of a deleted object.
```cpp
int* ptr = new int(10);
delete ptr; // Memory is freed
ptr = NULL; // Avoid dangling pointer
// Setting ptr = NULL; ensures that it doesn’t point to an invalid memory location.
```
#### 2. **Checking for Valid Memory Before Dereferencing**
```cpp
int* ptr = NULL;
if (ptr) {
cout << *ptr << endl; // Won't execute if ptr is NULL
} else {
cout << "Pointer is NULL, cannot dereference!" << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is the concept of Garbage Collection?
### What is Garbage Collection?
- Garbage collection is the **process of reclaiming unused memory** to prevent memory leaks. However, **C++ does not have built-in garbage collection** like Java or Python!
- Instead, programmers must manually manage memory using `new` and `delete`.
### Why is Garbage Collection Important?
Without proper memory management, programs can suffer from:
- **Memory leaks** (allocated memory is never freed)
- **Dangling pointers** (pointers referring to deleted memory)
- **Memory fragmentation** (small unused memory blocks slow down the program)
```cpp
// Example of Memory Leak
void memoryLeak() {
int* ptr = new int(10); // Memory allocated on heap
cout << "Value: " << *ptr << endl;
// No delete statement -> Memory leak occurs!
}
int main() {
memoryLeak();
}
```
**Problem:** Memory is allocated with `new`, but never deallocated with `delete`, causing a **memory leak**.
### Manual Garbage Collection in C++
#### 1️. **Free Memory Using `delete`**
```cpp
int* ptr = new int(10);
delete ptr; // Memory freed
ptr = NULL; // Avoids dangling pointer
```
- `Always **free dynamically allocated memory** to prevent leaks.`
#### 2️. **Use Smart Pointers (C++11)**
Smart pointers automatically manage memory by deleting unused objects.
##### 1. **Unique Pointer (`std::unique_ptr`)**
- Manages **exclusive ownership** of an object.
- Automatically deletes memory when it goes out of scope.
```cpp
#include
#include // Required for smart pointers
using namespace std;
int main() {
unique_ptr ptr = make_unique(20); // No need to use `new` or `delete`
cout << "Value: " << *ptr << endl;
} // `ptr` goes out of scope, memory is automatically freed!
```
##### 2. **Shared Pointer (`std::shared_ptr`)**
- Allows **multiple pointers** to share ownership.
- Deletes memory when the **last reference** is removed.
```cpp
#include
#include
using namespace std;
int main() {
shared_ptr p1 = make_shared(30);
shared_ptr p2 = p1; // Both share ownership
cout << "Value: " << *p1 << endl;
} // Memory is freed when `p1` and `p2` go out of scope.
```
- **C++ does NOT have automatic garbage collection** – manual memory management is required.
- **Memory leaks occur if allocated memory is not freed using `delete`.**
- **Use smart pointers (`unique_ptr`, `shared_ptr`) to avoid manual memory management.**
- **Always assign `ptr = NULL;` after `delete` to prevent dangling pointers.**
**[⬆ Back to Top](#table-of-contents)**
---
## What is an Array, and How are Arrays and Pointers Related?
### What is an Array?
An **array** is a collection of elements of the same data type stored in contiguous memory locations.
```cpp
int arr[] = {1, 2, 3};
int *ptr = arr; // Pointer to first element
cout << *(ptr + 1); // Output: 2
```
### Arrays and Pointers
**Array Name as a Pointer:**
- In C++, the name of an array acts as a pointer to the **first element** of the array.
- This means the array name itself holds the **memory address** of the first item in the array.
- `arr` is equivalent to `&arr[0]`.
- `*(arr + i)` is the same as `arr[i]`.
```cpp
int main() {
int marks[] = {23, 45, 56, 89}; // Array with 4 integers
int* p = marks; // Pointer to first element
// Loop through the array using pointer arithmetic
for (int i = 0; i < 4; i++) {
cout << *(p + i) << " "; // Accessing each element using pointer
}
cout << endl;
// Additional pointer arithmetic examples
cout << *(p++) << endl; // Output first element and move pointer
cout << *(++p) << endl; // Move pointer first, then output value
cout << "The value of *p is " << *p << endl;
cout << "The value of *(p+1) is " << *(p+1) << endl;
cout << "The value of *(p+2) is " << *(p+2) << endl;
cout << "The value of *(p+3) is " << *(p+3) << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are Struct, Union, and Enums in C++?
### 1. **Struct**
A **struct** is a user-defined data type in C++ that allows you to group different types of data together. It is similar to an array, but unlike arrays which store data of the same type, a struct can store data of multiple types.
```cpp
struct employee {
int eId; // Employee ID
char favChar; // Favorite character
int salary; // Salary
};
int main() {
employee Chilli; // Creating an instance of the struct
// Access struct members
Chilli.eId = 1;
Chilli.favChar = 'H';
Chilli.salary = 50000;
}
```
### 2. **Union**
A `union` is similar to a struct, but it provides better memory management. All members of a union share the same memory location, so only one member can be used at a time.
```cpp
union money {
int rice; // Amount of rice
char car; // Car type
float pounds; // Pounds of something
};
int main() {
money m1;
m1.rice = 34; // Assigning value to rice
cout << m1.rice; // Output the value of rice
}
```
### 3. **Enum**
An `enum` (enumeration) is a user-defined data type that consists of named constants representing integral values. It makes programs more readable and manageable by defining a set of named values.
```cpp
enum Meal {
breakfast, // 0
lunch, // 1
dinner // 2
};
int main() {
Meal m1 = dinner; // Setting enum value
if (m1 == 2) {
cout << "The value of dinner is " << dinner << endl; // Output value of dinner
}
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are Function and Function Prototypes in C++?
### 1. **Function**
- A **function** is a block of code that performs a specific task.
- It helps make the code **reusable, modular, and easier to debug**.
```cpp
// Function definition
int sum(int a, int b) {
return a + b;
}
int main() {
int result = sum(5, 3); // Calling the function
cout << "Sum is: " << result << endl;
}
```
### 2. **Function Prototypes**
- A **function prototype** is a declaration of a function before defining it.
- It tells the compiler the function's name, return type, and parameters before the actual function implementation.
```cpp
// Function prototype (declaration)
int sum(int a, int b);
// `int sum` → This is the **function signature**, where:
// - `sum` is the **function name**.
// - `int` before `sum` is the **return type**, meaning this function will return an `int` value.
// `(int a, int b)` → This is the **parameter list**, where:
// - `int a` and `int b` are **parameters** (also called **formal parameters**).
// - These define the expected input types when the function is called.
int main() {
int result = sum(5, 3); // Function call
cout << "Sum is: " << result << endl;
}
// Function definition
int sum(int a, int b) {
return a + b;
}
```
- Prototypes must match function definitions
- Prototypes allow calling functions before they are defined
```cpp
int sum(int a, b); // ❌ Incorrect: Missing type for 'b'
int sum(int, int); // ✅ Acceptable but less descriptive
```
- Using function prototypes improves code organization and avoids errors when calling functions before they are defined.
**[⬆ Back to Top](#table-of-contents)**
---
## What are Actual and Formal Parameters?
### 1. **Formal Parameters**
- **Formal parameters** are the variables declared in a function's definition.
- They act as placeholders for the values that will be passed when calling the function.
- They exist **only inside the function**.
### 2. **Actual Parameters**
- **Actual parameters** are the real values or variables passed to a function when it is called.
- They provide the function with specific data to process.
```cpp
// Function definition with formal parameters 'a' and 'b'
void add(int a, int b) {
cout << "Sum is: " << a + b << endl; // 'a' and 'b' are formal parameters
}
int main() {
int num1 = 5, num2 = 3;
add(num1, num2); // num1 and num2 are actual parameters
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What does it mean by Call by Value, Call by Reference, & Call by Pointer?
### 1. **Call by Value**
- A **copy** of the actual parameter is passed to the function.
- Changes made inside the function **do not affect** the original values.
```cpp
int sum(int a, int b){
int c = a + b;
return c;
}
// This will not swap a and b
void swap(int a, int b){
int temp = a;
a = b;
b = temp;
}
int main(){
int x = 4, y = 5;
cout << "The value of x is " << x << " and the value of y is " << y << endl;
swap(x, y); // This will not swap x and y
cout << "The value of x is " << x << " and the value of y is " << y << endl;
}
```
### 2. **Call by Pointer**
- A **memory address **(pointer) of the actual parameters is passed.
- Changes made inside the function affect the original values.
```cpp
// Call by Pointer
void swapPointer(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main() {
int x = 4, y = 5;
cout << "Before swap: x = " << x << ", y = " << y << endl;
swapPointer(&x, &y); // Passing memory addresses
cout << "After swap: x = " << x << ", y = " << y << endl;
}
```
### 3. **Call by Reference**
- A **reference** (alias) to the actual parameter is passed.
- Changes made inside the function affect the original values.
```cpp
// Call by Reference using C++ reference variables
void swapReferenceVar(int &a, int &b) {
int temp = a;
a = b;
b = temp;
}
int main() {
int x = 4, y = 5;
cout << "Before swap: x = " << x << ", y = " << y << endl;
swapReferenceVar(x, y); // Call by Reference
cout << "After swap: x = " << x << ", y = " << y << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are Static Variables & Functions?
### 1. **Static Variable**
A **static variable** is a variable that belongs to the **class** rather than an **instance**. It is shared among all objects of the class, meaning only **one copy** of the variable exists.
- **Shared Across Objects**: A static variable is common to all objects.
- **Declared Inside the Class**: But must be **defined outside** the class.
- **Memory Allocation**: Allocated once, at program start, and deallocated at program end.
- **Access**: Accessed using the **class name** with the `::` scope resolution operator.
```cpp
class Counter {
public:
static int count; // Static variable declaration
Counter() {
count++; // Increment count for each object created
}
static int getCount() { // Static function
return count;
}
};
// Define and initialize static variable
int Counter::count = 0;
int main() {
Counter obj1, obj2, obj3;
// Access static function using class name
cout << "Total objects created: " << Counter::getCount() << endl;
}
```
### 2. **What is a Static Function?**
A **static function** is a function that belongs to the **class**, not to any specific object. It can **only access static variables** and **other static functions**.
- ❌ **Cannot access non-static members**.
- ✅ **Does not require an object** to be called.
- ❌ **Cannot use** the `this` pointer.
- ✅ **Can be called using the class name**.
```cpp
class Circle {
int radius;
static const float Pi;
public:
void setRadius(int r) {
radius = r;
}
int getRadius() const {
return radius;
}
// Static function to get Pi value
static float getPi() {
return Pi;
}
};
// Define static constant
const float Circle::Pi = 3.14159;
int main() {
// Access static function without creating an object
cout << "Value of Pi: " << Circle::getPi() << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are Inline Functions, Default Arguments, & Constant Arguments?
### 1. **Inline Functions**
**Inline functions** are used to reduce the overhead of function calls. Instead of jumping to the function's memory location, the compiler replaces the function call with the function's actual code at **compile-time**.
**When to Use?**
- Useful for **small functions** to improve execution speed.
- Not recommended for **functions with static variables**, as they may lead to inefficiency.
```cpp
inline int product(int a, int b){
return a * b;
}
int main(){
int a = 5, b = 10;
cout << "The product of " << a << " and " << b << " is " << product(a, b) << endl;
}
```
### 2. **Default Arguments**
**Default arguments** allow functions to be called with fewer parameters than defined. If a value is not provided, the default value is used.
- Default arguments must be specified in the function prototype or definition.
- Default arguments should be placed after all required parameters.
```cpp
float moneyReceived(int currentMoney, float factor = 1.04) {
return currentMoney * factor;
}
int main() {
int money = 100000;
cout << "If you have " << money << " Rs in your bank account, you will receive "
<< moneyReceived(money) << " Rs after 1 year" << endl;
cout << "For VIP: If you have " << money << " Rs in your bank account, you will receive "
<< moneyReceived(money, 1.1) << " Rs after 1 year" << endl;
}
```
### 3. **Constant Arguments**
- **Constant arguments** prevent a function from modifying the values of the arguments. This ensures data integrity and avoids accidental changes inside the function.
- When passing read-only data to a function.
- When working with pointers to constant values to avoid accidental modification.
```cpp
int strlen(const char *p) {
int length = 0;
while (*p != '\0') {
length++;
p++;
}
return length;
}
int main() {
const char *str = "Hello, World!";
cout << "The length of the string is " << strlen(str) << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is Recursion and Recursive Functions?
**Recursion** is a process where a function **calls itself** to solve a problem. A function that does this is known as a **recursive function**.
### Key Components of Recursion:
1. **Base Case**
- The condition that **stops** recursion.
- Prevents infinite recursive calls.
2. **Recursive Case**
- The function **calls itself** with modified arguments.
- Continues until the base case is met.
```cpp
// Recursive function to calculate factorial
int factorial(int n){
if (n <= 1){
return 1; // Base case
}
return n * factorial(n - 1); // Recursive case
}
int main(){
int number = 5;
cout << "The factorial of " << number << " is " << factorial(number) << endl;
}
```
### How Recursion Works (Step-by-Step)
- For factorial(5), the recursive calls work like this:
```cpp
factorial(5) → 5 * factorial(4)
factorial(4) → 4 * factorial(3)
factorial(3) → 3 * factorial(2)
factorial(2) → 2 * factorial(1)
factorial(1) → 1 (Base Case)
```
- Now, returning back:
```cpp
factorial(2) = 2 * 1 = 2
factorial(3) = 3 * 2 = 6
factorial(4) = 4 * 6 = 24
factorial(5) = 5 * 24 = 120
```
### When to Use Recursion?
- When the problem can be divided into similar subproblems.
- When using loops makes the solution more complex.
❌ Avoid recursion if it causes stack overflow due to excessive function calls.
**[⬆ Back to Top](#table-of-contents)**
---
## What is Function Overloading?
- **Function Overloading** allows multiple functions to have the **same name** but different **parameters** (either in number or type).
- This enables functions to perform similar tasks while accepting different types or numbers of arguments.
### How Does Function Overloading Work?
Function overloading works by **changing:**
1. **Number of parameters**
2. **Type of parameters**
*(Changing only the return type is **not enough** to overload a function!)*
### **Function Overloading Based on Number of Parameters**
```cpp
// Function to add two numbers
int sum(int a, int b) {
cout << "Using function with 2 parameters" << endl;
return a + b;
}
// Function to add three numbers
int sum(int a, int b, int c) {
cout << "Using function with 3 parameters" << endl;
return a + b + c;
}
int main() {
cout << sum(10, 20) << endl; // Calls the function with 2 parameters
cout << sum(10, 20, 30) << endl; // Calls the function with 3 parameters
}
```
### **Function Overloading Based on Parameter Type**
```cpp
// Function to calculate the square of an integer
int square(int x) {
return x * x;
}
// Function to calculate the square of a double
double square(double x) {
return x * x;
}
int main() {
cout << "Square of 5 (int): " << square(5) << endl;
cout << "Square of 5.5 (double): " << square(5.5) << endl;
}
```
### ❌ What Does NOT Count as Function Overloading?
**Changing Only the Return Type**
```cpp
int func(int x); // Function 1
double func(int x); // ❌ Error: Only return type is different
```
| Feature | Description |
|---------|-------------|
| **Function Overloading** | Same function name, different **number/type of parameters** |
| **Valid Overloading** | ✅ Change in number of parameters or data type |
| **Invalid Overloading** | ❌ Changing only the return type |
**[⬆ Back to Top](#table-of-contents)**
---
## What is OOP?
- OOP stands for Object-Oriented Programming.
- It's a **programming paradigm** or way of writing code that uses "objects" to represent real-world things or concepts.
- Each object can have its own data and functions (called methods) that work with that data.
- It is easier to relate real world entities to the OOP.
### **Key OOP Concepts:**
1. **Class** – A blueprint for objects.
2. **Object** – An instance of a class.
3. **Encapsulation** – Restricts direct access to object data, ensuring security or Hiding internal/private details.
4. **Abstraction** –Hides complex details, exposing only essential features.
5. **Inheritance** – Reusing code from parent classes.
6. **Polymorphism** – Enables objects to be treated as instances of a common parent class.
```cpp
class Car {
public:
string brand;
void show() { cout << "Brand: " << brand; }
};
int main() {
Car myCar;
myCar.brand = "Toyota";
myCar.show();
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## Some Visual Things about OOP
---
## Why OOP? Purpose of Implementing OOP?
OOP provides several benefits that make software development efficient and maintainable:
- **Modularity** – Breaks programs into smaller, manageable parts.
- **Code Reusability** – Inheritance reduces code duplication.
- **Scalability** – Efficiently builds and extends large systems.
- **Maintainability** – Modular structure simplifies debugging and updates.
- **Real-world Modeling** – Represents real-world entities as objects.
- **Parallel Development** – Teams can work on different objects independently.
- **Data Security** – Encapsulation restricts unnecessary access to data.
**OOP helps write **organized, reusable, and maintainable code**, making it a preferred choice for large-scale software development.**
**[⬆ Back to Top](#table-of-contents)**
---
## Why is OOP so popular?
OOPs, programming paradigm is considered as a better style of programming. Not only it helps in writing a complex piece of code easily, but it also allows users to handle and maintain them easily as well.
#### **Key Reasons for OOP's Popularity**
- **Modularity** – Breaks programs into smaller, manageable parts.
- **Code Reusability** – **Inheritance** reduces duplication and promotes efficiency.
- **Scalability** – Easily extends and adapts to growing software needs.
- **Maintainability** – Modular structure simplifies debugging and updates.
- **Real-world Modeling** – Represents real-world entities as objects.
- **Parallel Development** – Teams can work on different modules independently.
- **Data Security** – **Encapsulation** restricts unauthorized access.
#### **Not only that, the main pillar of OOPs**
1. **Encapsulation** – Binds data and methods together, restricting direct access.
2. **Abstraction** – Hides unnecessary details, exposing only essential features.
3. **Inheritance** – Enables reusability by deriving new classes from existing ones.
4. **Polymorphism** – Allows one interface, multiple implementations for flexibility.
Makes it easy for programmers to solve complex scenarios. As a result of these, OOPs is so popular.
**[⬆ Back to Top](#table-of-contents)**
---
## What are the Pros and Cons of Object-Oriented Programming (OOP)?
Object-Oriented Programming (OOP) is a popular paradigm, but like any approach, it has both advantages and drawbacks. Below is a structured comparison:
### Pros of OOP
| **Advantage** | **Explanation** |
|----------------------|----------------|
| **Modularity** | Breaks programs into smaller, manageable parts, making debugging and maintenance easier. |
| **Code Reusability** | Inheritance allows efficient reuse of existing code, reducing redundancy. |
| **Scalability** | Easily extendable for larger projects and adaptable to changing requirements. |
| **Maintainability** | Organized structure makes it easier to debug and update code. |
| **Data Security** | Encapsulation restricts unauthorized access, ensuring better data protection. |
| **Real-World Modeling** | Represents real-world entities effectively, making software design intuitive. |
| **Parallel Development** | Different modules can be worked on independently, improving team collaboration. |
| **Extensibility** | Polymorphism allows modifying or extending functionalities without altering existing code. |
### Cons of OOP
| **Disadvantage** | **Explanation** |
|-----------------------|----------------|
| **Requires Skilled Programmers** | Developers need a strong understanding of objects, classes, and OOP concepts. |
| **Not Always Suitable** | Might not be the best choice for small-scale or simple problems. |
| **Larger Codebase** | OOP programs tend to have more lines of code compared to procedural programming. |
| **More Memory Consumption** | Object creation and dynamic features may lead to higher memory usage. |
| **More Planning Required** | The design phase is complex and requires proper planning before implementation. |
| **Slower Execution Speed** | Due to abstraction layers, OOP can be slightly slower than procedural programming. |
| **Documentation Dependency** | Understanding OOP code without proper documentation can be difficult. |
| **Longer Development Time** | Designing classes, relationships, and interactions requires more effort upfront. |
- **OOP is great for large-scale applications** due to its modularity, reusability, and scalability.
- **However, it requires more planning and can be resource-intensive** compared to procedural programming.
OOP remains a widely used paradigm in major programming languages like **C++, Java, and Python**, making it an essential concept for software developers.
**Additional Advantages of OOP:**
- Follows a **bottom-up approach**, making code more structured.
- **Encapsulation** avoids unnecessary data exposure and enhances security.
- OOP **forces extensive design planning**, leading to better architecture and fewer flaws.
- **Breaks down complex problems** into manageable chunks.
- **Enhances productivity** by minimizing complexity and allowing easy redesigns without affecting other functionalities.
- Provides **efficient modeling of real-world entities**, making programming more intuitive.
**[⬆ Back to Top](#table-of-contents)**
---
## What is the Difference Between Object-Oriented Programming vs Structural Programming?
| **Object-Oriented Programming (OOP)** | **Structural Programming** |
|---------------------------------------------------------------|--------------------------------------------------------------------------------------------|
| **Follows a bottom-up approach** – Development starts with objects and their interactions. | **Follows a top-down approach** – Development starts with defining functions and procedures. |
| **Supports data hiding** – Uses encapsulation to restrict direct access to data. | **Does not support data hiding** – Data is freely accessible within the program. |
| **Best suited for complex and large-scale applications.** | **Best suited for moderate or small-scale applications.** |
| **Code reusability** – Inheritance and polymorphism reduce redundancy. | **Limited code reusability** – Functions can be reused, but there is no built-in inheritance. |
| **Based on objects and classes** – Emphasizes real-world modeling. | **Based on procedures and functions** – Focuses on breaking a problem into smaller tasks. |
| **Provides better security** – Data is controlled through access modifiers. | **Less secure** – Data is shared across functions, increasing exposure. |
| **Higher abstraction and flexibility** – Uses encapsulation, polymorphism, and abstraction for better control. | **Less abstraction and flexibility** – Code organization is more rigid and procedural. |
| **Focuses on data and behavior (methods).** | **Focuses on process and step-by-step execution.** |
- **OOP** is ideal for complex, scalable applications with reusable components and better security.
- **Structural Programming** is suitable for simpler applications that require a straightforward, procedural approach.
**[⬆ Back to Top](#table-of-contents)**
---
## What is the Difference Between Procedure-Oriented Programming (POP) and Object-Oriented Programming (OOP)?
| **Procedure-Oriented Programming (POP)** | **Object-Oriented Programming (OOP)** |
|------------------------------------------|------------------------------------------|
| Centers around functions or procedures. | Centers around objects that bundle data and methods. |
| Data is often global and less secure. | Data is encapsulated within objects, providing better security. |
| Programs are structured as a sequence of steps or procedures. | Programs are structured around objects and classes. |
| Limited reusability of code due to a lack of modularity and encapsulation. | Promotes reusability through mechanisms like inheritance and polymorphism. |
| Less suitable for complex applications. | More suitable for complex applications. |
| Focuses on function calls. | Focuses on message passing between objects. |
**Limitations of OOP:**
- Programs written using OOP tend to be larger than those using procedural programming.
- Requires significant planning and pre-work before implementation.
- Without proper documentation, OOP code can be challenging to understand.
- Object-oriented programs may consume more memory due to dynamic features.
- Not ideal for small, simple problems.
- Development may take longer due to class and object structuring.
**[⬆ Back to Top](#table-of-contents)**
---
## What is a Pure Object-Oriented Language?
A programming language is called a **pure object-oriented language** if it treats everything inside the program as an object. Unlike hybrid OOP languages, pure OOP languages do not support primitive data types (e.g., integers, floats, characters) outside the object model.
A pure OOP language must satisfy the following properties:
- **Encapsulation** – Data hiding through access modifiers.
- **Inheritance** – Ability to derive new classes from existing ones.
- **Polymorphism** – Same interface, different implementations.
- **Abstraction** – Hiding implementation details and exposing only necessary functionalities.
- **All Predefined Types Are Objects** – No primitive data types exist outside objects.
- **All User-Defined Types Are Objects** – Every custom type must be an object.
- **All Operations Are Performed Through Methods** – Direct access to variables is restricted; all interactions happen through object methods.
### Examples of Pure OOP Languages
- **Smalltalk**
- **Eiffel**
- **Ruby**
Languages like **Java, C++, Python, and C#** are not purely object-oriented because they allow primitive data types like `int`, `char`, and `float` outside the object model.
**[⬆ Back to Top](#table-of-contents)**
---
## What is a Struct?
- A struct (structure) is a user-defined data type in C++ that groups related variables under a single name.
- Structs are typically used for lightweight objects that hold data without requiring encapsulation or functionality.
- Unlike classes, struct members are `public` by default.
```cpp
#include
using namespace std;
struct Person {
string name;
int age;
};
int main() {
Person p1;
p1.name = "Alice";
p1.age = 30;
cout << "Name: " << p1.name << ", Age: " << p1.age << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is a Class and Why Do We Need It in OOP?
- Class is a building block of OOP.
- It is a user defined data type.
- It is a blueprint or recipe for creating objects in object-oriented programming (OOP).
- It contains data members (attributes) and member functions (methods) that define the behaviors of objects.
**Why Do We Need It?**
- **Encapsulation:** Bundles data and methods that operate on the data.
- **Reusability:** Once defined, a class can create many instances (objects).
- **Inheritance:** A class can inherit properties and behaviors from other classes.
- **Abstraction:** Simplifies complex systems by hiding unnecessary details.
```cpp
#include
using namespace std;
class Person {
public:
string name;
int age;
void introduce() {
cout << "Hello, my name is " << name << " and I am " << age << " years old." << endl;
}
};
int main() {
Person p1;
p1.name = "Bob";
p1.age = 25;
p1.introduce();
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What are Class Attributes & Methods in OOP?
In Object-Oriented Programming (OOP), **attributes** and **methods** define the characteristics and behavior of an object.
- **Attributes (Member Variables)** - Represent the **state** or properties of an object.
- **Methods** - Functions inside a class that define the **behavior** of an object.
```cpp
class Car {
public:
// Attributes (Member Variables)
string model;
int year;
// Method (Member Function)
void display() {
cout << "Model: " << model << ", Year: " << year << endl;
}
};
int main() {
// Creating an object of Car
Car car1;
car1.model = "Tesla Model 3";
car1.year = 2023;
// Calling a method
car1.display();
}
```
- Attributes store data about an object.
- Methods define what the object can do.
- Methods can access and modify an object's attributes.
**[⬆ Back to Top](#table-of-contents)**
---
## Why Use a Class Instead of a Struct?
In C++, both **classes** and **structs** can be used to create custom data types, but **classes** offer more flexibility and control.
| Feature | **Class** | **Struct** |
|---------|----------|-----------|
| **Access Control** | Members are `private` by default. | Members are `public` by default. |
| **Encapsulation** | Can have private and protected members, restricting access. | No direct access restriction unless explicitly specified. |
| **Functionality** | Supports methods, constructors, destructors, and operator overloading. | Primarily used for grouping related data, lacks complex functionality. |
| **Inheritance** | Supports **inheritance** (base and derived classes). | **Does not support inheritance** in the same way as classes. |
```cpp
class Person {
private:
string name;
int age;
public:
// Constructor to initialize the data members
Person(string n, int a) : name(n), age(a) {}
// Member function to display the details
void showDetails() {
cout << "Name: " << name << ", Age: " << age << endl;
}
};
int main() {
// Creating an object of the class
Person p1("Charlie", 28);
// Calling the member function to show details
p1.showDetails();
}
```
### Why Use a Class Instead of a Struct?
- **Encapsulation** – Restrict access to sensitive data.
- **More Functionality** – Supports methods, constructors, and destructors.
- **Supports Inheritance** – Can extend and modify functionality.
- **Better Code Organization** – Ideal for complex data structures and OOP.
### When to Use Class vs Struct?
#### Use a class when you need:
- Encapsulation (private members)
- Inheritance and polymorphism
- Functions and behaviors in addition to data
#### Use a struct when you need:
- Simple data storage without complex behavior
- Lightweight objects for performance optimization
- Structs are ideal for small data models, while classes offer a better, scalable approach for Object-Oriented Programming.
**[⬆ Back to Top](#table-of-contents)**
---
## What are the Similarities Between Class and Struct?
- Both **group related data** into a single entity.
- Both can have **member variables** (data members).
- Both can have **member functions** (methods).
- Both support **constructors and destructors**.
- Both allow **operator overloading**.
- Both can define **static members**.
- Both can use **access specifiers** (`public`, `private`, `protected`).
```cpp
// Class Example
class ClassExample {
public:
int x;
void show() { cout << "Class x: " << x << endl; }
};
// Struct Example
struct StructExample {
int y;
void show() { cout << "Struct y: " << y << endl; }
};
int main() {
ClassExample obj1;
obj1.x = 10;
obj1.show();
StructExample obj2;
obj2.y = 20;
obj2.show();
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is the Difference Between Class and Struct?
| Feature | **Class** | **Struct** |
|----------------|----------|------------|
| **Default Access** | Members are `private` by default. | Members are `public` by default. |
| **OOP Features** | Fully supports **inheritance, polymorphism, encapsulation, and abstraction**. | Does **not** support inheritance. |
| **Functionality** | Can have **constructors, destructors, and member functions**. | Primarily used for **storing data** with limited functionality. |
```cpp
// Class Example
class Person {
private:
string name;
public:
Person(string n) : name(n) {} // Constructor
void display() { cout << "Name: " << name << endl; } // Method
};
// Struct Example
struct PersonStruct {
string name; // Public by default
};
int main() {
// Using a class
Person p1("Alice");
p1.display();
// Using a struct
PersonStruct s1;
s1.name = "Bob";
cout << "Name: " << s1.name << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is a Object and Why Do We Need It in OOP?
- An **object** is an **instance** of a class.
### 🧐 What Does "Instance" Mean?
- An **instance** is a **real, usable version** of a class.
- Think of a **class** as a **blueprint** and an **object** as the **actual thing created** using that blueprint.
- It represents real-world entities created from a blueprint (class) with properties (data members) and behaviors (member functions). Without objects, a class is just a blueprint and does not hold any actual data.
- Think of a **class** as a **recipe** and an **object** as the actual **dish** made using that recipe. A recipe defines the ingredients and steps, but unless you cook it, the recipe itself is useless!
- **Class = Recipe 📜**
- **Object = Dish 🍛 (Made from the recipe)**
### Why Do We Need Objects?
Objects are **crucial in OOP** because they:
- **Store Data** → A class is just a **template**; objects bring it to **life** by holding real values.
- **Encapsulate Behavior** → Objects allow actions using their **methods (functions)**.
- **Enable Modularity** → Promote **code reuse**, better organization, and easy debugging.
```cpp
// Class Definition
class Car {
public:
string brand;
int speed;
// Method to display car details
void showDetails() {
cout << "Brand: " << brand << ", Speed: " << speed << " km/h" << endl;
}
};
int main() {
Car myCar; // Creating an object of the Car class
// Assigning values to object properties
myCar.brand = "Toyota";
myCar.speed = 120;
// Calling the object's method
myCar.showDetails();
}
```
- A class is just a concept or a template.
- An instance (or object) is a real, created version of that class.
- You must create an object to use the class in practice!
**[⬆ Back to Top](#table-of-contents)**
---
## What is an Array of Objects?
### What is an Array of Objects?
- An **array of objects** is an array where **each element** is an **instance of a class**.
- Just like an array of integers (`int arr[5]`), we can create an **array of objects** to store multiple instances of a class.
### Why Use an Array of Objects?
- **Efficient Storage & Organization** → Store multiple objects in a single array.
- **Indexed Access** → Access individual objects using their index, just like normal arrays.
- **Better Code Management** → Helps manage related objects without separate variables.
```cpp
class Car {
public:
string brand;
int speed;
void setData(string b, int s) {
brand = b;
speed = s;
}
void showDetails() {
cout << "Brand: " << brand << ", Speed: " << speed << " km/h" << endl;
}
};
int main() {
Car cars[3]; // ✅ Creating an array of 3 Car objects
// Assign values to each object in the array
cars[0].setData("Toyota", 120);
cars[1].setData("Honda", 130);
cars[2].setData("BMW", 160);
// Display details of each car using a loop
for (int i = 0; i < 3; i++) {
cout << "Car " << i + 1 << ": ";
cars[i].showDetails();
}
}
```
- Objects can be stored in arrays just like primitive data types.
- Indexed access makes it easy to manipulate multiple objects.
- Loops make it efficient to process multiple instances of a class.
**[⬆ Back to Top](#table-of-contents)**
---
## How do you Pass Objects as Function Arguments?
Objects in C++ can be passed to functions in **two ways**:
1. **Pass by Value**: A copy of the object is made, meaning changes inside the function **won’t affect the original object**.
2. **Pass by Reference**: The function receives a reference to the object, meaning it can **directly modify the original object**.
```cpp
class Complex {
int a;
int b;
public:
// Function to set values of a and b
void setData(int v1, int v2) {
a = v1;
b = v2;
}
// Function to set object data by summing two other objects
void setDataBySum(const Complex &o1, const Complex &o2) {
a = o1.a + o2.a;
b = o1.b + o2.b;
}
// Function to print complex number
void printNumber() const {
cout << "Your complex number is " << a << " + " << b << "i" << endl;
}
};
int main() {
Complex c1, c2, c3;
c1.setData(1, 2);
c1.printNumber();
c2.setData(3, 4);
c2.printNumber();
// Passing objects as function arguments
c3.setDataBySum(c1, c2);
c3.printNumber();
}
```
- **Pass by Value** creates a copy of the object, meaning changes inside the function do not affect the original object.
- **Pass by Reference** (const &) avoids unnecessary copies and allows direct modification.
- **Function Overloading** can be used to perform different operations on objects.
**[⬆ Back to Top](#table-of-contents)**
---
## What is Pointer to Objects in C++? What are its Purpose and Benefits?
### What is a Pointer to an Object?
In C++, **pointers** are used to store addresses of both **primitive data types** (like `int`, `float`, `double`) and **objects of user-defined classes**.
A **pointer to an object** is a special pointer that stores the **memory address** of an object of a class type.
### Purpose of Pointers to Objects
Pointers to objects are widely used in C++ for the following reasons:
**Dynamic Object Creation**:
- Objects can be created dynamically at runtime using the `new` keyword.
- This allows more flexibility and efficient memory management.
**Indirect Access**:
- Objects can be accessed and manipulated indirectly through pointers.
- Useful when working with dynamically allocated objects or when passing objects to functions.
**Efficient Memory Management**:
- Reduces unnecessary memory allocation and deallocation.
- Helps in optimizing memory usage in large-scale applications.
```cpp
class Complex {
int real, imaginary;
public:
void setData(int a, int b) {
real = a;
imaginary = b;
}
void getData() {
cout << "The real part is " << real << endl;
cout << "The imaginary part is " << imaginary << endl;
}
};
int main() {
Complex *ptr = new Complex; // Dynamically creating an object
ptr->setData(1, 54); // Using -> operator to access members
ptr->getData();
delete ptr; // Free allocated memory
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## How is Memory Allocated for Variables, Functions, Member Functions, and Data Members?
Memory allocation happens at different times depending on the type of variable or function. Here's a breakdown:
### 1. Memory Allocation for Variables
| **Variable Type** | **When Allocated?** | **Where Stored?** | **When Deallocated?** |
|--------------------------|-----------------------------|--------------------------------|---------------------------------|
| **Local Variables** | When function is called | **Stack** | When function returns |
| **Global Variables** | When program starts | **Data Segment (BSS/Initialized Data)** | When program ends |
| **Static Variables** | When program starts (First use) | **Data Segment (BSS/Initialized Data)** | When program ends |
| **Dynamic Variables (`new`)** | When `new` is called | **Heap** | When `delete` is called |
### 2. Memory Allocation for Member Variables in a Class
| **Variable Type** | **When Allocated?** | **Where Stored?** | **When Deallocated?** |
|--------------------------|---------------------------|-----------------------------|--------------------------|
| **Non-Static Members** | When an object is created | **Heap/Stack** (depends on object creation) | When object is destroyed |
| **Static Members** | When program starts (First use) | **Data Segment** | When program ends |
```cpp
class MyClass {
public:
int x; // Non-static (allocated per object)
static int count; // Static (allocated once for all objects)
MyClass() { x = 0; }
};
int MyClass::count = 0; // Allocated when the program starts (Data Segment)
```
### 3.Memory Allocation for Functions
| **Function Type** | **When Allocated?** | **Where Stored?** | **When Deallocated?** |
|-------------------------|--------------------------|---------------------|----------------------|
| **Regular Functions** | When program starts | **Code Segment** | Never (Remains throughout execution) |
| **Member Functions** | When program starts | **Code Segment** | Never |
| **Virtual Functions (vtable)** | When the first object of a class is created | **Heap (vtable pointer per object)** | When the last object of class is destroyed |
```cpp
class Base {
public:
virtual void show() {} // Stored in vtable
};
int main() {
Base obj; // Allocates vtable pointer in Heap
}
```
### 4. Memory Allocation for Objects
| **Object Type** | **When Allocated?** | **Where Stored?** | **When Deallocated?** |
|-------------------------|--------------------------|---------------------|----------------------|
| **Automatic Objects** (`MyClass obj;`) | When function is called | **Stack** | When function returns |
| **Dynamic Objects** (`new MyClass();`) | When `new` is called | **Heap** | When `delete` is called |
```cpp
int main() {
MyClass obj1; // Stack allocation (Deallocated when function ends)
MyClass* obj2 = new MyClass(); // Heap allocation (Must delete manually)
delete obj2; // Deallocates obj2
}
```
- **Stack** variables exist only inside functions.
- **Heap** memory must be manually deallocated with `delete`.
- **Static variables exist throughout the program's execution.
- **Functions are stored once and never deallocated.
- **Virtual functions use a vtable allocated on the heap.
**[⬆ Back to Top](#table-of-contents)**
---
## What are Access Specifiers in OOP?
Access specifiers control the visibility of members in a class:
- **Public:** Members are accessible from anywhere in the program.
- **Private:** Members are accessible only within the class itself.
- **Protected:** Members are accessible within the class and its derived classes.
```cpp
class Person {
private:
string name;
public:
Person(string n) : name(n) {}
void displayName() {
cout << "Name: " << name << endl;
}
};
int main() {
Person p("David");
p.displayName(); // Accessing public method
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is the Default Access Modifier in a Class?
In C++, the **default access modifier** for members of a **class** is **private**.
- This means that if you do not explicitly specify an access modifier (`public`, `private`, or `protected`), the members of the class will be **private by default**.
However, in a **struct**, the default access modifier is **public**.
```cpp
class MyClass {
int privateVar; // Default access is private
public:
int publicVar; // Explicitly declared as public
};
struct MyStruct {
int publicVar; // Default access is public
};
int main() {
MyClass obj1;
// obj1.privateVar = 10; // ❌ Error: private member cannot be accessed
obj1.publicVar = 20; // ✅ Allowed
MyStruct obj2;
obj2.publicVar = 30; // ✅ Allowed (default access in struct is public)
cout << "obj1.publicVar: " << obj1.publicVar << endl;
cout << "obj2.publicVar: " << obj2.publicVar << endl;
}
```
- For **class**, the default access modifier is private.
- For **struct**, the default access modifier is public.
- You must `explicitly` use **public** if you want class members to be accessible outside the class.
**[⬆ Back to Top](#table-of-contents)**
---
## What is Sealed Modifier?
A **sealed class** or **sealed modifier** is used to prevent other classes from inheriting from it. In some languages like C# or Java, marking a class as sealed ensures that no class can derive from it.
```csharp
sealed class MyClass {
public void Display() {
Console.WriteLine("This is a sealed class.");
}
}
// This will result in a compile-time error:
// class DerivedClass : MyClass { } // Error: cannot inherit from sealed class
```
- In languages like C++, the equivalent would be to simply avoid inheritance by not defining any child classes, as C++ does not have a direct **sealed** keyword.
**[⬆ Back to Top](#table-of-contents)**
---
## What is Dynamic Memory Allocation (DMA) and the new Keyword? What are Their Purpose and Benefits?
### What is Dynamic Memory Allocation?
Dynamic Memory Allocation (DMA) in C++ allows memory to be **allocated at runtime**, rather than at compile time. This is done using the `new` keyword, which **allocates memory on the heap** and returns a pointer to the allocated space. The allocated memory must be **freed** using the `delete` operator (or smart pointers) to prevent **memory leaks**.
C++ also provides `new[]` and `delete[]` for dynamically **allocating and deallocating arrays**.
### Purpose
- **Allocates memory on the heap** (instead of the stack).
- **Returns a pointer** to the allocated memory.
- **Allows dynamic object creation** and flexible memory management.
### Benefits of Dynamic Memory Allocation
- **Efficient Memory Usage** – Allocates memory **only when needed**, reducing wastage.
- **Supports Object-Oriented Programming (OOP)** – Allows creating objects dynamically.
- **Flexible Array Allocation** – Arrays can be allocated dynamically based on user input.
- **Lifetime Control** – Objects persist beyond function calls if necessary.
```cpp
int main() {
// Allocating memory for a single integer
int* ptr = new int(10);
cout << "Value: " << *ptr << endl;
// Allocating memory for an array
int* arr = new int[5]{1, 2, 3, 4, 5};
cout << "Array elements: ";
for (int i = 0; i < 5; i++) {
cout << arr[i] << " ";
}
cout << endl;
// Freeing the allocated memory
delete ptr; // Free single integer
delete[] arr; // Free array
}
```
- Forgetting to delete dynamically allocated memory results in memory leaks.
**[⬆ Back to Top](#table-of-contents)**
---
## What is the `delete` What are its Purpose and Benefits?
The `delete` keyword in C++ is used to **free dynamically allocated memory** that was allocated using the `new` keyword. It ensures that memory allocated on the **heap** is properly released and made available for reuse.
### Purpose
- **Releases memory allocated with `new`**, preventing memory leaks.
- Returns the allocated memory back to the **operating system**.
- Improves memory efficiency, ensuring the program doesn't consume excessive resources.
### Benefits
**Prevents Memory Leaks** – Ensures memory allocated using `new` is properly deallocated.
**Efficient Memory Management** – Helps manage heap memory efficiently, especially for large objects and arrays.
**Avoids Unnecessary Memory Consumption** – Frees up memory for reuse.
```cpp
int main() {
// Dynamically allocate an array of 3 integers
int* arr = new int[3];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
cout << "Before delete: " << arr[0] << ", " << arr[1] << ", " << arr[2] << endl;
// Free the allocated memory
delete[] arr;
// After deletion, accessing the array leads to undefined behavior
cout << "After delete (undefined behavior): " << arr[0] << endl;
}
```
**[⬆ Back to Top](#table-of-contents)**
---
## What is the Arrow (`->`) and Dot (`.`) Operator? What is its Purpose or Benefit?
In C++, the **dot (`.`) operator** and **arrow (`->`) operator** are used to access **members (variabl