QNetworkInterface详解：Qt网络接口枚举与网卡筛选实战

1. 先搞清楚这个类是干什么的

1.1 为什么网络程序总在“选网卡”上翻车

你有没有遇到过这种情况：程序写好了，UDP 组播就是收不到包，局域网服务端绑定 IP 后只能在一个网卡上通信，客户反馈“明明连着 WiFi 却连不上服务”。我最早遇到这类问题时，第一反应是查防火墙、查路由器，折腾半天最后才发现，真正的原因是代码里用 QHostAddress::LocalHost 去 listen，或者干脆让系统默认路由去选网卡，结果程序永远只在回环接口或者错误的网卡上工作。

要摆脱这种“玄学”，你得先搞清楚这台机器上到底有哪些网卡、每块网卡处于什么状态、各绑定了哪些 IP。Qt 里干这件事的专门类，就是 QNetworkInterface。

它不是用来收发数据的，也不是用来解析域名的，它的职责非常单一：枚举和描述本机的网络接口。所谓“网络接口”，你可以理解成操作系统对每一块网卡（也包括虚拟网卡、回环接口）的抽象登记条目。QNetworkInterface 把这个登记簿完整地暴露给了 Qt 应用，你只需要几行代码就能拿到接口名、索引、MAC 地址、IP 地址列表、子网掩码、广播地址以及接口状态。

适合什么人来学？写局域网通信工具、远程调试助手、设备发现服务、组播客户端的人，都应该把它用起来。哪怕你只是需要在界面上给用户展示“当前本机 IP 是什么”，QNetworkInterface 也是最标准的答案。

1.2 类的信息模型：接口、地址条目和标志位

QNetworkInterface 这个类的信息模型，和操作系统对网卡的管理方式是对齐的。整个层级是这样的：

• 主机：一台机器可以有多个网络接口。
• 网络接口：每个接口对应一块物理或虚拟网卡，拥有自己的名称、索引、MAC 地址。
• 地址条目：一个接口下可以配置多条 IP 地址，包括 IPv4、IPv6、链路本地地址等。每条地址还带着子网掩码或前缀长度、广播地址。

在 Qt 里，这个结构被映射成三个相互配合的类：

• QNetworkInterface：描述接口本身（名称、索引、MAC、状态、类型）。
• QNetworkAddressEntry：描述接口下的一条地址配置（IP、掩码、广播地址）。
• QNetworkInterface::InterfaceFlags：一组枚举标志，描述接口的“活”的程度。

给你打个比方：一台主机是一栋楼，每个网卡是一个门，IP 是这个门的门牌号，子网掩码是这个门牌对应的街区范围。QNetworkInterface 就是物业的登记册，你翻登记册就能知道楼里每一扇门的情况。而很多人一开始用的 QHostAddress::LocalHost 或者 QNetworkInterface::allAddresses()，相当于只知道 1 楼有个房间，却没有去查这个房间是哪扇门里面的、在哪个街区。

理解了这个层级关系，你就明白为什么很多网络程序要多加一层“网卡筛选”逻辑。并不是有 IP 就能用，也不是名字里带“eth”就是物理网卡，你要结合接口状态、地址类型、甚至 MAC 地址前缀去做判断。后面我会把这一整套筛选方法完整写出来。

1.3 谁需要学它：典型场景清单

我梳理了一下实际项目中用到 QNetworkInterface 的高频场景，基本离不开下面几类：

这几个场景的共同点是：你需要的不是“某个 IP”，而是“某个可用接口下的某个 IP”。QNetworkInterface 正好把接口和地址绑定在了一起，这就是它的核心价值。

2. 常用接口逐个拆解，别当文档读

2.1 入口函数：allInterfaces() 和按名字/索引查询

QNetworkInterface 最重要的入口是静态函数 allInterfaces()，它返回一个 QList<QNetworkInterface>，代表系统当前能枚举到的所有接口。

cpp复制#include <QNetworkInterface>
#include <QDebug>

const auto interfaces = QNetworkInterface::allInterfaces();
qInfo() << "共发现" << interfaces.size() << "个网络接口";

这段代码在任何平台都能跑。但要注意，返回的列表里不仅有物理网卡，还有回环接口、虚拟网卡、容器网桥等。在 Linux 机器上，你可能看到 eth0、wlan0、docker0、br-xxxx；在 Windows 上可能有一长串 Ethernet、Loopback Pseudo-Interface 以及虚拟化软件创建的适配器；在 macOS 上则是 en0、utun0 之类。

除了枚举全部接口，还有两个按标识查询的静态函数：

• QNetworkInterface::interfaceFromName("eth0")：按接口名查。
• QNetworkInterface::interfaceFromIndex(2)：按接口索引查。

这两个函数在拿不到全部列表、只知道一个标识时很有用。比如某些 socket 错误信息里只给了 ifindex，你就可以用 interfaceFromIndex 反查出完整的接口信息。它们返回的接口对象如果无效，通常 isValid() 为 false，所以调用后要先检查一下：

cpp复制auto iface = QNetworkInterface::interfaceFromName("eth0");
if (!iface.isValid()) {
    qWarning() << "没有找到名为 eth0 的接口";
    return;
}

这里我提醒一句：接口名在不同平台上完全没有统一标准。Windows 上可能叫“以太网”或“WLAN”，Linux 上常见 eth0/ens33/wlan0，macOS 上则是 en0/bridge0。跨平台程序千万不要硬编码接口名去匹配，宁可全部枚举出来做筛选。

2.2 addressEntries() 才是主角，allAddresses() 是坑

这是新手最容易踩坑的地方。QNetworkInterface 提供了两个看起来差不多的接口：

• addressEntries()：返回 QList<QNetworkAddressEntry>，每个条目包含 IP、子网掩码/前缀长度、广播地址。
• allAddresses()：返回 QList<QHostAddress>，只包含所有 IP 地址。

很多人图省事直接用 allAddresses()，结果拿到一堆 127.0.0.1、192.168.1.100、fe80::... 混在一起的平铺列表，根本分不清哪个地址属于哪个网卡。我强烈建议，凡是涉及“选网卡”的逻辑，一律用 addressEntries()，它保留了我们前面说的“接口 → 地址条目”的层级关系。

QNetworkAddressEntry 的常用字段：

一个接口下可能有多条地址条目。比较常见的情况是：同一块网卡既有 IPv4 又有 IPv6，甚至同时存在 192.168.1.100 和链路本地 169.254.x.x。遍历的时候要逐个判断，不能假设“一个接口只有一个 IP”。

另外注意，broadcast() 只在 IPv4 下有意义，IPv6 没有广播概念，对应的 broadcast() 通常是一个无效地址。判断地址协议类型时，需要用到 QHostAddress::protocol()：

cpp复制#include <QAbstractSocket>

if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol) {
    // 这是一个 IPv4 地址
} else if (entry.ip().protocol() == QAbstractSocket::IPv6Protocol) {
    // 这是一个 IPv6 地址
}

这里有个细节：QAbstractSocket 的枚举用于协议判断，记得把对应的头文件包含进来。

2.3 flags() 和 type()：判断接口的有效状态

接口存在，不代表它“能用”。判断标准要看 flags() 的返回值。QNetworkInterface 用 InterfaceFlags 这个枚举组合来表示接口状态，通过 testFlag() 来检查：

我最常用的一组判断是：

cpp复制using QNetworkInterface;

if (iface.flags().testFlag(QNetworkInterface::IsUp)
    && iface.flags().testFlag(QNetworkInterface::IsRunning)
    && !iface.flags().testFlag(QNetworkInterface::IsLoopBack)) {
    // 这是一个“看起来可用”的非回环接口
}

有人会问：IsUp 和 IsRunning 有什么区别？我举个常见的现象：一块有线网卡，网线已经拔掉了，接口可能仍然是 IsUp，但 IsRunning 会变成 false；或者热插拔之后驱动没有完全就绪，也会出现 Up 但 Not Running 的情况。所以判断“能不能用”，两个标志位最好都看。

type() 返回 QNetworkInterface::InterfaceType，常见的有 Ethernet、Wifi、Loopback、Virtual、PPP、Cellular 等。理论上可以用它来过滤虚拟接口，但我要泼一盆冷水：不同平台对这个枚举的支持并不完美。某些系统把无线网卡也识别成 Ethernet，某些虚拟接口没有正确标成 Virtual。所以 type() 只能作为辅助条件，不能作为唯一依据。更可靠的过滤手段是后面会讲的 MAC 地址前缀启发式判断。

2.4 Qt 5 与 Qt 6 的 API 差异，编译不过先看这里

QNetworkInterface 在 Qt 5 和 Qt 6 之间存在一些差异，写代码之前先确认你用的是哪个版本。

主要变化有两个：

第一，获取 MAC 地址的接口改名。Qt 5 里是 hardwareAddress()，Qt 6 推荐用 physicalAddress()。Qt 6 早期版本仍保留 hardwareAddress() 以兼容旧代码，但长期维护的建议还是按新版来。如果你的工程需要同时兼容 Qt 5 和 Qt 6，用条件编译最省事：

cpp复制#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
    const QString mac = iface.physicalAddress();
#else
    const QString mac = iface.hardwareAddress();
#endif

第二，QNetworkAddressEntry 在新版本里加强了对前缀长度的支持。Qt 5 时代，我们习惯用 netmask() 拿 255.255.255.0 这样的掩码；Qt 6 推荐直接用 prefixLength() 拿 24。如果你需要的是 CIDR 写法，新接口更省事，不用自己把掩码换算成前缀长度。

这两个差异是实际工程里最常见的“能编过去和编不过去”的分水岭。你在网上搜旧代码时，看到 hardwareAddress() 不要急着抄，先看一眼项目里的 Qt 版本。

3. 完整实操：写一个跨平台网络信息采集工具

3.1 工程配置：CMake 与 qmake 两种写法

下面我们做一个真正能跑的小工具：遍历本机所有网络接口，打印接口名、MAC、状态、地址条目，并自动筛选出“主网卡 IPv4”。先搭工程。

项目名我取 netprobe，核心代码只有一个 main.cpp。

CMake 写法（适用于 Qt 6，Qt 5 把 Qt6 改成 Qt5 即可）：

cmake复制cmake_minimum_required(VERSION 3.16)
project(netprobe LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(Qt6 REQUIRED COMPONENTS Network)

add_executable(netprobe main.cpp)
target_link_libraries(netprobe PRIVATE Qt6::Network)

qmake 写法：

qmake复制QT += core network
CONFIG += console c++17
CONFIG -= app_bundle

TARGET = netprobe
SOURCES = main.cpp

注意到一个关键点：QNetworkInterface 属于 Network 模块，必须在工程配置里加上 network。很多人只写了 QT += core，结果编译时找不到头文件，这种低级错误排查起来还特别费时间。

3.2 核心实现：遍历接口并打印全部信息

完整的 main.cpp 如下，我会逐段解释关键逻辑。

cpp复制#include <QCoreApplication>
#include <QNetworkInterface>
#include <QNetworkAddressEntry>
#include <QAbstractSocket>
#include <QDebug>

static QString flagsToString(QNetworkInterface::InterfaceFlags flags)
{
    QStringList result;
    if (flags.testFlag(QNetworkInterface::IsUp)) result << "IsUp";
    if (flags.testFlag(QNetworkInterface::IsRunning)) result << "IsRunning";
    if (flags.testFlag(QNetworkInterface::CanBroadcast)) result << "CanBroadcast";
    if (flags.testFlag(QNetworkInterface::IsLoopBack)) result << "IsLoopBack";
    if (flags.testFlag(QNetworkInterface::IsPointToPoint)) result << "IsPointToPoint";
    if (flags.testFlag(QNetworkInterface::CanMulticast)) result << "CanMulticast";
    if (result.isEmpty()) result << "None";
    return result.join("|");
}

static QString typeToString(QNetworkInterface::InterfaceType type)
{
    switch (type) {
    case QNetworkInterface::Loopback: return "Loopback";
    case QNetworkInterface::Ethernet: return "Ethernet";
    case QNetworkInterface::Wifi: return "Wifi";
    case QNetworkInterface::Virtual: return "Virtual";
    case QNetworkInterface::PPP: return "PPP";
    case QNetworkInterface::Cellular: return "Cellular";
    default: return "Unknown";
    }
}

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    const auto interfaces = QNetworkInterface::allInterfaces();
    for (const auto &iface : interfaces) {
        qInfo().noquote() << "===============================";
        qInfo().noquote() << "接口名:" << iface.name()
                          << "| 可读名:" << iface.humanReadableName()
                          << "| 索引:" << iface.index();

#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
        qInfo().noquote() << "MAC:" << iface.physicalAddress();
#else
        qInfo().noquote() << "MAC:" << iface.hardwareAddress();
#endif

        qInfo().noquote() << "状态:" << flagsToString(iface.flags());
        qInfo().noquote() << "类型:" << typeToString(iface.type());

        const auto entries = iface.addressEntries();
        for (const auto &entry : entries) {
            QString line = "  地址条目: " + entry.ip().toString();
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
            line += " / " + QString::number(entry.prefixLength());
#else
            line += " 掩码 " + entry.netmask().toString();
#endif
            const auto broadcast = entry.broadcast().toString();
            if (!broadcast.isEmpty()) {
                line += " 广播 " + broadcast;
            }
            qInfo().noquote() << line;
        }
    }

    return 0;
}

代码里有两个值得说明的地方。

第一，flagsToString 和 typeToString 是我自己写的辅助函数。flags() 返回的是一组枚举值组合，直接打印只会显示一个整数，不直观。把位标志翻译成字符串，输出一眼就能看懂。

第二，entry.ip().toString() 对 IPv6 地址会输出带 % 作用域后缀的格式，比如 fe80::1234%eth0，这是 Qt 的正常行为，链路本地 IPv6 地址必须带接口名才有意义。后面讲组播时还会涉及这个问题。

humanReadableName() 值得单独提一下：在 Windows 上它往往返回本地化的友好名称，比如“以太网”或“WLAN”；在 Linux 上通常和 name() 一样。跨平台 UI 里展示给用户看时，优先用 humanReadableName()，而代码内部匹配时用 name()。

3.3 智能筛选：找出“真正在用”的那块网卡

光能打印还不够，实际项目里更常见的是“帮我自动选一个网卡”。我写了一个启发式的选择函数，过滤顺序很重要：

cpp复制static QNetworkInterface pickActiveInterface()
{
    const auto interfaces = QNetworkInterface::allInterfaces();
    for (const auto &iface : interfaces) {

        // 第一层：必须是非回环、Up、Running
        if (iface.flags().testFlag(QNetworkInterface::IsLoopBack))
            continue;
        if (!iface.flags().testFlag(QNetworkInterface::IsUp))
            continue;
        if (!iface.flags().testFlag(QNetworkInterface::IsRunning))
            continue;

        // 第二层：MAC 地址不是全零
        const QString mac = iface.physicalAddress();
        if (mac.isEmpty() || mac == "00:00:00:00:00:00")
            continue;

        // 第三层：里面至少要有一个可用的 IPv4 地址，且不是链路本地
        const auto entries = iface.addressEntries();
        for (const auto &entry : entries) {
            const QHostAddress ip = entry.ip();
            if (ip.protocol() == QAbstractSocket::IPv4Protocol
                    && !ip.isLinkLocal()
                    && !ip.isLoopback()) {
                return iface;
            }
        }
    }

    return QNetworkInterface();
}

逐层解释一下这个筛选逻辑：

第一层过滤标准，前面已经说过，IsUp 加 IsRunning 是对“能用”的最基本要求。第二层过滤全零 MAC，是为了排除回环、某些禁用状态下的虚拟适配器，这类接口即使枚举到了也没有实际通信能力。第三层则把目标明确到“有 IPv4 且不是链路本地”。169.254.x.x 是 DHCP 失败后的自动地址，它不代表你真正接入了局域网，所以必须用 isLinkLocal() 排掉。

拿到这个函数返回的接口之后，就能进一步拿到它的 IP 了：

cpp复制QNetworkInterface iface = pickActiveInterface();
if (iface.isValid()) {
    qInfo() << "自动选择接口:" << iface.name();
    for (const auto &entry : iface.addressEntries()) {
        if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol
                && !entry.ip().isLinkLocal()) {
            qInfo() << "主 IPv4:" << entry.ip().toString();
            break;
        }
    }
} else {
    qWarning() << "没有找到可用的活动接口";
}

这里有个现实问题要说明：QNetworkInterface 并不知道“哪个接口是默认路由出口”，它只描述接口，不解释路由表。所以 pickActiveInterface 是一种启发式方案，在大多数单网卡、双网卡机器上够用；如果机器上有多张物理网卡且都连着不同网络，最好把候选列表交给用户手动选择，或者结合操作系统路由表再决定。后面扩展部分我会再提一句。

3.4 运行效果与结果解读

在 Linux 机器上编译运行，输出大致长这样：

code复制共发现 3 个网络接口
===============================
接口名: lo | 可读名: lo | 索引: 1
MAC: 00:00:00:00:00:00
状态: IsUp|IsLoopBack|CanMulticast
类型: Loopback
  地址条目: 127.0.0.1 / 8 广播 127.255.255.255
  地址条目: ::1 / 128
===============================
接口名: eth0 | 可读名: eth0 | 索引: 2
MAC: 52:54:00:12:34:56
状态: IsUp|IsRunning|CanBroadcast|CanMulticast
类型: Ethernet
  地址条目: 192.168.1.100 / 24 广播 192.168.1.255
  地址条目: fe80::5054:ff:fe12:3456 / 64
===============================
接口名: docker0 | 可读名: docker0 | 索引: 3
MAC: 02:42:...（容器网桥地址）
状态: IsUp|IsRunning|CanBroadcast|CanMulticast
类型: Virtual
  地址条目: 172.17.0.1 / 16 广播 172.17.0.255

从这个输出可以看到，allInterfaces() 会把所有接口拉出来，但哪些接口真正服务于你的局域网通信需求，必须靠筛选逻辑判断。比如 docker0 虽然也是 Up 和 Running，但它是一个容器网桥，不是物理网卡，如果在它上面跑服务端就大错特错。所以前面 pickActiveInterface 的过滤还不够完善，需要加上虚拟网卡过滤。通用的启发式做法是看 MAC 地址前缀：

• VMware 虚拟网卡 MAC 常以 00:50:56 开头
• VirtualBox 虚拟网卡 MAC 常以 08:00:27 开头
• Hyper-V 虚拟网卡 MAC 常以 00:15:5d 开头
• 容器网桥往往没有真实 MAC，或使用特殊的本地管理地址段

没有完美的过滤办法，但组合起来能覆盖绝大多数开发机环境。我在项目中还会把这些前缀写成可配置列表，方便不同团队调整。

4. 高频问题与排查经验

4.1 问题速查表

4.2 三个最容易踩的暗坑

第一个暗坑是“枚举到了不等于能用”。回环接口永远存在，虚拟机虚拟网卡也总是挂着，它们经常出现在 allInterfaces() 的返回列表里。我见过不少代码，遍历时没做任何过滤，直接拿第一个有 IPv4 的接口就去 bind，结果在 VMware 环境里选中了虚拟网卡，局域网服务怎么都连不通。排查了老半天，最后发现程序监听的根本不是物理网卡。处理办法就是我们前面写的多层过滤，宁可多写几个 continue，也别盲目信任第一个候选。

第二个暗坑是“MAC 地址为空或全零”。在部分 Linux 驱动、特定虚拟接口上，physicalAddress() 返回的是空字符串，而不是常规的冒号分隔 MAC。如果你拿这个值去做界面展示或设备唯一标识，会出现一堆空值。我的建议：展示时加一个 isEmpty() 兜底，标识设备唯一性时不要只依赖 MAC，可以拼接接口名加 MAC。

第三个暗坑是“网络断开后地址还在”。很多人判断本机是否在线，靠“有没有拿到非 127.0.0.1 的 IP”，这在断网时经常翻车。因为 DHCP 失败后系统会给接口配置 169.254.x.x，或者 WiFi 虽然连不上路由器但还保留着上一次的静态配置。判断“能连”要同时看接口状态和地址类型。更严谨的做法是结合 QNetworkInformation 或者实际发送探测包，这个放到扩展部分讲。

4.3 判断“接口在线”的推荐排查顺序

我在调试网络程序时，反复用的排查顺序是固定的，分享给你：

1. 检查 iface.isValid()：接口对象本身是否有效。
2. 检查 flags()：确认 IsUp 和 IsRunning 同时成立。
3. 检查 addressEntries() 是否非空：有地址配置，才能谈通信。
4. 检查地址类型：排除回环地址、链路本地地址，选出 IPv4 或你需要的 IPv6。
5. 检查广播地址或前缀长度：确认子网范围是不是你预期的局域网网段。

按这个顺序写日志，出问题时看一眼输出就能定位到是哪一层挂了。我自己的调试工具里，专门把每层过滤结果都打印出来，比如“eth0 通过 IsUp 检查”“eth0 没有可用 IPv4 地址”，这样客户截图反馈时，我们不用盲猜。

5. 应用扩展：从“看网卡”到真正能用的功能

5.1 局域网服务端自动绑定

拿前面 pickActiveInterface 返回的接口，取到主 IPv4 后，服务端就能自动绑定了：

cpp复制QNetworkInterface iface = pickActiveInterface();
if (!iface.isValid()) {
    qWarning() << "未找到可用接口，退出";
    return 1;
}

QHostAddress listenAddress;
for (const auto &entry : iface.addressEntries()) {
    if (entry.ip().protocol() == QAbstractSocket::IPv4Protocol
            && !entry.ip().isLinkLocal()) {
        listenAddress = entry.ip();
        break;
    }
}

QTcpServer server;
if (!server.listen(listenAddress, 9527)) {
    qWarning() << "监听失败:" << server.errorString();
    return 1;
}

这里有一个设计上的取舍：监听 QHostAddress::Any 会同时监听所有网卡，配置简单，但会把服务暴露到所有接口上，包括虚拟网卡和不必要的网段；监听 listenAddress 则更精确，但用户换网络后需要重新获取 IP。折中的做法是：自动获取 IP 作为默认值，同时允许用户在界面上下拉选择其他接口。自动选择只负责“省事”，不负责“替用户做决定”。

5.2 UDP 组播、多网卡与接口名

组播场景是 QNetworkInterface 最典型的应用之一。多网卡机器上加入组播组时，如果只写：

cpp复制socket.joinMulticastGroup(groupAddress);

系统会按默认路由选择接口，在多网卡环境下很可能选错，导致组播包收不到。正确做法是指定接口名：

cpp复制QUdpSocket socket;
socket.bind(QHostAddress::AnyIPv4, 6666,
            QUdpSocket::ShareAddress | QUdpSocket::ReuseAddressHint);

QNetworkInterface iface = pickActiveInterface();
if (iface.isValid()) {
    socket.joinMulticastGroup(groupAddress, iface.name());
}

这里 joinMulticastGroup 的第二个参数是接口名，也就是 iface.name() 的返回值，不是 humanReadableName()，也不是 IP 字符串。我见过有人传了 IP 进去，编译能过但运行时行为不对，排查起来很费劲。

链路本地 IPv6 也是多网卡环境下的重灾区。IPv6 的链路本地地址本身带有 scope ID，绑定时需要把接口索引设置到 QHostAddress 上：

cpp复制QHostAddress addr;
addr.setAddress("fe80::1234");
addr.setScopeId(QString::number(iface.index()));

如果你忘了处理 scope ID，IPv6 通信经常会报“地址不可用”之类的错误。

5.3 和 QNetworkInformation 搭配，监听网络变化

QNetworkInterface 适合做“快照式”查询，但它本身不提供网络变化通知。你不能靠它知道“WiFi 断开、切到有线网络”这种实时状态。Qt 6 引入了 QNetworkInformation，专门解决可达性判断的问题：

cpp复制#include <QNetworkInformation>

if (QNetworkInformation::loadBackend()) {
    auto *info = QNetworkInformation::instance();
    QObject::connect(info, &QNetworkInformation::reachabilityChanged,
                     [](QNetworkInformation::Reachability newState) {
        qInfo() << "网络可达性变化:" << static_cast<int>(newState);
    });
}

两者是互补关系：QNetworkInformation 告诉你“现在有没有网络”，QNetworkInterface 告诉你“具体是哪块网卡有网络、IP 是什么”。一个负责宏观状态，一个负责微观细节。在 Qt 5 时代，没有 QNetworkInformation 这样的统一接口，只能靠 QNetworkConfigurationManager 或者监听系统事件，跨平台体验很差。所以如果你在用 Qt 6，建议把“网络变化监听”这件事交给 QNetworkInformation，别自己搞轮询。

有一个现实限制：QNetworkInformation 能否拿到真实信息，取决于运行环境是否提供了后端（比如 Linux 下的 NetworkManager 后端、Windows/macOS 的原生后端）。在嵌入式或精简环境里，loadBackend() 可能返回 false。这种情况下，退路就是用 QNetworkInterface 定时采样对比，虽然笨一点，但至少是跨平台可用的方案。

我自己在实际项目里的做法是：QNetworkInformation 作为主监听通道，QNetworkInterface 作为排查时的“详细快照”，两边配合，基本能覆盖从“检测断网”到“定位哪个接口断了”的完整链路。

最后再分享一个小技巧：做“自动选网卡”的模块时，把 pickActiveInterface 的过滤逻辑单独提取成公共组件，单元测试里用一套虚构的接口列表验证每层过滤条件。QNetworkInterface 既然是描述性 API，它就非常适合做纯函数式测试——输入接口列表，输出选中的接口，逻辑简单清晰。这个习惯能帮你省掉大量线上排查时间。