[C++知识库]C++入门

一.命名空间
在C++中，变量、函数、类都是大量存在的，这些变量、函数、类的名称将都存在于全局作用域中，可能会导致很多冲突。简单的来说namespace关键字的出现就是针对这种问题的，以避免命名冲突或名字污染。
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

//命名空间的用法
namespace Myspace 
{
	void func()
	{
		cout << "This is my space" << endl;
	}
}
namespace Youspace
{
	void func()
	{
		cout << "This is you space" << endl;
	}
}
void main()
{
	//第一种使用方法
	Myspace::func();   //::为作用域解析符
	Youspace::func();
}
//第二种方法
using namespace Myspace;   //直接可以引用Myspace中的所有函数
void main()
{
	func();
}

二.C++输入&输出

//C++的输入输出
void main() 
{
	int result;
	//scanf("%d,&resule);
	cin >> result;
	cout << "result=" << result<<endl;
}
//当没有using namespace std 的写法
void main()
{
	int result;
	//scanf("%d,&resule);
	std::cin >> result;
	std::cout << "result=" << result << std::endl;
}

三. 缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。
1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
四.函数重载
函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题。（函数的重载鱼函数的返回值没有关系）
五.extern “C”
有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。

extern "C" int Add(int left, int right); 

int main()
{ 
    Add(1,2); 
    return 0;
}

六. 引用
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

//引用就是取别名  不会为变量单独开辟空间( 原名不会被覆盖,操作两个名字都可以 )
//引用常量要加const
//没有空引用  int &b;
1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体
引用的实例
typedef int* List;
void InitList(List& list)  //int *&list
{
	list = NULL;
}
void main()
{
	List mylist;
	InitList(mylist);
}

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
void main()
{
	int a = 10;
	int b = 20;
	cout << a << ":" << b << endl;
	Swap(a, b);
	cout << a << ":" << b << endl;
}
引用示范
void main()
{
	int a = 10;
	int& b = a;
	//引用过程中要相同的类型
	char ch = 'A';
	char& c = ch;   //变量的引用

	int* pa = &a;
	int*& qa = pa;  //指针的引用

	int ar[10] = { 1,2,3,4,5,6,7,8,10 };
	int(&br)[10] = ar;    //数组的引用
}
void main()
{
	const int a = 10;
	const int* pa = &a;  // 当a是常量时  *pa是不能接收的  要加上const *pa就不能指向别的变量
}
void main()
{
	/*const int a = 10;
	const int& b = a;*/

	int a = 10;
	int& b = a;
	const int& c = a;  //常引用
}

 引用和指针的不同点:1. 引用在定义时必须初始化，指针没有要求
  2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
  3. 没有NULL引用，但有NULL指针
  4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
  5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
  6.有多级指针，但是没有多级引用
  7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
  8. 引用比指针使用起来相对更安全

七.auto关键字(C++11)
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
1. auto不能作为函数的参数
2. auto不能直接用来声明数组

void main()
{
	int ar[] = { 1,2,3,4,5,6,7,8 };
	int n = sizeof(ar) / sizeof(ar[0]);

	for (int i = 0; i < n; ++i)
	{
		printf("%d", ar[i]);
	}
	printf("\n");
	for (int i = 0;i < n;++i)
	{
		cout << ar[i] << "";
	}
	cout << endl;

	for (auto e : ar)
		cout << e << "";
	cout << endl;

	for (auto &e : ar)
		cout << e << "";
	cout << endl;
}