c++基础

1.命名空间
2.C++基本的输入输出流
3.重载（C++为什么支持重载？）
4.C++缺省参数
5.指针和引用(概念、使用方法、做参数、做返回值的作用，指针和引用的区别) 

1.命名空间 namespace

         相当于一个更加灵活的文件域（全局 域），可以用花括号把文件的一部分括起来，并以关键字namespace开头给它 起一            个名字。 要使用namespace 首先要引入 using namespace std；

#include<iostream>
#include<stdlib.h>
using namespace std;
namespace A1            //命名空间A1
{
  int a = 10;
  int b = 15;
}
namespace A2            //命名空间A2
{
  int a = 20;
  int b = 25;
}
int a = 30;             //全局变量a
int main()
{
	int a = 40;             //局部变量a
	cout<< a << endl;       //默认就近原则输出a   ->40
	cout<<:: a << endl;     //::代表全局变量a     ->30
	cout<<A1:: a << endl;   //A1域内的a           ->10
	cout<<A2:: a << endl;   //A2域内的a           ->20


	system("pause");
	return 0;
}

这样就在A1 和 A2 这两个不同的域内使用了相同的名字进行了定义且不会出现重定义。而且还可以多重域内嵌套。

namespace A3
{
	int  a = 50;

	namespace A4
	{
		int a = 60;
	}

}

2.C++基本的输入输出流

输入：cin>>x;

输出：cout<<x<<endl;

void test1()
{
	int a ;
	cin>>a;             //c++输入相当于c语言里面的scanf("%d",&a);
	cout<<a<<endl;		//c++输出相当于c语言里面的printf("%d",a);
}

C++支持连续输入输出  eg：cout<<a<<b<<c<<endl;

3.重载（C++为什么支持重载？）

函数重载就是指：在同一作用域类，一组函数的函数名相同，参数列表不同（个数不同或类型不同或参数顺序不同），返回值可同            可不同。

为什么c语言不支持重载而c++支持重载？

       主要原因是c和c++的编译器在对函数进行重命名的时候用的方法不一样，比如同一个函数 int ADD(int a,int b)

c编译器处理后 将这个函数重新命名为 _ADD

c++编译器处理后，将这个函数重新命名为 _ADD_int_int      //两个int 分别是参数a和b的类型，如果a和b都是long那么处理后的函数                                                                                           名就是_ADD_long_long

所以说函数重载的本质是：1参数的类型不同       2参数个数不同        3参数的顺序不同。  这三点引起的编译器修饰函数名的不同。

                                  

4.C++缺省参数

         所谓缺省参数，顾名思义，就是在声明方法的某个参数的时候为之指定一个默认值，在调用该方法的时候如果采用该默认值，你就无须指定该参数。缺省参数使用主要规则：调用时你只能从最后一个参数开始进行省略，换句话说，如果你要省略一个参数，你必须省略它后面所有的参数。缺省参数的使用规则还包括：带缺省值的参数必须放在参数表的最后面。 缺省值必须是常量。显然，这限制了缺省参数的数据类型，例如动态数组和界面类型的缺省参数值只能是 nil；至于记录类型，则根本不能用作缺省参数。 缺省参数必须通过值参或常参传递。

缺省参数类型分为两类：全缺省和半缺省

//全缺省参数
int Add1 (int a = 1, int b = 0) 
{    
	return a + b; 
}
// 半缺省参数 
int Add2 (int a, int b = 0) 
{    
	return a + b;
}

5.指针和引用(概念、使用方法、做参数、做返回值的作用，指针和引用的区别) 

    所谓引用：就是说将对象在内存中的地址传递给目标对象，就相当于使目标对象和原始对象对应同一个内存存储空间。如果对目标对象进行修改，内存中的数据也会改变。

引用：

        int a = 1;
	int& b = a;
	int& c = b;
	cout<<a<<"  "<<b<<"  "<<c<<endl;  //b和c都是a的别名，实际属性都和a一样包括地址。
常引用：

void test4()
{
	const int& a = 1;      //  1是常量
	//int& b = a;          //  不可以进行常引用，
	const int& b = a;      //  常量要用常引用才可以进行引用

	double c = 3.333; 
	//int& d = c           //不可以进行引用
	const int& d = c;      //c是double型 d是int型  要进行赋值 首先要生成一个临时变量 而临时变量具有常性，所以要用const对d进行修饰才能接收
}                              //会发生隐式类型转换 截断
引用做参数：

void Swap(int& a, int& b)       //这里传引用做参数和穿指针做参数起到的作用是一样的而且跟指针一样可以提高效率
{
        int tmp;
	tmp = a;
	a = b;
	b = tmp;
	
}

void test5()
{
	int a = 1;
	int b = 3;
	Swap(a,b);
	cout<<a<<" "<<b<<endl;
}
引用做返回值：

注意：

1. 不要返回一个临时变量的引用。

2. 如果返回对象出了当前函数的作用域依旧存在，则最好使用引用返回，因为这样更高效。

int& Add (int d1, int d2) 
{     
	static int ret;    //静态变量 或者全局变量
	 ret = d1 + d2;
     return ret ; 
}

void test6() 
{   
	int a = 3, b = 4;   
	int c = Add( a, b );  
	cout<<"c:" <<c<< endl; 
}

引用和指针的区别和联系：
1. 引用只能在定义时初始化一次，之后不能改变指向其它变量（从一而终）；指针变量的值可变。

2. 引用必须指向有效的变量，指针可以为空。

3. sizeof指针对象和引用对象的意义不一样。sizeof引用得到的是所指向的变量的大小，而sizeof指针是对象地址的大小。 

4. 指针和引用自增(++)自减(--)意义不一样。 

5. 相对而言，引用比指针更安全