拷贝

实验基于Centos 6.2 升级linux内核 直接在一个有编译环境的设备上，编译升级内核很简单。 make menuconfig 或者 拷贝现有系统的.config文件 修改.config文件 CONFIG_DEBUG_INFO=n （避免编译产生文件过大） make oldconfig make all -j4 make modules_install make install 制作linux内核安装包 有时需要在虚拟机上编译好内核后，安装到另外的设备上，而设备上工具有限，没有编译开发环境等。一种方式是通过nfs挂载，在设备上直接make modules_install，然后make install。 另外一种，就是手动拷贝安装。下面介绍怎么制作一个内核安装包，可以直接在设备上安装。以下以内核3.5.3为例说明。 1、编译 make all -j4 2、准备各种目录及文件 新建文件夹 kernel-3.5.3 export INSTALL_MOD_PATH=kernel-3.5.3 执行make modules_install 模块会安装到文件夹kernel-3.5.3中 拷贝源码目录下scripts中的depmod.sh 到kernel-3.5.3中 拷贝源码目录下arch/x86/boot/bzImage 到kernel-3.5.3中 拷贝源码目录下System

一、异常 万能捕捉异常公式 try: # 逻辑代码 1/0 except Exception as e: print(e) division by zero 二、深浅拷贝 2.1 拷贝 拷贝/浅拷贝/深拷贝都是针对可变类型数据而言的 l1 = ['a'，'b'，'c'，['d'，'e'，'f']] l2 = l1 l1.append('g') print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']，'g'] 如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变 2.2 浅拷贝 import copy l1 = ['a'，'b'，'c'，['d'，'e'，'f']] l2 = copy.copy(l1) l1.append('g') print(l1) # ['a'，'b'，'c'，['d'，'e'，'f']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f']] l1[3].append('g') print(l1) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']，'g'] print(l2) # ['a'，'b'，'c'，['d'，'e'，'f'，'g']]

赋值b=a 只传递对象的引用，b指向对象a的内存地址空间，因此，原有列表a改变的同时，被赋值的b也会做相应的改变。 浅拷贝b1=copy.copy(a) a与b1的内存地址不同，但是子对象的内存地址相同，因此，原始数据改变并不会造成深拷贝里面任何子项的改变 深拷贝b2=copy.deepcopy(a) a与b2的内存地址空间不同，包含子对象的拷贝，所以原始对象的改变并不会造成深拷贝里面的任何子对象的改变 当深拷贝和浅拷贝针对的对象全部是不可变数据类型时，两者效果相同； 当深拷贝和浅拷贝针对的对象包含的时可变数据类型时，两者才出现上述区别。 可变数据类型 不可变数据类型 list 所有数据类型、波尔型、元组、str 浅拷贝的实现 深拷贝的实现 li.copy( ) 或 li[:] 或 copy.copy( ) li.deepcopy( ) 可变数据类型镶嵌可变数据类型 >> > import copy >> > a = [ 1,2 ] >> > b = [ 3,4 ] >> > c = [ a,b ] >> > c [ [ 1, 2 ] , [ 3, 4 ] ] >> > d = copy.copy ( c ) >> > id ( a ) 139939016415712 >> > id ( b ) 139939016415640 >> > id ( c )

一、概述 列表 （list）是由一个个 Python对象 组成的序列。其中， Python对象 可以是任何类型的对象，包括 Python标准类型 （数值、字符串、列表、元组和字典）以及 用户自定义类型 （类）。相比而言， 字符串 仅仅是字符的序列，因此列表的概念和用途比字符串更广泛。 元组 （tuple）也是 Python对象 的序列，与列表非常接近。二者的主要差异点如下： 差异点 列表 元组 表示方法 空列表：[] 单元素列表：[1] 多元素列表[1, 'a'] 空元组：() 单元素元组：(1,) 多元素元组：(1, 'a') 可变性 可变 不可变 可操作性 支持丰富的操作 仅支持序列操作 可哈希性 不可哈希，不能作为字典的关键字 可哈希，可以作为字典的关键字 其中， 可变性 是列表和元组之间最本质的差异：列表是一个可变序列，而元组是一个不可变序列。用C/C++的话来讲， 元组是一个const版本的列表 。 二、操作 由于列表和元组都是序列类型，因此它们都支持 Python基础：序列 中给出的 通用序列操作 。 特别地，作为一个可变序列，列表还支持以下 列表操作 ： 操作 说明 s[i] = x 用x替换s中的第i个成员 del s[i] 从s中删除第i个成员 s[i:j] = t 用t替换s[i:j] del s[i:j] 从s中删除s[i:j]（等价于s[i:j] = []）

全称： copy files and directories 用途： 拷贝文件(目录) 格式： 　　cp [OPTION]... [-T] SOURCE DEST 　　cp [OPTION]... SOURCE... DIRECTORY 　　cp [OPTION]... -t DIRECTORY SOURCE... 类型： cp is /bin/cp 说明： 拷贝文件(目录)，不可避免的会涉及到文件(目录)自身属性和权限。根据不同的拷贝目的，拷贝后可能需要保留源文件(目录)的属性和权限，也可能需要变更源文件(目录)属性和权限。因此，根据不同的目的，需要配合使用不同的参数： -a, --archive: 相当于使用 "-dR --preserve=all"。 --attributes-only: 不拷贝文件数据，只拷贝其属性。 --backup[=CONTROL]: 为已存在文件创建备份，备份后缀默认"~"，除非设置了 "--suffix" 或者 SIMPLE_BACKUP_SUFFIX(具体参见 man cp)。 -b: 同 "--backup"，只是不接收参数。 --copy-contents: 遇到递归的时候，拷贝特殊文件的类容。 -d: 相当于"--no-dereference --preserve=links" -f, --force: 拷贝时如果目标文件(目录)存在

引言 山重水复疑无路，柳暗花明又一村，越探究越接近事物的本质。最近在学习原型模式（Prototype）时，发现原型模式本质就是对一个类原始数据的克隆，但在学习深拷贝和浅拷贝时又发现与值类型和引用类型有着千丝万缕的联系。回想好久都没有温习基础，于是就整理了值类型和引用类型的随笔，本文内容比较基础，对于想继续深入研究的同学可以查看IL更深入探究。 1.值类型(ValueType) 值类型包括：数值类型，结构体，bool型，用户定义的结构体，枚举，可空类型。 值类型的变量直接存储数据，分配在托管栈中。变量会在创建它们的方法返回时自动释放，例如在一个方法中声明Char型的变量name=’C’，当实例化它的方法结束时，name变量在栈上占用的内存就会自动释放 C#的所有值类型均隐式派生自System.ValueType。 结构体：struct（直接派生于System.ValueType）。 数值类型：整型，sbyte（System.SByte的别 名），short（System.Int16），int（System.Int32），long（System.Int64），byte（System.Byte），ushort（System.UInt16），uint（System.UInt32），ulong（System.UInt64），char（System.Char）。 浮点型：float

熟悉C++的朋友对这个话题应该很熟悉，浅拷贝就是指两个对象共同拥有同一个值，一个对象改变了该值，也会影响到另一个对象。深拷贝就是两个对象的值相等，但是互相独立。本来想把以前写的一篇文章扩充一下，没想到居然牵扯出很多复杂的问题。本文测试环境是windows xp sp3中文版、NetBeans6.7.1,JDK1.6-update16。这里抛砖引玉，希望大家能提宝贵意见。 首先，Java中常用的拷贝操作有三个，operator = 、拷贝构造函数 和 clone()方法。由于Java不支持运算符重载，我们无法在自己的自定义类型中定义operator=。拷贝构造函数大家应该很熟悉，现在看一下如何支持clone方法： 实现 Cloneable 接口，因为 Object 的 clone 方法将检查类是否实现了 Cloneable 接口，如果没有将抛出异常 CloneNotSupportedException 对象。 Cloneable 接口没有任何方法，只是个标志，所以只需要简单的写上 implements Cloneable 即可。 改写从 Object 继承而来的 clone 方法，使它的访问权限为 public ，因为为了防止意外的支持 clone 操作， Object 的 clone 方法是 protected 权限。 通过上面的分析，可以看出，如果我们要给自己的类添加拷贝功能

接口的方法默认死public，接口的属性默认为public static final。 为什么要接口，而不是使用抽象类。一个对象只能继承一个类，却可以实现多个接口。 clone： Object的浅拷贝 Object类的默认拷贝机制是浅拷贝：对于拷贝对象的属性：基本类型属性，拷贝值，对象属性，拷贝引用。 Object将clone设为protected方法，无法在外部调用。如果要使用，必须在使用的类里，将它设置为public。如下： @Override public Person clone() throws CloneNotSupportedException { return (Person) super .clone(); } 关于CloneNotSupportedException： 当调用 Object 类中的 clone 方法克隆对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。 重写 clone 方法的应用程序也可能抛出此异常，指示不能或不应克隆一个对象。 所以，还要在类的声明中加入implements Cloneable。 上面说的都是调用Object的默认clone的限制，如果你自己写Clone方法，是不会抛出CloneNotSupportedException异常的。如： @Override public Person clone() {

volatile的用处： 在JDK1.2之前，Java内存模型总是从主存(共享内存)中读取变量值，是不需要进行特别注意的。 在当前Java内存模型下，线程可以把变量保存在本地内存，如寄存器中，而不是直接在主存中进行读写。这就造成了一个线程在主存中修改了一个变量的值，而另一个线程还在使用它在寄存器中的变量值的拷贝，造成了了数据不一致。 为了解决这个问题，我们就需要把该变量声明为volatile，这就指示JVM，这个变量是不稳定的，每次使用他都要去主存中读取，而不是本地内存，一般说来，多任务环境下，各任务间共享的变量，都应该使用volatile进行修饰。 volatile修饰的变量，在被每次线程访问时，都强迫从共享内存中重读该变量的值。而且当该变量变化时，都强迫线程将变化的值写到共享内存中，这样在任何时刻，两个不同的线程总是看到该变量的同一个值。 Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才将私有拷贝与共享内存中的原始值进行比较。 这样当多个线程同时与某个对象交互时，就必须注意到要让线程及时的得到共享成员变量的变化。而volatile关键字就是提示JVM：对于这个成员变量，不能保存它的私有拷贝，而应直接与共享成员变量交互。 volatile是一种稍弱的同步机制，在访问volatile变量时不会执行加锁操作

#include <iostream> #include<algorithm> #include <string> #include <list> using namespace std; //3.6.4.1 list构造函数 //list<T> lstT;//list采用采用模板类实现,对象的默认构造形式： //list(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。 //list(n, elem);//构造函数将n个elem拷贝给本身。 //list(const list& lst);//拷贝构造函数。 //3.6.4.2 list数据元素插入和删除操作 //push_back(elem);//在容器尾部加入一个元素 //pop_back();//删除容器中最后一个元素 //push_front(elem);//在容器开头插入一个元素 //pop_front();//从容器开头移除第一个元素 //insert(pos, elem);//在pos位置插elem元素的拷贝，返回新数据的位置。 //insert(pos, n, elem);//在pos位置插入n个elem数据，无返回值。 //insert(pos, beg, end);//在pos位置插入[beg,end)区间的数据，无返回值。 //clear();//移除容器的所有数据 /