7-Day C++ Roadmap for Internship Interviews

Goal: Master C++ basics (arrays, functions, pointers, OOP, file

handling, STL) to prepare for entry-level internship interviews

Duration 7 days, 6 hours daily (May 25– June 01, 2025).

Resources Udemy Course: C++ Basic to Advance

Book: C++: From Control Structures Through Objects (8th
Edition) by Tony Gaddis
Practice Platforms: LeetCode (Easy, C++), HackerRank (C+
+), GeeksforGeeks.
Tools: IDE (Visual Studio Code) , GitHub for projects
Daily Structure 2 hours: Theory (Udemy + Gaddis book).
3 hours: Practice (programs + problems).
1 hour: Revision + interview prep (notes, mock interviews).

Daily Schedule

Time What to do at this time

9:00–11:00 AM Theory (Udemy + Gaddis book).
11:00 AM–2:00 PM Practice (programs,
LeetCode/HackerRank).
2:00–3:00 PM Break or catch-up on weak areas.

3:00–4:00 PM Revision + interview prep (notes,

mock questions).
 Day 1 Goal
Arrays and Strings

Goal Master arrays and strings for data manipulation

Time 6 hours

Tasks 1. Theory (2 hours):

a) Udemy (1 hour):
Watch arrays/strings sections.
Topics:
Array declaration (`int arr[10];`), initialization, multi-
dimensional arrays, `std::string`, C-style strings (`char[]`),
string operations (concatenation, `length()`, `substr()`).

b) Book (1 hour):
Gaddis Chapter 7 (Arrays), Chapter 3 (Strings).
Focus:
Array indexing, string manipulation, memory layout.

2. **Practice (3 hours):
a) Write programs:
b) Reverse an array (`[1,2,3]` → `[3,2,1]`).
c) Sum array elements.
d) Count vowels in a string using `std::string`.
e) Solve 4–5 problems:
f) LeetCode: “Two Sum” (Easy), “Reverse String” (Easy).
g) HackerRank: “Arrays – Left Rotation” (Easy).
h) GeeksforGeeks: “Find maximum element”.
3. Revision + Interview Prep (1 hour):
a) Summarize: Array bounds, `std::string` vs. `char[]`, O(n)
time complexity.
b) Prepare answers: “How are arrays stored in memory?”
“How to reverse a string?”
c) Debug code (e.g., check out-of-bounds errors).
d) **Interview Topics**: Array initialization, string
operations, buffer overflow.
e) **Output**: 3 programs, 4–5 problems solved, notes on
arrays/strings.
 Day 2 Goal
Functions and Pointers

Goal Understand functions for modularity and pointers for memory

management.

Time 6 hours

Tasks 1. Theory (2 hours):

a) Udemy (1 hour):
Watch functions/pointers sections.
Topics:
Function declaration/-definition, pass by
value/reference, return types, pointers (`int* ptr;`, `*ptr`, `&x`),
pointer arithmetic, pointers with arrays.

b) Book (1 hour):
Gaddis Chapter 6 (Functions), Chapter 9 (Pointers).
Focus:
Call stack, pointer-to-array, null pointers.

2. **Practice (3 hours):
a) Write programs:
b) Swap two numbers using pointers.
c) Factorial function (iterative/recursive).
d) Sum array elements using pointers.
e) Solve 4–5 problems:
f) LeetCode: “Valid Parentheses” (Easy).
g) HackerRank: “Functions” (Easy).
h) GeeksforGeeks: “Swap numbers”.
3. Revision + Interview Prep (1 hour):
a) Summarize: Pass by reference vs. value, dangling
pointers.
b) Prepare answers: “What’s a function?” “Why use
pointers with arrays?”
c) Explain code aloud (mimic interview).
d) Interview Topics: Function overloading, pointer vs.
reference, memory allocation.
e) Output: 3 programs, 4–5 problems solved, notes on
functions/pointers
 Day 3 Goal
OOP – Classes and Constructors

Goal Learn classes, objects, and constructors for OOP basics

Time 6 hours

Tasks 1. Theory (2 hours):

a) Udemy (1 hour):
Watch OOP sections (classes/constructors).
Topics:
Class syntax, objects, attributes, methods,
default/parameterized constructors, `this` pointer.
b) Book (1 hour):
Gaddis Chapter 13 (Introduction to Classes).
Focus:
Class declaration, object instantiation, constructor.

2. **Practice (3 hours):
a) Write programs:
b) `Rectangle` class with `length`, `width`, `area()` method.
c) `Student` class with constructor for name/roll number.
d) Store 5 students in an array of objects.
e) Solve 3–4 problems:
f) GeeksforGeeks: “Classes and Objects” (e.g., “Circle
class”).
g) Write a program to calculate area using a class.

3. Revision + Interview Prep (1 hour):

a) Summarize: Class vs. object, constructor types, `this`
pointer.
b) Prepare answers: “What’s a class?” “Why use
 constructors?”
c) Test code: (e.g., negative values for `Rectangle`).
d) Explain code aloud (mimic interview).
e) Interview Topics: Class vs. struct, constructor vs.
function, object initialization.
f) Output: 2–3 programs, 3–4 problems solved, notes on
classes/constructors.

Day 4 Goal
OOP – Encapsulation, Inheritance, Polymorphism
Goal Master encapsulation, inheritance, and basic polymorphism.

Time 6 hours

Tasks 1. Theory (2 hours):

a) Udemy (1 hour):
Watch encapsulation/inheritance/polymorphism
sections.
Topics:
Public/private access, getters/setters, single
inheritance, function overloading.
b) Book (1 hour):
Gaddis Chapter 14 (More About Classes), Chapter 15
(Inheritance, Polymorphism).
Focus:
Access specifiers, base/derived classes, function
overloading.
2. **Practice (3 hours):
a. Write programs:
b. `Vehicle` base class, `Car` derived class with
inherited methods.
c. `BankAccount` class with private balance,
getter/setter.
d. Overload `area()` for circle and rectangle.
e. Solve 3–4 problems:
f. GeeksforGeeks: “Inheritance” or “Polymorphism”
(e.g., “Single inheritance”).
g. Write a program for function overloading.
3. Revision + Interview Prep (1 hour):
a) Summarize: Encapsulation benefits, inheritance types,
overloading rules.
b) Prepare answers: “What’s encapsulation?” “Explain
inheritance.”
c) Review inheritance hierarchy.
d) Explain code aloud (mimic interview).
e) Interview Topics: Private vs. protected, inheritance use
cases, overloading vs. overriding.
f) Output: 3 programs, 3–4 problems solved, notes on
encapsulation/inheritance.
 Day 5 Goal
File Handling

Goal Learn file handling for input/output operations.

Time 6 hours

Tasks 1. Theory (2 hours):

a) Udemy (1 hour):
Watch file handling section.
Topics:
`fstream`, `ifstream`, `ofstream`, file modes (`ios::in`,
`ios::out`), reading/writing files.
b) Book (1 hour):
Gaddis Chapter 12 (File Input and Output).
Focus:
Opening/closing files, reading line-by-line, error
handling.
2. **Practice (3 hours):
a. Write programs:
b. Write student names to a text file, read them back.
c. Count words in a file.
d. Save `Student` class data to a file.
e. Solve 2–3 problems:
f. GeeksforGeeks: “File Handling” (e.g., “Read file
content”).
g. HackerRank: File-related problems (if available).
3. Revision + Interview Prep (1 hour):
a) Summarize: File modes, error checking (`fail()`), text
vs. binary files.
b) Prepare answers: “How to read a file?” “What’s
`fstream`?”
c) Test file programs: (e.g., empty file, invalid path).
d) Interview Topics: File stream classes, error handling,
sequential vs. random access.
e) Output: 2–3 programs, 2–3 problems solved, notes on
file handling.
 Day 6 Goal
Basic STL

Goal Learn file handling for input/output operations.

Time 6 hours

Tasks 1. Theory (2 hours):

a) Udemy (1 hour):
Watch STL section.
Topics:
Learn `vector`, `string`, `map`, and basic
algorithms.
b) Book (1 hour):
Gaddis Chapter 16 (Standard Template Library).
Focus:
`vector` vs. array, `map` operations, iterator basics.
2. **Practice (3 hours):
a. Write programs:
b. Use `vector` to store/sort numbers.
c. Use `map` to count word frequencies.
d. Store `Student` objects in a `vector`.
e. Solve 3–4 problems:
f. LeetCode: “Contains Duplicate” (Easy), “Valid
Anagram” (Easy).
g. HackerRank: “Vector-Sort” (Easy).
3. Revision + Interview Prep (1 hour):
Summarize: `vector` vs. array, `map` use cases, `sort`
complexity (O(n log n)).
Prepare answers: “What’s the STL?” “Why use `vector`?”
Optimize STL code: (e.g., use `auto` for iterators).
Interview Topics: STL containers, `sort` complexity, iterator
advantages.
Output: 3 programs, 3–4 problems solved, notes on STL.
 Day 7 Goal
Project, Mock Interviews, Final Prep

Goal Build a project, practice interviews, consolidate knowledge.

Time 6 hours

Tasks 1. Project (2.5 hours):

Build a Library Management System:
a. OOP: `Book` class (title, ID; `display()` method).
b. STL: Store books in `vector` or `map` (ID →
Book).
c. Functions: `addBook()`, `searchBook()`,
`deleteBook()`.
d. File Handling: Save/load book data to/from file.
e. Pointers: Use pointers for dynamic memory
(e.g.,`Book* ptr`).
f. Push to GitHub with README (describe
functionality, code).
2. Mocks Interviews (2 hours):
a. Solve 4–5 problems (arrays, functions, OOP, STL,
file handling):
b. LeetCode: “Reverse Array,” “Contains Duplicate,”
“Valid Parentheses.”
c. HackerRank: “Classes,” “Vector-Sort.”
d. Explain code aloud (30 minutes/problem).
e. Use Pramp or a friend for mock interview.
3. Revision + Interview Prep (1 hour):
a. Review notes on all topics.
b. Prepare behavioral answers:
c. “Describe a project.” (Library system.)
d. “Why this internship?” (“I’m eager to apply C++ to
real-world problems.”)
e. “What’s a challenge?” (“Debugged a pointer error
by tracing memory.”)
f. Update resume with project, skills (C++: arrays,
functions, pointers, OOP, file handling, STL).
g. Interview Topics: Project logic, debugging, time
complexity, C++ syntax.
h. Output: Project on GitHub, 4–5 problems solved,
updated resume, 3–4 behavioral answers.
 Daily Schedule
Time Day Date Topics Check box

9:00Am – Day 1 26-05-2025 Arrays and

Strings
4:00 Pm

9:00Am – Day 2 27-05-2025 Functions and

Pointers
4:00 Pm

9:00Am – Day 3 28-05-2025 OOP – Classes

and Constructors
4:00 Pm

9:00Am – Day 4 29-05-2025 OOP –

Encapsulation,
4:00 Pm
Inheritance,
Polymorphism

9:00Am – Day 5 20-05-2025 File Handling

4:00 Pm
9:00Am – Day 6 31-05-2025 Basic STL
4:00 Pm

9:00Am – Day 7 01-06-2025 Project, Mock

Interviews, Final
4:00 Pm
Prep

## Interview Preparation
- **Technical Questions**:
- Arrays: “Find duplicates in an array?”
- Functions: “Pass by reference vs. value?”
- Pointers: “What’s a null pointer?”
- OOP: “What’s encapsulation?” “Explain inheritance.”
- File Handling: “Read a file line by line?”
- STL: “`vector` vs. `array`?” “How does `map` work?”
- **Behavioral Questions**:
- “Describe a project.” (Use library system.)
- “Why this internship?” (“Apply C++ skills to software development.”)
- “What’s a challenge?” (“Debugged file handling error.”)
- Use STAR method (Situation, Task, Action, Result).
- **Coding Tips**:
- Explain thought process.
- Test edge cases (e.g., empty array, invalid file).
- Be honest: “I’m learning advanced STL but proficient with `vector`.”

## Expected Outcomes
- **Skills**: Proficiency in arrays, strings, functions, pointers, OOP
(classes, constructors, encapsulation, inheritance, polymorphism), file
handling, STL (`vector`, `string`, `map`, `sort`, `find`).
- **Practice**: 20–25 problems solved, 15–20 programs written.
- **Project**: Library management system showcasing all concepts.
- **Interview Readiness**: Ready for basic-to-intermediate C++
questions and easy coding problems.

## Tips for Success

- Follow the schedule strictly (6 hours/day).
- Debug code with edge cases (e.g., empty files, null pointers).
- Explain code aloud to mimic interviews.
- Push all programs/project to GitHub.
- Apply to multiple internships (LinkedIn, Indeed) for practice.