CodeCaptain头像

手写C/C++网络爬虫:从Socket到PageRank的工程实现解析

简介:这份资源是一份基于C/C++实现网络爬虫的工程代码包,面向具备TCP/IP与HTTP基础、希望深入网络编程和数据抓取的开发者。项目完整演示了套接字通信、异步I/O、HTTP解析、HTML链接提取以及多线程并发抓取等关键环节,同时包含基于PageRank思路的页面权重计算模块,将爬虫采集与链接分析串成一条可落地的实践链路,适合作为课程设计或中级网络编程学习参考。

压缩包共43个文件,整体约31KB,以.c源文件、.h头文件、.o编译目标文件为主,并配有makefile辅助构建;另含少量文本说明和备份文件,可据此梳理工程结构并重新编译运行。当前已有176人学习下载,适合想通过读源码、改代码来掌握爬虫框架与C/C++网络编程技巧的读者,从中可重点品味哈希表、布隆过滤器、队列操作与分页模块如何协作完成原始网页数据的处理与排序。

1. network-spider.tar.gz:一个把 C/C++ 网络编程和 PageRank 串起来的爬虫工程

network-spider.tar.gz 这个压缩包,第一眼看上去是一堆 .c、.h 和 .o 文件,真正可读的源码集中在 test2-l 目录里。它不是一个“写完就能爬全网”的成品爬虫,而是一个把 C/C++ 网络编程的每个环节都拆出来给你看的工程样本:network.c 管 socket,http_client.c 管 HTTP 请求,link_parser.c 从 HTML 里抽链接,hashtable.c 和 bloomfilter.c 负责去重,queue_op.c 维护抓取队列,最后交给 pagerank.c 算权重,结果写进 result.txt。

这个资源对两类人最有价值:一类是想弄懂爬虫全链路怎么落地的 C/C++ 开发者,另一类是准备面试、需要从网络编程一路讲到 PageRank 的求职者。它的缺点也很明显,代码是教学向的,生产级的超时重试和错误处理都比较薄。但正因如此,它比那些动辄上千行的爬虫框架更容易读透。

2. 网络编程的底层实现:network.c 与 http_client.c 怎么把 HTTP 请求发出去

2.1 套接字编程的最小骨架:socket、connect、send、recv

network.c 在整个工程里的位置,看文件依赖就能猜个大概:http_client.o 引用 network.h,http_client.h 又被 main.c 引用。也就是说,这一层是所有上层模块的地基。它的职责不是理解 HTTP,而是把 socket 生命周期管好:创建、连接、发送、接收、关闭。

我拆过不少 C 爬虫,很多项目习惯直接拉 libcurl 进来,把 HTTP 层全部交给第三方库。这个资源保留了 network.c 和 http_client.c 两层,说明设计意图是让你手动控制 TCP 链路。对想搞懂 socket 网络编程的人来说,这反而是好事,你能看到请求是怎么一条条发出去,响应又是怎么一段段收上来的。

先看最小骨架,我一般会把 socket 封装成下面这样:

// network.c 中的核心发送流程(示例,按工程常用写法整理)
int fetch_url(const char *host, int port, const char *request,
              char *out_buf, int out_len) {
    int sock = socket(AF_INET, SOCK_STREAM, 0);      // 1. 创建 TCP socket
    if (sock < 0) return -1;

    struct hostent *hp = gethostbyname(host);        // 2. DNS 解析
    if (!hp) { close(sock); return -2; }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);                      // 3. 端口转网络字节序
    memcpy(&addr.sin_addr, hp->h_addr, hp->h_length);

    if (connect(sock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        close(sock); return -3;                       // 4. 三次握手失败
    }

    send(sock, request, strlen(request), 0);          // 5. 发送 HTTP 请求
    int len = recv(sock, out_buf, out_len - 1, 0);    // 6. 接收响应
    close(sock);
    if (len < 0) return -4;
    out_buf[len] = '\0';
    return len;
}

逻辑说明:这段代码没有引入任何第三方库,纯 POSIX socket。第一步的 socket(AF_INET, SOCK_STREAM, 0) 用的是 IPv4 的 TCP 协议族; gethostbyname 处理域名到 IP 的解析; htons(port) 把端口从本机字节序转成网络字节序,这一步漏了,在 x86 机器上会连接到一个完全错误的端口。真实项目里 recv 不应该是单次调用,因为 HTTP 响应可能超过缓冲区,需要循环读直到 recv 返回 0 或超时;我在这里简化了,实际的 network.c 一般会拆成 socket_connect 、 socket_send 、 socket_read_all 三个函数,每个函数各管一段。

参数说明: out_buf 和 out_len 是调用方给的接收缓冲, out_len - 1 是为了留 \0 位; host 是域名而不是裸 IP,因为爬虫从 <a href> 里拿到的地址很少是 IP。返回值我约定为负数表示错误码,正数表示实际读取字节数。这套约定在 http_client.c 里会被直接使用,所以网络层最怕改接口,一旦把 send 和 recv 的返回语义改掉,上层的超时判断全部要跟着动。

补充一点,真实生产环境里 DNS 解析早就不用 gethostbyname 了,现代写法是 getaddrinfo 。但这份资源既然保留 network.c 这个文件名,大概率是教学向或实验向的写法。我复现这种老工程时不会急着重写 DNS 层,先保证链路跑通,再考虑移植。

顺带说一句,很多人在 VSCode 里配置完 C/C++ 环境,第一段练习代码就是 socket,最容易踩的坑是操作系统头文件差异。Linux 的 sys/socket.h 在 Windows 下不存在,Windows 要用 winsock2.h 并先 WSAStartup 。这套代码默认是 POSIX 环境,你在 Windows 上复现,最稳妥的是拉到 Linux 虚拟机或 WSL 里编译,不要在 Visual Studio 的 cl.exe 上硬刚,这个坑后面单独讲。

2.2 HTTP 请求构造与响应解析:GET、Header、状态码

socket 只负责字节流,HTTP 语义在 http_client.c 这一层。这一层要解决两件事:一是把目标 URL 拆成 host、port、path,拼出合法的 GET 请求;二是把服务器返回的字节流按 HTTP 协议切出状态码、Header 和 Body。

一个最简 GET 请求长这样:

GET /path/index.html HTTP/1.1\r\n
Host: example.com\r\n
Connection: close\r\n
User-Agent: network-spider/1.0\r\n
\r\n

注意末尾是两个 \r\n ,最后一个空行表示 Header 结束。常见错误是只写一个 \n ,不同服务器解析行为不一致,有的直接返回 400。我在构造入口会加一个断言,要求请求字符串必须以 \r\n\r\n 结尾。

响应解析的难点在 Body 长度怎么定。如果服务器返回 Content-Length ,直接按数字读;如果返回 Transfer-Encoding: chunked ,就得按块大小逐块读。老式爬虫往往只支持第一种,遇到 chunked 就会把页面截断,导致链接解析不全。这个项目的 http_client.c 大概率也是先从简单实现起步,真要抓现代网站,chunked 是绕不过去的坎。

还有个很实际的细节:URL 里的 path 可能为空,比如 http://example.com/ ,此时请求行要写成 GET / HTTP/1.1 。很多初学爬虫的人都栽在 path 为空上,服务器要么返回 301,要么直接挂断。http_client.c 在处理这种情况时,常见做法是对空 path 默认补一个 / 。

参数说明: Connection: close 是我个人偏好的省事方案,爬虫本来就不需要长连接,逐页新建 socket 比维护连接池简单得多。代价是每个 URL 都要重新 DNS 和握手,抓几千个页面时性能明显下降;想提速就得把 HTTP/1.1 的 Connection: keep-alive 和超时重试逻辑补上。

2.3 原生 socket 与 libcurl 的取舍

libcurl 提供了完整的 HTTP 语义,自动处理重定向、SSL、chunked,但它会把你和底层细节隔开。如果你是为了做产品抓数据,直接上 libcurl 是明智的;如果是为了弄懂 socket 网络编程,原生实现是必修课。

这份资源走的是原生路线,http_client.c 自己组装请求、自己解析响应,这也决定了它默认不处理 HTTPS,因为 TLS 握手要另外接 openssl。你在复现时别拿它去爬 https 站点,收到乱码或者连接失败都正常。这个边界在 network.h 里应该能看出来,头文件里大概率没有 SSL 相关的字段。

我在自己的项目里会做一个判断:种子 URL 超过 1000 个,或者目标站点的 https 比例超过一半,就直接换 libcurl 重写 http_client.c,保留 network.c 作为排查工具;反之,教学和面试场景用原生实现反而能讲清楚每一个字节的来历。

2.4 select/poll:爬虫需要的并发模型

单线程爬虫的瓶颈在于每个 URL 都要阻塞在 recv 上。摘要里提到的 select、poll、epoll 这类异步 I/O 手段,正是 C 爬虫提高并发的方式。核心套路:把所有 socket 放进 fd_set,调用 select 阻塞等待,哪个 socket 可读就处理哪个。教学代码用 select 更容易读,生产级一般上 epoll。

// select 等待 socket 可读(简化示例)
fd_set read_fds;
struct timeval tv = {5, 0};               // 5 秒超时
FD_ZERO(&read_fds);
FD_SET(sock, &read_fds);
int ready = select(sock + 1, &read_fds, NULL, NULL, &tv);
if (ready > 0 && FD_ISSET(sock, &read_fds)) {
    // 这个 socket 有数据可读
    recv(sock, buf, sizeof(buf) - 1, 0);
}

逻辑说明:select 的第一个参数是最大文件描述符加 1,很多人漏掉这个 +1 ,在 socket 恰好是某个临界值时行为很诡异; timeval 用来控制超时,传 NULL 则永远阻塞。select 本身是水平触发,处理大量已就绪 fd 时要循环检查 FD_ISSET ,否则并发上不去。真正的生产级爬虫会用 epoll 的边缘触发加非阻塞 socket,配合 EAGAIN 错误码判断数据是否读完,那是另一个话题。

在这个工程里,queue_op 队列加单线程 recv 的组合最容易跑通。先把并发放一边,把单链路调通,再考虑用 select 包一层。我见过太多人一上来就上 epoll,最后在边缘触发和 EAGAIN 上翻车。

3. 链接解析、去重与调度:link_parser、hashtable、bloomfilter、queue_op 的配合

3.1 HTML 链接提取:从 到绝对 URL 拼接

爬虫拿到 HTML 之后,第一件事是找出所有出链。link_parser.c 就是干这个的。它的输入是一整块 HTML 文本,输出是一堆 URL 字符串。看起来简单,但实际写起来有很多边界。

// link_parser.c 中解析 <a href> 的简化逻辑
while ((start = strstr(html, "<a ")) != NULL) {
    char *href = strstr(start, "href=\"");
    if (href && href < start + 200) {         // 限制单标签长度,防异常输入
        href += 6;                             // 跳过 "href="
        char *end = strchr(href, '\"');
        if (!end) end = strchr(href, ' ');
        if (!end) end = href + strlen(href);   // 兜底
        int len = end - href;
        // 拷贝 URL,做后续处理
        strncpy(url_buf, href, len);
        url_buf[len] = '\0';
    }
    html = start + 1;                          // 继续向后扫描
}

逻辑说明:这个解析器只处理小写 <a 和双引号 href,真实网页里会有单引号、无引号、大写标签、标签内换行,甚至 JavaScript 拼接,所以完整 parser 要复杂得多。这里的 200 阈值是我个人喜欢加的,防止一个损坏的 HTML 把缓冲区撑爆。

接下来要把相对 URL 拼接成绝对 URL。例如从 http://example.com/dir/page.html 解析出 ../other.html ,要拼成 http://example.com/other.html ,而不是 http://example.com/dir/../other.html 。这一步字符串处理最容易出 bug,我见过不少爬虫抓回来的 URL 带着 /../ ,导致去重失效、权重计算错乱。

正确的做法是分四段拼:协议、host、path 目录、文件名。协议和 host 不变,path 目录取当前页面的目录部分,然后按 .. 和 . 向上归约。link_parser.c 里如果没有现成实现,你补一个 resolve_url 函数就够了。

3.2 去重策略:hashtable 与 bloomfilter 的分工

爬虫最怕重复抓同一个 URL。hashtable.c 提供精确去重,bloomfilter.c 用极小内存挡住绝大多数重复请求。这个工程同时保留两个去重模块,说明原作者清楚两者的边界。

hashtable 的优点是精确,缺点是内存随 URL 数量线性增长;bloomfilter 的优点是省内存,缺点是有假阳性,它告诉你“可能存在”,你得回查 hashtable 才能确定。

// 布隆过滤器检查与插入(简化示例)
int bloom_check_and_add(unsigned char *bitmap, int bitmap_size,
                        const char *url, int url_len) {
    int hash1 = hash_str(url, url_len, 7);   // 两个不同盐值的哈希
    int hash2 = hash_str(url, url_len, 13);
    int b1 = hash1 % (bitmap_size * 8);
    int b2 = hash2 % (bitmap_size * 8);
    if (bitmap[b1 / 8] & (1 << (b1 % 8)) &&
        bitmap[b2 / 8] & (1 << (b2 % 8)))
        return 1;    // 可能存在,需要二次确认
    bitmap[b1 / 8] |= (1 << (b1 % 8));
    bitmap[b2 / 8] |= (1 << (b2 % 8));
    return 0;        // 肯定不存在,已插入
}

逻辑说明:布隆过滤器只看两个位,用两个独立哈希函数降低碰撞。如果两位都已经置 1,认为“可能见过”,这个结果不能当最终判断,要回查哈希表;如果两位任意一位为 0,那这个 URL 肯定没抓过。

这个组合的工作方式是:布隆过滤器挡掉绝大多数重复 URL,只有“可能存在”的才去查 hashtable.c 里的精确哈希表,这样内存占用从 O(N) 降到 O(N/8),代价是固定的假阳性率。我在处理百万级 URL 时就是这么干的,单机内存能压到几十 MB。

3.3 调度队列:queue_op 的 FIFO 与 BFS 抓取顺序

queue_op.c 维护抓取队列,决定了爬虫按什么顺序访问页面。默认 FIFO 对应 BFS,先抓当前层所有页面,再进入下一层。

// queue_op.c 接口(工程常用写法)
typedef struct {
    char **items;
    int head, tail, capacity;
} url_queue;

int q_push(url_queue *q, const char *url) {
    if ((q->tail + 1) % q->capacity == q->head) return -1; // 队满
    q->items[q->tail] = strdup(url);
    q->tail = (q->tail + 1) % q->capacity;
    return 0;
}

char *q_pop(url_queue *q) {
    if (q->head == q->tail) return NULL;     // 队空
    char *url = q->items[q->head];
    q->head = (q->head + 1) % q->capacity;
    return url;
}

逻辑说明:这是一个循环队列。capacity 取 2 的幂可以用位运算代替取模;队满和队空的判断最容易写错,经典做法是浪费一个元素位,或者维护独立的 size 字段。queue_op.h 存在说明队列操作是独立模块,替换动态扩容实现不会伤到解析和权重部分。

队列加去重放在一起才是完整的抓取循环:从队列弹 URL,去重模块查重,没抓过就发请求,解析出链接,再把新链接入队。main.c 里的主循环大概率就是这么串起来的。

3.4 devide.c:把 URL 列表切成可并行处理的分片

这个文件的名字 devide 我猜是 divide 的拼写错误,作者手滑了。作用上,它多半是数据分片或分段逻辑:按 host、按哈希值或按数量把 URL 分成若干块,方便多线程或多进程并行。

// devide.c 按 host 分片的思路
int slice_by_host(const char *url, int slice_count) {
    // 取 host 的哈希,落到 [0, slice_count)
    const char *host = get_host(url);
    unsigned int h = hash_str(host, strlen(host), 31);
    return h % slice_count;
}

逻辑说明:按 host 分片可以让同一个站点的请求落到同一个线程,减少重复握手;按 URL 哈希分片负载更均衡,但同一个站点会散到多个线程,需要额外的去重协调。这个模块在项目里不是核心逻辑,但它的存在说明原作者考虑过并行扩展。你把 main.c 改成多线程时,devide 的分片结果可以直接作为线程参数。

这里要提醒一点:多线程爬虫的共享队列必须加锁,queue_op 里的 head、tail 在两个线程同时操作时会错乱。常见做法是在 q_push 和 q_pop 里加 pthread_mutex,或者用无锁环形队列,后者对内存序要求高,不建议新手直接上。

4. 页面权重计算:pagerank.c 里的迭代公式与悬挂链接处理

4.1 PageRank 公式:0.85 阻尼系数从哪来

抓完页面、抽完链接,这个工程的最后一步是用 pagerank.c 给每个页面算权重。PageRank 的核心思想是:被越多高质量页面引用的页面,权重越高。公式是 PR(A) = (1-d)/N + d * Σ(PR(Ti)/C(Ti)),其中 d 是阻尼系数,N 是页面总数,Ti 是所有链接到 A 的页面,C(Ti) 是 Ti 的出链数。

阻尼系数 0.85 是经典论文里的取值,表示浏览者有 85% 的概率沿着链接继续点下去,15% 的概率随机跳到任意页面。d 越大,链接关系对权重影响越大;d 越小,全局平均分配占比越高,权重越收敛。

// pagerank.c 迭代更新逻辑(示例)
for (int iter = 0; iter < max_iter; iter++) {
    double diff = 0.0;
    for (int i = 0; i < N; i++) {
        double sum = 0.0;
        for (int j = 0; j < in_links[i].count; j++) {
            int src = in_links[i].list[j];
            sum += old_pr[src] / out_degree[src];
        }
        new_pr[i] = (1.0 - d) / N + d * sum;
        diff += fabs(new_pr[i] - old_pr[i]);
    }
    if (diff < threshold) break;   // 收敛
    memcpy(old_pr, new_pr, N * sizeof(double));
}

逻辑说明:外循环是迭代,内循环是每个页面的权重更新。 in_links[i] 是所有链接到 i 的页面集合; out_degree[src] 是 src 页面的出链数; diff 是两轮迭代所有页面权重变化的绝对值之和,小于阈值就认为收敛。

参数说明: max_iter 一般取 100 左右, threshold 取 1e-6 到 1e-8。diff 小于阈值就提前退出。如果 max_iter 太小或者 threshold 太严,diff 还没降到阈值以下就退出,输出结果会不理想。

4.2 链接矩阵的存储:hashtable 与边的组织

直接从公式实现一个 N×N 矩阵是不现实的。互联网网页数量是百亿级,N×N 的空间根本装不下。实际实现必须用稀疏结构:为每个页面维护一个出链列表和一个入链列表。这个工程里 hashtable.c 的作用就在这里,把 URL 字符串映射成整型 ID,pagerank 数组按下标访问。

典型做法是这样组织数据:

// 用哈希表把 URL 转成 ID
int page_id = hash_get_id(hashtable, url);   // 不存在则分配新 ID
// 记录一条从 src 到 dst 的边
add_edge(edges, src_id, dst_id);
// 迭代时按 ID 访问题目

逻辑说明:哈希表只负责映射 URL 和 ID,边的统计在 link_parser 解析的过程中同步进行。每解析出一个链接,就调一次 add_edge,把 src 页面的出链列表追加一个 dst。迭代开始前再根据出链列表建立入链列表,pagerank 更新时才能直接拿到所有指向当前页面的来源。

内存上,每条边存两个整型 ID,比存 URL 字符串省得多。我用过的最省方式是把出链放入链式数组,只存 ID 和 next 指针,配合内存池,百万节点千万边的规模能控制在 200MB 以内。

4.3 悬挂节点与收敛判断

没有出链的页面叫悬挂节点。它们会吸收权重而不释放,导致权重不断积累在死胡同页面,整个结果失真。标准 PageRank 实现必须处理这个。

// 悬挂节点处理:每轮迭代前计算悬挂节点总权重
double sink_sum = 0.0;
for (int i = 0; i < N; i++) {
    if (out_degree[i] == 0) sink_sum += old_pr[i];
}
// 把 sink_sum 平均分给所有页面,加到 new_pr 里

逻辑说明:如果不管悬挂节点,权重会不断流向这些没有出链的页面,最后收敛到某些页面上,实际权重分布完全失真。加入 sink_sum 平均分配后,每个页面能分到悬挂节点贡献的少量权重,这一份就是“用户随机跳转”的模拟。

除了悬挂节点,迭代还可能因为数据错误不收敛。最常见的错误是链接矩阵里有自环,页面链接自己,导致权重循环放大。我在给 pagerank.c 做单元测试时,会故意构造 A 链到 A 的单节点图,PR 必须稳定收敛到 1.0 才算过。这种测试能帮你刷掉大量边数据错误。

如果你在 result.txt 里发现某个页面的权重特别高,高到离谱,先查两件事:一是它是不是被自己或者大量站内页面互相引用;二是它的 in_links 是不是在解析和去重过程中被重复统计了。我遇到过重复统计,原因是在入队前没有去重,同一个 URL 的链接被加了两遍,导致权重虚高。

4.4 结果排序与 result.txt 输出

算完权重,最后一步是把页面按权重排序写进 result.txt。这个环节也有讲究:必须用稳定的归并排序,因为两个页面权重完全相同时,你得保证输出顺序和迭代顺序一致,否则多次跑结果对不上。

// 结果排序:按权重降序,权重相同按 URL 字典序
int compare_page(const void *a, const void *b) {
    page_t *pa = (page_t *)a;
    page_t *pb = (page_t *)b;
    if (pa->pr > pb->pr) return -1;
    if (pa->pr < pb->pr) return 1;
    return strcmp(pa->url, pb->url);
}

逻辑说明:排序键是权重,次键是字典序。这样输出可复现,方便做 diff 对比。result.txt 里的每一行应该是一个页面的权重和 URL,行数要和去重后的页面总数一致。如果 bfcheck 是用来自测布隆过滤器假阳性率的,跑一下还能看到当前位图大小下的误判概率,这对调整去重参数很有用。

5. 避坑 / 常见问题:C 爬虫编译和运行中的五个经典翻车点

5.1 现象:make 报错找不到头文件,或者编译出来的程序用的是旧的 .o

现象:直接执行 make,系统报 “hashtable.h: No such file or directory”,或者明明改了 .c 文件,重新运行程序行为没变化。

原因:压缩包里同时存在 makefile 和 makefile~ 两个文件, make 默认按 GNUmakefile、makefile、Makefile 的顺序找。如果你不小心用 make -f makefile~ 执行了备份文件,或者把备份文件改名成主 makefile,就会拿到备份里不完整的依赖和旧目标;另外 .o 文件是预编译好的,主 makefile 里如果没写头文件依赖,改了 .h 不会触发重编。

解决:先 make clean 把 .o 全部清掉,再用 make -f makefile 从源码重编。 ~ 结尾的文件是编辑器备份,直接忽略或删除。我一般在解包后第一件事就是 find . -name "*~" -delete ,防止备份文件干扰。

5.2 现象:爬虫拿到空页面,或者链接解析出来只有几条

现象:程序正常跑,网络请求也发出去了,但 link_parser 从 HTML 里解析出的链接数量远小于预期,甚至为 0。

原因:服务器返回了 gzip 压缩内容,http_client.c 没有做解压。现代 Web 服务器默认对带 Accept-Encoding: gzip 的请求返回压缩内容,爬虫不解压就只能看到二进制乱码和空壳页面。

解决:有两种做法。第一种是把请求头里的 Accept-Encoding: gzip 去掉,强制服务器返回原始内容,最简单;第二种是接 zlib 的 inflate 做解压,适用范围更广。我一般先看服务器响应头,如果有 Content-Encoding: gzip ,就优先去掉请求头里的 gzip 声明,改动最小。

5.3 现象:PageRank 不收敛,diff 一直在浮点噪声附近抖动

现象:迭代了很多轮, diff 始终降不到阈值以下,有时还会反弹,result.txt 里的排序每次跑都不太一样。

原因:悬挂节点没处理,或者阻尼系数 d 设得太接近 1,迭代次数不够。悬挂节点会让权重流向死胡同,diff 很难单调下降。很多人把不收敛归咎于调参玄学,其实九成是悬挂节点漏了。

解决:参考第 4 章的 sink_sum 处理,把悬挂节点贡献的权重平均分给所有页面;然后把 d 从 0.85 往回调到 0.8 试一轮;max_iter 先给 200,threshold 放宽到 1e-5,确认收敛趋势后再收紧。注意:PageRank 是线性系统,理论上一定有不动点,不收敛基本就是实现里漏了悬挂项。

5.4 现象:Windows 下 cl.exe 编译 POSIX socket 代码直接失败

现象:在 Windows 上把代码丢进 Visual Studio,编译时报 "error: command '...cl.exe' failed with exit status 2",错误列表里一堆 sys/socket.h 找不到。

原因:这套代码用的是 POSIX socket( sys/socket.h 、 arpa/inet.h 、 netinet/in.h ),MSVC 环境下根本没有这些头文件。cl.exe 找不到头文件,自然失败。这是 C/C++ 网络编程在跨平台上最常见的翻车点。

解决:不要在 Windows 原生编译器上硬编。用 Linux 环境,或者 WSL,或者在 VSCode 里配置 C/C++ 环境时把编译器切到 gcc 并启用 WSL 远程开发。如果必须在 Windows 原生环境,就得把 socket 部分改成 winsock2.h ,再额外调用 WSAStartup 初始化 Winsock,工程量大很多,不值得为一套教学代码折腾。

5.5 现象:运行到一半 Segmentation Fault,程序直接崩

现象:爬虫跑到几百个 URL 之后突然 Segmentation Fault,再跑一遍崩的位置还不一样。

原因:队列越界、URL 缓冲区没分配、 strstr 返回 NULL 后还在继续取值,或者链表节点没有初始化。这种教学向代码经常在边界条件上偷懒,一旦遇到畸形 HTML 或异常响应就炸。

解决:先开 -g -fsanitize=address 重新编译,运行时报错会直接指出栈和堆的问题位置;然后在 parser 入口对 html 和 href 做空指针判断。血泪经验:C 爬虫的段错误,八成来自 strstr 返回值没检查。我写 parser 的第一行一定是判空,第二行才允许取数据。

6. 构建、验证与调参:从 makefile 到 result.txt 的最后一公里

6.1 编译选项:把 .o 和 ~ 备份文件分开

不要直接 make,先 make clean 。用 -Wall -g 重新编,至少能看到所有 warning。我复现时习惯把 makefile~ 改名成 makefile.bak,避免编辑器备份干扰。编译通过后,用 valgrind --leak-check=full ./network-spider start.txt 跑一遍内存检查,比什么都放心。

6.2 用 start.txt 做最小验证

start.txt 是种子 URL 列表。跑完去看 result.txt,行数和输入种子数要能对上。先用 3 到 5 个互相链接的本地页面验证 pagerank 结果是否符合直觉,被多页引用的页面排名应该靠前。我一般会构造一个 A 链到 B、B 链到 C、C 链回 A 的三角,跑完看权重是否均匀,均匀就说明矩阵和迭代没问题。

6.3 调参:阻尼系数、迭代次数、去重阈值

参数 默认建议 调低效果 调高效果
阻尼系数 d 0.85 权重更平均,收敛更快 更强调链接关系,收敛变慢
max_iter 100 可能没收敛就退出 结果更稳定,耗时变长
threshold 1e-6 精度更高 更快退出,精度下降
布隆过滤器位图大小 1MB / 10万URL 假阳性率升高 内存变大,假阳性率下降

每次改完参数,都要重新检查 result.txt 的排序分布。从那以后,我每次拿这套代码跑新数据集,都会强制走一遍:先 make clean,再确认 start.txt 没有空行和重复,跑完对照 result.txt 的排序是否符合链接关系,最后才去动阻尼系数。这套流程帮我避开了不少“第二遍才翻车”的问题。希望帮到你。

本文还有配套的精品资源,点击获取 menu-r.4af5f7ec.gif

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/weixin_29173777/article/details/169644409

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--