C++ System-Level Projects

Key System Programming Areas

int* arr = new int[100];
delete[] arr;

#include <thread>
std::thread t(function);
t.join();

#include <filesystem>
namespace fs = std::filesystem;
fs::create_directory("folder");

#include <sys/socket.h>
int sock = socket(AF_INET, 
    SOCK_STREAM, 0);

🔹 Simple File Monitor

The Simple File Monitor is a lightweight utility that tracks changes to files or directories in real-time. It continuously watches for events like modifications, creations, or deletions, triggering alerts (e.g., File changed!) when detected. Built using file system APIs, it’s useful for automated backups, log monitoring, synchronization, and debugging. By eliminating manual checks, it ensures data integrity and timely responses to changes, making it essential in development environments, server administration, and applications requiring live data updates.

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

namespace fs = std::filesystem;

class FileMonitor {
private:
    std::string path;
    fs::file_time_type lastWrite;
    
public:
    FileMonitor(const std::string& filePath) : path(filePath) {
        if (fs::exists(path)) {
            lastWrite = fs::last_write_time(path);
        }
    }
    
    bool hasChanged() {
        if (!fs::exists(path)) return false;
        
        auto currentWrite = fs::last_write_time(path);
        if (currentWrite != lastWrite) {
            lastWrite = currentWrite;
            return true;
        }
        return false;
    }
};

int main() {
    FileMonitor monitor("test.txt");
    
    while (true) {
        if (monitor.hasChanged()) {
            std::cout << "File changed!" << std::endl;
        }
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    
    return 0;
}

🔹 Memory Pool Allocator

The Memory Pool Allocator is a custom memory management system designed to optimize performance by reducing fragmentation and allocation overhead. It pre-allocates fixed-size blocks (e.g., 984 bytes available) from a contiguous pool, allowing fast, predictable allocations and deallocations. This approach minimizes system calls, improves cache locality, and is ideal for real-time systems, game engines, or high-performance applications. By managing memory efficiently, it prevents leaks and fragmentation, ensuring stable, efficient resource usage in demanding C++ or embedded environments.

#include <iostream>
#include <vector>

class MemoryPool {
private:
    std::vector<char> pool;
    size_t poolSize;
    size_t offset;
    
public:
    MemoryPool(size_t size) : poolSize(size), offset(0) {
        pool.resize(poolSize);
    }
    
    void* allocate(size_t size) {
        if (offset + size > poolSize) {
            return nullptr; // Pool exhausted
        }
        
        void* ptr = &pool[offset];
        offset += size;
        return ptr;
    }
    
    void reset() {
        offset = 0;
    }
    
    size_t available() const {
        return poolSize - offset;
    }
};

int main() {
    MemoryPool pool(1024); // 1KB pool
    
    int* numbers = static_cast<int*>(pool.allocate(sizeof(int) * 10));
    
    for (int i = 0; i < 10; ++i) {
        numbers[i] = i * i;
    }
    
    std::cout << "Available memory: " << pool.available() << " bytes" << std::endl;
    
    return 0;
}

🔹 Simple TCP Server

The Simple TCP Server is a basic network application that listens for and handles client connections using socket programming. It starts on a specified port (e.g., 8080), accepts incoming connections from clients (e.g., 192.168.1.100), and exchanges data through send/receive operations. This server demonstrates key networking concepts like binding, listening, and multithreading, forming the backbone for web servers, chat applications, or distributed systems. It’s crucial for learning network protocols, concurrency, and client-server architecture in C++ or system programming.

#include <iostream>
#include <string>
#include <thread>
#include <vector>

// Simplified cross-platform socket wrapper
class SimpleServer {
private:
    int port;
    bool running;
    
public:
    SimpleServer(int p) : port(p), running(false) {}
    
    void start() {
        running = true;
        std::cout << "Server starting on port " << port << std::endl;
        
        // Simulate server loop
        while (running) {
            std::cout << "Listening for connections..." << std::endl;
            std::this_thread::sleep_for(std::chrono::seconds(2));
            
            // Simulate handling a client
            handleClient("192.168.1.100");
        }
    }
    
    void stop() {
        running = false;
        std::cout << "Server stopped" << std::endl;
    }
    
private:
    void handleClient(const std::string& clientIP) {
        std::cout << "Client connected from: " << clientIP << std::endl;
        std::cout << "Sending response..." << std::endl;
    }
};

int main() {
    SimpleServer server(8080);
    
    // Start server in separate thread
    std::thread serverThread([&server]() {
        server.start();
    });
    
    // Simulate running for a short time
    std::this_thread::sleep_for(std::chrono::seconds(5));
    server.stop();
    
    if (serverThread.joinable()) {
        serverThread.join();
    }
    
    return 0;
}