C and C++ programming, OOP, pointers, files, data structures, Git, debugging, testing and practical software mini-projects.
What you will cover
C
C++ programming
OOP
pointers
files
data structures
Git
debugging
testing
practical software mini-projects
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.
The programme title is as supplied in the institute's list. Please confirm the awarding body and recognition with the institute before enrolling.
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 6 stations. Each week builds one skill you can show, not just a topic you have heard.
1
C programming basics
Write structured C programs with functions, arrays and strings.
Week 1 First C program and the build process
Week 2 Decisions and loops
Week 3 Functions, scope and recursion
Week 4 Arrays and strings
2
Pointers, memory and files
Understand memory and handle structures, dynamic allocation and files.
Week 5 Pointers: addresses and indirection
Week 6 Pointer arithmetic and arrays
Week 7 Structures and dynamic memory
Week 8 File handling
Week 9 Debugging tools and Makefiles
3
Object-oriented C++
Design classes and use the C++ standard library safely.
Week 10 From C to C++
Week 11 Classes and encapsulation
Week 12 Inheritance and polymorphism
Week 13 Operator overloading and templates
Week 14 RAII, smart pointers and the STL
4
Data structures and algorithms
Implement core structures and reason about their cost.
Week 15 Complexity and searching
Week 16 Sorting
Week 17 Linked lists, stacks and queues
Week 18 Trees
Week 19 Hash tables and graphs
5
Engineering practice
Use Git, tests and code review to produce reliable software.
Week 20 Git for software teams
Week 21 Testing software
Week 22 Code review and AI-assisted learning
6
Mini-project
Plan, build and present a small software product.
Week 23 Mini-project build
Week 24 Project demonstration
★
Library Book Manager in C++
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
Write C programs using types, control flow, functions, arrays and strings.
Use pointers, structures and dynamic memory correctly, avoiding leaks and invalid access.
Read and write text and binary files safely.
Apply C++ OOP: classes, inheritance, polymorphism, templates and the standard library.
Implement and compare arrays, linked lists, stacks, queues, trees, hash tables and basic sorting and searching.
Debug with a debugger and sanitizers, and write tests that cover normal, edge and failure cases.
Use Git for version control and complete a documented software mini-project.
Who it suits
School Class 11-12 students who want to understand how programs and computer memory really work.
College Engineering and science students who want solid C and C++ foundations for placements-style problem solving and later subjects.
Professional Working adults and career changers who need systems-level programming fundamentals and good engineering habits.
Prerequisites: Basic computer skills and school-level mathematics. No programming experience required. Tools: GCC or Clang compiler, Visual Studio Code or CLion Community, GDB or LLDB debugger, AddressSanitizer and Valgrind where available, Make, A lightweight C++ test framework such as doctest or Catch2, Git and GitHub.
Weekly plan
C programming basics Weeks 1–4
Week 1: First C program and the build process
Theory
Source, compiler, linker and executable
int, float, char, printf and scanf
Compiler warnings and why -Wall matters
Lab
Install GCC, compile hello.c from the command line and write a program that reads two numbers and prints sum, difference and product.
Homework
Write a program to convert rupees to paise and a temperature converter; read compiler warnings for each.
Deliverable
Three C files compiled with -Wall -Wextra and zero warnings.
Weekly checkpoint
Name the stages from source to executable; predict the output of printf with format specifiers.
You will be able to
Write C programs using types, control flow, functions, arrays and strings.
Week 2: Decisions and loops
Theory
if/else, switch and logical operators
for, while and do-while
Tracing and dry runs
Lab
Write a menu-driven calculator and programs for factorial, Fibonacci and digit sum.
Homework
Print the pyramid patterns of stars for n rows and explain the loop bounds.
Deliverable
A set of five loop programs with trace tables for two.
Weekly checkpoint
Dry-run nested loops; find a condition off-by-one error.
You will be able to
Write C programs using types, control flow, functions, arrays and strings.
Week 3: Functions, scope and recursion
Theory
Function prototypes, parameters and return values
Local, global and static variables
Recursion and the call stack
Lab
Split a program into functions: is_prime, gcd, power by recursion and a stack trace drawing for factorial(4).
Homework
Write recursive and iterative versions of Fibonacci and compare behaviour for n = 40.
Deliverable
A multi-function program with a call-stack diagram.
Weekly checkpoint
Trace a recursive function; explain why a missing base case crashes.
You will be able to
Write C programs using types, control flow, functions, arrays and strings.
Week 4: Arrays and strings
Theory
One- and two-dimensional arrays
Null-terminated strings and string.h
Bounds and buffer overflow
Lab
Implement linear search, array reversal, matrix addition and a safe word counter using fgets.
Homework
Rewrite a program that uses gets-style input to use a bounded read.
Deliverable
An arrays and strings toolkit with tests in main().
Weekly checkpoint
Find the out-of-bounds write in a listing.
You will be able to
Write C programs using types, control flow, functions, arrays and strings. Debug with a debugger and sanitizers, and write tests that cover normal, edge and failure cases.
Pointers, memory and files Weeks 5–9
Week 5: Pointers: addresses and indirection
Theory
Address-of and dereference
Pointers and function parameters (pass by pointer)
NULL and dangling pointers
Lab
Write swap(int*, int*), a function returning min and max through pointers and draw memory diagrams for each.
Homework
Predict outputs of five pointer snippets, then run and check.
Deliverable
Memory diagrams plus working programs.
Weekly checkpoint
Draw boxes-and-arrows for a pointer example.
You will be able to
Use pointers, structures and dynamic memory correctly, avoiding leaks and invalid access.
Week 6: Pointer arithmetic and arrays
Theory
Arrays decay to pointers
Pointer arithmetic and strides
const correctness and pointer to pointer
Lab
Reimplement strlen, strcpy and reverse using pointers only and compare against the library.
Homework
Explain a[i] versus *(a+i) with a diagram.
Deliverable
A mini string library with documentation.
Weekly checkpoint
Predict outputs involving pointer increments.
You will be able to
Use pointers, structures and dynamic memory correctly, avoiding leaks and invalid access.
Week 7: Structures and dynamic memory
Theory
struct, typedef and enum
malloc, calloc, realloc and free
Memory leaks, double free and use-after-free
Lab
Build a dynamic array of student structs that grows with realloc and is freed correctly; run with AddressSanitizer.
Homework
Introduce a leak deliberately and find it with the sanitizer report.
Deliverable
A student record program with zero sanitizer errors.
Weekly checkpoint
Spot the leak and the use-after-free in two listings.
You will be able to
Use pointers, structures and dynamic memory correctly, avoiding leaks and invalid access. Debug with a debugger and sanitizers, and write tests that cover normal, edge and failure cases.
Week 8: File handling
Theory
fopen, fclose, fgets, fprintf and fscanf
Binary files with fread and fwrite
Checking return values and errno
Lab
Persist the student records in a CSV text file and a binary file; handle a missing file gracefully.
Homework
Add a search by roll number that works from the file.
Deliverable
A student manager that saves and loads data.
Weekly checkpoint
Fix a program that forgets to close and check a file.
You will be able to
Read and write text and binary files safely.
Week 9: Debugging tools and Makefiles
Theory
GDB breakpoints, watch and backtrace
Sanitizers and Valgrind
Make targets, dependencies and separate compilation
Lab
Fix five seeded bugs using GDB and AddressSanitizer, then build the project with a Makefile and header files.
Homework
Write a bug report for each bug: symptom, cause and fix.
Deliverable
A Makefile-based project and five bug reports.
Weekly checkpoint
Read a GDB backtrace and name the faulty line.
You will be able to
Debug with a debugger and sanitizers, and write tests that cover normal, edge and failure cases.
Object-oriented C++ Weeks 10–14
Week 10: From C to C++
Theory
Namespaces, references and bool
std::string and std::vector instead of raw arrays
cin, cout and range-based for
Lab
Convert last week's array and string programs to std::vector and std::string and compare code size and safety.
Homework
List five C idioms and their safer C++ replacements.
Deliverable
A converted project plus a comparison note.
Weekly checkpoint
Choose reference or pointer for four function designs.
You will be able to
Apply C++ OOP: classes, inheritance, polymorphism, templates and the standard library.
Week 11: Classes and encapsulation
Theory
Class, object, access specifiers
Constructors, destructors and member initialisation
Const methods and invariants
Lab
Create an Account class with private balance and validated operations; add a destructor message to see object lifetime.
Homework
Add a copy constructor demonstration and explain when it is called.
Deliverable
A class library with a demo and invariants documented.
Weekly checkpoint
Find the invariant broken by a public data member.
You will be able to
Apply C++ OOP: classes, inheritance, polymorphism, templates and the standard library.
Week 12: Inheritance and polymorphism
Theory
Base and derived classes
Virtual functions, override and virtual destructors
Abstract classes and interfaces
Lab
Model Shape with Circle and Rectangle, store pointers in a vector and print areas through the base interface.
Homework
Show what goes wrong when the base destructor is not virtual.
Deliverable
A polymorphic shapes program.
Weekly checkpoint
Predict output with and without virtual.
You will be able to
Apply C++ OOP: classes, inheritance, polymorphism, templates and the standard library.
Week 13: Operator overloading and templates
Theory
Overloading +, ==, << sensibly
Function and class templates
Compile-time errors from templates
Lab
Write a Fraction class with operators and a template Stack<T>.
Homework
Write a template max function with a custom comparator.
Deliverable
Fraction and Stack<T> with tests.
Weekly checkpoint
Read a template error message and name the cause.
You will be able to
Apply C++ OOP: classes, inheritance, polymorphism, templates and the standard library.
Week 14: RAII, smart pointers and the STL
Theory
RAII and resource ownership
unique_ptr, shared_ptr and when to use each
STL containers, algorithms and exceptions
Lab
Replace raw new/delete in an earlier project with smart pointers; use sort, find_if and map to analyse a list of orders.
Homework
Write an exception-safe file reader class using RAII.
Deliverable
A leak-free project using STL algorithms.
Weekly checkpoint
Pick the correct smart pointer for three ownership scenarios.
You will be able to
Apply C++ OOP: classes, inheritance, polymorphism, templates and the standard library. Use pointers, structures and dynamic memory correctly, avoiding leaks and invalid access.
Data structures and algorithms Weeks 15–19
Week 15: Complexity and searching
Theory
Big-O intuition with counting operations
Linear and binary search
Choosing algorithms by input size
Lab
Implement linear and binary search, count comparisons for n = 1000 and 1,000,000 and plot a table.
Homework
Explain why binary search needs sorted data.
Deliverable
A comparison table with counts.
Weekly checkpoint
State the complexity of five code fragments.
You will be able to
Implement and compare arrays, linked lists, stacks, queues, trees, hash tables and basic sorting and searching.
Week 16: Sorting
Theory
Bubble, selection and insertion sort
Merge sort and quick sort ideas
Stability and std::sort
Lab
Implement insertion and merge sort, test with random, sorted and reversed input and time them.
Homework
Sort student records by marks, breaking ties by name.
Deliverable
A sorting suite with timing results.
Weekly checkpoint
Trace a sort pass on a small array.
You will be able to
Implement and compare arrays, linked lists, stacks, queues, trees, hash tables and basic sorting and searching.
Week 17: Linked lists, stacks and queues
Theory
Singly linked list with insert, delete and search
Stack and queue operations
Applications: bracket matching and task queues
Lab
Build a linked list in C++, then a stack-based bracket matcher and a ticket queue.
Homework
Reverse a linked list iteratively and draw each pointer change.
Deliverable
A list, stack and queue library with tests.
Weekly checkpoint
Draw the result of inserting and deleting nodes.
You will be able to
Implement and compare arrays, linked lists, stacks, queues, trees, hash tables and basic sorting and searching. Use pointers, structures and dynamic memory correctly, avoiding leaks and invalid access.
Week 18: Trees
Theory
Binary tree terms and traversals
Binary search tree insert and search
Recursion on trees and tree height
Lab
Implement a BST with insert, search, in-order print and height; test with sorted input to see the unbalanced case.
Homework
Write the in-order, pre-order and post-order output for a given tree.
Deliverable
A BST class with tests.
Weekly checkpoint
Perform a traversal on paper.
You will be able to
Implement and compare arrays, linked lists, stacks, queues, trees, hash tables and basic sorting and searching.
Week 19: Hash tables and graphs
Theory
Hash functions and collision handling
Using unordered_map and set
Graphs as adjacency lists and breadth-first search
Lab
Build a simple chained hash table of names, then use BFS to find the shortest route in a small bus-route graph of Madurai stops.
Homework
Compare lookup cost in a vector, a map and an unordered_map.
Deliverable
A hash table and route finder.
Weekly checkpoint
Explain a collision with an example; run BFS by hand.
You will be able to
Implement and compare arrays, linked lists, stacks, queues, trees, hash tables and basic sorting and searching.
Engineering practice Weeks 20–22
Week 20: Git for software teams
Theory
Commits, branches and merging
Remote repositories, pull requests and reviews
Writing meaningful commit messages
Lab
In pairs create a repository, work on separate branches, open pull requests and resolve a merge conflict.
Homework
Write a README with build and run steps.
Deliverable
A repository with reviewed pull requests.
Weekly checkpoint
Interpret a git log; resolve a text conflict.
You will be able to
Use Git for version control and complete a documented software mini-project.
Week 21: Testing software
Theory
Test cases: normal, boundary and invalid
Unit tests with doctest or Catch2
Test-driven fixes for found bugs
Lab
Write 15 test cases for the stack and BST, including empty and single-element cases; add a failing test before fixing a bug.
Homework
Create a table of test cases with input, expected output and result.
Deliverable
A passing test suite and test table.
Weekly checkpoint
Design boundary tests for a given function.
You will be able to
Debug with a debugger and sanitizers, and write tests that cover normal, edge and failure cases.
Week 22: Code review and AI-assisted learning
Theory
Review checklist: naming, errors, memory and tests
Reading unfamiliar code
Using AI to explain code while verifying against the compiler and tests
Lab
Review a peer's code with the checklist; ask an AI to explain one function and confirm each claim by running a test.
Homework
Write a short review with three improvements and one praise.
Deliverable
A written code review.
Weekly checkpoint
Find defects in a short listing and explain each.
You will be able to
Debug with a debugger and sanitizers, and write tests that cover normal, edge and failure cases. Use Git for version control and complete a documented software mini-project.
Mini-project Weeks 23–24
Week 23: Mini-project build
Theory
Requirements, design sketch and milestones
Dividing code into modules
Integration and regression tests
Lab
Build the chosen project (library manager, inventory tracker or route finder) with a team review at mid-week.
Homework
Update the README and design sketch.
Deliverable
A working project in Git with tests.
Weekly checkpoint
Milestone review against requirements.
You will be able to
Implement and compare arrays, linked lists, stacks, queues, trees, hash tables and basic sorting and searching. Use Git for version control and complete a documented software mini-project.
Week 24: Project demonstration
Theory
Demonstration structure
Explaining design choices
Planning further learning
Lab
Present the project, run the tests live and answer questions on memory handling and one data structure used.
Homework
Write a short reflection on what you learned.
Deliverable
Final repository, README and a five-minute demo.
Weekly checkpoint
Panel evaluation with the project rubric.
You will be able to
Use pointers, structures and dynamic memory correctly, avoiding leaks and invalid access. Debug with a debugger and sanitizers, and write tests that cover normal, edge and failure cases. Use Git for version control and complete a documented software mini-project.
Sample lessons
Week 5
Pointers: variables that hold addresses
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 * follows a pointer to reach the value stored there. Pointers let a function change the caller's variable, work with arrays and build structures such as linked lists. They are powerful but dangerous: a pointer that is NULL, uninitialised or pointing to freed memory must never be dereferenced.
Name
Address
Value
x
0x1000
10
p
0x1004
0x1000
*p
(follows p)
10
p stores the address of x; *p reaches the value.
Step by step
Declare int x = 10; and int *p = &x;.
Print x, &x, p and *p and note which are equal.
Change *p = 20; and print x.
Write swap(int *a, int *b) using a temporary variable.
Call swap(&m, &n) and print both values.
In real life
A pointer is like a house address on a letter. The address is not the house, but with it you can reach the house, change what is inside or find it is empty.
Worked example
Problem. What is printed?
int a = 5, b = 7;
int *p = &a;
*p = *p + b;
printf("%d %d", a, b);
Solution. p points to a. *p + b is 5 + 7 = 12, stored into a through p. The output is 12 7.
Common mistakes
Dereferencing a pointer that was never initialised.
Confusing p (the address) with *p (the value).
Try it yourself
Draw boxes and arrows for int x = 3; int *p = &x; int **q = &p;.
Write a function that returns the largest and smallest of three numbers through pointer parameters.
Week 17
Linked list: insert at the front
A linked list stores items in separate nodes. Each node holds a value and a pointer to the next node, and a head pointer remembers the first node. Inserting at the front is fast because you do not shift elements: create a node, point it to the old head and move head to the new node. Unlike an array, a list can grow one node at a time, but finding the nth item means walking from the head.
1head
2Node 1
3Node 3
4Node 5
5nullptr
Each node points to the next one.
Step by step
Define struct Node { int value; Node* next; };.
Allocate a new node and set its value.
Set newNode->next = head.
Set head = newNode.
Walk with a cursor until next is nullptr to print the list.
Delete every node at the end to avoid leaks.
In real life
A train is a linked list of coaches. You can attach a new coach at the front without moving the others, but to reach coach 7 you must walk through the earlier ones.
Worked example
Problem. The list is 3 -> 5 -> nullptr. Insert 1 at the front. What are the steps and the result?
Solution. Create node(1). Set its next to head (the node 3). Set head to node(1). The list is 1 -> 3 -> 5 -> nullptr. If you moved head first, you would lose the old list.
Common mistakes
Updating head before linking the new node's next, which loses the old list.
Forgetting to free nodes, causing a memory leak.
Try it yourself
Write insert_back and explain why it is slower than insert_front without a tail pointer.
Draw the pointer changes when deleting the middle node of a three-node list.
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 / 4 · Order the build process
Put these steps of turning a C program into a running program in order.
1Source code
2Compiler
3Linker
4Executable
Link it with libraries
Compile it into machine code
Write the source code
Run the executable
Projects
Library Book Manager in C++
Build a console application for a small college library that stores books and members, issues and returns books, persists data to a file and reports overdue items. It must be leak-free, tested and managed in Git.
Tasks
Design Book, Member and Library classes with clear responsibilities.
Use a hash map for lookup by book id and a vector for listing.
Save and load all data from a file with error handling.
Write at least 15 test cases including empty library and returning a book not issued.
Run with sanitizers and fix every reported issue.
Sample input
issue B102 M7 (when B102 is already issued)
Expected output
A clear message that B102 is already issued; no state change and the test passes.
How it is assessed
Criterion
Weight
Correct behaviour and edge cases
30%
Class design and data structure choice
20%
Memory safety and error handling
20%
Tests and Git history
20%
Documentation and demo
10%
Stretch challenge: Add a fine calculator and a search by author.
Bus Route Finder
Model six to ten Madurai bus stops as a graph and write a C++ program that finds a route with the fewest stops between two stops using breadth-first search.
Tasks
Represent stops with an adjacency list loaded from a text file.
Implement BFS and reconstruct the path.
Handle unknown stops and disconnected stops.
Write tests for direct, multi-hop and no-route cases.
Sample input
route Periyar Mattuthavani
Expected output
Periyar -> Goripalayam -> Mattuthavani (2 hops), or 'No route' when none exists.
How it is assessed
Criterion
Weight
Correct shortest-hop result
40%
Error handling
20%
Tests
25%
Code clarity
15%
Stretch challenge: Add weights and compare with Dijkstra's algorithm.
How you are assessed
Each week: a short quiz with code tracing, output prediction and one debugging item; a lab submitted through Git; and a trainer review. Pointer, memory and data-structure weeks include a diagram question.
Practical work. Learners are assessed on compiling clean code, passing their own tests, running under a debugger or sanitizer, and a mini-project demo with questions on memory handling and design choices.
What trainers look for
Weight
Correct, working code
35%
Memory safety and debugging
20%
Tests and edge cases
20%
Design, naming and Git practice
15%
Explanation and reflection
10%
Where this can lead
Prepares you for junior software developer and trainee programmer roles.
Prepares you for embedded, systems and algorithm-heavy study.
Builds a base for Java, Python and advanced data-structure learning.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
