如果你认为修改一个结构体不会造成太大的干扰（它不会改变你现有的定义，你甚至不需要把它放在公共头中）：

BOOST_FUSION_ADAPT_STRUCT(S, n, name)

字符串
然后你可以为序列构造一个通用的operator<<：

namespace BF = boost::fusion;
template <typename T,
          typename Enable = std::enable_if_t<
              // BF::traits::is_sequence<T>::type::value>
              std::is_same_v<BF::struct_tag, typename BF::traits::tag_of<T>::type>>>
std::ostream& operator<<(std::ostream& os, T const& v)
{
    bool first = true;
    auto visitor = [&]<size_t I>() {
        os << (std::exchange(first, false) ? "" : ", ")
           << BF::extension::struct_member_name<T, I>::call()
           << " = " << BF::at_c<I>(v);
    };
    // visit members
    [&]<size_t... II>(std::index_sequence<II...>)
    {
        return ((visitor.template operator()<II>(), ...);
    }
    (std::make_index_sequence<BF::result_of::size<T>::type::value>{});
    return os;
}

型

• （在c++20之前，这需要一些显式的模板类型，而不是paddas，也许会使它更具可读性。我想我是懒惰的......）*

这里有一个现场演示：Live On Compiler Explorer

n = 1, name = foo

型

额外好处：正确引用类字符串类型

Live On Compiler Explorer

#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <iostream>
#include <iomanip>
namespace MyLib {
    struct S {
        int         n;
        std::string name;
    };
    namespace BF = boost::fusion;
    static auto inline pretty(std::string_view sv) { return std::quoted(sv); }
    template <typename T,
            typename Enable = std::enable_if_t<
                not std::is_constructible_v<std::string_view, T const&>>>
    static inline T const& pretty(T const& v)
    {
        return v;
    }
    template <typename T,
            typename Enable = std::enable_if_t<
                // BF::traits::is_sequence<T>::type::value>
                std::is_same_v<BF::struct_tag, typename BF::traits::tag_of<T>::type>>>
    std::ostream& operator<<(std::ostream& os, T const& v)
    {
        bool first = true;
        auto visitor = [&]<size_t I>() {
            os << (std::exchange(first, false) ? "" : ", ")
            << BF::extension::struct_member_name<T, I>::call()
            << " = " << pretty(BF::at_c<I>(v));
        };
        // visit members
        [&]<size_t... II>(std::index_sequence<II...>)
        {
            return (visitor.template operator()<II>(), ...);
        }
        (std::make_index_sequence<BF::result_of::size<T>::type::value>{});
        return os;
    }
} // namespace MyLib
BOOST_FUSION_ADAPT_STRUCT(MyLib::S, n, name)
int main()
{
    MyLib::S o{1, "foo"};
    std::cout << o << "\n";
}

型
产出：

n = 1, name = "foo"

型

库不能提供任何这样的功能，因为目前不可能获得类成员的名称作为对象的值。
如果要输出字段名，则需要声明与成员Map的字符串对象，并实现手动使用这些字符串的operator<<。
要做到这一点，一个更复杂的反射库可能会提供宏来定义成员。宏可以使用提供的名称作为标识符将其参数扩展到声明中，同时也可以使用名称作为字符串字面量（通过#宏替换操作符）生成代码。

这是愚蠢的，但嘿，与字符串化宏每个字段可能是足够的你。

• C++14，没有额外的库 *

#include <boost/pfr.hpp>
struct S
{
    int n;
    std::string name;
    static char const* const s_memNames[2];
};
char const* const S::s_memNames[2] = {"n", "name"};
// utility
template< size_t I, typename TR >
char const* MemberName()
{
    using T = std::remove_reference_t<TR>;
    if (I < std::size(T::s_memNames))
        return T::s_memNames[I];
    return nullptr;
}
// test:
#include <iostream>
using std::cout;
template< size_t I, typename T >
void StreamAt(T&& inst)
{
    char const* n = MemberName<I,T>();
    auto& v = boost::pfr::get<I>(inst);
    cout << "(" << n << " = " << v << ")";
}
int main()
{
    S s{2, "boo"};
    boost::pfr::for_each_field(s, [&](const auto&, auto I)
                               {
                                   StreamAt<decltype(I)::value>(s);
                                   cout << "\n";
                               });
}

字符串
产出：
（n = 2）
(name（嘘）

• （以前版本的建议，这一个有更多的绒毛，所以不太有趣）*

#include <boost/pfr.hpp>
// library additions:
static char const* g_names[100];
template< size_t V >
struct Id : std::integral_constant<size_t, V > {};
template< size_t I, typename T >
using TypeAt = boost::pfr::tuple_element_t<I, T>;
template<std::size_t Pos, class Struct>
constexpr int Ni()  // name index
{
    return std::tuple_element_t<Pos, typename std::remove_reference_t<Struct>::NamesAt >::value;
}
struct StaticCaller
{
    template< typename Functor >
    StaticCaller(Functor f) { f();}
};
///
/// YOUR CODE HERE
struct S
{
    using NamesAt = std::tuple<Id<__COUNTER__>, Id<__COUNTER__>>;  // add this
    int n;
    std::string name;
    static void Init()  // add this
    {
        g_names[Ni<0,S>()] = "n";
        g_names[Ni<1,S>()] = "name";
    }
};
StaticCaller g_sc__LINE__(S::Init);  // add this
// utilities
template< size_t I, typename T >
auto GetValueName(T&& inst)
{
    return std::make_pair(boost::pfr::get<I>(inst), g_names[Ni<I,T>()]);
}
// test:
#include <iostream>
using std::cout;
template< size_t I, typename T >
void StreamAt(T&& inst)
{
    auto const& [v,n] = GetValueName<I>(inst);
    cout << "(" << v << ", " << n << ")";
}
int main()
{
    S s{2, "boo"};
    boost::pfr::for_each_field(s, [&](const auto&, auto I)
                               {
                                   StreamAt<decltype(I)::value>(s);
                                   cout << "\n";
                               });
}

型
输出
（2，n）
(boo，姓名）

这在boost 1.84中是可能的，在最新版本的pfr git repo中也是可能的。你可以使用像boost::pfr::names_as_array<Type>()和boost::pfr::get_name<N, Type>这样的函数（我在使用今天的预发布代码构建后者时遇到了一些问题，但是names_as_array在所有三大编译器上都解决了）。请参阅文档。
(for有关其工作原理的说明，请参阅this answer by Artyer）