构造函数

与拷贝构造函数不同，移动构造函数不分配任何新内存；它接管给定的StrVec中的内存。在接管内存之后，它将给定对象中的指针都置为nullptr。这样就完成了从给的对象的移动操作，此对象将继续存在。最终，移后源对象会被销毁。 //移动构造函数 StrVec::StrVec(StrVec &&s) noexcept:elements(s.elements), first_free(s.first_free), cap(s.cap){ s.elements = nullptr; s.first_free = nullptr; s.cap = nullptr; } 移动赋值运算符执行与析构函数和移动构造函数相同的工作。类似拷贝赋值运算符，移动赋值运算符必须正确处理自赋值。 //移动赋值运算符 StrVec& StrVec::operator=(StrVec &&rhs) noexcept{ //直接检测自赋值:检测this指针与rhs的地址是否相同 if(this != &rhs){ free(); //释放已有元素 elements = rhs.elements; //从rhs接管资源 first_free = rhs.first_free; cap = rhs.cap; //将rhs置为可析构状态 rhs.elements = rhs.first_free = rhs.cap =

1. 基础部分 Item 1: View C++ as a federation of languages. 对于内建类型，按值传递优于按引用传递，对于自定义类型则相反。 C++可视为4中子语言的联合：C，Object-Oriented C++，Template C++和STL。 Item 2: Prefer consts, enums, and inlines to #defines. 只有整型常量可以在类声明里面初始化： class Klass { const static int num = 1 ; //也可只声明，在定义文件中，即类外部定义、初始化； }; enum类型也可以在类内部初始化。 Item 3: Use const whenever possible. 对于指针p，const在 * 左边时，p指向的值为常量，const出现在 * 右边时，p指向的地址为常量。 const int * p1 ; int const * p2 ; int * const p3 ; ​ //以上代码，p1和p2一样，其指向的值为常量；p3指向的地址为常量 如果类Klass有同名的两个成员函数foo，其中一个为const类型，那么const实列优先调用const版的foo。 const函数不能改变非static的成员变量。 mutable修饰的成员，在const函数中也可以改变其值。

语言基础类 1. 指针和引用的区别？ （1）指针有自己的一块空间，而引用只是一个别名； 　（2）使用 sizeof 看一个指针的大小为 4 字节（32位，如果要是64位的话指针为8字节），而引用则是被引用对象的大小。 （3） 引用必须在定义时被初始化，指针不必； (4)不存在指向空值的引用，但存在指向空值的指针。 2.static和 const的用法，（能说出越多越好）（重点） 首先说说const的用法（绝对不能说是常数） 1.限定变量为不可修改。 2.限定成员函数不可以修改任何数据成员。 3.使用const关键字修饰的变量，一定要对变量进行初始化 下面的声明都是什么意思？ const int a; a是一个常整型数 int const a; a是一个常整型数 const int *a; a是一个指向常整型数的指针，整型数是不可修改的，但指针可以 int * const a; a为指向整型数的常指针，指针指向的整型数可以修改，但指针是不可修改的 int const * a const; a是一个指向常整型数的常指针，指针指向的整型数是不可修改的，同时指针也是不可修改的 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

1.对象的表现形式 // new Object() var person = new Object(); person.name = "sdf"; person.age = "23"; person.job = "Enginer"; person.sayName = function () { alert(this.name) } person.sayName(); //对象字面量模式 var person = { name: "sdf", age: 23, job: "Enginer", sayAge: function () { alert(this.age) } } person.sayAge(); 　　Reflection：如果有多个对象需要创建多次 2.创建对象工厂模式 func：解决了创建多个对象模式，但是没有解决对象识别的问题（即怎么知道一个对象的类型） function creatPerson(name, age, job) { var o = new Object(); o.name = name; o.age = age; o.job = job; o.sayName = function () { alert(this.name) } return o; } var person1 = creatPerson("Nicholas", 23, "Enginer"

派生类构造函数各部分的执行次序为 1.调用基类的构造函数，按他们在派生类定义的先后顺序，顺序调用。 2.调用成员对象的构造函数，按他们在类定义中声明的先后顺序，顺序调用 3.派生类的构造函数体中的操作 在派生类构造 函数中，只要基类不是使用缺省构造函数，都要显式给出基类名和参数表 如果基类没有定义构造函数，则派生类也可以不定义，全部采用系统给定的缺省构造函数。 如果基类定义了带有形参表的构造函数时，派生类就应当定义构造函数。 //Test1.h #include<iostream> using namespace std; class Base1 { private: int a1; public: Base1()//(int _a):a1(_a) { cout<<"It's base1 built. "<<endl; } ~Base1(){cout<<"Base1 was free. "<<endl;} }; class Base2 { private: int a2; public: Base2()//(int _a):a2(_a) { cout<<"It's base2 built. "<<endl; } ~Base2(){cout<<"Base2 was free. "<<endl;} }; class Base3 { private: int a3; public:

1. 内置类型变量是否初始化取决于变量定义的位置，在函数体外定义的变量都初始化为0，在函数体内定义的内置类型变量不能自动初始化，类的话都会自动调用构造函数。 2. C++也可以有嵌套类。 3. const修饰一个类对象可以不用初始化，它会自动调用构造函数进行初始化，而int等就不行。如： 1 const A a; // 会自动调用构造函数对a进行初始化 2 // const int i; // 这里将出错，必须像下面这样初始化 3 const int i = 2; 4. 可以直接显示调用构造函数 类名(); 来创建一个临时类对象，如: 1 class A{ 2 A() {} 3 A operator() (){} 4 }; 5 A a = A()(); 这里A()()使用到了()的操作符重装，感觉这样用挺有新鲜感。 来源： https://www.cnblogs.com/wnarutou/archive/2012/11/19/2778199.html

假设我们需要一个名叫Kitty的类，其在Pets程序集下。 1 // specify a new assembly name 2 var assemblyName = new AssemblyName("Pets"); 3 4 // create assembly builder 5 var assemblyBuilder = AppDomain.CurrentDomain 6 .DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave); 7 8 // create module builder 9 var moduleBuilder = assemblyBuilder.DefineDynamicModule("PetsModule", "Pets.dll"); 10 11 // create type builder for a class 12 var typeBuilder = moduleBuilder.DefineType("Kitty", TypeAttributes.Public); 定义字段 Kitty类包含两个私有字段_id和_name。用类型构造器来定义， 1 var fieldId = typeBuilder.DefineField( 2 "_id", typeof(int),

使用new关键字 } → 调用了构造函数 使用Class类的newInstance方法 } → 调用了构造函数 使用Constructor类的newInstance方法 } → 调用了构造函数 使用clone方法 } → 没有调用构造函数 使用反序列化 } → 没有调用构造函数 如果你运行了末尾的的程序，你会发现方法1,2,3用构造函数创建对象，方法4,5没有调用构造函数。 1.使用new关键字 这是最常见也是最简单的创建对象的方式了。通过这种方式，我们可以调用任意的构造函数(无参的和带参数的)。 Employee emp1 = new Employee(); 0: new #19 // class org/programming/mitra/exercises/Employee 3: dup 4: invokespecial #21 // Method org/programming/mitra/exercises/Employee."":()V 2.使用Class类的newInstance方法 我们也可以使用Class类的newInstance方法创建对象。这个newInstance方法调用无参的构造函数创建对象。 我们可以通过下面方式调用newInstance方法创建对象: Employee emp2 = (Employee) Class.forName("org

继承性： 　　子类可以共享父类的数据结构和方法。新类可以在一个类的基础上定义； 　　JavaScript构造函数： ( 方法添加到原型上，共享空间 ) 　　　　function Tab( name ){ 　　　　　　this.name = name; 　　　　} 　　　　Tab.prototype.hobby = function( ){ // 共享空间 　　　　　　console.log( ".=== 打篮球 ===" ); 　　　　} 　　注意继承后，新类方法的改变不能影响到原类； 原类方法的改变不能影响到新类 （构造函数的原型是公共空间，新类要建立一个新的公共空间且__proto__不指向 原类的原型空间） 　　继承的关键点是能得到一个新的公共空间且constructor属性指向这个新类 ----> 定义类一般把属性写在构造函数里面，定义的方法写在原型上 　　======================================================================== 　　　　　　　　　　　　构造函数部分 和 构造函数原型部分（深copy） 　　======================================================================== 来源： https://www.cnblogs.com

__proto__（隐式原型）与prototype（显式原型） 　　是什么？ 显式原型 explicit prototype property： 每一个函数在创建之后都会拥有一个名为prototype的属性，这个属性指向函数的原型对象。 隐式原型 implicit prototype link： JavaScript中任意对象都有一个内置属性[[prototype]]，在ES5之前没有标准的方法访问这个内置属性， 但是大多数浏览器都支持通过__proto__来访问。ES5中有了对于这个内置属性标准的Get方法Object.getPrototypeOf(). 　　Object.prototype 这个对象是个例外，它的__proto__值为null 二者的关系： 隐式原型指向 创建 这个对象的构造函数(constructor)的prototype 　　作用？ 显式原型的作用：用来实现基于原型的继承与属性的共享。 隐式原型的作用：构成原型链，同样用于实现基于原型的继承。举个例子，当我们访问obj这个对象中的x属性时， 　　　如果在obj中找不到，那么就会沿着__proto__依次查找。 实例： 声明构造函数A，给A的原型对象添加一个属性和一个方法， 用函数A创建一个对象a： 1 A.prototype.name = "Jack"; 2 A.prototype.say =