The Ultimate C++ Web Development Cheatsheet

// ── CMakeLists.txt ──
// find_package(Boost REQUIRED COMPONENTS system beast)
// target_link_libraries(server Boost::system Boost::beast)

#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
#include <boost/asio/await.hpp>
#include <boost/asio/ip/tcp.hpp>

namespace beast = boost::beast;
namespace http = beast::http;
namespace net = boost::asio;
using tcp = net::ip::tcp;

// ── Simple HTTP Server (C++20 coroutine) ──
net::awaitable
do_session(tcp::socket socket) {
    beast::flat_buffer buffer;
    beast::tcp_stream stream{std::move(socket)};

    http::request<http::string_body> req;
    http::read(stream, buffer, req);

    http::response<http::string_body> res{http::status::ok, req.version()};
    res.set(http::field::server, "Boost.Beast");
    res.set(http::field::content_type, "text/plain");
    res.body() = "Hello from C++ HTTP Server!";
    res.prepare_payload();
    res.keep_alive(req.keep_alive());
    http::write(stream, res);

    // Read body
    std::string body = req.body();
}

net::awaitable
do_listen(tcp::endpoint endpoint) {
    auto acceptor = tcp::acceptor{endpoint};
    for (;;) {
        auto socket = co_await acceptor.async_accept();
        if (!socket) break;
        net::co_spawn(do_session(std::move(*socket)));
    }
}

int main() {
    auto address = tcp::endpoint{tcp::v4(), 8080};
    net::co_spawn(do_listen(address));
    net::io_context ioc{1};
    ioc.run();
}

// ── Function Template ──
template <typename T>
T max_val(T a, T b) {
    return (a > b) ? a : b;
}

// ── Template Specialization ──
template <>
const char* max_val(const char* a, const char* b) {
    return (strcmp(a, b) > 0) ? a : b;
}

// ── Variadic Templates ──
template <typename... Args>
void print_all(Args&&... args) {
    (std::cout << ... << std::endl);
}
// Usage: print_all(1, "hello", 3.14);

// ── Concept (C++20) ──
template <typename T>
concept Numeric = std::integral<T>;

template <Numeric T>
T multiply(T a, T b) { return a * b; }

// ── STL Containers ──
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <stack>
#include <queue>

std::vector<int> vec = {1, 2, 3, 4, 5};
std::map<std::string, int> m = {{"a", 1}, {"b", 2}};
std::unordered_map<std::string, int> um; // O(1) lookup
std::set<int> s = {3, 1, 4, 1, 5};      // sorted, unique
std::deque<int> dq;
std::stack<int> stk;
std::queue<int> q;

// ── STL Algorithms ──
#include <algorithm>
#include <numeric>
#include <iterator>

std::sort(vec.begin(), vec.end());
std::find(vec.begin(), vec.end(), 3);
std::count(vec.begin(), vec.end(), 2);
std::transform(vec.begin(), vec.end(), vec.begin(),
    [](int x) { return x * 2; });
auto sum = std::accumulate(vec.begin(), vec.end(), 0);
std::remove_if(vec.begin(), vec.end(),
    [](int x) { return x < 0; });

// ── Smart Pointers ──
#include <memory>

std::unique_ptr<User> user = std::make_unique<User>("Alice", 30);
auto& name = user->name;    // access member

std::shared_ptr<int> sp1 = std::make_shared<int>(42);
auto sp2 = sp1;              // reference count = 2

std::weak_ptr<int> wp = sp1;  // no increment

// ── RAII (Resource Acquisition Is Initialization) ──
class FileHandle {
    FILE* fp;
public:
    FileHandle(const char* path, const char* mode)
        : fp(fopen(path, mode)) {
        if (!fp) throw std::runtime_error("Cannot open file");
    }
    ~FileHandle() { if (fp) fclose(fp); }
    FileHandle(const FileHandle&) = delete;  // non-copyable
    FileHandle& operator=(const FileHandle&) = delete;
    FileHandle(FileHandle&& other) noexcept : fp(other.fp) {
        other.fp = nullptr;  // take ownership
    }
};

// ── Threading ──
#include <thread>
#include <mutex>
#include <shared_mutex>
#include <future>
#include <atomic>

std::mutex mtx;
std::lock_guard<std::mutex> lock(mtx);  // RAII lock

std::shared_mutex rw_mtx;
std::unique_lock<std::shared_mutex> rlock(rw_mtx);  // read lock
std::unique_lock<std::shared_mutex> wlock(rw_mtx);  // write lock

// Atomic operations (lock-free)
std::atomic<int> counter{0};
counter.fetch_add(1, std::memory_order_relaxed);
counter.load(std::memory_order_acquire);

// ── Thread + Future ──
std::future<int> f = std::async(std::launch::async, [] {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
});
int result = f.get();  // blocks until ready

// ── ThreadPool ──
#include <boost/asio/thread_pool.hpp>
boost::asio::thread_pool pool(4);
auto task = pool.submit([] { /* work */ });
auto result = task.get();