Intermediate C++ projects: 10 ideas that teach data structures and design
Intermediate C++ projects with real trade-offs: an LRU cache, a rate limiter, a formula parser, Dijkstra routing, a JSON parser and more, each with tests and review.
Intermediate projects are where data structures stop being exam topics and start being decisions.
An LRU cache needs O(1) operations, so a plain std::map won't do. A room booking system must reject
clashes without scanning every booking. A parser must say where the input went wrong.
These ten projects form Devventura's Expedition level. They assume you're comfortable with classes, the standard containers and running tests.
What you'll practise
- Choosing and combining containers for a complexity target (see the guide to C++ containers).
- Parsing with tokenizers, state machines and recursive descent (see strings and parsing in C++).
- Classic algorithms in context: interval merging, Dijkstra, edit distance.
- Designing for testability, for example passing the current time in instead of reading the clock.
- Deterministic output: defining tie-breaks so results never depend on hash order.
The projects
Meetly
Room bookings for Meetly
Stop double bookings in Meetly's rooms with an ordered index, then find times when everyone is free by merging calendars.
- half-open intervals
- ordered maps
- interval merging
- lower_bound
Quickcart
A product cache for Quickcart
Put a least-recently-used cache in front of Quickcart's slow product service, with O(1) operations, statistics and live resizing.
- hash maps
- linked lists
- iterator stability
- amortised O(1)
Gatekeep
Rate limiting for Gatekeep
Protect Gatekeep's customers from traffic floods with token buckets: exact integer refills, a testable clock, per-client limits and bounded memory.
- token buckets
- injected time
- integer arithmetic
- memory bounds
Draftboard
Undo and redo for Draftboard
Give Draftboard's editor an undo history that behaves the way writers expect: reversible commands, typing that undoes a word at a time, grouped edits and a bounded history.
- command pattern
- stacks
- inverse operations
- bounded history
Shipwright
Order lifecycle for Shipwright
Replace Shipwright's tangle of status flags with an explicit state machine: one transition table, guards, an audit history and replay from an event log.
- finite state machines
- transition tables
- guards
- event replay
Tracehound
Log analysis for Tracehound
Parse structured log lines, quoted values and all, then compute error rates and p95 latencies so on-call engineers find the slow endpoint in seconds.
- tokenising
- key-value parsing
- percentiles
- aggregation
Findly
Search suggestions for Findly
Build the autocomplete behind Findly's search box with a trie, then add 'did you mean' suggestions using edit distance computed along the trie.
- tries
- tree ownership
- edit distance
- dynamic programming
Sheetwise
A formula engine for Sheetwise
Write the formula engine behind Sheetwise's cells: a tokenizer and a recursive-descent parser with correct precedence, precise error positions, cell references and functions.
- tokenizers
- recursive descent
- operator precedence
- error reporting
Roundtrip Couriers
Delivery routes for Roundtrip Couriers
Find the fastest routes through the city with Dijkstra's algorithm, handle road closures, and plan the best round trip through a courier's stops.
- graphs
- Dijkstra's algorithm
- priority queues
- exhaustive search
Configo
A JSON parser for Configo
Write the strict, dependency-free JSON parser at the heart of Configo: exact error positions, Unicode escapes, depth limits, compact output and path lookups.
- recursive descent
- recursive data types
- Unicode and UTF-8
- defensive parsing
Where to start
If you've just finished the beginner level, start with room bookings for Meetly (ordered maps and intervals) or a product cache for Quickcart (a hash map and a linked list working together).
The hardest of the ten is a JSON parser for Configo: the whole standard, Unicode escapes, a depth limit against hostile input, and exact error positions.
Habits worth building at this level
- State the complexity of each operation in your design note, and check your code meets it.
- Write the boundary tests first: exactly at the limit, one past it, empty, huge.
- Keep parsing and logic apart. Text in, structured data out, then work on the data.
Ready for concurrency and systems work? Continue with advanced C++ projects.
Questions and answers
- What makes a C++ project intermediate rather than beginner?
- The data structure or algorithm is a decision with consequences. Beginner projects can be solved with a vector and a loop; intermediate ones need an ordered map, a hash map plus a list, a priority queue or a parser, chosen for performance or correctness.
- Should I implement data structures myself or use the standard library?
- Use the standard library's containers as building blocks, and implement the structure the project is about (an LRU cache, a trie, a token bucket) yourself. That's how it works on the job too.
Practise it in a project
These projects put this guide to work, with tickets, tests and code review.
Quickcart
A product cache for Quickcart
Put a least-recently-used cache in front of Quickcart's slow product service, with O(1) operations, statistics and live resizing.
- hash maps
- linked lists
- iterator stability
- amortised O(1)
Gatekeep
Rate limiting for Gatekeep
Protect Gatekeep's customers from traffic floods with token buckets: exact integer refills, a testable clock, per-client limits and bounded memory.
- token buckets
- injected time
- integer arithmetic
- memory bounds
Sheetwise
A formula engine for Sheetwise
Write the formula engine behind Sheetwise's cells: a tokenizer and a recursive-descent parser with correct precedence, precise error positions, cell references and functions.
- tokenizers
- recursive descent
- operator precedence
- error reporting
Configo
A JSON parser for Configo
Write the strict, dependency-free JSON parser at the heart of Configo: exact error positions, Unicode escapes, depth limits, compact output and path lookups.
- recursive descent
- recursive data types
- Unicode and UTF-8
- defensive parsing