What You'll Learn
- TCP socket lifecycle
- Build a simple HTTP server
- Event-driven async I/O patterns
- Networking libraries overview
C++ Networking
Networking in C++ uses the POSIX socket API — the same foundation that powers web servers, game engines, and distributed systems. This lesson covers TCP sockets, HTTP server architecture, and the event-driven model used by high-performance servers.
Socket Fundamentals
A socket is an endpoint for communication. TCP sockets provide reliable, ordered byte streams — like a phone call. UDP sockets provide fast, unreliable datagrams — like sending letters. The server creates a socket, binds to an address, listens for connections, and accepts clients.
Pro Tip: Always set SO_REUSEADDR on server sockets — without it, restarting the server fails for 60 seconds because the OS holds the port in TIME_WAIT state.
Socket Basics
TCP socket lifecycle and key options
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
// Sockets are endpoints for network communication
// This lesson explains the concepts with simulated code
// Socket API workflow:
// SERVER: socket() → bind() → listen() → accept() → recv/send → close()
// CLIENT: socket() → connect() → send/recv → close()
struct SocketAddress {
string ip;
int port;
string toString() const { return ip + ":" + to_string(port); }
};
// Simulated TCP connection
class S
...Building a Simple HTTP Server
HTTP is text-based: the client sends a request line (GET /path HTTP/1.1), the server parses it and returns a response with status code, headers, and body. A basic server is just a loop: accept connection → parse request → generate response → send → close.
Common Mistake: Assuming recv() returns a complete message. TCP is a byte stream — one send() can arrive as multiple recv() calls. Always buffer until you have a complete message (check Content-Length or delimiter).
HTTP Server
Parse requests and generate responses
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
using namespace std;
// Simulated multi-client TCP server
// Real code uses: sys/socket.h, netinet/in.h, arpa/inet.h
struct HttpRequest {
string method;
string path;
string version;
static HttpRequest parse(const string& raw) {
istringstream iss(raw);
HttpRequest req;
iss >> req.method >> req.path >> req.version;
return req;
}
};
struct HttpResponse {
int statusC
...Event-Driven Async I/O
Blocking I/O dedicates one thread per connection — fine for 100 clients, impossible for 10,000. Event-driven servers (epoll, kqueue, IOCP) use a single thread to handle thousands of connections by registering callbacks and processing events in a loop.
Event Loop
Event-driven I/O pattern with callbacks
#include <iostream>
#include <string>
#include <vector>
#include <functional>
#include <queue>
using namespace std;
// Event-driven I/O model (like Boost.Asio / libuv)
// Instead of blocking on each connection, register callbacks
struct Event {
string type;
string data;
function<void(const string&)> handler;
};
class EventLoop {
queue<Event> events;
bool running = true;
public:
void on(const string& type, const string& data,
function<void(const string&)> ha
...Quick Reference
| Concept | Description |
|---|---|
| TCP | Reliable, ordered byte stream |
| UDP | Fast, unreliable datagrams |
| epoll/kqueue | OS-level event notification |
| Boost.Asio | Portable async networking |
| gRPC | High-performance RPC framework |
Lesson Complete!
You now understand TCP sockets, HTTP server architecture, and event-driven I/O for scalable networking.
Sign up for free to track which lessons you've completed and get learning reminders.