标签: deep-copy

我需要编写一个复制构造函数,深度复制一个内容std::shared_ptr.但是,int a, b, c, d, e;在类中还定义了一堆变量.有没有办法在我的新重载的代码中生成默认的复制构造函数代码(或调用默认的复制构造函数).

这是一个带有注释的代码片段,希望能够澄清问题.

class Foo {
public:
     Foo() {}
     Foo(Foo const & other);
     ...
private:
     int a, b, c, d, e;
     std::shared_ptr<Bla> p;
};

Foo::Foo(Foo const & other) {
    p.reset(new Bla(*other.p));

    // Can I avoid having to write the default copy constructor code below
    a = other.a;
    b = other.b;
    c = other.c;
    d = other.d;
    e = other.e;
}

在C中,我习惯于strcpy制作一个字符串的深层副本,但在C++中使用它还是"很好"strcpy还是有更好的替代方法,我应该使用它？

是clone()Java中的浅拷贝？

最终,这将获得Object的clone()方法(最上层的类),它创建与对象相同的类的新实例,并将所有字段复制到新实例("浅拷贝").

我是从维基百科读到的.

我不明白为什么它是浅拷贝.clone()将创建一个包含所有字段的新实例.这只是一个很深的副本吗？困惑.需要一些解释.

我试图对setParentPython中的一个对象(一个继承自不同类的类的实例 - 具体而言QtGui.QLabel)执行一些操作(),但是在运行时期间引发了上述错误.对象本身有一些具有实际内容的字段(在调试时验证),但由于某种原因我无法"使用"它.错误意味着什么,我该如何解决？对于一些其他信息,我会说在我尝试对它执行此操作之前,该对象是从静态方法返回的.

子类具有__init__()自己的功能:

def __init__(self, image, father):
        super(AtomicFactory.Image, self).__init__(father)
        self.raw_attributes = image.attributes
        self.attributes = {}
        father.addChild(self)
        self.update()

现在我写了一个类似的代码,一个简单的代码,widget.setParent(mw)当窗口移动时在行上有相同的错误.

#!/usr/bin/env python
import sys
import copy
from PyQt4 import QtCore, QtGui

if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    main_widget=QtGui.QWidget()
    widget = QtGui.QPushButton('Test')
    widget.resize(640, 480)
    widget.setParent(main_widget)
    widget.move(0, 0)
    widget2=QtGui.QPushButton('Test2')
    widget2.i=0
    widget2.resize(600, 200)
    widget2.setParent(main_widget)
    widget2.move(640, 0)
    def onResize(event):
        print event
        mw=copy.deepcopy(main_widget)
        widget.setParent(mw)
        widget2.setParent(mw)
        widget.move(0, 0)
        widget2.move(640, 480)
        main_widget_width=main_widget.width()
        widget_width=widget.width()
        width2=main_widget_width-widget_width
        height2=widget2.height()
        widget2.resize(width2, height2)
        widget2.move(640, 0) …

我们有下一个javascript对象.现在我想克隆它,但没有一些字段.例如,我想要没有字段"lastName"和输入的克隆对象"cars.age"

{
   "firstName":"Fred",
   "lastName":"McDonald",
      "cars":[
           {
              "type":"mersedes",
              "age":5
           },
           {
              "model":"bmw",
              "age":10
           }
       ]
}  

输出(克隆)

{
   "firstName":"Fred",
   "cars":[
       {
          "model":"mersedes"
       },
       {
          "model":"bmw"
       }
   ]
}   

我可以做点什么

var human = myJson   
var clone = $.extend(true, {}, human)  
delete clone.lastName  
_.each(clone.cars, function(car))  
{  
   delete car.age  
}  

你知道更容易解决方案吗？

在大多数情况下,在C++中很容易实现复制构造函数(或重载赋值运算符),因为有一个指针的概念.但是,我对如何在Python中实现浅层和深层复制感到困惑.

我知道其中一个库中有特殊命令,但它们不适用于您自己编写的类.那么实施的常用方法有哪些？

PS将显示一些基本数据结构(链表或树)上的显示过程.

编辑:谢谢,他们工作,这是我在语法上的错误.我很感兴趣用__copy__()和覆盖这些函数__deep_copy()__.例如.如何在不知道数据结构中包含哪种类型的信息的情况下进行深层复制？

我正在研究技术图纸(svg/ruby​​)的解决方案.我想操纵矩形,并add!在这个类中有一个方法:

class Rect
  def add!(delta)
    @x1+=delta 
    ... # and so on
    self
  end
end

我还需要一个add返回a Rect但不操作的方法self:

def add(delta)
  r=self.dup/clone/"copy" # <-- not realy the 3 and no quotes, just in text here
  r.add! delta
end

dup并且clone不要做我的事情但是:

def copy; Marshal.load(Marshal.dump(self)); end

确实.

为什么普通Ruby中不存在这样的基本功能？请不要告诉我,我可以扭转add和add!,让add做的工作,并add!调用它.

在Go中,什么是深度复制切片的简洁/良好表现方式？我需要将切片复制到新的后备阵列,因为另一个阵列由其他内容拥有,并且可能在复制后进行修改.

我现在这样做:

copy := append([]T{}, orig...)

T元素类型在哪里orig.

在这里,我试图为连续录制的音频系统编写一些代码.然后,当某个幅度阈值被破坏时,我试图将音频记录一段时间.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <portaudio.h>
#include <sndfile.h>

#define FRAMES_PER_BUFFER (1024)
#define SAMPLE_SIZE (4)

typedef struct
{
    uint16_t formatType;
    uint16_t numberOfChannels;
    uint32_t sampleRate;
    float* recordedSamples;
} AudioData;

AudioData initAudioData(uint32_t sampleRate, uint16_t channels, int type)
{
    AudioData data;
    data.formatType = type;
    data.numberOfChannels = channels;
    data.sampleRate = sampleRate;
    return data;
}

float avg(float *data)
{
    int elems = sizeof(data) / sizeof(data[0]);
    float sum = 0;
    for (int i = 0; i < elems; i++)
    { …

我有一个对象，它有自己的内容（即某物的列表）和对另一个对象的引用，它与其链接。如何排除对另一个对象的引用进行深度复制？

from copy import deepcopy
class Foo:
    def __init__(self, content, linked_to):
        self.content = content
        self.linked_to = linked_to

a1 = Foo([[1,2],[3,4]], None)
a2 = Foo([[5,6],[7,8]], a1)

a3 = deepcopy(a2) # <- I don't want there, that a3.linked_to will be copied
# I want that a3.linked_to will still point to a1

a3.linked_to.content.append([9,10])
print a1.content # [[1,2],[3,4]], but I want [[1,2],[3,4], [9,10]]