复制类的一部分

Question

我想将类的一部分复制到缓冲区。我需要这个来制作一些可以查看类中是否有更改的东西，并通过网络发送它以更新服务器上的更改。

我做了一个模板类，可以备份和恢复类。现在我正在制作“寻找差异”功能。我希望用户可以定义内存块有多大。这将类分成几部分并且需要发送更少的数据。

问题是我无法将类内存的一部分复制到堆中，我无法获得正确的地址。如果我做“类的地址”+“0x04”。然后我就得不到正确的地址。

这是我制作的一个例子：

testclass test1;
testclass test2;

test1.set(1,1);
test2.set(1,2);

cout << &test1 << " " << (&test1 + 0x04) << endl; //0018FF24 0018FF44

memcpy(&test2,&test1 + 0x04,4);

test2.echo(); //Wrong data!

标题：

class testclass
{
    int test,test2;

public:
    void set(int a, int b) {test = a, test2 = b;}
    void echo() {cout << test << " " << test2 << endl;}
};

我希望有人帮助我解决这个问题。

谢谢！

Answer 1

基本上，你不能乱用这样的指针。您通常不能依赖编译器巧合地将有意义的数据放在那里。

如果你想要成员的地址，你应该写 &(test1.test2) 而不是 &test1+0x04 因为即使 IF 是一个 int 4 个字节，并且 IF 编译器没有填充结构，并且 IF 您或其他人没有更改类的内容，则 &test1+ 0x04 的真正含义“&test1 plus 4*sizeof(test) bytes”，这是达到 (&test1)[4] 的另一种方式指针数组等价。

另外，一般情况下，您不能对类进行 memcpy 并期望得到有意义的结果，除非它们是 POD。

如果你想比较一个类的实例，你应该编写一个函数来依次比较每个成员。

您无法为此编写通用方法，因为 C++ 不是反射语言。这意味着您无法编写能够神奇地知道类成员的名称和类型的代码。

因此，如果您想像这样比较和修补数据，您将需要执行以下操作：

struct Foo {
    int a;
    int b;

    void export_differences (std :: ostream & o, const Foo & f) {
        if (a != f.a) o << "a " << f.a << " ";
        if (b != f.b) o << "b " << f.b << " ";
        o << ";";
    }

    void import_differences (std :: istream & i) {
        std :: string s;
        while (i >> s) {
            if (s == "a") i >> a;
            else if (s == "b") i >> b;
            else if (s == ";") break;
            else throw std :: runtime_error ("bad input");
        }
    }
};

您必须为要修补的每个类编写类似的内容。

Answer 2

神奇的 0x04 和 4 从哪里来？

如果这有效，那只是因为特定的调整和实现。
更好的更结构化的方式：

class testclass
{
    int test,test2;

public:
    void set(int a, int b) {test = a, test2 = b;}
    void echo() {cout << test << " " << test2 << endl;}

    void backup_to(testclass& s)
    { s.test2 = test2; }

    bool has_changed_respect(const testclass& s)
    { return s.test2 == test2; }

    friend std::ostream& operator<<(std::ostream& s, const testclass& a)
    { return s << "testclass["<<&a<<"]: test="<<a.test<<", test2="<<a.test2<< std::endl; }
};

int main()
{
    testclass t1, t2;
    t1.set(1,1);
    t2.set(3,4);

    std::cout << t1 << t2;

    t1.backup_to(t2);
    std::cout << t2;

    t1.set(5,6);
    cout << t1 << t2 << t1.is_changed_respect(t2) << std::endl; 

    return 0;
}

Answer 3

&test1 + 0x04表示将testclass大小的4倍添加到test1的地址上，得到的指针类型为testclass *。它将指向数组的第五个元素，其第一个元素位于 test1 的地址，但 test1 不是数组的一部分，因此加法未定义行为。

您似乎想要的是向 test1 的地址添加 4字节。例如，您可以使用 ((char*)&test1) + 4 来执行此操作，这会生成 char* 类型的指针。请注意，该标准不保证 sizeof(int) 为 4，也不保证 offsetof(testclass, test2) == sizeof(int)。

您可以以 char* 或 unsigned char* 形式检查任何对象的内存。但这种能力的有用性有一些限制：

1. 类中可以有填充字节，可以采用任何值。因此，仅仅因为两个对象在内存中具有不同的字节值并不意味着它们不相等。
2. 非 POD 类中可以包含几乎任意的“额外内容”，由实现放置在那里，并且不能安全地按字节复制。
3. 具有指针成员的类通常无法安全地按字节复制，当然也不能通过网络复制到另一台机器。
4. 即使类是 POD，如果您通过网络发送它，那么您也必须确保该类在两台机器上具有相同的布局。如果代码是使用不同的选项、由不同的编译器或针对不同的体系结构编译的，则不一定是这种情况，但有时确实是这样。

Answer 4

1）首先，你需要你的类是POD。至少你可以取出数据成员来分离结构。

2) 然后，如果需要的话选择偏移粒度 = 1、2、4 或 2^n 字节；并确定适合此要求的类型：2^n == sizeof(chunk_type)。例如，您希望进行字节到字节的比较，因此将指向 _State （或 MyClass 参见 #1）的指针转换为所需类型： (char*)this- >m_state。

这是一个函数，它尝试找到两个类中不同的第一个块，并返回其偏移量，如果没有找到差异，则返回 -1。

class MyClass {
  struct _State { 
    int a,b
  };

  _State m_state;

public:
  typedef char  chunk_type;
  int next_diff_pos(const MyClass& other, size_t offset = 0) const {
      chunk_type *pThis = &m_state, 
                 *pOther = &other.m_state;

      if (offset < sizeof(_State)) {
        size_t n = offset;
        while(*pThis++ == *pOther++ && n < sizeof(_State)) 
          n++;
        // We need to test this again, because of ambigous while condition
        if (n < sizeof(_State))
          return n;
      } 

      return -1;
  }
};

PS：当然，您的 chunk_type 必须定义 == 运算符（这已经针对 char、int 和其他标量完成）。

（我没有测试过代码）