怎么打印sender_address.sin_addr.s_addr

sender_address.sin_addr.s_addr 是一个无符号整数，表示 IP 地址。如果要打印 IP 地址，可以使用 inet_ntoa 函数将无符号整数转换成字符串格式，然后使用 printf 函数输出。示例代码如下：

#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main() {
    struct sockaddr_in sender_address;
    sender_address.sin_family = AF_INET;
    sender_address.sin_addr.s_addr = inet_addr("192.168.0.1");
    printf("IP address: %s\n", inet_ntoa(sender_address.sin_addr));
    return 0;
}

输出结果为：

IP address: 192.168.0.1

相关问题

printf("-ip11111----ip=%s", inet_ntoa(sender_address.sin_addr.s_addr));

这段代码的作用是将一个IP地址转换成字符串格式，并输出到控制台上。具体来说，inet_ntoa函数将in_addr结构体中存储的二进制IP地址转换成点分十进制格式的字符串，然后通过%s格式符输出到控制台上。其中，sender_address.sin_addr.s_addr是一个32位的无符号整型数，表示发送方的IP地址。

帮我用c++写windows下基于socket通信的聊天室服务器与客户端实现的代码 完成功能： 1.用户注册功能； 2.两个用户服务器发送私密消息； 3.用户创建一个或多个聊天群组； 4.用户加入群组、在群组内发送消息、离开群组； 5.用户之间的聊天信息通过服务器端转发；

以下是一个简单的基于socket通信的聊天室服务器与客户端实现的代码，仅供参考：

服务器端代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
#include <ws2tcpip.h>

#define MAX_CLIENTS 10
#define MAX_USERNAME_LEN 20
#define MAX_MESSAGE_LEN 256

SOCKET client_sockets[MAX_CLIENTS];
char client_usernames[MAX_CLIENTS][MAX_USERNAME_LEN];
int num_clients = 0;

typedef struct {
    char name[MAX_USERNAME_LEN];
    SOCKET socket;
} client_info_t;

typedef struct {
    char name[MAX_USERNAME_LEN];
    int num_clients;
    client_info_t clients[MAX_CLIENTS];
} chatroom_t;

chatroom_t chatrooms[MAX_CLIENTS];
int num_chatrooms = 0;

void error(char *msg) {
    perror(msg);
    exit(1);
}

void add_client_to_chatroom(char *chatroom_name, client_info_t client) {
    int i;
    for (i = 0; i < num_chatrooms; i++) {
        if (strcmp(chatroom_name, chatrooms[i].name) == 0) {
            chatrooms[i].clients[chatrooms[i].num_clients++] = client;
            return;
        }
    }
    // Chatroom not found, create new chatroom
    chatroom_t new_chatroom;
    strcpy(new_chatroom.name, chatroom_name);
    new_chatroom.clients[0] = client;
    new_chatroom.num_clients = 1;
    chatrooms[num_chatrooms++] = new_chatroom;
}

void remove_client_from_chatroom(char *chatroom_name, SOCKET client_socket) {
    int i, j;
    for (i = 0; i < num_chatrooms; i++) {
        if (strcmp(chatroom_name, chatrooms[i].name) == 0) {
            for (j = 0; j < chatrooms[i].num_clients; j++) {
                if (chatrooms[i].clients[j].socket == client_socket) {
                    // Remove client from chatroom
                    chatrooms[i].num_clients--;
                    while (j < chatrooms[i].num_clients) {
                        chatrooms[i].clients[j] = chatrooms[i].clients[j+1];
                        j++;
                    }
                    return;
                }
            }
            return; // Client not found in chatroom
        }
    }
}

void broadcast_message(char *message, SOCKET sender_socket) {
    int i;
    for (i = 0; i < num_clients; i++) {
        if (client_sockets[i] != sender_socket) {
            send(client_sockets[i], message, strlen(message), 0);
        }
    }
}

void send_private_message(char *message, char *recipient) {
    int i;
    for (i = 0; i < num_clients; i++) {
        if (strcmp(recipient, client_usernames[i]) == 0) {
            send(client_sockets[i], message, strlen(message), 0);
            return;
        }
    }
}

void send_chatroom_message(char *message, char *chatroom_name, SOCKET sender_socket) {
    int i, j;
    for (i = 0; i < num_chatrooms; i++) {
        if (strcmp(chatroom_name, chatrooms[i].name) == 0) {
            for (j = 0; j < chatrooms[i].num_clients; j++) {
                if (chatrooms[i].clients[j].socket != sender_socket) {
                    send(chatrooms[i].clients[j].socket, message, strlen(message), 0);
                }
            }
            return;
        }
    }
}

void *handle_client(void *arg) {
    SOCKET client_socket = *(SOCKET *)arg;
    char username[MAX_USERNAME_LEN];

    // Receive username from client
    int n = recv(client_socket, username, MAX_USERNAME_LEN, 0);
    if (n < 0) {
        error("ERROR receiving username from client");
    }
    username[n] = '\0';
    printf("New client connected: %s\n", username);

    // Add client to list of clients
    client_sockets[num_clients] = client_socket;
    strcpy(client_usernames[num_clients], username);
    num_clients++;

    // Send welcome message to client
    char welcome_message[MAX_MESSAGE_LEN];
    sprintf(welcome_message, "Welcome to the chatroom, %s!\n", username);
    send(client_socket, welcome_message, strlen(welcome_message), 0);

    while (1) {
        // Receive message from client
        char message[MAX_MESSAGE_LEN];
        n = recv(client_socket, message, MAX_MESSAGE_LEN, 0);
        if (n < 0) {
            error("ERROR receiving message from client");
        }
        message[n] = '\0';

        // Parse message
        if (strncmp(message, "/pm", 3) == 0) {
            // Private message
            char recipient[MAX_USERNAME_LEN];
            char private_message[MAX_MESSAGE_LEN];
            sscanf(message + 4, "%s %[^\t\n]", recipient, private_message);
            char pm_message[MAX_MESSAGE_LEN];
            sprintf(pm_message, "%s (private): %s\n", username, private_message);
            send_private_message(pm_message, recipient);
        } else if (strncmp(message, "/join", 5) == 0) {
            // Join chatroom
            char chatroom_name[MAX_USERNAME_LEN];
            sscanf(message + 6, "%s", chatroom_name);
            char join_message[MAX_MESSAGE_LEN];
            sprintf(join_message, "%s joined chatroom %s\n", username, chatroom_name);
            send_chatroom_message(join_message, chatroom_name, client_socket);
            client_info_t client;
            strcpy(client.name, username);
            client.socket = client_socket;
            add_client_to_chatroom(chatroom_name, client);
        } else if (strncmp(message, "/leave", 6) == 0) {
            // Leave chatroom
            char chatroom_name[MAX_USERNAME_LEN];
            sscanf(message + 7, "%s", chatroom_name);
            char leave_message[MAX_MESSAGE_LEN];
            sprintf(leave_message, "%s left chatroom %s\n", username, chatroom_name);
            send_chatroom_message(leave_message, chatroom_name, client_socket);
            remove_client_from_chatroom(chatroom_name, client_socket);
        } else {
            // Broadcast message to all clients
            char broadcast_message[MAX_MESSAGE_LEN];
            sprintf(broadcast_message, "%s: %s", username, message);
            broadcast_message(broadcast_message, client_socket);
        }
    }
}

int main(int argc, char *argv[]) {
    WSADATA wsaData;
    int i, portno;

    if (argc < 2) {
        fprintf(stderr, "Usage: %s port\n", argv[0]);
        exit(1);
    }

    portno = atoi(argv[1]);

    // Initialize Winsock
    if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) {
        error("WSAStartup failed");
    }

    // Create socket
    SOCKET server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == INVALID_SOCKET) {
        error("ERROR creating socket");
    }

    // Bind socket to port
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(portno);
    if (bind(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) {
        error("ERROR binding socket");
    }

    // Listen for connections
    if (listen(server_socket, MAX_CLIENTS) == SOCKET_ERROR) {
        error("ERROR listening for connections");
    }

    // Accept connections
    struct sockaddr_in client_addr;
    int client_addr_len = sizeof(client_addr);
    while (1) {
        // Accept new connection
        SOCKET client_socket = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_len);
        if (client_socket == INVALID_SOCKET) {
            error("ERROR accepting connection");
        }

        // Spawn new thread to handle client connection
        HANDLE thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)handle_client, &client_socket, 0, NULL);
        if (thread == NULL) {
            error("ERROR creating thread");
        }
    }

    // Close socket
    closesocket(server_socket);

    // Cleanup Winsock
    WSACleanup();

    return 0;
}

客户端代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <winsock2.h>
#include <ws2tcpip.h>

#define MAX_USERNAME_LEN 20
#define MAX_MESSAGE_LEN 256

void error(char *msg) {
    perror(msg);
    exit(1);
}

void *receive_messages(void *arg) {
    SOCKET server_socket = *(SOCKET *)arg;

    while (1) {
        char message[MAX_MESSAGE_LEN];
        int n = recv(server_socket, message, MAX_MESSAGE_LEN, 0);
        if (n < 0) {
            error("ERROR receiving message from server");
        }
        message[n] = '\0';
        printf("%s", message);
    }
}

int main(int argc, char *argv[]) {
    WSADATA wsaData;
    int portno, n;
    char username[MAX_USERNAME_LEN], message[MAX_MESSAGE_LEN];
    struct sockaddr_in server_addr;
    SOCKET server_socket;

    if (argc < 3) {
        fprintf(stderr, "Usage: %s hostname port\n", argv[0]);
        exit(1);
    }

    portno = atoi(argv[2]);

    // Initialize Winsock
    if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0) {
        error("WSAStartup failed");
    }

    // Create socket
    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == INVALID_SOCKET) {
        error("ERROR creating socket");
    }

    // Connect to server
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(portno);
    if (inet_pton(AF_INET, argv[1], &server_addr.sin_addr) <= 0) {
        error("ERROR invalid address");
    }
    if (connect(server_socket, (struct sockaddr *)&server_addr, sizeof(server_addr)) == SOCKET_ERROR) {
        error("ERROR connecting to server");
    }

    // Receive welcome message from server
    n = recv(server_socket, message, MAX_MESSAGE_LEN, 0);
    if (n < 0) {
        error("ERROR receiving message from server");
    }
    message[n] = '\0';
    printf("%s", message);

    // Send username to server
    printf("Enter username: ");
    fgets(username, MAX_USERNAME_LEN, stdin);
    username[strcspn(username, "\n")] = '\0';
    n = send(server_socket, username, strlen(username), 0);
    if (n < 0) {
        error("ERROR sending username to server");
    }

    // Create thread to receive messages
    HANDLE thread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)receive_messages, &server_socket, 0, NULL);
    if (thread == NULL) {
        error("ERROR creating receive thread");
    }

    // Send messages
    while (1) {
        fgets(message, MAX_MESSAGE_LEN, stdin);
        message[strcspn(message, "\n")] = '\0';
        if (strcmp(message, "/quit") == 0) {
            break;
        }
        n = send(server_socket, message, strlen(message), 0);
        if (n < 0) {
            error("ERROR sending message to server");
        }
    }

    // Close socket
    closesocket(server_socket);

    // Cleanup Winsock
    WSACleanup();

    return 0;
}