c++基础（命名空间—New）

命名空间：程序设计者命名的内存区域

作用：开发时就是各自使用独立的空间，便于联合开发

格式：

namespace  空间名

{

         变量，函数，类等；

}

刚开始每次编写cpp时，都会出现 using namespace std；这句话的意思是把未指名空间的对象，指定到std空间中

1. std是一个空间名
2. c++中标准库的内容都存放到std空间中

什么时候调用std 

调用标准库的内容时使用：例如使用 cout cin等

c++为兼容C：做出以下调整（仅对空间这一点）

1.  导入C的头文件可以不用命名空间
2. 为了区分C的头文件 ，C++的头文件不使用 .h做后缀
3. C++的头文件位于 std 命名空间中

//导入C的头文件可以不用命名空间
#include<stdio.h>
int main()
{
	printf("hellow");
	return 0;
}

使用命名空间的内容需要指名在那个命名空间使用：  ::域解析操作符

• 格式：  空间名::(变量，函数，类等)
• 使用 using namespace  空间名； 把未指名空间的对象，指定到该空间
• usingusing namespace  空间名需要放置在定义空间位置后

include<iostream>
using namespace std;
int main()
{
   cout<<"hellow"<<endl;//相当于 std::cout
}

#include <iostream>
namespace p
{
	int a;
}

int main()
{
	p::a = 10;//需要指名空间
	return 0;
}

使用 using 的弊端：

当using的空间过多易产生二义性   

#include<iostream>
namespace p
{
	int a;
	double b;
	char c;
}
namespace p1
{
	int a;
	double b1;
	char c1;
}
using namespace p;
using namespace p1;
int main()
{
	a = 10;//不知道调用哪个a（存在二义性） 错误 
	return 0;
}

 为避免以上问题 可以对常用的一些 方法变量单独指名出来

using 空间名：：变量，方法，等；（强烈推荐使用）

#include<iostream>
using p::a;
namespace p
{
	int a;
	double b;
	char c;
}
namespace p1
{
	int a;
	double b1;
	char c1;
}

int main()
{
	a = 10;//正确
	return 0;
}

 还有另一种情况：空间嵌套

使用一： 用 ：：限定空间使用

#include<iostream>
namespace s
{
	int a;
	double b;
	namespace s1
	{
		int a;
		double b1;
	}
}
int main()
{
	s::a = 10;//直接用域限定空间  可以使用
	s::s1::a = 20;//直接用域限定空间   可以使用
	return 0;
}

使用二： using namespace 空间名

只会调用该空间的非嵌套内容 （不会使用嵌套空间的内容）

#include<iostream>
using std::cout;
using std::endl;
namespace s
{
	void text()
	{
		cout << "s" << endl;
	}
	namespace s1
	{
		void text()
		{
			cout << "s1" << endl;
		}
        double p；
	}
}
using namespace s;
int main()
{
	text();//调用的是s中的，不是s1中的text()
    p=2；//错误，使用不了嵌套循环里面的对象
	return 0;
}

这里再作死一下，在提几种情况：

• 无法直接对 嵌套空间 用 using namespace  (通俗的讲，没老子不能有儿子)
• 可以先对 外层使用 using namespace 然后再对内层使用using namespace
• 可以对  外层：：内层   来使用内层空间 （仅导入内层，外层不能使用）

namespace s
{
	int a;
	namespace s1
	{
		int a;
		double p;
	}
}
using namespace s1;//错误不能这么定义

namespace s
{
	int a;
	namespace s1
	{
		int a;
		double p;
	}
}
using namespace s;
using namespace s1;//可以这么定义(但也是会出现二义性)

namespace s
{
	int a;
	namespace s1
	{
		int a=10;
		double p;
	}
}
using namespace s::s1;//可以使用  仅导入s1

命名空间的使用规范：

•  使用在已命名的名称空间中的变量，而不是使用外部全局变量和静态全局变量
• 不要再头文件中使用using编译指令
• 首选：：访问，和using声明的方法
• using 声明，首选将作用域设置为局部而不是全局

c++11中using可以取别名：

格式：  using   新标识符 = 现有的类型；（常用于模板)模板时会介绍

#include<iostream>
using namespace std;
typedef int  p1;
using p = int;
int main() {
	p a = 10;//using 取别名
	p1 b = 20;//typedef 取别名
	return 0;
}

c++中特有的输入输出：

头文件为：#include<iostream> //包含输入输出流对象

• cin 输入流对象    输入时使用 >>
• cout 输出流对象  输出时使用 <<

cin 和cout 不是关键词 而是对象

>>和<<可以自行分析所处理的数据类型，使用更加简单

endl为换行，也可以使用'\n'来换行

#include<iostream>
using namespace std;
int main()
{
	int a;
	cin >> a;
	cout << a<<endl;
    //等价于 cout<<a<<'\n';
	return 0;
}

 cin和cout 于 scanf和printf 的区别：

scanf和printf 的区别：

1. cin获取键盘输入： 将键盘输入的一系列数据转化为接受信息变量可接受的类型
2. scanf是用指针操作的，没有类型安全机制，比如一个char类型数据你就可以用%f获得输入，而不会报错，但在运行时会出现异常

cout和printf的区别 ：

1. cout是输出流，先把要输出的东西存入缓冲区，再输出，导致效率降低。
2. printf是格式化输出，输出时没有缓冲区，输出效率高。
3. cout不是线程安全的，printf是线程安全的，所以多线程程序，一般都用printf。

C++中内存开辟：

malloc ：

是C语言中的内存开辟的关键词，使用方式为：（C++也能使用）

类型 *  标识符=（类型 *）malloc（int size）

1. malloc 默认返回 void * ，一般需要自己指定
2. 清空内存使用 free();
3. free(标识符)

#include<iostream>
using namespace std;
int main()
{
	int *p = (int *)malloc(100);
    free(p);
    return 0;
}

 calloc 函数： void *calloc(unsigned int num, unsigned int size)

 按照所给的数据个数和数据类型所占字节数，分配一个 num * size 连续的空间。

calloc申请内存空间后，会自动初始化内存空间为 0，但是malloc不会进行初始化，其内存空间存储的是一些随机数据。

realloc 函数： void *realloc(void *ptr, unsigned int size)

 动态分配一个长度为size的内存空间，并把内存空间的首地址赋值给ptr，把ptr内存空间调整为size。申请的内存空间不会进行初始化。 

new是动态分配内存的运算符，自动计算需要分配的空间，在分配类类型的内存空间时，同时调用类的构造函数，对内存空间进行初始化，即完成类的初始化工作。动态分配内置类型是否自动初始化取决于变量定义的位置，在函数体外定义的变量都初始化为0，在函数体内定义的内置类型变量都不进行初始化。 

new：

是C++语言中的内存开辟的关键词，使用方式为：

类型 *  标识符=new 类型（int size）

1. new 会自动推导返回类型
2. 使用 delete释放内存
3. delete（标识符）

#include<iostream>
using namespace std;
int main()
{
	int *p = new int(5);
	delete(p);
	return 0;
}

int *p = (int *)malloc(4);
等价于(表面含义)
int *p = new int();


int *p = (int *)malloc(4 * 10);
等价于(表面含义)
int *p = new int[10];

 malloc和new的区别：

内容太多，请点击下面链接：

c++ new和malloc的区别_旷工锁的博客-CSDN博客_c++ new和malloc的区别