C++入门知识

1.命名空间

（1）定义：namespace即"命名空间"，也称"名称空间" 、"名字空间"。VS.NET中的各种语言使用的一种代码组织的形式 通过名称空间来分类，区别不同的代码功能 同时也是VS.NET中所有类的完全名称的一部分。

（2）出现原因 ：命名空间是用来组织和重用代码的编译单元。如同名字一样的意思，NameSpace(名字空间)，之所以出来这样一个东西，是因为人类可用的单词数太少，并且不同的人写的程序不可能所有的变量都没有重名现象，对于库来说，这个问题尤其严重，如果两个人写的库文件中出现同名的变量或函数(不可避免)，使用起来就有问题了，为了解决这个问题，引入了名字空间这个概念，通过使用 namespace xxx;你所使用的库函数或变量就是在该名字空间中定义的，这样一来就不会引起不必要的冲突了。

（3）命名空间的用法以及解决全局冲突的问题：

#include<iostream>//库
using namespace std;//全局域

                //命名空间，C++库中所有组件都是在std命名空间中声明和定义的，
                      只要写一个using指示符就可使用标准C++库中所有成员or用 std::成员使用 

int a=10;
int b=20;
int a=30;
//不能通过，两个a不能同时存在，即同一区域同名不能存在
int main()  //局部域
{   
   //printf("hello world\n");
   //cout<<"hello world"<<end1;
   int a=40;
  //不同区域同名可以存在
  //存储区域不同
   return 0;
}
解决不同名变量存在存在的方法：命令不同的空间
(1)
#include<iostream>
using namespace std;
      命名空间  命名空间的名字
namespace AA1
{
    int a=10;
}
namespace AA2
{
    int b=30;
}
//C++中一个花括号定义一个域
int b=20;
int a=50;
int main()
{
    int a=40;
//printf（"%d\n",a）; C输出 
  cout<<a<<end1;  //C++输出 就近原则，默认输出局部区域a=40
  cout<<::a<<end1; //指定输出全局a=50 ::为作用域解析符
  cout<<AA1::a<<end1;//输出全局域AA1中a的值
  cout<<AA2::a<<end1;
   return 0;
}
(2)
using namespace AA1
int main()
{
  cout<<a<<end1;
  return 0;
}
如同名链表要分配两个命名空间
include<iostream>
using namespace std;
namespace S1
{
   struct ListNode
   {
     //单链表
     //next
    }；

}
namespace S2
{
   struct ListNode
   {
     //双向链表
     //next
     //pre
    }；
}
return 0;
}
}
无using namespace时命名空间的用法
#include<iostream>  
int main()
{
   std::cout<<"hello world"<<std::end1;//添加std限制
   return 0;
}
命名空间另一种用法:多层嵌套
#include<iostream>
using namespace std;
namespace AA1
{
   int a=1;
   namespace AA2
   {
      int a=2;
      namespace AA3
      {
          int a=3;
      }
   }
 }
int main()
{
cout<<AA1::a<<end1;
cout<<AA1::AA2::a<<end1;
cout<<AA1::AA2::AA3::a<<end1;
   return 0;
}

2.C++基本的输入输出流(简单介绍一下就行)

#include<iostream>//库
using namespace std;//命名空间，C++库中所有组件都是在std命名空间中声明和定义的，
                      只要写一个using指示符就可使用标准C++库中所有成员or用 std::成员使用 
int main()
{
   cout<<"hello world"<<end1;//输出
  // 控制台（即变量a或者字符串hello world流向控制台然后输出）
   return 0;
}
//cout是标准输出流对象，<<是输出操作符；
  cin是标准输入流对象,>>是输入操作符；
  endl是换行操作符；
  都属于C++标准库，都在std的名字空间里面

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

（1）重载定义：同一个作用域，函数名相同，参数不同(类型不同，个数不同)）这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

（2）代码实现;

/void f(int i)
//{
//	printf("%d\n", i);
//}
//void f(ch)
//{
//	printf("%c\n", ch);
//}

在C中函数名相同，参数不同，运行时会报错，但在 C++中不会报错。

再如：

在c语言中，编译器在编译后在库中的名字为_function,在c++中，编译器在编译后在库中的名字为_function_int_int
函数的声明如下：void function（float x,float y)；在c语言中，编译器在编译后在库中的名字为_function在c++中，编译器在编译后在库中的名字为_function_float_float，在找名字链接时，在C语言中两个的名字一样，就会在链接中报错，C++中名字不一样，不会报错。

（3）返回值不同，不能构成重载。如：

void f(char a,int i)
{
}
 
int f(char a,int i )
{
}

4.C++缺省参数（缺省：系统默认状态）

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

（2）分类：

1)全缺省：一个参数都不传，全用缺省参数。

2）半缺省：一个缺省，一个不 缺省。

（3）代码实现;

//int Add(int a = 10, int b = 20)//全缺省
int Add(int a,int b=20)//半缺省 
//{
//	return a + b;
//}
//int main()
//{
//	cout << Add(1, 2) << endl;
//	cout << Add() << endl;//输出30 即10+20
//	cout << Add(20) << endl;//输出40 即20+20 默认20传给a 没有传b用缺省的b=20
//	cout << Add(10) << endl;//30=10+20
//	cout << Add(10, 30) << endl;//40=10+30
//	getchar();
//	return 0;
//}

(4)注意：缺省必须是从右向左连续的，只能缺省最右边的。

int Add(int a,int b,int c=40)//错误 
int Add(int a,int b=30,int c=40) //正确

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

（1）引用不是定义一个新的变量而是给一个已经定义的变量重新起一个别名。

（2）定义格式：类型&引用变量名=已定义过的变量名

int &b=a;//即b是a的别名

（3）特点：

1）一个变量可取多个别名。

2）引用必须初始化。

3）引用只能在初始化时引用一次，不能改变再引用其他的变量。

（4）作用：

1）作参数 

如：交换变量

void swap(int *l,int *r)//C
{
   int tmp=*l;
   *l=*r;
   *r=tmp;
}
void swap(int &l,int &r)//C++
{
   int tmp=l;
   l=r;
   r=tmp;
}
int main()
{
   int a=10;
   int b=20;
   swap(&a,&b;);//c
   swap(a,b);//C++
}

2）提高效率。

（5）引用作返回值

通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似。

代码实现

int Add(int d1, int d2)
{
	int ret = d1 + d2;
	getchar();
	return ret;//临时变量
}
void f(int d1, int d2)
{
	int ret = d1 + d2;
}
void main()
{
	int a = 3, b = 4;
	const int& c = Add(a, b);
	cout << "c:" << c << endl;
	f(10, 20);
	cout << "c:" << c << endl;
}

引用之后

int& Add(int d1, int d2)
{
	int ret = d1 + d2;
	getchar();
	return ret;//临时变量&
}
void f(int d1, int d2)
{
	int ret = d1 + d2;
}
void main()
{
	int a = 3, b = 4;
	const int& c = Add(a, b);
	cout << "c:" << c << endl;
	f(10, 20);
	cout << "c:" << c << endl;
}

（6）指针与引用区别

（指针危险容易出现问题，从而提出引用 ）
1.从现象上看：指针在运行时可以改变其所指向的值，而引用一旦和某个对象绑定后就不再改变。引用访问一个变量是直接访问，而指针是间接访问。
2.从内存分配上看：程序为指针变量分配内存区域，而引用不分配内存区域
3.从编译上看：程序在编译时分别将指针和引用添加到符号表上，符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值，而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改，因此指针可以改变指向的对象（指针变量中的值可以改），而引用对象不能改。