c和c++动态内存开辟&newnamespace

c中动态开辟内存空间：

malloc 函数原型  void  * malloc(size_t size);  size_t--------无符号整型      操作系统----》内核驱动----》硬件

                            void*是一个半开半闭区间，只知道动态内存起始地址而不知道什么时候结束

                            void  free(void *ptr)//free是不需要指定free的空间大小，free()时和内核存放的首地址对比，如果匹配上则证明地址合法，就可以释放。

                             int *p=(int *)malloc(1)将1个字节的地址空间强制转换成int，实际上只有1字节的空间，使用时会导致越界

C++动态开辟内存空间：

                                   开辟内存用new关键字，释放内存用Delete

                                  int *p=new int//不用指定空间大小，大小由编译器控制

                                  int *p=new int(10);//p指向一个值为10的int数

                                  int *p = new int[10]; //申请一个动态整型数组，数组的长度为[]中的值

int main()
{
	int* p = new int(10);//p指向一个值为10的整型数据数据
	delete p;

	int*cp = (int*)malloc(sizeof(int)* 10);//malloc时需要指定内存大小,为一个一维数组开辟内存空间
	free(cp);//释放



	int* cppp = new int[10](0);//new一维整型数组开辟空间，只能做0初始化
	delete[] cppp;//释放




	//int arr[10][10];//int*   int(*)[10]
	int**parr = (int**)malloc(sizeof(int*)* 10);//malloc动态开辟一个二维数组
	for (int i = 0; i < 10; i++)
	{
		parr[i] = (int*)malloc(sizeof(int)* 10);
	}
        for (int i = 0; i < 10; i++)//释放
	{
		free(parr[i]);
	}
	free(parr);



	int** cpparr = new int*[10];//new动态开辟二维数组
	for (int i = 0; i < 10; i++)
	{
		cpparr[i] = new int[10];
	}


	for (int i = 0; i < 10; i++)//释放
	{
		delete[] cpparr[i];
	}
	delete[] cpparr;




	double* pd = new double(10);
	delete[] pd;




	const int* cp1 = new const int(10);//常量内存块开辟时要初始化，因为常量内存不允许被修改
	//const int* cparr = new const int[10](0);//开辟常量数组没有意义，只能是0
	delete cp1;

replacement new(重定位new)

int main()
{
    int *q= new int;
    char *q=new(q)char('a');//在分配的4个字节的空间里分配出1个字节存储'a'
    return 0;
}//释放时释放q不用释放P    

new开辟的内存区域叫自由存储区域

new/malloc   new:自由存储区域
    1、new  在自由存储区域开辟
      malloc  在堆上开辟
    2、new     返回类型安全（直接处理所需要内存）
      malloc  返回类型不安全
    3、new     不需要计算内存开辟的大小
      malloc  需要计算内存开辟的大小
    4、new     抛出异常  (bad_alloc)
      malloc  返回NULL
    5、new     可以做初始化
      malloc  单纯开辟内存

 

    全局作用域
    局部作用域
    名字空间作用域
        同名：
            合并
    类作用 

#include
#include  // std
using namespace std;
namespace CY1207
{
	int a = 10;
	int Sum(int a, int b)
	{
		std::cout << "namespace CY1207" << std::endl;
		return a + b;
	}
}

int Sum(int a, int b)
{
	cout << "global" << endl;
	return a + b;
}
int main()
{

	Sum(10, 20);//默认访问全局作用域
	
	return 0;
}

namespace CY1207
{
	int a = 10;
	int Sum(int a, int b)
	{
		std::cout << "namespace CY1207" << std::endl;
		return a + b;
	}
}
int main()
{
	using CY1207::Sum;//using声明 把后面声明的符号暴露在using声明当前的作用域
	//using namespace CY1207;//using指示符  把后面的名字空间作用域下的所有符号暴露在using指示符当前的作用域下
	Sum(10, 20);
	//int b = a;
	return 0;
}

namespace CY1207
{
	int a = 10;
	int Sum(int a, int b)
	{
		std::cout << "namespace CY1207" << std::endl;
		return a + b;
	}
}

int main()
{
	//using CY1207::Sum;//using声明 把后面声明的符号暴露在using声明当前的作用域
	using namespace CY1207;//using指示符  把后面的名字空间作用域下的所有符号暴露在using指示符当前的作用域下
	Sum(10, 20);
	int b = a;
	return 0;
}

#include//名字相同合并
#include  // std
using namespace std;
namespace CY1207
{
	int a = 10;
	int Sum(int a, int b)
	{
		std::cout << "namespace CY1207" << std::endl;
		return a + b;
	}
}
namespace CY1207
{
	int a = 10;
	int b = 10;
}
//int Sum(int a, int b)
//{
//	cout << "global" << endl;
//	return a + b;
//}
int main()
{
	//using CY1207::Sum;//using声明 把后面声明的符号暴露在using声明当前的作用域
	using namespace CY1207;//using指示符  把后面的名字空间作用域下的所有符号暴露在using指示符当前的作用域下
	Sum(10, 20);
	int b = a;
	return 0;
}