标签: deep-copy

如果我使用以下内容:

  var myList = Enumerable.Repeat(myCustomObject, 2);

列表中的第二个元素是否是第一个元素的深层副本？

注意: myCustomObject可以是任何Object

编辑:在处理自定义对象时,您能告诉我Enumerable.Repeat的潜在用途吗？

谢谢

我正在尝试制作通用列表的深层副本,并且想知道是否有任何其他方法然后创建复制方法并实际上一次复制每个成员.我有一个看起来像这样的课程:

public class Data
{            
    private string comment;
    public string Comment
    {
        get { return comment; }
        set { comment = value; }
    }

    private List<double> traceData;
    public List<double> TraceData
    {
        get { return traceData; }
        set { traceData = value; }
    }
}

我有一份上述数据清单,即List<Data>.我要做的是将List子集的跟踪数据绘制到图形上,可能需要对数据进行一些缩放或扫描.我显然不需要在列表中绘制所有内容,因为它们不适合屏幕.

我最初尝试使用该List.GetRange()方法获取列表的子集,但似乎底层List<double>是浅层复制而不是深度复制.当我使用List.GetRange()再次获取子集时,我获得了先前修改过的数据,而不是其他地方检索到的原始数据.

任何人都可以给我一个如何处理这个问题的方向吗？非常感谢.

试图在我的"变量"类中理解这个错误.

我希望在我的"变量"类中存储一个sre.SRE_Pattern.我刚刚开始复制Variable类,并注意到它导致我的所有Variable类实例都发生了变化.我现在明白我需要对这个类进行深度复制,但现在我遇到了"TypeError:无法深度复制这个模式对象".当然,我可以将模式存储为文本字符串,但我的其余代码已经预期编译模式!使用模式对象复制Variable类的最佳方法是什么？

import re
from copy import deepcopy

class VariableWithRE(object):
    "general variable class"
    def __init__(self,name,regexTarget,type):
        self.name = name
        self.regexTarget = re.compile(regexTarget, re.U|re.M) 
        self.type = type 

class VariableWithoutRE(object):
    "general variable class"
    def __init__(self,name,regexTarget,type):
        self.name = name
        self.regexTarget = regexTarget
        self.type = type 

if __name__ == "__main__":

    myVariable = VariableWithoutRE("myName","myRegexSearch","myType")
    myVariableCopy = deepcopy(myVariable)

    myVariable = VariableWithRE("myName","myRegexSearch","myType")
    myVariableCopy = deepcopy(myVariable)

我只是想找出如何制作深层副本的最佳解决方案HashMap.此映射中没有实现的对象Cloneable.我想找到比序列化和反序列化更好的解决方案.

假设我有以下(简化案例):

class Color;

class IColor
{
public: 
    virtual Color getValue(const float u, const float v) const = 0;
};

class Color : public IColor
{
public:
    float r,g,b;
    Color(float ar, float ag, float ab) : r(ar), g(ag), b(ab) {}
    Color getValue(const float u, const float v) const 
    { 
        return Color(r, g, b)
    }
}

class Material
{
private:
    IColor* _color;
public:
    Material();
    Material(const Material& m);
}

现在,有没有办法让我在Material的复制构造函数中做一个抽象IColor的深层复制？也就是说,我想要复制m._color的值(颜色,纹理),而不仅仅是指向IColor的指针.

我有一个非常简单的python例程,它涉及在大约20,000个纬度,经度坐标的列表中循环并计算每个点到参考点的距离.

def compute_nearest_points( lat, lon, nPoints=5 ):
    """Find the nearest N points, given the input coordinates."""

    points = session.query(PointIndex).all()
    oldNearest = []
    newNearest = []
    for n in xrange(nPoints):
        oldNearest.append(PointDistance(None,None,None,99999.0,99999.0))
        newNearest.append(obj2)

    #This is almost certainly an inappropriate use of deepcopy
    #  but how SHOULD I be doing this?!?!
    for point in points:
        distance = compute_spherical_law_of_cosines( lat, lon, point.avg_lat, point.avg_lon )
        k = 0
        for p in oldNearest:
            if distance < p.distance:
                newNearest[k] = PointDistance(
                    point.point, point.kana, point.english, point.avg_lat, point.avg_lon, distance=distance …

有一种方法或简单方法如何将一个TDictionary内容复制到另一个中？假设我有以下声明

type
  TItemKey = record
    ItemID: Integer;
    ItemType: Integer;
  end;
  TItemData = record
    Name: string;
    Surname: string;
  end;
  TItems = TDictionary<TItemKey, TItemData>;

var
  // the Source and Target have the same types
  Source, Target: TItems;
begin
  // I can't find the way how to copy source to target
end;

我想将源1:1复制到目标.有这样的方法吗？

谢谢!

我有一些图书馆代码在我身上无休止地骑自行车.

我不清楚如何在javascript中最好地执行循环检测和避免.也就是说,没有程序化的方法来检查一个物体是否来自"这个"参考,是吗？

这是代码.谢谢!

setAttrs: function(config) {
    var go = Kinetic.GlobalObject;
    var that = this;

    // set properties from config
    if(config !== undefined) {
        function setAttrs(obj, c) {
            for(var key in c) {
                var val = c[key];

                /*
                 * if property is an object, then add an empty object
                 * to the node and then traverse
                 */
                if(go._isObject(val) && !go._isArray(val) && !go._isElement(val)) {
                    if(obj[key] === undefined) {
                        obj[key] = {};
                    }
                    setAttrs(obj[key], val);  // <--- offending code; 
                                              // one of my …

我想知道我是否误解了某些内容:复制构造函数是否std::string 不复制其内容？

string str1 = "Hello World";
string str2(str1);

if(str1.c_str() == str2.c_str()) // Same pointers!
  printf ("You will get into the IPC hell very soon!!");

这将打印出"你很快就会进入IPC地狱!" 它让我烦恼

这是正常的行为std::string吗？我在某处读到它通常会做一个深层复制.

但是,这可以按预期工作:

string str3(str1.c_str());

if(str1.c_str() == str3.c_str()) // Different pointers!
  printf ("You will get into the IPC hell very soon!!");
else
  printf ("You are safe! This time!");

它将内容复制到新字符串中.

我正在实现一个模板化的向量类(不是数据容器,而是线性代数意义上的向量),每当我rhs在运算符重载中引用时,我都会遇到很多错误.此外,我的复制构造函数似乎没有工作.

#ifndef __VecXd__VecXd__
#define __VecXd__VecXd__

#define ULL unsigned long long
#include <iostream>

using namespace std;

template <class T>
class VecXd
{

public:

    explicit VecXd(ULL newDimension = 1) { dimension = newDimension; vector = new T[newDimension];}
    VecXd(const VecXd<T> &rhs);
    VecXd<T>& operator=(const VecXd<T> &rhs);
    const VecXd<T> operator+(const VecXd<T> &rhs) const;
    VecXd<T>& operator+=(const VecXd<T> &rhs);
    friend ostream& operator<<(ostream &out, VecXd<T> vec);
    friend istream& operator>>(istream &in, VecXd<T>& vec);
    ~VecXd() { delete[] vector; }

    const ULL getDimension() { return dimension; }
    const T …