C++中合规地将结构体成员当作数组遍历的方法

咱们先把核心问题掰明白：你原来的C代码在C里触发未定义行为，根源是C标准对指针算术的严格限制——只有指向同一个数组对象（或单个对象被视为的单元素数组）的指针，才能在合法范围内做算术运算。结构体的独立成员不属于同一个数组，所以从&p1->x偏移到y/z的操作，哪怕内存布局看起来连续，也是标准明确禁止的UB。

下面针对C++17及旧版本，给出几种完全合规的解决方案：

C++17 最优方案：用std::array重构结构体 #

如果可以调整结构体的定义，最稳妥的方式是把成员放进std::array，同时保留原有的x/y/z访问方式：

#include <array>
#include <cmath>

struct Point {
    std::array<double, 3> coords;

    // 提供与原结构体一致的成员访问接口
    double& x() noexcept { return coords[0]; }
    const double& x() const noexcept { return coords[0]; }
    double& y() noexcept { return coords[1]; }
    const double& y() const noexcept { return coords[1]; }
    double& z() noexcept { return coords[2]; }
    const double& z() const noexcept { return coords[2]; }
};

double dist(const Point* p1, const Point* p2) {
    double d2 = 0;
    for (std::size_t i = 0; i < 3; ++i) {
        const double d = p2->coords[i] - p1->coords[i];
        d2 += d * d;
    }
    return std::sqrt(d2);
}

这个方案完全符合C++17标准：std::array是标准数组容器，遍历数组元素的指针算术完全合法，同时通过getter函数保留了原有的成员访问习惯。如果需要编译期访问，还可以把getter改成constexpr。

C++17 备选：结构化绑定+std::apply遍历tuple #

如果不想重构结构体，也可以把成员打包成tuple，通过编译期索引遍历：

#include <tuple>
#include <cmath>
#include <utility>

struct Point {
    double x, y, z;

    // 返回成员的引用tuple
    auto as_tuple() noexcept { return std::tie(x, y, z); }
    auto as_tuple() const noexcept { return std::tie(x, y, z); }
};

double dist(const Point* p1, const Point* p2) {
    double d2 = 0;

    // 用std::apply展开tuple，配合索引序列做对应位置计算
    std::apply([&](auto&&... coords1) {
        std::apply([&](auto&&... coords2) {
            auto calc = [&]<std::size_t... Is>(std::index_sequence<Is...>) {
                ((d2 += (std::get<Is>(coords2) - std::get<Is>(coords1)) * (std::get<Is>(coords2) - std::get<Is>(coords1))), ...);
            };
            calc(std::index_sequence_for<decltype(coords1)...>{});
        }, p2->as_tuple());
    }, p1->as_tuple());

    return std::sqrt(d2);
}

这个方案不需要修改结构体的内存布局，完全依赖标准库的tuple和编译期特性，没有任何UB风险。

旧版本C++（C++11/14）方案 #

如果需要兼容C11或C14，可以用普通数组替代std::array，或者用递归模板遍历tuple：

方案1：普通数组重构结构体 #

#include <cmath>

struct Point {
    double coords[3];

    double& x() { return coords[0]; }
    const double& x() const { return coords[0]; }
    double& y() { return coords[1]; }
    const double& y() const { return coords[1]; }
    double& z() { return coords[2]; }
    const double& z() const { return coords[2]; }
};

double dist(const Point* p1, const Point* p2) {
    double d2 = 0;
    for (int i = 0; i < 3; ++i) {
        const double d = p2->coords[i] - p1->coords[i];
        d2 += d * d;
    }
    return std::sqrt(d2);
}

逻辑和C++17的std::array版本一致，只是用原生数组替代标准容器。

方案2：递归模板遍历tuple（C++11兼容） #

#include <tuple>
#include <cmath>
#include <type_traits>

struct Point {
    double x, y, z;

    auto as_tuple() -> decltype(std::tie(x, y, z)) { return std::tie(x, y, z); }
    auto as_tuple() const -> decltype(std::tie(x, y, z)) const { return std::tie(x, y, z); }
};

namespace detail {
    // 递归终止条件
    template<std::size_t I = 0, typename Tuple1, typename Tuple2>
    typename std::enable_if<I == std::tuple_size<Tuple1>::value, void>::type
    calc_dist_sq(double& d2, const Tuple1& t1, const Tuple2& t2) {}

    // 递归遍历tuple索引
    template<std::size_t I = 0, typename Tuple1, typename Tuple2>
    typename std::enable_if<I < std::tuple_size<Tuple1>::value, void>::type
    calc_dist_sq(double& d2, const Tuple1& t1, const Tuple2& t2) {
        const double d = std::get<I>(t2) - std::get<I>(t1);
        d2 += d * d;
        calc_dist_sq<I+1>(d2, t1, t2);
    }
}

double dist(const Point* p1, const Point* p2) {
    double d2 = 0;
    detail::calc_dist_sq(d2, p1->as_tuple(), p2->as_tuple());
    return std::sqrt(d2);
}

这个方案用C++11的SFINAE和递归模板实现tuple遍历，完全合规，不需要依赖编译器扩展。

避坑提醒 #

• 不要用C风格的union类型双关：C标准没有像C那样允许通过union访问不同成员来做类型双关，这种操作在C里属于明确的UB，哪怕编译器看起来支持。
• 不要依赖内存布局断言：哪怕你用offsetof断言成员连续，跨成员的指针算术依然是UB——标准不保证结构体成员的内存布局可以被当作数组处理，哪怕实际运行时没问题。

内容的提问来源于stack exchange，提问作者Serge Ballesta