【C++】基础知识篇

1.命名空间
在C++中，标识符（name）可以是符号常量、变量、宏、函数、结构、枚举、类和对象等。为了避免在大规模程序设计中以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入了关键字namespace（命名空间），以便更好控制标识符作用域。
定义格式如下：

namespace 命名空间
{
命名空间声明内容
}

例如：定义两个命名空间AA1，AA2

#include<iostream>
using namespace std;
namespace AA1
{
    int i;
    void print（）
    {
          count<<"AA1"<<end1;
}
namespace AA2
{
    int j;
    void print（）
    {
          count<<"AA2"<<end1;
}
int main()
{
     AA1::print();
     AA2::print();
     return 0;
}

using声明
在C++中，我们可以使用using可以不需要加前缀“namespace_name::”的情况下访问命名空间中的成员。using声明同其他声明一样有一个作用域，它引入的名字从声明开始直到其所在的域结束都是可见的。
例如命名空间std，这是最常用的命名空间，标准C++库中所有的组件都在该命名空间中声明和定义。
例如：

#include <iostream>
using namespace std;
int main ()
{
     std::cout<<"hello world"<<std::endl;
     return 0;
}

2.C++基本的输入输出流
C++的输入和输出功能除了支持C语言的输入/输出系统外，还可以有iostream库提供。最常用的输入/输出运算符是“>>”和“<<”。
（1）cin：标准输入的istream类对象，使用户能够从终端读数据，默认键盘。
（2）cout：标准输出的ostream类对象，使用户能够从终端写数据，默认是屏幕。
（3）cerr：标准错误的ostream类对象，cerr输出程序错误，默认是屏幕。

#include <iostream>
#include<string>
using namespace std;
int main ()
{
    string s;
    char* p = "abc";
    int i;
    cout<<"Hello world"<<endl ;
    cin>>i;
    count<<"i=\t"<<i<<endl;
    count<<p<<endl;
    cin>>s;
    if(s.empty() == true)
    {
        cerr<<"string s is empty"<<endl;
    }
}

常用的格式流

3.重载（C++为什么支持重载？）
C++重载：在同一作用域类，一组函数的函数名相同，参数列表不同（个数不同/类型不同）,返回值可同可不同
在学习C语言的时候我们不能用下面的方式定义两个函数：

#include<stdio.h>
void fun(int i)
{
}
void fun(char j)
{

}
int main()
{
    fun(1);
    fun('a');
    return 0;
}

会出现如下的错误：

而C++可以实现这样的函数重载，那么问题来了，为什么C++支持函数重载，而C语言不支持呢？
从代码的编译到运行，在VS这种编译器下，它是系统直接完成了翻译与链接，直接生成了运行结果。
编译器内部完成了翻译部分：
1.预处理
1）头文件展开
2）宏的替换
3）去注释
4）条件编译
2.编译过程：将高级语言转为汇编语言
3.汇编过程：汇编语言转为二进制程序
链接部分：所引用的数据链接进来
比如一个函数的声明如下：
void fun(int i)；
在c语言中，编译器在编译后在库中的名字为_fun
在c++中，编译器在编译后在库中的名字为_function_int
还有一个函数的声明如下：
void fun(char j);
在c语言中，编译器在编译后在库中的名字为_fun
在c++中，编译器在编译后在库中的名字为_function_char
在链接时，都是找名字进行链接的,就比如以上两个函数，
在C语言中两个的名字一样，就会在链接中报错。
C++中它们的名字不一样，所以就不会报错。
4.C++缺省参数
如果函数说明或函数定义中为形参指定一个默认值，则称此函数为带缺省参数的函数。如果在调用时，指定了形参相对应的实参，则形参使用实参的值。如果未指定相应的实参，则形参使用默认值，这为函数的使用提供了很大的便利。
例如，函数int可以被说明为：

void init（int x = 1）;

如果调用语句为init(2),则这个调用语句传递给形参的值为2，如果调用语句为init( ),则传递给形参的值为1。
如果函数有多个缺省参数，则缺省参数必须是从右向左定义，并且在一个默认参数的右边不能有未指定缺省参数。
例如：

void fun（int a，int b = 1，int c = 4，int d = 5）;

这个函数声明语句是正确的，但是下面的声明语句是错误的：

void fun（int a，int b = 1，int c，int d）;
void fun（int a，int b = 1，int c，int d = 5）;

缺省参数分为全缺省参数和半缺省参数，例如：

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

【注意】
1. 带缺省值的参数必须放在参数表的最后面。
2. 缺省参数不能同时在函数的声明和函数定义中出现，二者只能选其一。
3. 缺省值必须是常量或全局变量。
4. 缺省参数必须通过值参或常参传递。

5.指针和引用
C语言中函数有两种传参的方式：传值和传址。
以传值方式，在函数调用过程中会生成一份临时变量用形参代替，最终把实参的值传递给新分配的临时变量即形参。它的优点是避免了函数调用的副作用，确无法改变形参的值。如果要改变实参的值，只能通过指针传递。

void swap (int *_pleft , int * _pRight)
{
    int iTemp = * _pleft;
    *_pleft = * _pRight;
    *_pRight = iTemp;
}

指针可以解决问题，但不是很形象友好，不安全，因此C++中引入了一种新的符合类型–引用。
引用概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
定义的格式为：
类型 &引用变量名 = 已定义过的变量名;
【引用特性】
1. 引用在定义时必须初始化。
2. 一个变量可以有多个引用。
3. 引用一旦绑定了一个实体，就不能再改变为其他变量的引用。

void Test()
{
   int i = 10;
   int &i1= i;
   int &i2 = i1;
   //int &i3; // 定义引用时必须进行初始化
   int &i5= i;
   int i6 = 20;   
   //&i5 = i6; // 引用一旦定义，就不能够在改变
}

使用场景
【函数形参】

void swap(int &_iLeft, int &_iRight)
{
int iTemp = _iLeft;
_iLeft = _iRight;
_iRight = iTemp;
}

【返回值】

// 值返回
int Add(int _iLeft, int _iRight)
{
return _iLeft + _iRight;
}
// 引用返回
int& Add(int & _iLeft, int& _iRight)
{
int iResult = _iLeft+_iRight;
return iResult;
}

引用与指针的区别
【相同点】
底层的实现方式相同，都是按照指针的方式来实现的

【不同点】

void Test()
{
// 相同点两者的底层处理方式相同
int iTest0 = 10;
int &iTest1 = iTest0;
int *pTest2 = &iTest0;
// 不同点
// 定义时必须初始化，指针可以不用，正常情况下需初始化为NULL
int &iTest3;
int *pTest4;
// 引用一旦定义就不能再改变，指针可以
int iTest5 = 20;
int &iTest6 = iTest0;
&iTest5 = iTest5;
int *pTest7 = &iTest0;
pTest7 = &iTest6;
// sizeof
printf( "%d", sizeof (iTest6));
printf( "%d", sizeof (pTest7));
// 自++含义不同
iTest6++;
pTest7++;
// 可以有多级指针，但是没有多级引用
int &&iTest8;
int **pTest9;
}

总结：
1、引用在定义时必须初始化，指针没有要求。
2、一旦一个引用被初始化为指向一个对象，就不能再指向
其他对象，而指针可以在任何时候指向任何一个同类型对象
3、没有NULL引用，但有NULL指针。
4、在sizeof中含义不同：引用结果为引用类型的大小，
但指针始终是地址空间所占字节个数。
5、引用自加改变变量的内容，指针自加改变了指针指向
6、有多级指针，但是没有多级引用
7、引用比指针使用起来相对更安全