Question

我有一个类，它存储一个指向数据块的指针和数据的大小。它实现了诸如“head”，“tail”之类的操作......但是从问题的角度来看它是无关紧要的。我使用它代替std :: vector，我不想深度复制。但是我有时需要复制数据，所以我有一个成员函数'duplicate'来做它。

struct ByteArray {
    char* data;
    int size;
    ByteArray(char* data, int size) : data(data), size(size) {}
    ByteArray duplicate() const {
        char *duplicatedData = new char[size];
        memcpy(duplicatedData, data, size);
        return ByteArray(duplicatedData, size);
    }
};

现在我有了一个派生类 - 扩展了前一个类，我需要一个重复的方法，它调用基类的重复。我已经设法通过将两个对象都转换为基类来解决它，但我怀疑这不是最好的解决方案。我错过了一个更明显的解决方案吗？这个类也是原始问题的正确解决方案（没有深层复制）或者有我不知道的标准解决方案吗？

struct Foo : ByteArray
{
    int bar;
    ... // more members
    Foo(ByteArray &bytes, int bar) : ByteArray(bytes), bar(bar) {}
    Foo duplicate() const {
        Foo dup = *this;
        static_cast<ByteArray&>(dup) = ByteArray::duplicate();
        return dup;
    }
};

Answer 1

如果您将Foo构造函数更改为 const 引用ByteArray，则duplicate()将非常简单：

Foo duplicate() const {
    return Foo(ByteArray::duplicate(), bar);
}

按原样，你仍然可以用同样的方式做，只需要额外的一行：

Foo duplicate() const {
    ByteArray ba = ByteArray::duplicate();
    return Foo(ba, bar);
}

Answer 2

那样的事情呢......

#include <cstring>
#include <iostream>

using namespace std;

struct ByteArray {
  char* data;
  int size;
  ByteArray(char* data, int size) : data(data), size(size) {}
  void duplicate(ByteArray &toCopy) const {
    cout<<"Byte array duplicate."<<endl;
    char *data = new char[toCopy.size];
    memcpy(data, toCopy.data, size);
  }
};

struct Foo : ByteArray
{
  int bar;
  Foo(ByteArray &bytes, int bar) : ByteArray(bytes), bar(bar) {}
  void duplicate(Foo &toCopy) const {
    cout<<"Foo duplicate."<<endl;
    ByteArray::duplicate(toCopy);
  }
};

int main(){
  char* str = "some data";
  char* null = "";
  ByteArray barr (str, 9);
  ByteArray barr2 = barr;
  barr2.duplicate(barr);

  Foo farr (barr, 2);
  Foo farr2 = farr;
  farr2.duplicate(farr);

}

从派生类方法设置基础对象

2 个答案: