C++ System Programming

Environment variables are system-wide settings that programs can read to configure their behavior. They store information like the user's home directory, system paths, and application-specific settings without hardcoding values into your program.

Reading Environment Variables

The getenv() function from <cstdlib> retrieves the value of an environment variable by name. It returns a pointer to the variable's value or nullptr if the variable doesn't exist. This allows programs to adapt to different system configurations without modification.

Basic Environment Variable Access

#include <iostream>
#include <cstdlib>

int main() {
    // Get the PATH environment variable
    const char* path = std::getenv("PATH");
    
    if (path != nullptr) {
        std::cout << "PATH: " << path << std::endl;
    } else {
        std::cout << "PATH is not set" << std::endl;
    }
    
    return 0;
}

Safe Environment Variable Access

#include <iostream>
#include <cstdlib>
#include <string>

std::string getEnvSafe(const char* name, const std::string& defaultValue = "") {
    const char* value = std::getenv(name);
    return (value != nullptr) ? std::string(value) : defaultValue;
}

int main() {
    // Get with default values
    std::string home = getEnvSafe("HOME", "/tmp");
    std::string editor = getEnvSafe("EDITOR", "nano");
    std::string debugMode = getEnvSafe("DEBUG", "false");
    
    std::cout << "Home directory: " << home << std::endl;
    std::cout << "Default editor: " << editor << std::endl;
    std::cout << "Debug mode: " << debugMode << std::endl;
    
    return 0;
}

Cross-Platform Home Directory

#include <iostream>
#include <cstdlib>
#include <string>

std::string getHomeDirectory() {
    // Try Unix-style first
    const char* home = std::getenv("HOME");
    if (home != nullptr) {
        return std::string(home);
    }
    
    // Try Windows-style
    const char* userProfile = std::getenv("USERPROFILE");
    if (userProfile != nullptr) {
        return std::string(userProfile);
    }
    
    // Windows alternative: combine HOMEDRIVE and HOMEPATH
    const char* homeDrive = std::getenv("HOMEDRIVE");
    const char* homePath = std::getenv("HOMEPATH");
    if (homeDrive != nullptr && homePath != nullptr) {
        return std::string(homeDrive) + std::string(homePath);
    }
    
    return "";  // Could not determine home directory
}

int main() {
    std::string home = getHomeDirectory();
    
    if (!home.empty()) {
        std::cout << "Home directory: " << home << std::endl;
    } else {
        std::cerr << "Could not determine home directory" << std::endl;
    }
    
    return 0;
}

Application Configuration from Environment

#include <iostream>
#include <cstdlib>
#include <string>

struct AppConfig {
    std::string dbHost;
    int dbPort;
    std::string logLevel;
    bool debugMode;
};

AppConfig loadConfigFromEnv() {
    AppConfig config;
    
    // Database settings
    const char* host = std::getenv("DB_HOST");
    config.dbHost = (host != nullptr) ? host : "localhost";
    
    const char* port = std::getenv("DB_PORT");
    config.dbPort = (port != nullptr) ? std::stoi(port) : 5432;
    
    // Logging settings
    const char* logLevel = std::getenv("LOG_LEVEL");
    config.logLevel = (logLevel != nullptr) ? logLevel : "INFO";
    
    // Debug mode
    const char* debug = std::getenv("DEBUG");
    config.debugMode = (debug != nullptr && std::string(debug) == "true");
    
    return config;
}

int main() {
    AppConfig config = loadConfigFromEnv();
    
    std::cout << "Database: " << config.dbHost << ":" << config.dbPort << std::endl;
    std::cout << "Log Level: " << config.logLevel << std::endl;
    std::cout << "Debug Mode: " << (config.debugMode ? "enabled" : "disabled") << std::endl;
    
    return 0;
}

// Environment: USER=john, HOME=/home/john, SHELL=/bin/bash

User: john
Home: /home/john
Shell: /bin/bash

#include <iostream>
#include <cstdlib>

void printEnv(const char* name, const char* label) {
    const char* value = std::getenv(name);
    if (value != nullptr) {
        std::cout << label << ": " << value << std::endl;
    } else {
        std::cout << label << ": (not set)" << std::endl;
    }
}

int main() {
    printEnv("USER", "User");
    printEnv("HOME", "Home");
    printEnv("SHELL", "Shell");
    return 0;
}

// PATH=/usr/local/bin:/usr/bin:/bin

1. /usr/local/bin
2. /usr/bin
3. /bin

#include <iostream>
#include <cstdlib>
#include <sstream>
#include <string>

int main() {
    const char* path = std::getenv("PATH");
    
    if (path == nullptr) {
        std::cerr << "PATH is not set" << std::endl;
        return 1;
    }
    
    std::istringstream iss(path);
    std::string dir;
    int count = 1;
    
    // Use ':' on Unix, ';' on Windows
    char delimiter = ':';
    #ifdef _WIN32
    delimiter = ';';
    #endif
    
    while (std::getline(iss, dir, delimiter)) {
        if (!dir.empty()) {
            std::cout << count++ << ". " << dir << std::endl;
        }
    }
    
    return 0;
}

// APP_PORT=8080, APP_TIMEOUT=30.5, APP_DEBUG=true, APP_NAME=MyApp

Config cfg;
int port = cfg.getInt("APP_PORT", 3000);        // 8080
double timeout = cfg.getDouble("APP_TIMEOUT", 10.0);  // 30.5
bool debug = cfg.getBool("APP_DEBUG", false);    // true

#include <iostream>
#include <cstdlib>
#include <string>

class Config {
public:
    std::string getString(const char* name, const std::string& def = "") {
        const char* val = std::getenv(name);
        return (val != nullptr) ? std::string(val) : def;
    }
    
    int getInt(const char* name, int def = 0) {
        const char* val = std::getenv(name);
        if (val == nullptr) return def;
        try {
            return std::stoi(val);
        } catch (...) {
            return def;
        }
    }
    
    double getDouble(const char* name, double def = 0.0) {
        const char* val = std::getenv(name);
        if (val == nullptr) return def;
        try {
            return std::stod(val);
        } catch (...) {
            return def;
        }
    }
    
    bool getBool(const char* name, bool def = false) {
        const char* val = std::getenv(name);
        if (val == nullptr) return def;
        std::string s(val);
        return (s == "true" || s == "1" || s == "yes" || s == "on");
    }
};

int main() {
    Config cfg;
    
    std::cout << "Name: " << cfg.getString("APP_NAME", "DefaultApp") << std::endl;
    std::cout << "Port: " << cfg.getInt("APP_PORT", 3000) << std::endl;
    std::cout << "Timeout: " << cfg.getDouble("APP_TIMEOUT", 10.0) << std::endl;
    std::cout << "Debug: " << (cfg.getBool("APP_DEBUG", false) ? "yes" : "no") << std::endl;
    
    return 0;
}

Process control allows your C++ program to interact with the operating system, execute other programs, and manage program termination. Understanding these concepts is crucial for building system utilities and applications that integrate with other software.

Program Termination

C++ provides several ways to terminate a program, each with different behaviors regarding cleanup and resource management. Choosing the right termination method ensures your program exits cleanly and communicates its status properly to the operating system.

Exit Codes and Status

#include <iostream>
#include <cstdlib>

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Error: Missing required argument" << std::endl;
        return EXIT_FAILURE;  // Usually 1
    }
    
    std::string arg = argv[1];
    
    if (arg == "--help") {
        std::cout << "Usage: program <input>" << std::endl;
        return EXIT_SUCCESS;  // Usually 0
    }
    
    // Process the argument...
    std::cout << "Processing: " << arg << std::endl;
    
    return EXIT_SUCCESS;
}

Using exit() for Early Termination

#include <iostream>
#include <cstdlib>
#include <fstream>

void cleanup() {
    std::cout << "Cleanup: Releasing resources..." << std::endl;
}

int main() {
    // Register cleanup function
    std::atexit(cleanup);
    
    std::ifstream file("config.txt");
    
    if (!file.is_open()) {
        std::cerr << "Fatal: Cannot open config file" << std::endl;
        exit(EXIT_FAILURE);  // cleanup() will be called
    }
    
    std::cout << "Processing configuration..." << std::endl;
    
    // ... program logic ...
    
    return EXIT_SUCCESS;  // cleanup() called here too
}

Executing External Commands

The system() function allows your program to execute shell commands and other programs. While simple to use, it has security implications that must be understood for safe usage.

Basic System Command Execution

#include <iostream>
#include <cstdlib>

int main() {
    std::cout << "Directory contents:" << std::endl;
    
    // Execute a shell command
    #ifdef _WIN32
    int result = system("dir");
    #else
    int result = system("ls -la");
    #endif
    
    if (result == 0) {
        std::cout << "Command executed successfully" << std::endl;
    } else {
        std::cerr << "Command failed with code: " << result << std::endl;
    }
    
    return 0;
}

Checking Command Availability

#include <iostream>
#include <cstdlib>

bool commandExists(const char* cmd) {
    #ifdef _WIN32
    std::string check = "where " + std::string(cmd) + " > nul 2>&1";
    #else
    std::string check = "which " + std::string(cmd) + " > /dev/null 2>&1";
    #endif
    
    return system(check.c_str()) == 0;
}

int main() {
    // Check if git is installed
    if (commandExists("git")) {
        std::cout << "Git is installed" << std::endl;
        system("git --version");
    } else {
        std::cout << "Git is not installed" << std::endl;
    }
    
    return 0;
}

Security Warning: Command Injection

#include <iostream>
#include <cstdlib>
#include <string>
#include <algorithm>

// DANGEROUS - Never do this with user input!
void dangerousSearch(const std::string& userInput) {
    std::string cmd = "grep " + userInput + " data.txt";
    system(cmd.c_str());  // User could inject: "; rm -rf /"
}

// SAFER - Validate and sanitize input
bool isValidFilename(const std::string& name) {
    // Only allow alphanumeric, dash, underscore, and dot
    return std::all_of(name.begin(), name.end(), [](char c) {
        return std::isalnum(c) || c == '-' || c == '_' || c == '.';
    });
}

void saferOperation(const std::string& filename) {
    if (!isValidFilename(filename)) {
        std::cerr << "Invalid filename" << std::endl;
        return;
    }
    
    std::string cmd = "cat " + filename;
    system(cmd.c_str());
}

int main() {
    std::string input;
    std::cout << "Enter filename: ";
    std::cin >> input;
    
    saferOperation(input);
    
    return 0;
}

./validate 42
./validate abc
./validate

./validate 42    # exits with 0
./validate abc   # prints error, exits with 1
./validate       # prints usage, exits with 1

#include <iostream>
#include <cstdlib>
#include <string>

int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cerr << "Usage: " << argv[0] << " <number>" << std::endl;
        return EXIT_FAILURE;
    }
    
    try {
        int num = std::stoi(argv[1]);
        if (num <= 0) {
            std::cerr << "Error: Number must be positive" << std::endl;
            return EXIT_FAILURE;
        }
        std::cout << "Valid: " << num << std::endl;
        return EXIT_SUCCESS;
    } catch (...) {
        std::cerr << "Error: Invalid number format" << std::endl;
        return EXIT_FAILURE;
    }
}

Starting program...
Cleanup 3: Final cleanup
Cleanup 2: Closing connections
Cleanup 1: Saving state

#include <iostream>
#include <cstdlib>

void cleanup1() {
    std::cout << "Cleanup 1: Saving state" << std::endl;
}

void cleanup2() {
    std::cout << "Cleanup 2: Closing connections" << std::endl;
}

void cleanup3() {
    std::cout << "Cleanup 3: Final cleanup" << std::endl;
}

int main() {
    // Register in order - will be called in reverse
    std::atexit(cleanup1);
    std::atexit(cleanup2);
    std::atexit(cleanup3);
    
    std::cout << "Starting program..." << std::endl;
    
    // Normal exit - all handlers will be called
    return 0;
}

./build compile main.cpp   # compiles main.cpp
./build run main           # runs ./main (Unix) or main.exe (Windows)
./build clean              # removes executables

#include <iostream>
#include <cstdlib>
#include <string>

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: " << argv[0] << " <compile|run|clean> [args]" << std::endl;
        return 1;
    }
    
    std::string cmd = argv[1];
    
    if (cmd == "compile" && argc >= 3) {
        std::string src = argv[2];
        std::string out = src.substr(0, src.find('.'));
        
        #ifdef _WIN32
        std::string compile = "g++ -o " + out + ".exe " + src;
        #else
        std::string compile = "g++ -o " + out + " " + src;
        #endif
        
        std::cout << "Compiling: " << compile << std::endl;
        return system(compile.c_str());
        
    } else if (cmd == "run" && argc >= 3) {
        #ifdef _WIN32
        std::string run = std::string(argv[2]) + ".exe";
        #else
        std::string run = "./" + std::string(argv[2]);
        #endif
        
        std::cout << "Running: " << run << std::endl;
        return system(run.c_str());
        
    } else if (cmd == "clean") {
        #ifdef _WIN32
        return system("del *.exe 2>nul");
        #else
        return system("rm -f *.out a.out 2>/dev/null");
        #endif
        
    } else {
        std::cerr << "Unknown command: " << cmd << std::endl;
        return 1;
    }
}

Signals are software interrupts sent to a program to indicate that an important event has occurred. Learning to handle signals allows your program to respond gracefully to events like user interrupts (Ctrl+C), termination requests, and other system notifications.

Understanding Signals

Signals are a form of inter-process communication used by the operating system to notify programs of various events. Each signal has a default action (terminate, ignore, or stop), but programs can install custom handlers to respond differently.

Basic Signal Handling

#include <iostream>
#include <csignal>
#include <cstdlib>

// Signal handler function
void signalHandler(int signum) {
    std::cout << "\nInterrupt signal (" << signum << ") received.\n";
    
    // Cleanup and close up stuff here
    std::cout << "Cleaning up..." << std::endl;
    
    // Terminate program
    exit(signum);
}

int main() {
    // Register signal handler for SIGINT (Ctrl+C)
    signal(SIGINT, signalHandler);
    
    std::cout << "Program running. Press Ctrl+C to interrupt..." << std::endl;
    
    // Infinite loop - wait for signal
    while (true) {
        std::cout << "." << std::flush;
        // Sleep would go here in real code
    }
    
    return 0;
}

Graceful Shutdown Pattern

#include <iostream>
#include <csignal>
#include <atomic>

// Use atomic for thread-safe flag
std::atomic<bool> running(true);

void shutdownHandler(int signum) {
    std::cout << "\nShutdown requested (signal " << signum << ")" << std::endl;
    running = false;  // Signal main loop to stop
}

int main() {
    // Handle both SIGINT and SIGTERM
    signal(SIGINT, shutdownHandler);
    signal(SIGTERM, shutdownHandler);
    
    std::cout << "Server starting... (Ctrl+C to stop)" << std::endl;
    
    int counter = 0;
    while (running) {
        // Simulate server work
        std::cout << "Processing request " << ++counter << std::endl;
        
        // In real code: process requests, handle connections, etc.
    }
    
    std::cout << "Shutting down gracefully..." << std::endl;
    std::cout << "Processed " << counter << " requests total." << std::endl;
    
    return 0;
}

Ignoring and Restoring Default Handlers

#include <iostream>
#include <csignal>

int main() {
    // Ignore SIGINT - Ctrl+C will do nothing
    signal(SIGINT, SIG_IGN);
    std::cout << "SIGINT ignored. Ctrl+C won't work for 5 seconds..." << std::endl;
    
    // Do critical work that shouldn't be interrupted
    for (int i = 5; i > 0; i--) {
        std::cout << i << "..." << std::endl;
        // sleep(1) would go here
    }
    
    // Restore default behavior
    signal(SIGINT, SIG_DFL);
    std::cout << "SIGINT restored. Ctrl+C will now terminate." << std::endl;
    
    while (true) {
        std::cout << "Running..." << std::endl;
    }
    
    return 0;
}

Running... Press Ctrl+C 3 times to exit
^CInterrupt 1 of 3
^CInterrupt 2 of 3
^CInterrupt 3 of 3 - Exiting!

#include <iostream>
#include <csignal>
#include <cstdlib>

int interruptCount = 0;

void handler(int signum) {
    interruptCount++;
    std::cout << "\nInterrupt " << interruptCount << " of 3";
    
    if (interruptCount >= 3) {
        std::cout << " - Exiting!" << std::endl;
        exit(0);
    }
    std::cout << std::endl;
}

int main() {
    signal(SIGINT, handler);
    
    std::cout << "Running... Press Ctrl+C 3 times to exit" << std::endl;
    
    while (true) {
        // Keep running
    }
    
    return 0;
}

Enter your name (5 seconds): 
Timeout! No input received.

#include <iostream>
#include <csignal>
#include <cstdlib>
#include <unistd.h>  // For alarm() - Unix only
#include <string>

void timeoutHandler(int signum) {
    std::cout << "\nTimeout! No input received." << std::endl;
    exit(1);
}

int main() {
    signal(SIGALRM, timeoutHandler);
    
    std::cout << "Enter your name (5 seconds): " << std::flush;
    
    alarm(5);  // Set 5 second alarm
    
    std::string name;
    std::getline(std::cin, name);
    
    alarm(0);  // Cancel alarm
    
    std::cout << "Hello, " << name << "!" << std::endl;
    
    return 0;
}

Working with dates and times is essential for logging, scheduling, and time-based calculations. Modern C++ provides the powerful chrono library for precise time measurements and the traditional ctime functions for calendar operations and formatting.

The Chrono Library (C++11)

The <chrono> library provides a type-safe way to work with time durations and points. It prevents common errors by encoding time units in the type system, so you can't accidentally mix seconds and milliseconds.

Measuring Execution Time

#include <iostream>
#include <chrono>
#include <thread>

int main() {
    using namespace std::chrono;
    
    // Get start time
    auto start = high_resolution_clock::now();
    
    // Code to measure
    std::cout << "Working..." << std::endl;
    std::this_thread::sleep_for(milliseconds(1500));
    
    // Calculate elapsed time
    auto end = high_resolution_clock::now();
    auto duration = duration_cast<milliseconds>(end - start);
    
    std::cout << "Elapsed time: " << duration.count() << " ms" << std::endl;
    
    // Can also get in different units
    auto microsecs = duration_cast<microseconds>(end - start);
    std::cout << "Or: " << microsecs.count() << " microseconds" << std::endl;
    
    return 0;
}

Duration Arithmetic

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    using namespace std::chrono_literals;  // For h, min, s, ms literals (C++14)
    
    // Create durations using literals
    auto flight = 2h + 30min;
    auto layover = 45min;
    auto total = flight + layover;
    
    // Convert and display
    std::cout << "Flight: " << duration_cast<minutes>(flight).count() << " min\n";
    std::cout << "Layover: " << layover.count() << " min\n";
    std::cout << "Total: " << duration_cast<minutes>(total).count() << " min\n";
    
    // Comparison
    auto shortTrip = 90min;
    if (total > shortTrip) {
        std::cout << "This is a long trip!" << std::endl;
    }
    
    // Create from numbers
    seconds secs(3661);  // 1 hour, 1 minute, 1 second
    auto hrs = duration_cast<hours>(secs);
    auto mins = duration_cast<minutes>(secs) % 60;
    auto remaining = secs % 60;
    
    std::cout << secs.count() << " seconds = " 
              << hrs.count() << "h " 
              << mins.count() << "m " 
              << remaining.count() << "s" << std::endl;
    
    return 0;
}

Traditional C Time Functions

Getting Current Date and Time

#include <iostream>
#include <ctime>

int main() {
    // Get current time as time_t
    time_t now = time(nullptr);
    
    // Convert to local time struct
    tm* localTime = localtime(&now);
    
    // Access individual components
    std::cout << "Current date and time:\n";
    std::cout << "Year:   " << (1900 + localTime->tm_year) << std::endl;
    std::cout << "Month:  " << (1 + localTime->tm_mon) << std::endl;
    std::cout << "Day:    " << localTime->tm_mday << std::endl;
    std::cout << "Hour:   " << localTime->tm_hour << std::endl;
    std::cout << "Minute: " << localTime->tm_min << std::endl;
    std::cout << "Second: " << localTime->tm_sec << std::endl;
    std::cout << "Day of week: " << localTime->tm_wday << " (0=Sun)\n";
    std::cout << "Day of year: " << localTime->tm_yday << std::endl;
    
    // Quick formatted output
    std::cout << "\nFormatted: " << ctime(&now);  // Includes newline
    
    return 0;
}

Custom Date Formatting with strftime

#include <iostream>
#include <ctime>

int main() {
    time_t now = time(nullptr);
    tm* localTime = localtime(&now);
    
    char buffer[100];
    
    // ISO 8601 format
    strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", localTime);
    std::cout << "ISO format: " << buffer << std::endl;
    
    // US format
    strftime(buffer, sizeof(buffer), "%m/%d/%Y %I:%M %p", localTime);
    std::cout << "US format:  " << buffer << std::endl;
    
    // Full date with day name
    strftime(buffer, sizeof(buffer), "%A, %B %d, %Y", localTime);
    std::cout << "Full date:  " << buffer << std::endl;
    
    // Log timestamp
    strftime(buffer, sizeof(buffer), "[%Y-%m-%d %H:%M:%S]", localTime);
    std::cout << buffer << " Application started" << std::endl;
    
    // Useful specifiers:
    // %Y=year(4), %y=year(2), %m=month, %d=day, %H=hour24, %I=hour12
    // %M=minute, %S=second, %p=AM/PM, %A=weekday, %B=month name
    
    return 0;
}

Bridging Chrono and ctime

#include <iostream>
#include <chrono>
#include <ctime>
#include <iomanip>

int main() {
    using namespace std::chrono;
    
    // Get current time using chrono
    auto now = system_clock::now();
    
    // Convert chrono time_point to time_t for formatting
    time_t now_t = system_clock::to_time_t(now);
    
    // Format using ctime functions
    std::cout << "Current time: " << std::put_time(localtime(&now_t), "%F %T") << std::endl;
    
    // Create a specific date and convert to time_point
    tm date = {};
    date.tm_year = 2024 - 1900;  // Years since 1900
    date.tm_mon = 11;             // December (0-based)
    date.tm_mday = 25;
    date.tm_hour = 12;
    
    time_t target_t = mktime(&date);
    auto target = system_clock::from_time_t(target_t);
    
    // Calculate duration until target
    auto diff = target - now;
    auto days = duration_cast<hours>(diff).count() / 24;
    
    std::cout << "Days until target: " << days << std::endl;
    
    return 0;
}

Press Enter to start...
Press Enter to stop...
Elapsed time: 3.24 seconds

#include <iostream>
#include <chrono>
#include <iomanip>

int main() {
    using namespace std::chrono;
    
    std::cout << "Press Enter to start..." << std::endl;
    std::cin.get();
    
    auto start = high_resolution_clock::now();
    
    std::cout << "Press Enter to stop..." << std::endl;
    std::cin.get();
    
    auto end = high_resolution_clock::now();
    
    duration<double> elapsed = end - start;
    
    std::cout << std::fixed << std::setprecision(2);
    std::cout << "Elapsed time: " << elapsed.count() << " seconds" << std::endl;
    
    return 0;
}

Enter birth year: 1995
Enter birth month (1-12): 6
Enter birth day: 15
You are 29 years, 4 months, and 10 days old.

#include <iostream>
#include <ctime>

int main() {
    int byear, bmonth, bday;
    
    std::cout << "Enter birth year: ";
    std::cin >> byear;
    std::cout << "Enter birth month (1-12): ";
    std::cin >> bmonth;
    std::cout << "Enter birth day: ";
    std::cin >> bday;
    
    // Get current date
    time_t now = time(nullptr);
    tm* current = localtime(&now);
    
    int cyear = current->tm_year + 1900;
    int cmonth = current->tm_mon + 1;
    int cday = current->tm_mday;
    
    // Calculate age
    int years = cyear - byear;
    int months = cmonth - bmonth;
    int days = cday - bday;
    
    // Adjust for negative days
    if (days < 0) {
        months--;
        days += 30;  // Approximate
    }
    
    // Adjust for negative months
    if (months < 0) {
        years--;
        months += 12;
    }
    
    std::cout << "You are " << years << " years, " 
              << months << " months, and " 
              << days << " days old." << std::endl;
    
    return 0;
}

factorial(20) = 2432902008176640000
Execution time: 0.002 ms

#include <iostream>
#include <chrono>
#include <iomanip>
#include <functional>

template<typename Func, typename... Args>
auto measureTime(Func func, Args&&... args) {
    using namespace std::chrono;
    
    auto start = high_resolution_clock::now();
    auto result = func(std::forward<Args>(args)...);
    auto end = high_resolution_clock::now();
    
    auto duration = duration_cast<microseconds>(end - start);
    std::cout << std::fixed << std::setprecision(3);
    std::cout << "Execution time: " << duration.count() / 1000.0 << " ms" << std::endl;
    
    return result;
}

long long factorial(int n) {
    long long result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

int main() {
    int n = 20;
    auto result = measureTime(factorial, n);
    std::cout << "factorial(" << n << ") = " << result << std::endl;
    
    return 0;
}