C & C++ Foundation + Advanced (Combined Programme)
C/C++ fundamentals and OOP, then memory management, data structures, algorithms, STL/templates, debugging and a project.
What you will cover
C/C++ fundamentals
OOP
then memory management
data structures
algorithms
STL/templates
debugging
a project
Topic list from the institute's programme record.
Certification
Certificate terms for this programme are confirmed by the institute at admission. Any ADIVAS course-completion certificate is an institute certificate; it is not a university degree, an externally accredited qualification or a vendor certification (such as AWS or Microsoft) unless the institute states so in writing.
Curriculum 0.1 · Draft: written for ADIVAS and awaiting academic review and approval. Topics and weeks may change before your batch starts.
Your skill trail
You move through 8 stations. Each week builds one skill you can show, not just a topic you have heard.
1
Logic and first programs
Turn problems into algorithms and write simple C programs.
Week 1 Think like a programmer
Week 2 C basics: data, input and output
2
Control flow
Use decisions and loops confidently with trace tables and test cases.
Week 3 Making decisions
Week 4 Loops and tracing
3
Functions, arrays and pointers
Structure programs with functions and arrays and understand pointers.
Week 5 Functions
Week 6 Arrays and strings
Week 7 Pointers
4
Records, files, C++ objects and foundation project
Store data in structs and files, model it with a C++ class and deliver the foundation mini-project.
Week 8 Structures and file basics
Week 9 From C to C++: classes and objects
Week 10 Debugging and mini-project demo
5
Memory and pointers in depth
Understand memory layout and manage heap memory safely.
Week 11 Pointers and the memory model
Week 12 Dynamic memory and memory safety
6
Data structures and algorithms
Implement core data structures and analyse algorithms.
Week 13 Linked lists
Week 14 Stacks, queues and trees
Week 15 Searching, sorting and complexity
7
Modern C++
Use the STL, templates, smart pointers and RAII.
Week 16 Modern C++: STL and templates
Week 17 Smart pointers and RAII
8
Debugging and capstone project
Debug crashes systematically and present the advanced project.
Week 18 Debugging, profiling and project demo
★
Student Marks Manager (C with a C++ class version)
Your project, reviewed by a trainer.
The ADIVAS mastery ladder: how each skill is recognised
Explored You have seen the idea and tried a first example.
Practising You can do it with hints and keep improving.
Proficient You complete the weekly practical task correctly on your own.
Proven You apply it in a project reviewed by your trainer.
Skill-level tracking is being added to the learner workspace. Your trainer already reviews weekly practical work.
What you will be able to do
Express a solution as an algorithm or flowchart and trace it by hand.
Write C programs using variables, input/output, decisions, loops, functions and arrays.
Use pointers, structs and files correctly and build a simple C++ class.
Debug with compiler warnings, tracing and test tables and deliver a mini-project.
Allocate and release dynamic memory safely and find memory errors with sanitizers.
Implement linked lists, stacks, queues and trees and compare algorithms using Big-O reasoning.
Use STL containers, templates, smart pointers and RAII in modern C++.
Debug crashes with gdb and sanitizers and deliver a tested data-structure project.
Who it suits
School Strong Class 11-12 students who want one continuous path from first program to data structures.
College College students who want a complete C/C++ programme for course work and technical interviews.
Professional Career changers and working professionals building C/C++ skills from the start.
Prerequisites: Comfortable use of a computer and basic school mathematics. No prior programming needed. Tools: GCC or Clang compiler (MinGW-w64 on Windows), Visual Studio Code or Code::Blocks, GDB debugger, Valgrind or AddressSanitizer (Linux, or WSL on Windows), Git, A C++17 or later compiler.
Weekly plan
Logic and first programs Weeks 1–2
Week 1: Think like a programmer
Theory
Problems, algorithms and flowcharts
Sequence, decision and repetition
Installing GCC and VS Code; compile and run
Lab
Install a C compiler and editor, compile and run Hello World, then draw a flowchart and numbered steps for finding the largest of three marks.
Homework
Write an algorithm for withdrawing cash from an ATM and trace it with two example inputs.
Deliverable
A flowchart and a compiling Hello program saved in a Week-1 folder.
Weekly checkpoint
Order the steps of an algorithm; trace a small flowchart.
You will be able to
Express a solution as an algorithm or flowchart and trace it by hand.
Week 2: C basics: data, input and output
Theory
Variables and the types int, float, char
printf and scanf format specifiers
Arithmetic operators and integer division
Lab
Write a program that reads quantity and unit price in ₹ and prints the bill with 18% GST, then explain why 7/2 gives 3.
Homework
Write a temperature converter and a simple-interest calculator.
Deliverable
bill.c with sample runs pasted as comments.
Weekly checkpoint
Predict outputs of five short snippets involving int and float.
You will be able to
Write C programs using variables, input/output, decisions, loops, functions and arrays.
Control flow Weeks 3–4
Week 3: Making decisions
Theory
if, else-if ladders and nested conditions
Relational and logical operators; = versus ==
switch and menu-driven programs
Lab
Build a grade calculator and a leap-year checker. Before coding, write a table of test inputs including boundary values.
Homework
Write a menu program (1 Add, 2 Subtract, 3 Multiply, 4 Divide) that refuses division by zero.
Deliverable
Two programs plus a written test table.
Weekly checkpoint
Debug an if statement that uses = by mistake; choose good test inputs.
You will be able to
Write C programs using variables, input/output, decisions, loops, functions and arrays.
Week 4: Loops and tracing
Theory
for, while and do-while
break and continue
Nested loops and patterns
Trace tables
Lab
Print a multiplication table, the sum of digits of a number and a triangle pattern; trace each loop on paper first.
Homework
Write a program that reads marks until the user enters -1 and prints the average.
Deliverable
A trace table and three loop programs.
Weekly checkpoint
Predict loop output and find one off-by-one bug.
You will be able to
Write C programs using variables, input/output, decisions, loops, functions and arrays.
Functions, arrays and pointers Weeks 5–7
Week 5: Functions
Theory
Declaration, definition and calling
Parameters, return values and scope
Pass by value
Recursion: factorial and Fibonacci
Lab
Refactor the bill program into functions (readInput, calcGst, printBill) and test each function with five inputs.
Homework
Write isPrime(n) and use it to list primes up to 100.
Deliverable
A modular program with one test table per function.
Weekly checkpoint
Predict output when a function changes its parameter; identify scope errors.
You will be able to
Write C programs using variables, input/output, decisions, loops, functions and arrays.
Week 6: Arrays and strings
Theory
One- and two-dimensional arrays
Array bounds and common errors
Strings and the null terminator; string.h
Linear search and bubble sort
Lab
Read marks of 10 students, then print the average, highest, lowest and search for a given mark; reverse a string without using strrev.
Homework
Sort 8 numbers with bubble sort and show the array after each pass.
Deliverable
marks.c and a pass-by-pass sorting table.
Weekly checkpoint
Find an out-of-bounds bug; trace a bubble sort pass.
You will be able to
Write C programs using variables, input/output, decisions, loops, functions and arrays.
Week 7: Pointers
Theory
Addresses and the & and * operators
Pointers and arrays
Passing pointers to functions (swap)
NULL and common pointer bugs
Lab
Write swap(), a function that doubles a value through a pointer and a loop that walks an array with a pointer; draw a memory picture.
Homework
Explain in your own words the difference between p and *p with two diagrams.
Deliverable
pointers.c and a hand-drawn memory diagram.
Weekly checkpoint
Match pointer expressions to meanings; predict output of a pointer snippet.
You will be able to
Use pointers, structs and files correctly and build a simple C++ class.
Records, files, C++ objects and foundation project Weeks 8–10
Week 8: Structures and file basics
Theory
struct and arrays of struct
Opening, reading, writing and closing text files
Checking fopen for NULL
Designing a record format
Lab
Create a Student struct, save five records to students.txt and load them back; test what happens when the file is missing.
Homework
Add search by roll number and plan the mini-project menu.
Deliverable
Working save/load code and the mini-project plan.
Weekly checkpoint
Find the missing NULL check; order the steps to save records.
You will be able to
Use pointers, structs and files correctly and build a simple C++ class.
Week 9: From C to C++: classes and objects
Theory
cin/cout, references and the C++ string and vector
Classes, objects and constructors
private/public and encapsulation
Introduction to inheritance
Lab
Convert the Student struct into a class with a validating constructor and a display() method; store students in a std::vector.
Homework
Add a Teacher class that shares a Person base class and explain what is reused.
Deliverable
student.cpp with a short design note.
Weekly checkpoint
Scenario questions on encapsulation; read a small class and predict its output.
You will be able to
Use pointers, structs and files correctly and build a simple C++ class.
Week 10: Debugging and mini-project demo
Theory
Reading compiler errors and warnings (-Wall)
Debugging with print statements and gdb basics
Writing test tables
Presenting and reviewing code
Lab
Fix five seeded bugs (missing return, off-by-one, uninitialised variable, wrong operator, missing NULL check) and then demo your Student Marks Manager.
Homework
Write a short reflection on the three bugs that cost you the most time.
Deliverable
Final mini-project with test table and reflection.
Weekly checkpoint
Debugging scenario questions and a live demo with questions from the trainer.
You will be able to
Debug with compiler warnings, tracing and test tables and deliver a mini-project.
Memory and pointers in depth Weeks 11–12
Week 11: Pointers and the memory model
Theory
Stack, heap and static memory
Pointer arithmetic and pointers to pointers
const with pointers; function pointers
Reading memory diagrams
Lab
Print addresses and sizeof of variables, arrays and struct members, then draw the memory layout of a small program and verify it with a debugger or printed addresses.
Homework
Write a function pointer table for add, subtract and multiply and call it in a loop.
Deliverable
Memory diagram with printed address evidence.
Weekly checkpoint
Predict output of pointer arithmetic on an int array; match memory regions to examples.
You will be able to
Allocate and release dynamic memory safely and find memory errors with sanitizers.
Week 12: Dynamic memory and memory safety
Theory
malloc, calloc, realloc and free
Leaks, dangling pointers and double free
new and delete in C++
AddressSanitizer and Valgrind
Lab
Build a growable integer array, then deliberately introduce a leak, a use-after-free and an overflow and find each with AddressSanitizer or Valgrind.
Homework
Write a checklist of ten memory-safety rules from your lab findings.
Deliverable
dynarray.c plus sanitizer reports for each seeded bug.
Weekly checkpoint
Spot memory errors in code snippets; choose the correct fix.
You will be able to
Allocate and release dynamic memory safely and find memory errors with sanitizers.
Data structures and algorithms Weeks 13–15
Week 13: Linked lists
Theory
Nodes, head pointer and traversal
Insert at head, tail and middle
Deleting and reversing a list
Testing empty, one-node and many-node cases
Lab
Implement a singly linked contact list with add, find, delete and reverse; write tests for the three list sizes.
Homework
Implement a doubly linked list insert and compare it with the singly linked version.
Deliverable
contacts list with a test log.
Weekly checkpoint
Order pointer updates for insert; trace a delete on paper.
You will be able to
Implement linked lists, stacks, queues and trees and compare algorithms using Big-O reasoning.
Week 14: Stacks, queues and trees
Theory
Stack and queue with arrays and with lists
Bracket matching with a stack
Binary search tree: insert, search and in-order traversal
Recursion on trees
Lab
Implement a stack to check balanced brackets in expressions and build a BST of roll numbers with in-order printing.
Homework
Draw the BST created by inserting 50, 30, 70, 20, 40 and show its in-order output.
Deliverable
bracket checker and BST program.
Weekly checkpoint
Trace BST insertion; choose between stack and queue for a scenario.
You will be able to
Implement linked lists, stacks, queues and trees and compare algorithms using Big-O reasoning.
Week 15: Searching, sorting and complexity
Theory
Big-O: O(1), O(log n), O(n), O(n^2)
Binary search and its precondition
Insertion sort, merge sort and quicksort ideas
Measuring running time
Lab
Time linear and binary search and two sorting algorithms on 10,000 and 100,000 random numbers and record the results in a table.
Homework
Explain why binary search fails on unsorted data using an example.
Deliverable
Timing table with a one-paragraph conclusion.
Weekly checkpoint
Match algorithms to complexities; predict which is faster for large n.
You will be able to
Implement linked lists, stacks, queues and trees and compare algorithms using Big-O reasoning.
Modern C++ Weeks 16–17
Week 16: Modern C++: STL and templates
Theory
vector, map, unordered_map and set
STL algorithms and lambdas
Function and class templates
Choosing the right container
Lab
Rewrite a word-frequency counter with std::unordered_map and sort the result with std::sort and a lambda; create a template class Stack<T>.
Homework
Compare the vector, list and deque for inserting at the front and explain the results.
Deliverable
wordfreq.cpp and a templated Stack<T>.
Weekly checkpoint
Read a template function and predict output; select a container for a scenario.
You will be able to
Use STL containers, templates, smart pointers and RAII in modern C++.
Week 17: Smart pointers and RAII
Theory
unique_ptr, shared_ptr and weak_ptr
RAII and the rule of zero
Move semantics basics
Exceptions and resource safety
Lab
Refactor the raw-pointer contact list to use unique_ptr nodes and write a small RAII class that closes a file in its destructor.
Homework
List three bugs that smart pointers prevent and one situation where shared_ptr is a poor choice.
Deliverable
Refactored list with a clean sanitizer run.
Weekly checkpoint
Explain why a unique_ptr copy fails; choose ownership types for scenarios.
You will be able to
Use STL containers, templates, smart pointers and RAII in modern C++.
Debugging and capstone project Weeks 18
Week 18: Debugging, profiling and project demo
Theory
gdb: breakpoints, backtrace and watch
Sanitizers and core dumps
Regression tests and assert
Code review checklist
Lab
Debug a crashing program with gdb and AddressSanitizer, write a regression test, then demo your contact directory project with timings.
Homework
Write a review of a classmate's code using the checklist.
Deliverable
Debug report, final project and review notes.
Weekly checkpoint
Debugging scenario questions and a project viva.
You will be able to
Debug crashes with gdb and sanitizers and deliver a tested data-structure project.
Sample lessons
Week 4
Loops and trace tables
A loop repeats a block of code while a condition is true. Before running a loop on the computer, you can run it on paper with a trace table: one row per repetition, one column per variable. Tracing is the fastest way to understand a loop and to find off-by-one mistakes, such as running one time too many or too few.
1Check the condition
2Run the loop body
3Update the variable
4Repeat or exit
↻
Step by step
Write the loop and list its variables: start value, condition, update.
Draw a table with a column for each variable and for the output.
Fill one row per repetition, updating the variables exactly as the code does.
Stop when the condition becomes false and note the final values.
Run the program and compare its output with your table.
In real life
A shop assistant adds the prices of 5 items on a bill one by one. A loop does the same: it repeats "add next price" until all 5 items are done.
Worked example
Problem. Trace: int sum = 0; for (int i = 1; i <= 4; i++) { sum = sum + i; } What is sum at the end?
Solution. i=1: sum=1; i=2: sum=3; i=3: sum=6; i=4: sum=10; then i=5 fails the condition i <= 4. Final sum is 10.
Common mistakes
Using <= when < is needed (or the reverse), giving one repetition too many or too few.
Forgetting to update the loop variable, which creates an infinite loop.
Changing the loop variable inside the body without meaning to.
Try it yourself
Trace for (int i = 10; i > 0; i -= 3) and list the values of i.
Write a loop that prints the table of 7 up to 10 times, then trace the first three rows.
Find the bug: for (int i = 1; i <= 5; i--) { printf("%d", i); }
Week 7
Pointers: addresses and values
Every variable lives at an address in memory. A pointer is a variable that stores such an address. The & operator gives the address of a variable and the * operator reads or writes the value at an address. Pointers let a function change the caller's variables and are the basis of arrays, strings and dynamic data structures in C.
Variable x holds 5
Address of x, for example 0x7ffe10
Pointer p holds that address
*p reads or writes x
Step by step
Declare int x = 5; and print x and &x.
Declare int *p = &x; and print p and *p.
Change the value with *p = 9; and print x again.
Write void swap(int *a, int *b) and call it as swap(&m, &n).
Draw boxes for x and p with an arrow from p to x.
In real life
A courier needs a delivery address, not the house itself. A pointer is that address; following it (dereferencing) reaches the real house.
Worked example
Problem. int a = 4, b = 9; swap(&a, &b); What are a and b if swap exchanges the values through pointers?
Solution. swap receives the addresses of a and b and exchanges the values stored there, so a becomes 9 and b becomes 4.
Common mistakes
Using a pointer before it points to valid memory (uninitialised pointer).
Confusing p (the address) with *p (the value at the address).
Passing x instead of &x to a function that expects a pointer.
Try it yourself
Predict the output: int x = 3; int *p = &x; *p = *p + 2; printf("%d", x);
Write a function that doubles a number in place using a pointer.
Draw the memory picture for int arr[3] and a pointer to arr[1].
Week 12
Dynamic memory and leak-free code
Local variables disappear when a function ends, but sometimes the size of data is known only at run time, such as the number of students typed by the user. malloc asks the system for a block on the heap and returns its address. You must release it with free exactly once. Forgetting free leaks memory; using it after free or freeing twice causes undefined behaviour. Tools such as AddressSanitizer and Valgrind find these errors.
1malloc requests a block
2Check for NULL
3Use the block
4free returns it
5Set pointer to NULL
Step by step
Read n from the user and allocate int *marks = malloc(n * sizeof(int)).
Check that marks is not NULL before using it.
Fill and print the values using marks[i].
Call free(marks) and set marks = NULL.
Compile with -fsanitize=address -g and run to confirm there are no errors or leaks.
In real life
Renting a hall for a function: you book the size you need, use it and must hand it back. If nobody returns the keys, the hall stays blocked for everyone.
Worked example
Problem. You allocate int *a = malloc(10 * sizeof(int)); then write a[10] = 1;. What is wrong?
Solution. The valid indexes are 0 to 9, so a[10] writes outside the block (heap buffer overflow). Fix the index or allocate 11 ints; AddressSanitizer reports this exactly.
Common mistakes
Not checking malloc for NULL.
Calling free twice on the same pointer.
Losing the only pointer to a block before freeing it, which leaks it.
Try it yourself
Write a program that allocates an array for n marks, finds the average and frees the memory.
Use realloc to grow the array when the user adds more marks and explain what happens if realloc fails.
Intentionally leak memory, then find it with Valgrind or LeakSanitizer.
Week 13
Linked lists step by step
A linked list stores items in separate nodes. Each node holds data and a pointer to the next node, and a head pointer remembers the first node. Unlike an array, inserting at the front does not move other items, but reaching the n-th item means following n links. Most list bugs come from changing pointers in the wrong order or forgetting the empty-list case.
1head
23 | next
35 | next
48 | next
5NULL
Step by step
Define struct Node { int data; struct Node *next; };
Write insertAtHead: allocate a node, set node->next = head, then head = node.
Write printList that walks from head until the pointer is NULL.
Write deleteValue that finds the node, links its previous node to the next one and frees it.
Test with an empty list, one node and several nodes.
In real life
A treasure hunt where each clue tells where the next clue is hidden: you can only reach clue 4 by following clues 1, 2 and 3.
Worked example
Problem. The list is 3 -> 5 -> NULL. After insertAtHead(1), what is the list?
Solution. The new node points to the old head (3) and becomes the head: 1 -> 3 -> 5 -> NULL.
Common mistakes
Setting head = new node before linking new->next, losing the old list.
Dereferencing NULL when the list is empty.
Freeing a node before reading its next pointer.
Try it yourself
Write a function that counts nodes.
Write reverseList that reverses the list in place and draw the pointers after each step.
List three test cases for deleteValue.
Try the questions
The same skills are asked at three levels: School (Classes 6–12), College and Professional. Switch the level and the language (English or Tamil), and say how sure you are before you check: knowing what you are unsure about is part of learning.
Classes 6–12: everyday examples, no prior knowledge. Practice only. Nothing here is graded or saved.
Question 1 / 8 · Order the steps of an algorithm
Put the steps of making tea in a sensible order. A clear list of steps like this is called an algorithm.
1Understand the problem
2Write the steps (algorithm)
3Write the code
4Test and fix
Add tea powder and milk
Serve hot
Boil the water
Strain the tea into a cup
Add sugar
Projects
Student Marks Manager (C with a C++ class version)
A tuition centre in Madurai records marks for 5 subjects per student on paper. Build a console program in C that stores student records, calculates totals and averages, assigns grades, saves everything to a text file and loads it again. Then rewrite the Student record as a C++ class.
Tasks
Define a struct Student with roll number, name and five marks, and keep an array of students.
Write functions for add, list, search by roll number, total/average and grade.
Save all records to students.txt and load them when the program starts, handling a missing file.
Write a test table with at least 8 inputs, including boundary marks such as 0, 34, 35 and 100.
Rewrite Student as a C++ class with private data, a constructor with validation and a display() method.
Sample input
Roll 101, Name Anu, Marks 78 82 91 67 74
Expected output
Anu: total 392, average 78.4, grade B. The record is present again after restarting the program.
How it is assessed
Criterion
Weight
Correct calculations and grades
25%
Functions, structs and arrays used cleanly
20%
File save/load with error handling
20%
Test table and debugging evidence
20%
C++ class conversion and readability
15%
Stretch challenge: Add sorting by average and a menu option that lists the top three students.
Contact Directory with Linked List, BST and STL Comparison
Build a contact directory for a small business that holds 20,000 contacts. Implement the storage three ways, measure them and recommend one with evidence: a linked list in C-style code, a binary search tree, and std::unordered_map with smart pointers.
Tasks
Implement insert, search by phone number and delete for the linked list and for the BST.
Implement the same operations with std::unordered_map and std::unique_ptr<Contact>.
Generate 20,000 test contacts and time 1,000 searches for each version with std::chrono.
Run every version under AddressSanitizer and Valgrind (or LeakSanitizer) and fix all reported errors.
Write a one-page report with a results table and a justified recommendation.
Sample input
20,000 generated contacts; 1,000 random phone-number searches
Expected output
A table of timings (milliseconds) for list, BST and hash map, a clean sanitizer log and a recommendation such as "use unordered_map for lookups".
How it is assessed
Criterion
Weight
Correct data-structure implementations
25%
Memory safety (clean sanitizer and leak reports)
25%
Measurement method and results table
20%
Modern C++ usage (STL, smart pointers, RAII)
15%
Report clarity and recommendation
15%
Stretch challenge: Add persistence to a file and a unit test suite for the delete operation covering first, middle, last and missing items.
How you are assessed
Each week: five short questions (concept, code reading, debugging), a graded lab with a test table and, from week 11, a sanitizer-clean run, plus a two-line reflection on what failed first.
Practical work. Two practical assessments: the foundation mini-project at week 10 (test table, explanation, seeded bug) and the advanced project at week 18 (clean sanitizer output, timings, viva).
What trainers look for
Weight
Correct output and test evidence
30%
Memory safety and debugging
25%
Code structure and data-structure choice
20%
Modern C++ usage
10%
Explanation and documentation
15%
Where this can lead
Prepares you for junior programming practice and for further study in systems, embedded and data-structure topics.
Builds the debugging and memory-safety habits used in professional C/C++ work.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
