18.1. 프로그램언어 C++에서의 소켓 프로그래밍

by

프로그램언어 C++의 소켓 생성과 바인딩

C++에서 소켓을 생성하고 바인딩하는 방법에 대해 알아보겠습니다. 소켓은 네트워크 통신을 위한 중요한 요소로, 통신을 위한 연결을 설정하고 데이터를 주고받을 수 있게 해줍니다.

먼저, 소켓을 생성하기 위해서는 socket() 함수를 사용해야 합니다. 이 함수는 소켓 디스크립터를 반환하며, 이를 통해 소켓을 식별합니다. 예를 들어, TCP 소켓을 생성하는 코드는 다음과 같습니다: 


#include <sys/socket.h>

int main() {
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == -1) {
        // 소켓 생성 실패
        return -1;
    }

    // 소켓 생성 성공
    return 0;
}

다음으로, 소켓을 특정 IP 주소와 포트에 바인딩해야 합니다. 이를 위해 bind() 함수를 사용합니다. 예를 들어, 소켓을 로컬 호스트의 8080 포트에 바인딩하는 코드는 다음과 같습니다: 


#include <sys/socket.h>
#include <netinet/in.h>

int main() {
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == -1) {
        // 소켓 생성 실패
        return -1;
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = INADDR_ANY;
    serverAddr.sin_port = htons(8080);

    if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
        // 바인딩 실패
        return -1;
    }

    // 바인딩 성공
    return 0;
}

프로그램언어 C++의 소켓과 인터넷 통신

HTML은 웹 페이지를 구성하는 언어로, C++ 프로그래밍 언어를 사용하여 소켓을 통해 인터넷 통신을 할 수 있습니다. 소켓은 네트워크 통신을 위한 인터페이스로, 클라이언트와 서버 간의 데이터 교환을 가능하게 합니다. C++에서는 소켓을 사용하여 TCP 또는 UDP 프로토콜을 통해 데이터를 주고받을 수 있습니다.

아래는 C++에서 소켓을 사용하여 간단한 클라이언트와 서버 간의 통신을 수행하는 예제 코드입니다. 


// 서버 코드
#include <iostream>
#include <winsock2.h>

int main() {
    WSADATA WSAData;
    SOCKET serverSocket;
    SOCKADDR_IN serverAddr;

    WSAStartup(MAKEWORD(2, 0), &WSAData);
    serverSocket = socket(AF_INET, SOCK_STREAM, 0);

    serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(5555);

    bind(serverSocket, (SOCKADDR*)&serverAddr, sizeof(serverAddr));
    listen(serverSocket, 0);

    SOCKET clientSocket;
    SOCKADDR_IN clientAddr;
    int clientAddrSize = sizeof(clientAddr);

    clientSocket = accept(serverSocket, (SOCKADDR*)&clientAddr, &clientAddrSize);

    char buffer[1024] = "Hello from server!";
    send(clientSocket, buffer, sizeof(buffer), 0);

    closesocket(clientSocket);
    closesocket(serverSocket);
    WSACleanup();

    return 0;
}


// 클라이언트 코드
#include <iostream>
#include <winsock2.h>

int main() {
    WSADATA WSAData;
    SOCKET clientSocket;
    SOCKADDR_IN clientAddr;

    WSAStartup(MAKEWORD(2, 0), &WSAData);
    clientSocket = socket(AF_INET, SOCK_STREAM, 0);

    clientAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    clientAddr.sin_family = AF_INET;
    clientAddr.sin_port = htons(5555);

    connect(clientSocket, (SOCKADDR*)&clientAddr, sizeof(clientAddr));

    char buffer[1024];
    recv(clientSocket, buffer, sizeof(buffer), 0);
    std::cout << "Message from server: " << buffer << std::endl;

    closesocket(clientSocket);
    WSACleanup();

    return 0;
}

프로그램언어 C++에서의 소켓 상태 관리

소켓 상태 관리는 네트워크 프로그래밍에서 중요한 부분입니다. C++에서 소켓을 사용할 때, 소켓의 상태를 적절히 관리해야 합니다. 소켓의 상태는 주로 연결 상태, 수신 대기 상태, 송신 대기 상태 등으로 나뉩니다.

소켓의 상태를 관리하기 위해서는 소켓의 상태를 확인하고 필요에 따라 적절한 조치를 취해야 합니다. 소켓의 상태를 확인하기 위해서는 주로 소켓의 상태를 나타내는 변수나 상수를 사용하며, 이를 통해 소켓이 현재 어떤 상태에 있는지 확인할 수 있습니다.

예를 들어, 소켓이 연결 상태인지 확인하기 위해서는 connect 함수의 반환 값을 확인하거나 getsockopt 함수를 사용하여 소켓 옵션을 확인할 수 있습니다. 송신 대기 상태인지 확인하기 위해서는 select 함수를 사용하여 소켓의 상태를 확인하고, 필요에 따라 송신 작업을 수행할 수 있습니다.

다음은 C++에서 소켓 상태를 관리하는 간단한 예제 코드입니다. 이 예제 코드는 소켓이 연결 상태인지 확인하는 부분을 보여줍니다.


#include <iostream>
#include <sys/socket.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        std::cout << "Error creating socket" << std::endl;
        return -1;
    }

    // 연결 상태 확인
    int result = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if (result < 0) {
        std::cout << "Error connecting to server" << std::endl;
        close(sockfd);
        return -1;
    }

    std::cout << "Socket connected successfully" << std::endl;

    close(sockfd);
    return 0;
}

프로그램언어 C++에서의 비동기 소켓 프로그래밍

비동기 소켓 프로그래밍은 C++에서 네트워크 통신을 처리하는 방법 중 하나입니다. 이 기술은 소켓 통신을 효율적으로 처리하고, 다중 클라이언트 연결을 관리할 수 있도록 도와줍니다.

비동기 소켓 프로그래밍을 위해서는 주로 비동기 I/O와 이벤트 기반 프로그래밍을 사용합니다. 이를 통해 여러 작업을 동시에 처리하고, 블로킹되지 않고 다른 작업을 수행할 수 있습니다.

예를 들어, 비동기 소켓을 사용하여 클라이언트와 서버 간의 통신을 구현할 수 있습니다. 클라이언트는 요청을 보내고, 서버는 요청을 받아 처리한 후 응답을 보내는 방식으로 동작합니다.

아래는 C++에서 비동기 소켓 프로그래밍을 구현한 간단한 예제 코드입니다.


#include 
#include 

using namespace boost::asio;

void handleRead(const boost::system::error_code& error, std::size_t bytes_transferred) {
    if (!error) {
        std::cout << "Received data: " << bytes_transferred << " bytes" << std::endl;
    } else {
        std::cerr << "Error: " << error.message() << std::endl;
    }
}

int main() {
    io_service io;
    ip::tcp::socket socket(io);
    ip::tcp::endpoint endpoint(ip::address::from_string("127.0.0.1"), 8080);

    socket.async_connect(endpoint, [](const boost::system::error_code& error) {
        if (!error) {
            std::cout << "Connected to server" << std::endl;
            socket.async_read_some(buffer(data, max_length), handleRead);
        } else {
            std::cerr << "Connection error: " << error.message() << std::endl;
        }
    });

    io.run();

    return 0;
}

프로그램언어 C++의 소켓 프로그래밍 기술 활용

프로그램언어 C++의 소켓 프로그래밍은 네트워크 통신을 위한 강력한 도구로 사용됩니다. 소켓은 통신을 위한 엔드포인트를 나타내는 추상화된 개념으로, 클라이언트와 서버 간의 데이터 교환을 가능하게 합니다.

C++에서 소켓 프로그래밍을 위해 주로 사용되는 라이브러리는 Winsock과 Boost.Asio가 있습니다. 이러한 라이브러리를 활용하여 네트워크 통신을 구현할 수 있습니다.

아래는 간단한 C++ 소켓 프로그래밍 예제 코드입니다. 이 예제는 서버와 클라이언트 간의 간단한 텍스트 통신을 보여줍니다.


#include <iostream>
#include <string>
#include <WS2tcpip.h>
#include <winsock2.h>

#pragma comment(lib, "ws2_32.lib")

int main() {
    // Initialize Winsock
    WSADATA wsData;
    WORD ver = MAKEWORD(2, 2);
    int wsOK = WSAStartup(ver, &wsData);
    if (wsOK != 0) {
        std::cerr << "Can't initialize Winsock! Quitting" << std::endl;
        return -1;
    }

    // Create a socket
    SOCKET listening = socket(AF_INET, SOCK_STREAM, 0);
    if (listening == INVALID_SOCKET) {
        std::cerr << "Can't create a socket! Quitting" << std::endl;
        return -1;
    }

    // Bind the socket to an IP address and port
    sockaddr_in hint;
    hint.sin_family = AF_INET;
    hint.sin_port = htons(54000);
    hint.sin_addr.S_un.S_addr = INADDR_ANY;

    bind(listening, (sockaddr*)&hint, sizeof(hint));

    // Tell Winsock the socket is for listening
    listen(listening, SOMAXCONN);

    // Wait for a connection
    sockaddr_in client;
    int clientSize = sizeof(client);

    SOCKET clientSocket = accept(listening, (sockaddr*)&client, &clientSize);

    char host[NI_MAXHOST];      // Client's remote name
    char service[NI_MAXSERV];   // Service (i.e. port) the client is connected on

    ZeroMemory(host, NI_MAXHOST); // same as memset(host, 0, NI_MAXHOST);
    ZeroMemory(service, NI_MAXSERV);

    if (getnameinfo((sockaddr*)&client, sizeof(client), host, NI_MAXHOST, service, NI_MAXSERV, 0) == 0) {
        std::cout << host << " connected on port " << service << std::endl;
    }
    else {
        inet_ntop(AF_INET, &client.sin_addr, host, NI_MAXHOST);
        std::cout << host << " connected on port " << ntohs(client.sin_port) << std::endl;
    }

    // Close listening socket
    closesocket(listening);

    // While loop: accept and echo message back to client
    char buf[4096];
    while (true) {
        ZeroMemory(buf, 4096);

        // Wait for client to send data
        int bytesReceived = recv(clientSocket, buf, 4096, 0);
        if (bytesReceived == SOCKET_ERROR) {
            std::cerr << "Error in recv(). Quitting" << std::endl;
            break;
        }

        if (bytesReceived == 0) {
            std::cout << "Client disconnected" << std::endl;
            break;
        }

        // Echo message back to client
        send(clientSocket, buf, bytesReceived + 1, 0);
    }

    // Close the socket
    closesocket(clientSocket);

    // Cleanup Winsock
    WSACleanup();

    return 0;
}

Leave a Comment