拷贝

下面第一部分文字描述来源于： http://www.cnblogs.com/yxnchinahlj/archive/2010/09/20/1831615.html 源代码自写。 深克隆浅克隆简要描述、 浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷贝不仅拷贝对象本身，而且拷贝对象包含的 引用指向的所有对象。举例来说更加清楚：对象A1中包含对B1的引用，B1中包含对C1的引用。浅拷贝A1得到A2，A2 中依然包含对B1的引用，B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归，深拷贝A1得到A2，A2中包含对B2（B1的copy）的引用，B2 中包含对C2（C1的copy）的引用。 浅复制（浅克隆） 被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不 复制它所引用的对象 深复制（深克隆） 被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原 有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 浅度克隆步骤： 1、实现java.lang.Cloneable接口 2、重写java.lang.Object.clone()方法 在浅度克隆的基础上

一、常用备份： 下面的方法是比较简单且常用的SQLite数据库备份方式，见如下步骤： 1). 使用SQLite API或Shell工具在源数据库文件上加共享锁。 2). 使用Shell工具(cp或copy)拷贝数据库文件到备份目录。 3). 解除数据库文件上的共享锁。 以上3个步骤可以应用于大多数场景，而且速度也比较快，然而却存在一定的刚性缺陷，如： 1). 所有打算在源数据库上执行写操作的连接都不得不被挂起，直到整个拷贝过程结束并释放文件共享锁。 2). 不能拷贝数据到in-memory数据库。 3). 在拷贝过程中，一旦备份数据库所在的主机出现任何突发故障，备份数据库可能会被破坏。 在SQLite中提供了一组用于在线数据库备份的APIs函数(C接口)，可以很好的解决上述方法存在的不足。通过该组函数，可以将源数据库中的内容拷贝到另一个数据库，同时覆盖目标数据库中的数据。整个拷贝过程可以以增量的方式完成，在此情况下，源数据库也不需要在整个拷贝过程中都被加锁，而只是在真正读取数据时加共享锁。这样，其它的用户在访问源数据库时就不会被挂起。 二、在线备份APIs简介： SQLite提供了以下3个APIs函数用于完成此操作，这里仅仅给出它们的基本用法，至于使用细节可以参考SQLite官方网站"APIs Reference"( http://www.sqlite.org/c3ref

注：命令中ID有时长有时短，在此做个解释：大多情况无需拷贝完整的id，通常来讲最开始的三至四个字母即可区分 1、给tomcat容器部署项目即拷贝文件到tomcat容器中（向容器内拷贝） 方法一、挂载宿主机目录到容器（弊端：必须在容器启动时执行挂载） 命令：docker run -d -itp 80:8080 -v /zpfile:/mnt c0c /bin/bash （-v即挂载参数， -v 宿主机目录：容器的目录） [root@localhost ROOT]# docker images REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE hub.c.163.com/wangjiaen/centos6.9 ssh 5caf8ed79df7 9 weeks ago 370.9 MB hub.c.163.com/public/tomcat 7.0.28 a3c2d8714b1c 15 months ago 266.9 MB [root@localhost /]# docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES c3e6b957608e c0c "/bin/sh -c '/etc/in 13 minutes ago Up 13 minutes 22/tcp, 0.0.0

创建型模式 5）原型模式 这种模式主要是用于获取当前实例的拷贝。 假如当前基类有很多派生类，而我们只有基类指针而无法确定指向对象时，是无法直接执行拷贝动作的。因为拷贝时需要显式调用该派生类的拷贝构造函数，也就必须要确定派生类的类型。 为了解决这个问题，在基类中添加clone方法，通过return new (*this)返回当前对象。 class Juice{ public: virtual void show() = 0; virtual Juice* clone() = 0; }; class AppleJuice : public Juice{ public: void show(){ cout<< "this is applejuice"<<endl; } Juice* clone(){ return new AppleJuice(*this); } }; class OrangeJuice: public Juice{ public: void show(){ cout<<"this is orangejuice"<<endl; } Juice* clone(){ return new OrangeJuice(*this); } }; int main(){ Juice* p1 = new OrangeJuice(); /* 传了很久很久 以至于忘了p1是什么 */ /

注：本文基于CentOS 6.5 3.10内核，docker版本1.7.1 背景 制作docker镜像时，要把一个文件拷贝至镜像中，可以使用ADD或者COPY命令，但是使用的时候一直报错。 [root@localhost test]# docker build . Sending build context to Docker daemon 3.072 kB Sending build context to Docker daemon Step 0 : FROM gpmidi/centos-6.5 ---> d7943348aefb Step 1 : ADD a /root stat /var/lib/docker/devicemapper/mnt/45f35175c0848980b14929ead6ba6bc3b85b4836c5f0861cd25c9fad7c27e4eb/rootfs/root/a: not a directory 最简单的操作，把当前目录的a文件拷贝至镜像环境中的/root目录，然而就是不成功。 换成COPY也一样报错。 [root@localhost test]# docker build . Sending build context to Docker daemon 3.072 kB Sending build context to Docker

memcpy和memmove函数 memcpy函数 1.源函数 void * memcpy ( void * dest , const void * src , size_t n ) 2.作用 (小编自己的理解)内存拷贝。从src内存空间移动n个元素，将其赋值给dest的内存中，从内存中第一个地址所指向的数据开始赋值，直到赋值n个数据，该函数调用结束，同时返回dest，即返回被赋值的内存的起始位置。返回dest的意义是可是增加链接属性。 memcpy函数实现 : (my_memcpy) 原谅小编没有找到源代码 #include <assert.h> //包含assert函数的头文件 #define my_type int //自己定义要进行内存赋值的数据类型 ​ my_type * my_memcpy ( my_table * dest , const my_type * src , size_t n ) { my_type * start = dest ; //用于返回dest的初始地址,使该函数具有链接属性 assert ( dest != NULL ); //断言dest与src不是空地址 assert ( src != NULL ); while ( n -- ) { * dest ++ = * src ++ ; } return start ; }

memcpy和memmove均为内存拷贝函数，原型分别为： void * memcpy ( void *dest, const void *src, size_t n); void *memmove( void *dest, const void *src, size_t n); 当拷贝的内存存在重叠区域时，memcpy可能会发生错误，而memmove不会发生。 下图为重叠情况剖析【绿色代表重叠区域】： 重叠情况（1）： 重叠情况（2）： 两个函数具体实现如下： void * memcpy ( void *dst, const void *src, size_t n) /*将src 的 n 字节拷贝到dst 内存中*/ { char *su1; const char *su2; for (su1 = dst, su2 = src; 0 < n; ++su1, ++su2, --n) { *su1 = *su2; } return dst; } void *memmove( void *dst, const void *src, size_t n) /*将scr 的 n 字节拷贝到dst 内存中*/ { char *sc1; const char *sc2; sc1 = dst; sc2 = src; if (sc2 < sc1 && sc1 < sc2 + n) { for

memcpy与memmove函数异同 memcpy memmove memset memcpy 函数原型 void * memcpy ( void * destination , const void * source , size_t num ) 头文件 < string . h > 作用：从源src所指的内存地址的起始位置开始拷贝num个字节到目标dest所指的内存地址的起始位置中。 注意： （1）memcpy是内存拷贝函数； （2）此函数不考虑类型，以字节为单位进行拷贝； （3）这个函数在遇到’\0’时不会停下来； （4）memcpy与strcpy功能有所重叠，但拷贝字符串一般使用strcpy，因为strcpy以’\0’结尾，更加专业安全。 模拟实现： # include <stdio.h> # include <windows.h> # include <assert.h> void * My_Memcpy ( void * dst , const void * src , int num ) { assert ( dst ) ; assert ( src ) ; char * dst_ = ( char * ) dst ; char * src_ = ( char * ) src ; while ( num ) { * dst_ = * src_ ; * dst_ ++

在python中，对象的赋值、拷贝（深浅）之间是有差异的，如果使用的时候不注意，就可能产生意外的结果。 其实这些问题是由共享内存导致的结果 拷贝原则上是把数据分离出来，复制其数据，以后修改互不影响。 =是赋值，数据完全共享（=赋值是在内存中指向同一个对象，如果是可变类型，如列表，修改其中一个 （不是重新建一个列表） ，必定会改变。 如果是不可变类型(immutable),比如字符串，修改了其中一个列表里面的值，另一个并不会变。） l1 = [1, 2, 3, ['aa', 'bb']] l2 = l1 l2[0]='aaa' l2[3][0]='bbb' print(l1) #['aaa', 2, 3, ['bbb', 'bb']] print(id(l1)==id(l2)) #True 　　l2 = l1 ，l1 完全赋值给l2 ，l2的内存地址与l1 相同，即内存完全指向 浅拷贝：数据半共享（复制其数据独立内存存放，但是只拷贝成功第一层） l1 = [1,2,3,[11,22,33]] l2 = l1.copy() print(l2) #[1,2,3,[11,22,33]] l2[3][2]='aaa' print(l1) #[1, 2, 3, [11, 22, 'aaa']] print(l2) #[1, 2, 3, [11, 22, 'aaa']] l1[0]= 0

/*--> */ /*--> */ 浅拷贝：通过一个对象来创建一个新对象，如果对象的属性的值是基本数据类型，直接把值赋给新对象，如果值是引用类型则把数据的对应的内存地址赋给新对象；因为两个对象对应的是同一个内存地址，当其中一个对象数据改变了，就相当于改变了内存地址，所以会影响到别一个对象； 深拷贝：通过一个对象来创建一个新对象，无论基本类型还是引用类型都将值赋给新对象，引用类型会开辟一块新的内存地址用于存放数据，因为不会相互影响； 浅拷贝的方法： 1.直接赋值： var obj1 = {a: 1, b: 2}; var obj2 = obj1; obj2.b = 22; console.log(obj1.b); // 22 2.Object.assign var obj1 = {a: 1, b: 2}; var obj2 = {c: 3}; Object.assign(obj1, obj2); console.log(obj1) // {a: 1, b: 2, c: 3} obj2.c = 4; console.log(obj1.c) // 3 乍一看，这貌似两个对象互不影响了！难道是深拷贝了？ var obj1 = {a: 1, b: 2}; var obj2 = {c: {z: 3}}; Object.assign(obj1, obj2); console.log(obj1);