#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <optional>
/*
Sorting string-based dates in C++ using the standard library.
This program demonstrates:
- Converting date strings into std::tm using std::get_time
- Modular parsing and sorting functions
- Error handling for malformed dates
- Multiple test cases, including edge cases
- Notes on performance, memory, and pitfalls inside the code
Format used: "DD Mon YYYY" (e.g., "24 Jun 2020")
*/
// ------------------------------------------------------------
// Parse a date string into std::tm
// ------------------------------------------------------------
std::optional<std::tm> parse_date(const std::string& s) {
/*
Converts a date string into a std::tm structure.
Uses std::get_time, which is safe and does not execute arbitrary code.
If parsing fails, returns std::nullopt so the caller can decide how to handle it.
Complexity: O(length of string)
Pitfall: std::get_time is locale-dependent; using "%d %b %Y" requires English month abbreviations.
*/
std::tm tm{};
std::istringstream iss(s);
iss >> std::get_time(&tm, "%d %b %Y");
if (!iss.fail()) {
return tm;
}
return std::nullopt;
}
// ------------------------------------------------------------
// Sort a list of date strings
// ------------------------------------------------------------
std::vector<std::string> sort_dates(const std::vector<std::string>& dates) {
/*
Steps:
1. Parse each date into std::tm.
2. Store (tm, original string) pairs.
3. Sort by tm.
4. Return sorted original strings.
Complexity:
- Parsing: O(n)
- Sorting: O(n log n)
- Total: O(n log n)
Memory:
- Temporary vector of parsed results proportional to input size.
Pitfalls:
- Invalid dates must be handled.
- Mixed formats will fail parsing.
*/
struct Parsed {
std::tm tm;
std::string original;
};
std::vector<Parsed> parsed;
parsed.reserve(dates.size());
for (const auto& d : dates) {
auto tm_opt = parse_date(d);
if (!tm_opt) {
throw std::runtime_error("Invalid date: " + d);
}
parsed.push_back({*tm_opt, d});
}
std::sort(parsed.begin(), parsed.end(),
[](const Parsed& a, const Parsed& b) {
// Compare tm fields lexicographically
// std::tm stores year since 1900, month 0–11, etc.
if (a.tm.tm_year != b.tm.tm_year) return a.tm.tm_year < b.tm.tm_year;
if (a.tm.tm_mon != b.tm.tm_mon) return a.tm.tm_mon < b.tm.tm_mon;
return a.tm.tm_mday < b.tm.tm_mday;
});
std::vector<std::string> result;
result.reserve(parsed.size());
for (const auto& p : parsed) {
result.push_back(p.original);
}
return result;
}
// ------------------------------------------------------------
// Test harness
// ------------------------------------------------------------
void run_test(const std::string& name, const std::vector<std::string>& dates) {
std::cout << "\nTest case: " << name << "\n";
std::cout << "Input:\n";
for (const auto& d : dates) std::cout << " " << d << "\n";
try {
auto sorted = sort_dates(dates);
std::cout << "Sorted:\n";
for (const auto& d : sorted) std::cout << " " << d << "\n";
} catch (const std::exception& ex) {
std::cout << "Error: " << ex.what() << "\n";
}
}
// ------------------------------------------------------------
// Main
// ------------------------------------------------------------
int main() {
/*
Multiple test cases:
- Normal dates
- Already sorted
- Reverse sorted
- Duplicate dates
- Invalid date
- Empty list
*/
run_test("Normal case",
{"24 Jun 2020", "25 Dec 2019", "26 Jul 2019",
"20 Jan 2020", "27 Oct 2019", "31 Dec 2018"});
run_test("Already sorted",
{"01 Jan 2018", "02 Jan 2018", "03 Jan 2018"});
run_test("Reverse sorted",
{"31 Dec 2020", "01 Jun 2020", "01 Jan 2020"});
run_test("Duplicates",
{"24 Jun 2020", "24 Jun 2020", "23 Jun 2020"});
run_test("Invalid date",
{"24 Jun 2020", "not-a-date", "25 Dec 2019"});
run_test("Empty list", {});
}
/*
run:
Test case: Normal case
Input:
24 Jun 2020
25 Dec 2019
26 Jul 2019
20 Jan 2020
27 Oct 2019
31 Dec 2018
ERROR!
Sorted:
31 Dec 2018
26 Jul 2019
27 Oct 2019
25 Dec 2019
20 Jan 2020
24 Jun 2020
Test case: Already sorted
Input:
01 Jan 2018
02 Jan 2018
03 Jan 2018
Sorted:
01 Jan 2018
02 Jan 2018
03 Jan 2018
Test case: Reverse sorted
Input:
31 Dec 2020
01 Jun 2020
01 Jan 2020
Sorted:
01 Jan 2020
01 Jun 2020
31 Dec 2020
Test case: Duplicates
Input:
24 Jun 2020
24 Jun 2020
23 Jun 2020
Sorted:
23 Jun 2020
24 Jun 2020
24 Jun 2020
Test case: Invalid date
Input:
24 Jun 2020
not-a-date
25 Dec 2019
Error: Invalid date: not-a-date
Test case: Empty list
Input:
Sorted:
*/