5 examples of creating client-server applications in C++

Creating client-server programs in C++ helps in understanding network programming and communication between applications over a network. Here are five examples that demonstrate basic client-server interactions:

Example 1: Basic TCP Echo Server

Description: A simple server that listens for connections on a TCP port and echoes back any data it receives from the client.

Server Code:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};

    // Creating socket file descriptor
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // Assigning IP and Port
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // Binding
    bind(server_fd, (struct sockaddr *)&address, sizeof(address));

    // Listening for connections
    listen(server_fd, 3);

    // Accepting a connection
    new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
    read(new_socket, buffer, 1024);
    send(new_socket, buffer, strlen(buffer), 0);
    
    close(new_socket);
    close(server_fd);
    return 0;
}

Client Code:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 8080

int main() {
    int sock = 0;
    struct sockaddr_in serv_addr;
    char *hello = "Hello from client";
    char buffer[1024] = {0};

    // Creating socket
    sock = socket(AF_INET, SOCK_STREAM, 0);

    // Setting up the struct
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT);

    // Convert IPv4 and IPv6 addresses from text to binary
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);

    // Connect to the server
    connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    // Send and then receive data
    send(sock, hello, strlen(hello), 0);
    read(sock, buffer, 1024);

    std::cout << buffer << std::endl;
    close(sock);
    return 0;
}

Example 2: UDP Communication

Description: A basic UDP server-client model where the server sends a message and the client receives it.

Server Code:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080

int main() {
    int sockfd;
    struct sockaddr_in servaddr, cliaddr;
    char buffer[1024] = "Hello UDP Client";
    socklen_t len = sizeof(cliaddr);

    // Create socket file descriptor
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    // Filling server information
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = INADDR_ANY;
    servaddr.sin_port = htons(PORT);

    // Bind the socket
    bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    // Send a message to the client
    sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr *) &cliaddr, len);

    close(sockfd);
    return 0;
}

Client Code:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 8080

int main() {
    int sockfd;
    struct sockaddr_in servaddr;
    char buffer[1024] = {0};

    // Create socket
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    // Server info
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);

    // Receive message
    socklen_t len = sizeof(servaddr);
    recvfrom(sockfd, buffer, 1024, 0, (struct sockaddr*)&servaddr, &len);

    std::cout << "Message from server: " << buffer << std::endl;

    close(sockfd);
    return 0;
}

Example 3: Multithreaded TCP Server

Description: A multithreaded TCP server that can handle multiple client connections simultaneously.

Server Code:

#include <iostream>
#include <thread>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080

void handle_client(int client_socket) {
    char buffer[1024] = {0};
    read(client_socket, buffer, 1024);
    send(client_socket, buffer, strlen(buffer), 0);
    close(client_socket);
}

int main() {
    int server_fd, client_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);

    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    bind(server_fd, (struct sockaddr *)&address, sizeof(address));
    listen(server_fd, 3);

    while ((client_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) >= 0) {
        std::thread(handle_client, client_socket).detach();
    }

    close(server_fd);
    return 0;
}

Example 4: HTTP-like Simple Web Server

Description: A simple HTTP-like web server that serves predefined messages.

Server Code:

#include <iostream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080

int main() {
    int server_fd, client_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[30000] = {0};

    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    bind(server_fd, (struct sockaddr *)&address, sizeof(address));
    listen(server_fd, 3);

    while ((client_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) >= 0) {
        read(client_socket, buffer, 30000);
        const char *response = "HTTP/1.1 200 OK\nContent-Type: text/plain\nContent-Length: 12\n\nHello world";
        send(client_socket, response, strlen(response), 0);
        close(client_socket);
    }

    return 0;
}

Example 5: File Transfer via TCP

Description: Server sends a file to the client over a TCP connection.

Server Code:

#include <iostream>
#include <fstream>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8080

bool sendFile(int socket) {
    std::ifstream file("example.txt", std::ios::binary);
    if (!file.is_open()) return false;

    // Send file data to the socket
    char buffer[1024];
    while (!file.eof()) {
        file.read(buffer, sizeof(buffer));
        send(socket, buffer, file.gcount(), 0);
    }

    file.close();
    return true;
}

int main() {
    int server_fd, client_socket;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);

    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    bind(server_fd, (struct sockaddr *)&address, sizeof(address));
    listen(server_fd, 3);

    while ((client_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) >= 0) {
        if (!sendFile(client_socket)) {
            std::cerr << "Failed to send file." << std::endl;
        }
        close(client_socket);
    }

    close(server_fd);
    return 0;
}

In each example, you may need to add appropriate error handling to check the result of socket calls and ensure resources are managed correctly. The examples demonstrate typical use cases and provide a foundation on which more complex applications can be built.