经典问题解析（2）---malloc和new、编译器和构造函数、静态成员

malloc与free和new与delete有什么区别

程序：

#include <cstdlib>
#include <iostream>
using namespace std;

class Test
{
private:
int i;
public:
Test()
{
cout<<"Test()"<<endl;
i = 0;
}
Test(int i)
{
cout<<"Test(int i)"<<endl;
this->i = i;
}
~Test()
{
cout<<"~Test"<<endl;
}
int getI()
{
return i;
}
};

void func()
{
int* p = reinterpret_cast<int*>(malloc(sizeof(int)));
//malloc返回的指针为void*类型，需要强制类型转换，申请4个字节的空间
//malloc只能申请空间，不能进行初始化
int* q = new int(10);
//定义了一个int变量，值为10 ，new可以做到在申请空间时进行初始化

*p = 5;
//*q = 10;

cout<<*p<<" "<<*q<<endl;

free(p);
delete q;

cout<<"op:"<<endl;
Test* op = reinterpret_cast<Test*>(malloc(sizeof(Test)));
//没有打印出构造函数中的内容
//malloc只是负责单纯的申请空间，并不负责调用构造函数

cout<<"oq:"<<endl;
Test* oq = new Test;
//打印出了构造函数的内容
//new不但申请了空间，而且把这段空间构造成了一个Test类的对象

cout<<"op:"<<op->getI()<<" "<<"oq:"<<oq->getI()<<endl;

free(op);
delete oq;
}

int main(int argc, char *argv[])
{
func();

cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}

1、malloc和free是库函数，以字节为单位申请和释放堆内存。

2、new和delete是关键字，以类型为单位申请和释放堆内存。

3、malloc和free单纯的对内存进行申请与释放。

4、对于基本类型new关键字会对内存进行初始化，为变量赋初值，为类对象调用构造函数。

5、对于类类型new和delete还负责构造函数和析构函数的调用。因此对于new分配的空间，不能使用free进行释放，否则没有析构会造成内存泄漏。

编译器对构造函数的调用

在 现代的 C++编译器看来，上面func函数中的3中类对象的初始化方式是相同的。

C++编译器会尝试各种手段尝试让程序通过编译

方式一：尽力匹配重载函数

方式二：尽力使用函数的默认参数

方式三：尽力尝试调用构造函数进行类型转换



因为拷贝构造函数总是存在的，因此上面的用一个类对象给另一个类对象赋值，总是成功的。

但是一般编译器会采用一种更简单的方式：



编译器会采用方案B的方法，因此上面的程序的运行结果中，没有拷贝构造函数的打印输出。

因此，现代的编译器会把上面的4种方式进行优化，优化为方案B。

“剥夺”编译器对构造函数的调用尝试：

C++提供了explicit关键字用于阻止编译器对构造函数的调用尝试，如果加上explicit关键字，上面的程序会报错。



如果程序这样写，就会产生以下结果：

Test t1(5);//不报错，这是标准的初始化写法
Test t2 = 5;//报错
Test t3 = Test(5);//报错

类的静态成员

对象数目控制需要用到类的静态成员。

单例模式的实现：

#include <cstdlib>
#include <iostream>
using namespace std;
//实现单例模式
class Singleton
{
private:
static Singleton* cInstance;//定义一个指针

Singleton()//将构造函数定义为private
{
}
public:
static Singleton* GetInstance()//静态成员函数可以访问静态成员变量和其他成员函数
{
if( cInstance == NULL )//只能申请一次
{
cout<<"new Singleton()"<<endl;
cInstance = new Singleton();//创建一个类对象
}

return cInstance;
}

void print()
{
cout<<"I'm Singleton!"<<endl;
}
};

Singleton* Singleton::cInstance = NULL;

void func()
{
Singleton* s = Singleton::GetInstance();
Singleton* s1 = Singleton::GetInstance();
Singleton* s2 = Singleton::GetInstance();

cout<<s<<" "<<s1<<" "<<s2<<endl;//三个指针指向的的地址相同

s->print();
}

int main(int argc, char *argv[])
{
func();

cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}

无状态函数：

函数的调用结果只与实参值相关。但是多次调用会浪费时间。

状态函数：

函数的调用结果不仅与实参值相关还与之前的函数调用有关。但是不能回头。

函数对象来实现结合无状态函数和状态函数的优点：

#include <cstdlib>
#include <iostream>
using namespace std;
//三种方法实现斐波那契数列

int fib1(int i)//无状态的函数，比较浪费时间
{
int a1 = 0;
int a2 = 1;
int ret = a2;
while( i > 1)
{
ret = a2 + a1;
a1 = a2;
a2 = ret;
i--;
}
return ret;
}

int fib2()//有状态的函数，可以节约计算时间，但是不能回头
{
static int a1 = 0;
static int a2 = 1;

int ret = a2;
int t = a2;
a2 = a2 + a1;
a1 = t;
return ret;
}

class Fib
{
private:
int a1;
int a2;
public:
Fib()
{
a1 = 0;
a2 = 1;
}

int operator() () //重载（）操作符
{
int ret = a2;
int t = a2;

a2 = a2 + a1;
a1 = t;

return ret;
}
};

int main(int argc, char *argv[])
{
cout<<"int fib1(int i)"<<endl;

for(int i=1; i<=10; i++)
{
cout<<fib1(i)<<endl;
}

cout<<endl;

cout<<"int fib2()"<<endl;

for(int i=1; i<=10; i++)
{
cout<<fib2()<<endl;
}

cout<<endl;

Fib fib;//采用类对象，可以回头从1开始，也可以记录状态

cout<<"Fib fib;"<<endl;

for(int i=1; i<=10; i++)
{
cout<<fib()<<endl;//调用重载操作符
}

cout<<endl;

cout << "Press the enter key to continue ...";
cin.get();
return EXIT_SUCCESS;
}