//汽车类
class Car{
public:Car(){cout << "Car 默认构造函数!" << endl;mName = "大众汽车";}Car(string name){cout << "Car 带参数构造函数!" << endl;mName = name;}~Car(){cout << "Car 析构函数!" << endl;}
public:string mName;
};
//拖拉机
class Tractor{
public:Tractor(){cout << "Tractor 默认构造函数!" << endl;mName = "爬土坡专用拖拉机";}Tractor(string name){cout << "Tractor 带参数构造函数!" << endl;mName = name;}~Tractor(){cout << "Tractor 析构函数!" << endl;}
public:string mName;
};
//人类
class Person{
public:#if 1//类 mCar 不存在合适的构造函数Person(string name){mName = name;}#else//初始化列表可以指定调用构造函数Person(string carName, string tracName, string name) : mTractor(tracName), mCar(carName), mName(name){cout << "Person 构造函数!" << endl;}#endifvoid GoWorkByCar(){cout << mName << "开着" << mCar.mName << "去上班!" << endl;}void GoWorkByTractor(){cout << mName << "开着" << mTractor.mName << "去上班!" << endl;}~Person(){cout << "Person 析构函数!" << endl;}
private:string mName;Car mCar;Tractor mTractor;
};
void test(){//Person person("宝马", "东风拖拉机", "赵四");Person person("刘能");person.GoWorkByCar();person.GoWorkByTractor();
}

explicit 关键字

[explicit 注意 ]

        explicit 用于修饰构造函数 , 防止隐式转化。

        是针对单参数的构造函数( 或者除了第一个参数外其余参数都有默认值的多参构造 ) 而言。

class MyString{
public:explicit MyString(int n){cout << "MyString(int n)!" << endl;}MyString(const char* str){cout << "MyString(const char* str)" << endl;}
};
int main(){//给字符串赋值？还是初始化？//MyString str1 = 1; MyString str2(10);//寓意非常明确，给字符串赋值MyString str3 = "abcd";MyString str4("abcd");return EXIT_SUCCESS;
}

动态对象创建

        当我们创建数组的时候，总是需要提前预定数组的长度，然后编译器分配预定长度的数组空间，在使用数组的时，会有这样的问题，数组也许空间太大了，浪费空间，也许空间不足，所以对于数组来讲，如果能根据需要来分配空间大小再好不过。

        所以动态的意思意味着不确定性。

        为了解决这个普遍的编程问题，在运行中可以创建和销毁对象是最基本的要求。当然 c 早就提供了动态内存分配（ dynamic memory allocation ） , 函数 malloc 和 free 可以在运行时从堆中分配存储单元。

        然而这些函数在 c++ 中不能很好的运行，因为它不能帮我们完成对象的初始化工作。

对象创建

当创建一个 c++ 对象时会发生两件事 :

        1. 为对象分配内存

        2. 调用构造函数来初始化那块内存

        第一步我们能保证实现，需要我们确保第二步一定能发生。c++ 强迫我们这么 做是因为使用未初始化的对象是程序出错的一个重要原因。

 C 动态分配内存方法

        为了在运行时动态分配内存，c 在他的标准库中提供了一些函数 ,malloc 以及 它的变种 calloc 和 realloc, 释放内存的 free, 这些函数是有效的、但是原始的， 需要程序员理解和小心使用。为了使用 c 的动态内存分配函数在堆上创建一个 类的实例，我们必须这样做

class Person{
public:Person(){mAge = 20;pName = (char*)malloc(strlen("john")+1);strcpy(pName, "john");}void Init(){mAge = 20;pName = (char*)malloc(strlen("john")+1);strcpy(pName, "john");}void Clean(){if (pName != NULL){free(pName);}}
public:int mAge;char* pName;
};
int main(){//分配内存Person* person = (Person*)malloc(sizeof(Person));if(person == NULL){return 0;}//调用初始化函数person->Init();//清理对象person->Clean();//释放 person 对象free(person);return EXIT_SUCCESS;
}

问题：

        1) 程序员必须确定对象的长度。

        2) malloc 返回一个 void 指针， c++ 不允许将 void 赋值给其他任何指针，必须强转。

        3) malloc 可能申请内存失败，所以必须判断返回值来确保内存分配成功。

        4) 用户在使用对象之前必须记住对他初始化，构造函数不能显示调用初始化 ( 构造 函数是由编译器调用) ，用户有可能忘记调用初始化函数。

        c 的动态内存分配函数太复杂，容易令人混淆，是不可接受的， c++ 中我们推荐使 用运算符 new 和 delete

new operator

        C++中解决动态内存分配的方案是把创建一个对象所需要的操作都结合在一个称为 new 的运算符里。当用 new 创建一个对象时，它就在堆里为对象分配内存并调用 构造函数完成初始化。

        Person* person = new Person;

相当于 :

        Person* person = (Person*)malloc( sizeof (Person));

        if (person == NULL){

                return 0 ;

        }

        person->Init(); 构造函数

New 操作符能确定在调用构造函数初始化之前内存分配是成功的，所有不用显式 确定调用是否成功。

        现在我们发现在堆里创建对象的过程变得简单了，只需要一个简单的表达式，它带 有内置的长度计算、类型转换和安全检查。这样在堆创建一个对象和在栈里创建对 象一样简单。

delete operator

        new 表达式的反面是 delete 表达式。 delete 表达式先调用析构函数，然后释放内 存。正如 new 表达式返回一个指向对象的指针一样， delete 需要一个对象的地址。

        delete 只适用于由 new 创建的对象。

        如果使用一个由 malloc 或者 calloc 或者 realloc 创建的对象使用 delete, 这个行为是未定义的。因为大多数 new 和 delete 的实现机制都使用了 malloc 和 free, 所以很 可能没有调用析构函数就释放了内存。

        如果正在删除的对象的指针是 NULL, 将不发生任何事，因此建议在删除指针后，立 即把指针赋值为 NULL ，以免对它删除两次，对一些对象删除两次可能会产生某些 问题。

class Person{
public:Person(){cout << "无参构造函数!" << endl;pName = (char*)malloc(strlen("undefined") + 1);strcpy(pName, "undefined");mAge = 0;}Person(char* name, int age){cout << "有参构造函数!" << endl;pName = (char*)malloc(strlen(name) + 1);strcpy(pName, name);mAge = age;}void ShowPerson(){cout << "Name:" << pName << " Age:" << mAge << endl;}~Person(){cout << "析构函数!" << endl;if (pName != NULL){delete pName;pName = NULL;}}
public:char* pName;int mAge;
};
void test(){Person* person1 = new Person;Person* person2 = new Person("John",33);person1->ShowPerson();person2->ShowPerson();delete person1;delete person2;
}

用于数组的 new 和 delete

使用 new 和 delete 在堆上创建数组非常容易。
//创建字符数组
char* pStr = new char[100];
//创建整型数组
int* pArr1 = new int[100]; 
//创建整型数组并初始化
int* pArr2 = new int[10]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//释放数组内存
delete[] pStr;
delete[] pArr1;
delete[] pArr2;

        当创建一个对象数组的时候，必须对数组中的每一个对象调用构造函数，除了在栈上可以聚合初始化，必须提供一个默认的构造函数。

class Person{
public:Person(){pName = (char*)malloc(strlen("undefined") + 1);strcpy(pName, "undefined");mAge = 0;}Person(char* name, int age){pName = (char*)malloc(sizeof(name));strcpy(pName, name);mAge = age;}~Person(){if (pName != NULL){delete pName;}
}
public:char* pName;int mAge;
};
void test(){//栈聚合初始化Person person[] = { Person("john", 20), Person("Smith", 22) };cout << person[1].pName << endl;//创建堆上对象数组必须提供构造函数Person* workers = new Person[20];
}

delete void*可能会出错

        如果对一个 void* 指针执行 delete 操作，这将可能成为一个程序错误，除非指针指 向的内容是非常简单的，因为它将不执行析构函数. 以下代码未调用析构函数，导致可用内存减少。

class Person{
public:Person(char* name, int age){pName = (char*)malloc(sizeof(name));strcpy(pName,name);mAge = age;}~Person(){if (pName != NULL){delete pName;}
}
public:char* pName;int mAge;
};
void test(){void* person = new Person("john",20);delete person;
}

        问题：malloc 、 free 和 new 、 delete 可以混搭使用吗？也就是说 malloc 分配的内 存，可以调用 delete 吗？通过 new 创建的对象，可以调用 free 来释放吗？

使用 new 和 delete 采用相同形式

                Person* person = new Person[ 10 ];

                delete person;

        以上代码有什么问题吗？(vs 下直接中断、 qt 下析构函数调用一次 )

        使用了 new 也搭配使用了 delete ，问题在于 Person 有 10 个对象，那么其他 9 个 对象可能没有调用析构函数，也就是说其他 9 个对象可能删除不完全，因为它们 的析构函数没有被调用。

        我们现在清楚使用 new 的时候发生了两件事 : 一、分配内存；二、调用构造函数， 那么调用 delete 的时候也有两件事：一、析构函数；二、释放内存。

        那么刚才我们那段代码最大的问题在于：person 指针指向的内存中到底有多少个 对象，因为这个决定应该有多少个析构函数应该被调用。换句话说，person 指针 指向的是一个单一的对象还是一个数组对象，由于单一对象和数组对象的内存布局 是不同的。更明确的说，数组所用的内存通常还包括“ 数组大小记录 ” ，使得 delete 的时候知道应该调用几次析构函数。单一对象的话就没有这个记录。单一对象和数 组对象的内存布局可理解为下图:

        本图只是为了说明，编译器不一定如此实现，但是很多编译器是这样做的。

        当我们使用一个 delete 的时候，我们必须让 delete 知道指针指向的内存空间中是 否存在一个“ 数组大小记录 ” 的办法就是我们告诉它。当我们使用 delete[] ，那么 delete 就知道是一个对象数组，从而清楚应该调用几次析构函数。

结论 :

        如果在 new 表达式中使用 [] ，必须在相应的 delete 表达式中也使用 []. 如果在 new 表达式中不使用[], 一定不要在相应的 delete 表达式中使用 []