C语言网络编程实战:用socket()函数手把手搭建你的第一个TCP服务器(附完整代码)

【socket】C语言的Socket网络编程 目录 Socket网络编程 1、网络知识 网络中进程之间如何通信? 什么是Socket? socket一词的起源 怎么理解端口? 怎么理解socket ? 2. 客户/服务器模式 2.1 服务器端: 2.2 客户端: 4. 套接字函数 4.1 创建套接字──sock... 阅读详情

从零构建:用C语言打造一个健壮的TCP回显服务器

最近在辅导几位刚接触系统编程的朋友时,我发现一个有趣的现象:很多人在学习网络编程时,会陷入两个极端。要么被各种抽象的概念和函数原型吓退,觉得这是“底层魔法”;要么就是照着教程敲完代码,看到终端里蹦出“Hello World”就以为大功告成,却对背后发生了什么一无所知。实际上,用C语言写一个网络服务器,就像是亲手搭建一座桥梁——你需要理解每一块砖(系统调用)的作用,知道如何将它们稳固地组合在一起,还要预见到风雨(网络异常)可能带来的影响。

这篇文章就是为你准备的,如果你已经掌握了C语言的基础语法,对指针和内存管理有初步了解,并且对“程序如何通过网络对话”感到好奇,那么接下来的内容将带你走完从概念到成品的完整路径。我们不会止步于一个只能运行一次的玩具程序,而是要构建一个能够处理多个客户端、优雅应对各种边界情况的TCP回显服务器。所谓回显,就是服务器将客户端发送来的任何数据,原封不动地发回去。这个简单的功能,是理解网络通信基石的最佳练手项目。

1. 理解基石:Socket到底是什么?

在开始敲代码之前,我们得先统一“语言”。当你听到“Socket”(套接字)时,脑海里浮现的是什么?一个网络端口?还是一种编程接口?其实,你可以把它想象成进程间通信(IPC)的一个特殊“文件描述符”。是的,在Unix/Linux哲学里,“一切皆文件”,网络连接也不例外。

一个Socket由三个核心属性唯一确定,这构成了所谓的“协议三元组”:

  • 地址族(Address Family):决定了使用哪种寻址方案。对于互联网通信,我们最常用的是 AF_INET(IPv4)和 AF_INET6(IPv6)。
  • 套接字类型(Socket Type):定义了数据传输的风格。SOCK_STREAM 提供面向连接的、可靠的字节流服务(这就是TCP);而 SOCK_DGRAM 提供无连接的、可能丢包乱序的数据报服务(这就是UDP)。
  • 协议(Protocol):通常指定为0,系统会根据前两个参数自动选择最合适的协议(如TCP或UDP)。

为什么理解这个很重要?因为后续所有函数调用都建立在这个抽象模型之上。当你调用 socket() 函数时,你就是在向操作系统申请一个符合这个三元组的通信端点。成功之后,你拿到的是一个整型的文件描述符,后续的绑定地址、监听连接、收发数据,都是通过操作这个描述符来完成的。

提示:SOCK_STREAM 和 TCP 的关系常常让人困惑。你可以这样记:SOCK_STREAM 是一种接口类型,要求提供流式服务;而TCP是一种具体的网络协议,它实现了这种服务。在绝大多数情况下,指定 SOCK_STREAM 就会默认使用TCP协议。

2. 搭建框架:核心四步曲与完整代码骨架

一个TCP服务器的生命周期,可以清晰地划分为四个阶段,我称之为“核心四步曲”:创建、绑定、监听、接受。让我们先跳过繁琐的细节,看一眼最终成型的服务器代码骨架,建立一个全局观。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>

#define PORT 8080
#define BACKLOG 5
#define BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_addr_len = sizeof(client_addr);
    char buffer[BUFFER_SIZE] = {0};

    // 1. 创建套接字 (Create)
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 2. 绑定地址 (Bind)
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY; // 绑定到本机所有IP
    server_addr.sin_port = htons(PORT);

    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 3. 开始监听 (Listen)
    if (listen(server_fd, BACKLOG) < 0) {
        perror("listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }
    printf("Server listening on port %d\n", PORT);

    // 主循环:4. 接受并处理连接 (Accept & Handle)
    while (1) {
        if ((new_socket = accept(server_fd, (struct sockaddr*)&client_addr, &client_addr_len)) < 0) {
            perror("accept failed");
            continue; // 接受失败,继续等待下一个连接
        }
        printf("New connection from %s:%d\n",
               inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

        // 处理连接(例如:回显数据)
        handle_connection(new_socket);

        close(new_socket); // 处理完毕,关闭连接套接字
    }

    close(server_fd); // 通常不会执行到这里
    return 0;
}

代码清单1:TCP服务器的基础骨架

这个骨架揭示了服务器最核心的流程。server_fd 是监听套接字,它的使命就是守在门口(某个IP和端口),迎接新的客人(连接请求)。而 new_socket 是已连接套接字,每当 accept() 成功,系统就会创建一个全新的它,专门用于和对应的客户端进行一对一的数据收发。理解“监听”和“已连接”套接字的分离,是掌握TCP服务器模型的关键。

2.1 深入第一步:socket()函数与错误处理

创建套接字看似简单,但这里藏着第一个实践要点:立即检查返回值并处理错误。网络编程中,任何系统调用都可能失败,原因可能是资源耗尽、权限不足或参数错误。

int server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == -1) {
    // perror()会自动在错误信息前加上你提供的字符串,并解释errno
    perror("[-] socket() error");
    // 更灵活的做法是使用strerror,可以组合自定义日志
    // fprintf(stderr, "socket failed: %s\n", strerror(errno));
    exit(EXIT_FAILURE); // 创建失败,程序无法继续
}

代码清单2:创建套接字与基础错误处理

常见的错误 errno 有:

  • EACCES:没有权限创建指定类型的套接字。
  • EAFNOSUPPORT:不支持指定的地址族。
  • EMFILE / ENFILE:进程或系统打开的文件描述符达到上限。
  • ENOMEM / ENOBUFS:内存不足。

在生产环境中,你可能会选择记录日志后优雅降级或重启,但作为学习,直接退出并打印错误信息是最直观的。

2.2 关键第二步:bind()与网络字节序的“坑”

bind() 调用是将套接字与一个本地网络地址(IP + 端口)关联起来。这里我们遇到了网络编程的第一个“坑”:字节序。

计算机CPU存储数据有大端序和小端序之分,而网络传输为了统一,规定使用大端序(网络字节序)。我们的主机可能是小端序(如x86架构),因此,在将IP地址和端口号放入 sockaddr_in 结构体之前,必须进行转换。

#include <arpa/inet.h> // 包含字节序转换函数

struct sockaddr_in server_addr;
memset(&server_addr, 0, sizeof(server_addr)); // 清空结构体,避免脏数据
server_addr.sin_family = AF_INET; // 使用IPv4

// 将主机short型端口号(如8080)转换为网络字节序
server_addr.sin_port = htons(PORT);

// 设置IP地址。INADDR_ANY是一个特殊值(0),表示绑定到本机所有网络接口
server_addr.sin_addr.s_addr = INADDR_ANY;
// 如果你想绑定到特定IP,可以这样:
// inet_pton(AF_INET, "192.168.1.100", &server_addr.sin_addr);

if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
    perror("[-] bind() error");
    close(server_fd); // 注意:绑定失败,需要关闭之前创建的套接字!
    exit(EXIT_FAILURE);
}

代码清单3:地址绑定与字节序转换

几个关键函数:

  • htons(): Host TO Network Short, 转换端口。
  • htonl(): Host TO Network Long, 转换IP地址(但通常用 inet_pton 更方便)。
  • inet_pton(): 将点分十进制的IP字符串(如“127.0.0.1”)转换为网络字节序的二进制形式。

注意:INADDR_ANY 是一个非常实用的常量。它让你的服务器监听所有可用的网络接口(网卡),无论是本地回环(127.0.0.1)还是真实网卡IP(如192.168.x.x)。这在开发阶段特别方便。

2.3 第三步:listen()与连接队列

调用 listen() 后,套接字才正式进入被动等待连接的状态。它的第二个参数 backlog 经常被误解。它不是指服务器能维持的最大连接数,而是指已完成三次握手、等待应用层调用 accept() 取走的连接队列的最大长度。

队列状态描述对应TCP状态
未完成连接队列 (SYN队列)客户端SYN已到达,服务器回复SYN+ACK,等待客户端ACK。SYN_RCVD
已完成连接队列 (Accept队列)三次握手已完成,连接已建立,等待accept()取出。ESTABLISHED

backlog 参数历史上影响这两个队列的总和,在现代Linux系统中,其行为可通过 net.core.somaxconn 等内核参数精细调整。对于一个学习型服务器,设置为5-10就足够了。如果队列已满,新的连接请求会被忽略,客户端会收到“连接被拒绝”的错误。

2.4 第四步:accept()循环与并发雏形

accept() 是一个阻塞式调用。如果没有客户端连接,程序会停在这里等待。一旦有连接进入已完成队列,accept() 就会返回一个新的套接字描述符(new_socket)。

骨架代码中的 while(1) 循环,构成了一个迭代服务器模型:一次只处理一个客户端,处理完后才能接待下一个。这显然不适合现实世界。我们稍后会改进它。accept() 的第二个参数可以用来获取客户端的地址信息,这对于日志记录或访问控制非常有用。

3. 实现核心逻辑:健壮的数据收发与连接处理

现在,我们来填充骨架中的 handle_connection 函数,实现回显功能。这里面的门道,比想象中要多。

3.1 send()和recv()的真相:它们可能只完成部分工作

这是网络编程新手最容易栽跟头的地方。recv() 和 send() 的返回值 n,表示的是本次系统调用实际接收或发送的字节数,而不是你请求的长度。

void handle_connection(int conn_socket) {
    char buffer[BUFFER_SIZE];
    ssize_t bytes_received;
    ssize_t bytes_sent;
    size_t total_sent;

    while (1) {
        // 接收数据
        bytes_received = recv(conn_socket, buffer, BUFFER_SIZE - 1, 0);
        if (bytes_received <= 0) {
            // 返回值0表示对方已关闭连接(收到FIN)
            // 返回值-1表示出错
            if (bytes_received == 0) {
                printf("Client closed the connection.\n");
            } else {
                perror("recv error");
            }
            break; // 退出循环,结束对此连接的处理
        }
        buffer[bytes_received] = '\0'; // 确保字符串终止,便于打印
        printf("Received: %s\n", buffer);

        // 发送数据(回显) - 必须处理“部分发送”的情况
        total_sent = 0;
        while (total_sent < bytes_received) {
            bytes_sent = send(conn_socket, buffer + total_sent, bytes_received - total_sent, 0);
            if (bytes_sent <= 0) {
                perror("send error");
                break; // 发送失败,结束
            }
            total_sent += bytes_sent;
        }
        printf("Echoed back %zd bytes.\n", total_sent);
    }
}

代码清单4:一个能处理部分发送/接收的回显处理函数

为什么需要循环发送?因为 send() 只是将数据从用户缓冲区拷贝到内核的发送缓冲区。如果内核缓冲区满了(比如网络拥塞),send() 可能只拷贝了一部分数据就返回。我们的循环确保了所有数据都被尝试送入内核缓冲区。

3.2 处理粘包与拆包

对于TCP这种流式协议,它只保证字节流的顺序和可靠性,不维护消息边界。这意味着,如果你连续发送“Hello”和“World”,对方可能一次 recv() 就收到“HelloWorld”(粘包),也可能分两次收到“Hel”、“loWorld”(拆包)。这是应用层协议需要自己解决的问题。

对于我们的回显服务器,由于我们原样发回,边界问题不明显。但如果你要设计一个传输“消息”的协议,通常有几种方法:

  1. 定长消息:每条消息固定长度,不足则填充。
  2. 分隔符:用特殊字符(如换行符\n)标记消息结束。我们的例子可以改进为基于行的回显。
  3. 长度前缀:在消息头部添加一个固定长度的字段,指明后面消息体的长度。

例如,实现一个基于换行符的回显:

// 这是一个简化的示例,假设一行不会超过缓冲区
bytes_received = recv(conn_socket, buffer, BUFFER_SIZE - 1, 0);
if (bytes_received > 0) {
    char *line = strtok(buffer, "\n");
    while (line != NULL) {
        printf("Echo line: %s\n", line);
        // 发送时加上换行符
        send(conn_socket, line, strlen(line), 0);
        send(conn_socket, "\n", 1, 0);
        line = strtok(NULL, "\n");
    }
}

代码清单5:简单的按行处理示例

4. 从迭代到并发:支持多个客户端的服务器模型

我们的骨架代码是迭代式的,体验很差。现实中,服务器必须能同时服务多个客户端。主要有三种经典模型:

4.1 多进程模型

这是最传统的并发模型。主进程负责 accept(),每当有新连接,就 fork() 出一个子进程来处理。子进程继承父进程的文件描述符,处理完毕后退出。

优点:编程模型简单,进程间隔离性好,一个客户端崩溃不影响服务器主进程和其他客户端。 缺点:创建进程开销大,系统能支持的进程数有限,进程间通信(如果需要)较复杂。

// 在主循环accept之后
pid_t pid = fork();
if (pid == 0) {
    // 子进程
    close(server_fd); // 子进程不需要监听套接字
    handle_connection(new_socket);
    close(new_socket);
    exit(0); // 处理完毕,子进程退出
} else if (pid > 0) {
    // 父进程
    close(new_socket); // 父进程不需要已连接套接字
    // 注意:需要回收子进程资源(waitpid),避免僵尸进程
} else {
    perror("fork failed");
    close(new_socket);
}

代码清单6:多进程模型的代码片段

4.2 多线程模型

与多进程类似,但使用 pthread_create 创建线程。线程共享进程的地址空间和文件描述符表。

优点:创建和切换开销比进程小,共享数据方便。 缺点:需要处理线程同步(锁)问题,一个线程崩溃可能导致整个进程崩溃,调试复杂。

#include <pthread.h>

void* connection_handler(void* socket_desc) {
    int sock = *(int*)socket_desc;
    free(socket_desc); // 释放主线程分配的内存
    handle_connection(sock);
    close(sock);
    return NULL;
}

// 在主循环accept之后
int *new_sock_ptr = malloc(sizeof(int));
*new_sock_ptr = new_socket;
pthread_t thread;
if (pthread_create(&thread, NULL, connection_handler, (void*)new_sock_ptr) != 0) {
    perror("could not create thread");
    free(new_sock_ptr);
    close(new_socket);
}
// 可以将thread id存入列表管理,或使用分离线程(pthread_detach)
pthread_detach(thread); // 使线程结束后自动释放资源

代码清单7:多线程模型的代码片段

4.3 I/O多路复用模型(select/poll/epoll)

这是目前高性能网络服务器的主流选择。核心思想是一个线程管理多个文件描述符,通过系统调用监控这些描述符的状态(是否可读、可写、出错),当有事件发生时再进行处理。

技术描述优点缺点
select最古老的I/O多路复用API。跨平台支持好。文件描述符数量有限(FD_SETSIZE),每次调用需重置和遍历整个集合,效率低。
poll改进的select,使用链表存储描述符。无最大描述符限制。和select一样,需要遍历所有描述符来查找就绪者,当连接数多时效率线性下降。
epoll (Linux特有)事件驱动,内核维护一个就绪列表。仅返回就绪的描述符,效率与连接数无关,性能极高。仅限Linux系统。

这里给出一个使用 select 的简单示例,它让我们的服务器可以同时处理多个客户端连接和新的连接请求:

fd_set readfds, masterfds;
int max_fd;
int client_sockets[FD_SETSIZE]; // 简易的客户端数组
memset(client_sockets, 0, sizeof(client_sockets));

FD_ZERO(&masterfds);
FD_SET(server_fd, &masterfds);
max_fd = server_fd;

while (1) {
    readfds = masterfds; // select会修改传入的集合,所以每次要用副本
    if (select(max_fd + 1, &readfds, NULL, NULL, NULL) == -1) {
        perror("select error");
        exit(EXIT_FAILURE);
    }

    // 检查所有文件描述符
    for (int i = 0; i <= max_fd; i++) {
        if (FD_ISSET(i, &readfds)) {
            if (i == server_fd) {
                // 有新连接
                socklen_t addr_len = sizeof(client_addr);
                new_socket = accept(server_fd, (struct sockaddr*)&client_addr, &addr_len);
                if (new_socket < 0) { perror("accept"); continue; }

                // 将新套接字加入主集合
                FD_SET(new_socket, &masterfds);
                if (new_socket > max_fd) max_fd = new_socket;
                printf("New client connected (socket %d).\n", new_socket);
            } else {
                // 某个客户端有数据可读
                int bytes_read = recv(i, buffer, BUFFER_SIZE, 0);
                if (bytes_read <= 0) {
                    // 连接关闭或出错
                    if (bytes_read == 0) printf("Client (socket %d) disconnected.\n", i);
                    else perror("recv error");
                    close(i);
                    FD_CLR(i, &masterfds); // 从集合中移除
                } else {
                    // 处理数据并回显
                    buffer[bytes_read] = '\0';
                    send(i, buffer, bytes_read, 0); // 简单回显,未处理部分发送
                }
            }
        }
    }
}

代码清单8:使用select实现I/O多路复用的服务器主循环

这个模型避免了进程/线程的庞大开销,用一个线程就能处理成百上千的连接,是构建高性能服务器的基石。当然,对于真正的生产环境,epoll 是Linux下的不二之选,而跨平台项目可能会使用 libevent 或 libuv 这样的高级网络库来封装底层差异。

5. 打磨细节:让服务器更健壮、更可用

一个能跑起来的服务器和一个能用的服务器之间,隔着无数细节。让我们关注几个关键点。

5.1 地址复用(SO_REUSEADDR)与优雅重启

你有没有遇到过这种情况:服务器崩溃或关闭后立即重启,bind() 调用失败,提示“Address already in use”?这是因为之前的连接处于 TIME_WAIT 状态(TCP正常关闭后的一个等待期,通常为2MSL),内核还没有完全释放该端口。

解决方案是在 bind() 之前设置套接字选项 SO_REUSEADDR。

int opt = 1;
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
    perror("setsockopt SO_REUSEADDR failed");
    close(server_fd);
    exit(EXIT_FAILURE);
}
// 然后再调用 bind()

代码清单9:设置地址重用选项

这个选项允许新的套接字绑定到仍处于 TIME_WAIT 状态的地址上,对于开发调试和服务器热重启至关重要。

5.2 超时控制

网络环境不稳定,一个 recv() 可能永远阻塞下去。为套接字设置超时是必要的。

#include <sys/time.h>

struct timeval tv;
tv.tv_sec = 5;  // 5秒超时
tv.tv_usec = 0;

if (setsockopt(conn_socket, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv)) < 0) {
    perror("setsockopt SO_RCVTIMEO failed");
}
// 同样可以设置 SO_SNDTIMEO 用于发送超时

代码清单10:设置接收超时

5.3 系统资源限制与守护进程化

一个长期运行的服务器还需要考虑:

  • 文件描述符限制:使用 ulimit -n 查看和修改。服务器程序可能需要自己调用 setrlimit 来提高限制。
  • 变成守护进程:脱离终端在后台运行。这涉及 fork()、setsid()、关闭标准输入输出、改变工作目录等一系列操作。
  • 信号处理:处理 SIGTERM、SIGINT 等信号,实现优雅关闭(关闭监听套接字,等待现有连接处理完毕再退出)。

例如,一个简单的信号处理,让服务器可以通过Ctrl+C优雅退出:

#include <signal.h>

volatile sig_atomic_t keep_running = 1;

void handle_signal(int sig) {
    keep_running = 0;
    printf("\nSignal received, shutting down...\n");
}

int main() {
    signal(SIGINT, handle_signal);
    signal(SIGTERM, handle_signal);

    // ... 服务器初始化代码 ...

    while (keep_running) {
        // ... 主循环代码,将之前的 while(1) 改为检查 keep_running ...
        // 在select/poll/epoll中,可能需要使用带超时的版本,以便定期检查标志
    }

    // 清理资源,关闭所有套接字
    printf("Server shutdown complete.\n");
    return 0;
}

代码清单11:简单的信号处理实现优雅关闭

把这些碎片拼凑起来,你得到的就不再是一个简单的示例,而是一个具备了基本工业强度的网络程序原型。我建议你从迭代服务器开始,亲手敲一遍每一行代码,理解每个函数调用和错误检查的意义。然后,尝试将它改造成多进程或多线程版本,感受并发编程的挑战。最后,挑战一下 select 或 poll 模型,体会单线程处理高并发的设计美学。这个过程里遇到的每一个错误和调试的夜晚,都会让你对网络编程的理解加深一分。网络编程的魅力,就在于这种与操作系统和网络协议栈直接对话的掌控感,以及用简洁代码驾驭复杂网络世界的成就感。

C语言网络编程实战:用socket()和bind()快速搭建本地TCP服务器(附完整代码) 本文通过实战案例,详细讲解了如何使用C语言进行网络编程,从零开始搭建一个本地TCP服务器。文章核心围绕socket()和bind()函数展开,涵盖了套接字创建、地址绑定、端口监听以及实现一个简易回声服务的完整流程,并提供了可直接编译运行的完整代码示例,帮助开发者深入理解TCP协议与底层网络通信机制。 阅读详情

相关推荐

C语言实现TCP服务器:从创建Socket到多线程通信(附代码解析)

本文详细解析了一个用C语言编写的TCP服务器创建函数create_tcp_server(),该函数实现了TCP服务器的主要功能:创建套接字、设置地址复用选项、绑定8080端口、监听客户端连接,并创建线程处理通信。文章从源码出发,逐步解析socket创建、选项设置、绑定监听等核心步骤,并总结网络字节序转换、多线程编程等关键技术点。该函数适用于嵌入式设备通信、物联网应用和网络编程学习场景,是理解TCP服务器实现的经典案例。

2302_81526349的博客 1200

C语言网络编程:TCP、UDP、HTTP深度解析

本文深入解析C语言网络编程中的TCP、UDP和HTTP协议,提供详细的代码实现和避坑指南。主要内容包括:1) TCP网络编程基础,涵盖可靠传输、面向连接等核心特点,提供服务器/客户端完整代码示例;2) UDP网络编程基础,分析其不可靠传输、无连接等特性,给出UDP服务器实现代码;3) HTTP协议基础。文章强调网络编程作为C语言开发的重要技能,适合开发Web应用、网络游戏和物联网设备,并提供了实际开发中的常见问题解决方案。

编程世界如山海,探索不止。 1万+

C语言的网络编程

随着互联网的快速发展,网络编程已经成为计算机科学与技术领域中不可或缺的一部分。C语言作为一种底层语言,以其高效、快速和灵活的特性,广泛应用于网络编程中。本文将深入探讨C语言在网络编程中的应用,包括基本的网络编程原理、Socket编程、TCP和UDP协议的应用以及相关的编程示例。

2401_90032377的博客 920

C语言网络编程基础:Socket与TCP/UDP通信实战

本文介绍了C语言网络编程的基础知识,重点讲解了Socket编程的核心概念和API。主要内容包括:1)网络通信的基本要素IP地址和端口的作用;2)TCP与UDP协议的核心差异及适用场景;3)Socket作为网络编程接口的定义和类型;4)字节序转换的必要性和相关API。文章还详细解析了创建套接字的socket函数及其参数说明,为后续实现TCP/UDP通信打下基础。这些知识是开发客户端/服务器应用、物联网设备通信等网络程序的重要基础。

今天比昨天更努力一点! 9599

基于TCP/UDP的socket服务器搭建流程

socket网络编程初探

lixiaotouDku的博客 2841

【C语言实战(54)】C语言网络编程进阶:TCP服务器实战攻略

本文是 C 语言实战网络编程系列的第 54 篇,聚焦 TCP 服务器搭建。先详细讲解 TCP 服务器实现的四大核心步骤,包括用 socket () 创建套接字、bind () 绑定地址、listen () 监听连接、accept () 接受连接;再介绍数据交互实战操作,如 recv () 接收数据、send () 发送反馈及简易多客户端处理;最后提供完整服务器代码,说明测试方法,并给出绑定失败、接收超时等错误的处理方案,助力读者实操掌握 TCP 服务器开发。

邓邓子的博客 1190

C语言网络编程:Socket通信与高并发服务器实战

本文介绍了网络编程的核心概念与实战技巧,重点讲解了Socket通信和高并发服务器的实现方法。主要内容包括:1)网络编程基础概念如IP地址、端口、TCP/UDP协议的区别;2)Socket编程的核心函数和使用流程;3)TCP Socket编程的具体实现步骤,包括服务器端和客户端的开发流程;4)通过TCP回声服务器案例演示了网络通信的实际应用。文章还提供了多线程和IO复用技术在高并发服务器中的应用建议,以及解决网络编程常见问题的方法。

今天比昨天更努力一点! 9297

linux C语言socket函数send

在Linux中,使用C语言进行网络编程时,send函数是用于发送数据到已连接的套接字的重要函数之一。它通常用于TCP连接,但也可以用于UDP(尽管对于UDP,通常更推荐使用sendto,因为它允许你指定目标地址和端口)。下面是send。

数字人生 3019

C语言网络编程与socket通信:TCP、UDP、HTTP、WebSocket深度解析

本文深入探讨了C语言网络编程与socket通信的核心技术,重点解析了TCP、UDP、HTTP和WebSocket协议的应用。文章首先阐述了网络编程的重要性,即实现远程通信和构建网络应用。随后详细介绍了TCP通信的可靠连接特性,提供了完整的TCP服务器/客户端代码示例,涵盖socket创建、绑定、监听、连接及数据传输等关键步骤。在UDP通信部分,则突出了其无连接特性,并给出UDP服务器/客户端的实现代码。文章还特别强调了网络编程中的常见问题及避坑指南,包括连接失败、数据收发异常等情况的处理。通过理论讲解与代码

编程世界如山海,探索不止。 1万+

C语言实现TCP Socket客户端数据发送

本文还有配套的精品资源,点击获取 简介:网络编程是IT领域的重要组成部分,而Socket编程是客户端和服务器间通信的关键技术。本示例展示了如何使用C语言进行TCP Socket通信,包括创建连接、发送数据、接收数据、封装函数以及错误处理等方面。通过理解这些基础操作,初学者可以打下网络编程的坚实基础,并进一步探究多线程、异步I/O等高级主题,提升系统的稳定性和健壮性。 ...

weixin_35935514的博客 2577

Openclaw Onboarding向导全攻略——如何配置你的第一个AI助手

很多新手在成功运行 `openclaw --version` 后,面对黑底白字的终端就陷入了迷茫:“安装好了,然后呢?” 本篇我们就彻底解决这个问题,带你完整走完 `openclaw onboard` 交互式初始化配置向导的每一步,从“安装完成”到“真正能用”,只差这一个向导的距离。 本文为2026年3月最新版,适配OpenClaw v2026.2.x 稳定版,所有步骤均经过实测验证,可直接落地。

夏日清风 1921

网络编程基础:C语言实现TCP/UDP通信

本文系统介绍了C语言网络编程的核心知识,重点讲解了TCP/UDP协议差异、Socket编程接口和实现方法。主要内容包括:1)网络基础概念如IP地址、端口、字节序转换;2)TCP/UDP协议特点对比及适用场景选择;3)Socket核心函数详解和编程流程;4)TCP服务器/客户端和UDP通信的具体实现。通过代码示例演示了网络字节序转换、地址结构体初始化、Socket创建等关键操作,为开发网络应用提供了实践指导。

今天比昨天更努力一点! 1万+

一文搞懂 Transformer 工作原理 !!

本文将从单头Attention工作原理多头Attention工作原理全连接网络工作原理三个方面,实现一文搞懂Transformer的工作原理。Transformer工作原理。

不要给自己设限,尝试更多可能(思所向 皆可往) 2993

C语言Socket网络编程详解:从入门到实战

摘要:本文系统介绍了C语言Socket网络编程的核心技术,涵盖TCP/UDP两种协议的实现。内容包含:1) Socket概念与应用场景;2) TCP/UDP协议对比;3) 完整编程流程与代码示例(含服务器/客户端实现);4) 关键API深度解析(socket/bind/listen等);5) 常见问题解决方案;6) 进阶学习建议。通过详细注释的代码示例(已测试通过),帮助开发者快速掌握网络通信编程要点,包括地址转换、数据收发、错误处理等核心技能,为构建高性能网络应用奠定基础。

Jay_515的博客 4554

5分钟看懂LTE注网全流程:从PLMN选择到小区驻留的log分析技巧

本文深入解析了LTE终端从开机到成功驻留小区的完整流程,重点分享了基于QXDM和QCAT工具的log分析实战技巧。文章详细拆解了PLMN选择、System/Band扫频、小区搜索与同步、系统消息解析及驻留等关键步骤,并提供了高频问题场景的排查思路,帮助网络优化工程师快速定位终端侧、射频环境或网络配置问题。

app77的博客 435

如何用matlab扫频法测考虑频率耦合的并网逆变器的序阻抗,如何实现?

🏆本文收录于 《全栈Bug调优(实战版)》 专栏,该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因,并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者,还是拥有多年项目经验的资深工程师,本专栏都将为你提供一条系统化、高质量的问题排查与优化路径,助力你加速成长,攻克技术壁垒,迈向技术价值最大化与职业发展的更高峰🚀!

**My Coding Family** 1194

《C 语言 Socket 网络编程:深入剖析与实战》

服务端:1、创建套接字socket2、绑定地址和端口(bind)3、开始监听(listen)4、等待客户端连接(accept)5、接收和发送数据(receive、send)6、关闭套接字(close)客户端:1、创建套接字(socket)2、连接服务器(connect)3、发送和接收数据(send、receive)4、关闭套接字(close)

zhen_yr19的博客 1541

44、单级静态电流消耗最小化方法及功率优化比较器设计

本文探讨了单级静态电流消耗最小化方法及功率优化的多米诺逻辑比较器设计。通过分析类“AB”输入CMOS差分对电路,提出利用补偿电流源实现高低电流模式切换,提升运算放大器性能;结合VTCMOS与时钟门控技术,在90nm CMOS中设计低功耗比较器,并采用多米诺逻辑提高速度与能效。通过对比传统与改进型多米诺逻辑的静态功耗、动态功耗、延迟和PDP,验证了所提方案在高性能与低功耗方面的优势,适用于便携式设备等对能效要求严苛的应用场景。

pp12345的博客 122

【C语言网络编程基础】一文搞懂 TCP 服务器核心函数:socket、bind、listen、accept、setsockopt、pthread_create

本文介绍了构建TCP服务器所需的6个核心系统函数:socket()创建通信端点,setsockopt()设置socket选项,bind()绑定IP与端口,listen()开始监听连接,accept()接受客户端连接,以及pthread_create()创建线程处理并发通信。这些函数是网络编程和嵌入式开发的基础,适用于C/C++学习者和物联网开发者。掌握它们能帮助理解TCP服务器的构建流程,为开发WebSocket、IoT通信等高级功能奠定基础。文章还提供了各函数的原型说明和典型应用示例,适合初学者和进阶学习

2302_81526349的博客 1514

【75】OpenCV C++实战篇——OpenCV 图像拼接、全景拼接(教程合集)

本文整理了OpenCV实现图像拼接的技术教程合集,涵盖C++和Python两种语言实现方案。图像拼接技术旨在将多张重叠图像融合为无缝全景图,既扩大视角又保持高分辨率。内容包含水平矫正等关键步骤(附对比效果图),提供多个实战案例的完整代码和详细讲解,涉及单应性矩阵、图像变换等核心技术。不同案例展示了从两张到多张图像的拼接效果,适合不同层次的学习者参考实践。

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 528

英飞凌TC3xx之一起认识GTM系列(四)如何实现GTM与GPIO关联的配置(ATOM/TIM实例)

本文详细描述了针对英飞凌TC3xx芯片,如何运用GTM与GPIO之间的连接性,根据实际应用的需要对TOM和TIM相关寄存器进行配置。

无所适从的我的博客 3497

Linux 网络编程基础:构建你的第一个 TCP 服务器

在现代互联网应用中,网络编程是不可或缺的一部分。Linux作为强大的服务器平台,提供了丰富的网络编程接口,帮助开发者构建高效、可靠的网络应用。本文将带你走进 Linux 网络编程的世界,从最基础的 IO 概念入手,逐步学习 Socket 函数的使用,并通过构建一个简单的 TCP 服务器,让你体验网络编程的魅力。我们将深入探讨阻塞和非阻塞 IO 的区别,并解析如何利用这些知识构建出稳定的网络程序。准备好迎接挑战,开启你的 Linux 网络编程之旅吧!

Lion_Long的博客 1433

UG\NX二次开发 判断对象是虚线还是实线

网友提问“怎么区分虚线实线”,这个可以通过函数判断。

王牌飞行员_里海的博客 359

Linux C语言TCP网络编程实战:从Socket到epoll并发服务器

网络编程是现代软件开发的基石,其核心在于实现不同主机间进程的可靠通信。TCP协议通过三次握手建立连接、四次挥手断开连接,并利用序列号、确认应答和重传机制,确保了数据传输的可靠性与顺序性。这一技术价值在于为上层应用提供了稳定的字节流传输服务,是构建Web服务器、即时通讯、分布式系统等高性能网络应用的基础。在实际工程中,开发者通过操作系统提供的Socket API进行编程,需要处理地址绑定、端口监听、连接建立、数据收发以及资源释放等关键步骤。针对高并发场景,I/O多路复用技术如epoll模型成为提升服务器性能的

weixin_30325487的博客 945

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

c语言网络编程详解,Socket网络编程详解(TCP)

socket到底是个什么东西,socket是个TCP协议吗?我们平时很多方面都会用到socket,但确定真的了解socket吗?一.说起Socket我们在说什么?Wikipedia:A network socket is an endpoint of a connection in a computer network. In Internet Protocol (IP) networks, th...

weixin_33274610的博客 1718

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

上一篇: 深入解析ONVIF Audio BackChannel的RTSP实现与调试技巧
下一篇: Gin框架实战:5分钟搞定JWT鉴权中间件(附完整代码)
人间清醒863
博客等级 码龄3年 33粉丝 1544原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值