如何在C++中用更少重复代码拷贝不同命名空间的同结构Proto消息？

现有两个Protocol Buffers定义的消息类型Test1::A与Test2::A，二者属性结构完全一致，仅所属命名空间不同且无法修改。在C++代码中，当前需将Test1::A实例的属性赋值给Test2::A实例，采用的是逐个属性复制的方式，存在大量重复代码，询问是否有更优的实现方式。

定义文件示例 #

A.proto

syntax = "proto3";

package Test1;

message A{
    double x = 1;
    double y = 2;
    double z = 3;
    double theta = 4;
    double kappa = 5;
    float s = 6;
    float v = 7;
    float a = 8;
}

B.proto

syntax = "proto3";

package Test2;

message A{
    double x = 1;
    double y = 2;
    double z = 3;
    double theta = 4;
    double kappa = 5;
    float s = 6;
    float v = 7;
    float a = 8;
}

C++代码示例 #

#include <iostream>
#include "A.pb.h"
#include "B.pb.h"

void fun(){
    Test1::A t1;
    Test2::A t2;
    // t1的赋值操作，无需关注
    t1.set_x(1.0);
    t1.set_y(2.0);
    t1.set_z(3.0);
    t1.set_theta(4.0);
    t1.set_kappa(5.0);
    t1.set_s(6.0);
    t1.set_v(7.0);
    t1.set_a(8.0);

    // t2 = static_cast<Test2::A>(t1); 无法强制转换

    // 通过t1为t2赋值，是否有其他更简洁的方式？
    t2.set_x(t1.x());
    t2.set_y(t1.y());
    t2.set_z(t1.z());
    t2.set_theta(t1.theta());
    t2.set_kappa(t1.kappa());
    t2.set_s(t1.s());
    t2.set_v(t1.v());
    t2.set_a(t1.a());
    
    // 后续关于t2的操作....
    std::cout << t2.z() << std::endl;
}

int main(){
    fun();
}

因为两个消息的字段编号、类型、结构完全一致，可通过以下两种方式替代逐个字段复制：

方法一：序列化/反序列化批量转换 #

利用Protobuf的序列化特性，将源消息转为字节流，再反序列化为目标消息类型，代码简洁且无需关注字段细节：

void fun(){
    Test1::A t1;
    Test2::A t2;
    // t1赋值操作...
    t1.set_x(1.0);
    t1.set_y(2.0);
    // ...其他赋值

    // 序列化+反序列化实现转换
    std::string serialized_data;
    t1.SerializeToString(&serialized_data);
    t2.ParseFromString(serialized_data);

    // 后续操作t2...
    std::cout << t2.z() << std::endl;
}

优势：后续字段增减时，只要两个消息结构同步更新，代码无需修改，完全避免重复代码。

方法二：反射API直接复制字段（低开销） #

如果不想产生序列化的字节流开销，可使用Protobuf的反射机制直接复制字段值，性能更高且通用：

#include <google/protobuf/reflection.h>

void copyProtoMessage(const google::protobuf::Message& src, google::protobuf::Message* dst) {
    // 断言确保两个消息结构完全匹配
    GOOGLE_DCHECK_EQ(src.GetDescriptor(), dst->GetDescriptor());
    
    const google::protobuf::Reflection* src_reflection = src.GetReflection();
    google::protobuf::Reflection* dst_reflection = dst->GetReflection();

    // 遍历所有字段完成复制
    for (int i = 0; i < src.GetDescriptor()->field_count(); ++i) {
        const google::protobuf::FieldDescriptor* field = src.GetDescriptor()->field(i);
        if (src_reflection->HasField(src, field)) {
            if (field->is_repeated()) {
                // 处理重复字段
                dst_reflection->ClearField(dst, field);
                int count = src_reflection->FieldSize(src, field);
                for (int j = 0; j < count; ++j) {
                    const google::protobuf::Message& src_element = src_reflection->GetRepeatedMessage(src, field, j);
                    google::protobuf::Message* dst_element = dst_reflection->AddRepeatedMessage(dst, field);
                    copyProtoMessage(src_element, dst_element);
                }
            } else if (field->type() == google::protobuf::FieldDescriptor::TYPE_MESSAGE) {
                // 处理嵌套消息
                const google::protobuf::Message& src_msg = src_reflection->GetMessage(src, field);
                google::protobuf::Message* dst_msg = dst_reflection->MutableMessage(dst, field);
                copyProtoMessage(src_msg, dst_msg);
            } else {
                // 处理基础类型字段
                dst_reflection->CopyField(dst, field, src, field);
            }
        } else {
            dst_reflection->ClearField(dst, field);
        }
    }
}

// 使用示例
void fun(){
    Test1::A t1;
    Test2::A t2;
    // t1赋值...

    copyProtoMessage(t1, &t2);

    // 后续操作t2...
}

优势：无序列化开销，性能更优，同时支持任意结构一致的Protobuf消息转换。

注意事项 #

• 必须保证两个消息的字段编号、类型、重复属性完全一致，否则反射方法会触发断言，序列化方法会忽略不匹配字段。
• 两种方法都比逐个字段复制的维护成本低，后续消息结构更新时无需修改转换代码。

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