08-内存管理

1.匿名对象：匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。

2.匿名对象的特点:

1、创建匿名对象直接使用，没有变量名。

new Person().eat()  //eat方法被一个没有名字的Person对象调用了。

2、匿名对象在没有指定其引用变量时，只能使用一次。

new Person().eat(); 创建一个匿名对象，调用eat方法

new Person().eat(); 想再次调用eat方法，重新创建了一个匿名对象

        

3、匿名对象可以作为方法接收的参数、方法返回值使用

class Soultion
{
public:
	Soultion()
	{
		cout << "Soultion()" << endl;
	}
	int Sum_Soultion(int n)
	{
		//...
		cout << "Sum_Soultion()" << endl;
		return 0;
	}

	~Soultion()
	{
		cout << "~Soultion()" << endl;
	}

};
int main()
{
	Soultion a1;//a1的声明周期在main函数中
	a1.Sum_Soultion(10);

	//Soultion();//匿名对象，声明周期就在这一行

	Soultion() .Sum_Soultion(10);//只有我这一行会使用这个创建对象，别人不需要使用
	return 0;
}

 3.全局变量，静态变量，成员变量，析构和构造的顺序（和它们存储的区域有关）

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
};
class B
{
public:
	B()
	{
		cout << "B()" << endl;
	}
	~B()
	{
		cout << "~B()" << endl;
	}
};
class C
{
public:
	C()
	{
		cout << "C()" << endl;
	}
	~C()
	{
		cout << "~C()" << endl;
	}
};
class D
{
public:
	D()
	{
		cout << "D()" << endl;
	}
	~D()
	{
		cout << "~D()" << endl;
	}
};

C c;//全局变量
int main()
{
	A a;
	B b;
	static D d;//静态变量

	return 0;
}
//构造顺序： C A B D
//析构顺序：~B ~A ~D ~C

 4.考点：计算下段程序进行了多少次拷贝构造（一共有7次拷贝构造）

class Widget
{
public:
	Widget()
	{}
	Widget(const Widget & w)
	{
		cout << "Widget(const Widget&w)" << endl;
	}
};
Widget f(Widget u)//1 
{
	Widget v(u);//2     4和5会被合二为一，优化掉成一个对象
	Widget w = v;//3    在一个连续的动作中，连续的拷贝构造
	return w;//4，8     都会被优化成一个拷贝
}                       优化都发生返回和传参时，第8和第9被合二为一
int main()
{
	Widget  x;
	//f(x);
	Widget y = f(f(x));//5，6，7，9
	//一共有7次拷贝构造
	return 0;
}

 5.C/C++内存分布

int globalVar = 1;//main函数之前就初始化，在哪都能用，作用域是全局的，这两个全局变量有什么区别呢？        
                    链接属性不一样，globalVar所有文件中可见
static int staticVar = 1;//main函数之前就初始化，在哪都能用，作用域是全局的，只在当前文件可见
void Test()
{
	static int staticVar = 1;//运行到这里再初始化，它的作用域在Test函数中，只能在Test函数中使用
	int localVar = 1;

	int n = 4;
	int num1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	char char2[] = "abcd";//char2是一个栈上的数组
	const char* pChar3 = "abcd";
	int* ptr1 = (int*)malloc(sizeof (int*)*n);
	int* ptr2 = (int*)calloc(4,sizeof(int));
	int* ptr3 = (int*)realloc(ptr2,sizeof(int*)*n);
	free(ptr1);
	free(ptr3);
}

 

 6.C语言动态内存管理：

考点：malloc/calloc/realloc的区别：

void Test()
{
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);
	//1.malloc/calloc/realloc的区别是什么
	int* p2 = (int*)calloc(4, sizeof(int));
	int* p3 = (int*)realloc(p2, sizeof(int)*10);

	//这里需要free(p2)吗？
	free(p3);
}

 7.C++内存管理方式：

int main()
{
	//C  本质上是malloc函数
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)malloc(sizeof(int)*10);
	free(p1);
	free(p2);

	//C++ 本质上是操作符
	//int* p3 = new int;
	int* p3 = new int(10);//申请一个int4个字节空间，初始化成10
	int* p4 = new int[10];//申请10个int的40个字节空间
	delete p3;
	delete[] p4;

	return 0;
}

 8.既然已经有了mallloc和free,new和delete的意义何在？
 

1.对于上面内置类型，他们的效果是一样的
2.对于自定义类型，是不一样的，malloc只申请空间，new 申请空间+构造函数初始化
free只释放空间，delete 析构函数+释放空间

 9.全局的对象和全局的静态对象的析构顺序

class A
{
public:
	A()
	{
		_a = 0;
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class B
{
public:
	B()
	{
		_b = 0;
		cout << "B()" << endl;
	}
	~B()
	{
		cout << "~B()" << endl;
	}
private:
	int _b;
};
//全局的对象和全局的静态对象差别是链接属性
//所以同一个文件中是跟定义的先后顺序有关，都是最后定义的先析构
//多个文件就不确定了
A a1;
B b1;
int main()
{
	return 0;
}

 10.内置类型和自定义类型不一样：

int main()
{
	//内置类型和自定义类型不一样

	int* p1 = new int;
	int* p2 = (int*)malloc(sizeof(int));
	A* p3 = (A*)malloc(sizeof(A));//只是申请空间
	A* p4 = new A;//申请空间加构造函数初始化

	free(p3);//释放空间
	delete p4;//析构函数加释放空间
}