c++入门基础知识

名字空间：namespace，即名字空间，是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。使用“using namespace”可以使得后面不需要每次指定名字空间。

1）名字空间除了系统定义的名字空间之外，还可以自定义，定义名字空间用关键字“namespace”，使用名字空间时用作用域解释符号“::”指定。

2）不指定名字空间的变量或函数都是当前名字空间下的变量或函数。

3）不定义名字空间的情况下，都属于全局名字空间。同一个名字空间可以定义多次。

4）名字空间可以一层层嵌套，指定时也得一层层地指定，这样很不方便，一般用别名代替就方便多了。

5） 名字空间的名字也可以省略，称之为“无名名字空间”，无名名字空间经常被使用，其作用是“内部可以引用，而外部不能引用”。

C++标准输入输出

cout是标准输出流对象，<<是标准操作符。

cin是标准输入流对象，>>是标准操作符。

endl是换行操作符。

他们都属于C++标准库，所以都在std的名字空间里面。

更详细的C++输出格式控制可查看：http://c.biancheng.net/cpp/biancheng/view/2227.html

函数重载：指在同一作用域内，可以有一组具有相同函数名，不同参数列表(个数不同/类型不同)的函数，参数可同可不同，这组函数被称为重载函数。

函数重载的作用：

1）试想如果没有函数重载机制，如在C中，你必须要这样去做：为这个print函数取不同的名字，如print_int、print_string。这里还只是两个的情况，如果是很多个的话，就需要为实现同一个功能的函数取很多个名字，如加入打印long型、char*、各种类型的数组等等。这样做很不友好！

2）类的构造函数跟类名相同，也就是说：构造函数都同名。如果没有函数重载机制，要想实例化不同的对象，那是相当的麻烦！

3）操作符重载，本质上就是函数重载，它大大丰富了已有操作符的含义，方便使用，如+可用于连接字符串等！

#include <iostream>
using namespace std;

double Add(int i = 0, double j = 0)//编译后函数名变为_Z3Addid
{
	return i+j;
}

double Add(double i = 0, int j = 0)//编译后函数名变为_Z3Adddi
{
	return i+j;
}

int main()
{
	cout<<Add(1, 1.1)<<endl;
	cout<<Add(2, 2.2)<<endl;
	return 0;
}

函数重载重命名规则：作用域+函数名+参数列表。更详细可参看：http://www.cnblogs.com/skynet/archive/2010/09/05/1818636.html

C++缺省参数

#include <iostream>
using namespace std;

//全缺省参数
double Add1(int i = 0, int j = 0)
{
	return i+j;
}
//半缺省参数
double Add2(int i, int j = 0)
{
	return i+j;
}

int main()
{
	cout<<Add1()<<endl;
	cout<<Add1(1)<<endl;
	cout<<Add1(1, 1)<<endl;
	cout<<Add2(2)<<endl;
	cout<<Add2(2,2)<<endl;
	return 0;
}

执行结果为：

0
1
2
2
4
指针和引用

引用不是定义一个新的变量，而是给一个已经定义的变量重新起一个别名。
引用的特点:
1. 一个变量可取多个别名  2. 引用必须初始化 3. 引用只能在初始化的时候引用一次，不能改变为再引用其他的变量

引用的错误使用：

	int a1 = 0;
	int& b1 = a1;//b1是a1的别名
	b1 = 1;

	int a2 = 0;
	const int& b2 = a2;
	a2 = 1;//a2改变b2改变
	//b2 = 1;//不能给常量(d2被const修饰)赋值

	const int a3 = 0;
	//int& b3 = a3;//错误
	const int& b3 = a3;//常量具有常性，只有常引用可以引用常量

	double a4 = 1.1;
	//int& b4 = a4;
	//a4是double类型，b4是int,a4赋值给b4要生成一个临时变量(该变量具有常性)，所以不能赋值。
	const int& b4 = a4;

值传递

void swap(int left, int right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

引用传递

void swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

指针传递

void swap(int* left, int* right)
{
	int tmp = *left;
	*left = *right;
	*right = tmp;
}

指针传递和引用传递在效率上要优于值传递(可用GetTickCount验证)。
注意：当不希望函数内容改变参数的值时，尽量在使用时加上const。

传值做返回值与传引用做返回值

int Add(int a, int b)
{
	int ret = a + b;
	return ret;
}


int Add(int a, int b)
{
	int ret = a + b;
	return ret;
}

int main()
{
	int a = 1;
	int b = 1;
	int c = Add(a, b);
	cout<<"c:"<<c<<endl;
	
	return 0;
}

通过调试进入反汇编查看

结论:( 重点记忆)
1. 不要返回一个临时变量的引用。
2. 如果返回对象出了当前函数的作用域依旧存在，则最好使用引用返回，因为这样更高效
引用和指针的区别和联系
1. 引用只能在定义时初始化一次，之后不能改变指向其它变量（从一而终），指针变量的值可变。 
2. 引用必须指向有效的变量，指针可以为空。 
3. sizeof指针对象和引用对象的意义不一样。sizeof引用得到的是所指向的变量的大小，而sizeof指针是对象地址的大小。 
4. 指针和引用自增(++)自减(--)意义不一样。 
5. 相对而言，引用比指针更安全。
总结:指针比引用更灵活，但是也更危险。使用指针时一定要注意 检查指针是否为空。指针所指的地址释放以后最好置0，否则可能存在野指针问题