命名空间，输入输出流，为什么支持重载，缺省，指针与引用

C++入门知识

在我们学习了C语言后，我们开始了C++的学习，而学习C++的第一节课，我们需要知道C++一些不同于C语言的基本特点：
例如：
1：命名空间

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

　C++引入了命名空间namespace主要解决了多个程序员在编写同一个项目中可能出现的函数等重名的现象。解决方法就是加上自己的命名空间。这样就可以很好的控制。
　

#define _CRT_SECURE_NO_WARNINGS 1 

#include <iostream>
using namespace std;

namespace A1
{
    int a = 10;
}
namespace A2
{
    int a = 20;
}

using namespace  A2;
int main()
{
    cout<<a<<endl;
    cout<<A1::a<<endl;
    return 0;
}

iostream是输入输出流，using namespace + 命名空间名就可以使用该命名空间。就相当于将该命名空间里的变量展开，也就是释放命名空间里的东西。就如上面程序里的using namespace A2这一句，正因为有了这一句所以下面cout<

#include <iostream>

using namespace std;
int main()
{
    std::cout<<"hello bit!"<<endl;
    return 0;
}

正因为所有的标准库函数都在标准命名空间std中进行了定义。所以要想使用cout，就必须使用std命名空间，使用方法有两种；第一种：using namespace std; 第二种 : std**::**cout;

另外命名空间的定义是：
有名的命名空间
namespace 命名空间名
{
变量；
}

无名的命名空间：
namespace
{
变量；
}

命名空间也支持多层嵌套
例如：

#include <iostream>

using namespace std;

namespace A1
{
    int a = 2;
    namespace A2
    {
        int a = 1;
    }
}
int main()
{
    cout<<A1::a<<endl;
    cout<<A1::A2::a<<endl;
    return 0;
}

结果输出2和1；
2：C++基本的输入输出流

#include <iostream>
using namespace std;

int main()
{
    cout<<"hello bit!"<<endl;
    return 0;
}

字符串“hello bit！“流向控制台然后输出。
cout是标准输出流对象，<<是输出操作符。
cin是标准输入流对象，>>是输入操作符。
endl是换行操作符。

3:重载：
重载定义：同一个作用域，函数名相同，参数不同（既包括参数类型，也包括参数个数）。这样的名字相同而参数不同的函数或者方法，互相之间称之为重载的函数或者方法。
返回值不同，不能构成重载
例如下面的代码，编译器会报错。原因就是那两个函数不构成重载，有语法错误。

#include <iostream>

using namespace std;
void f(int i)
{

}
int f(int i)
{
    return i;
}

int main()
{
    f(2);
    return 0;
}

C++为什么支持重载？
举个例子：

#include <iostream>

using namespace std;
void f(int i)
{

}
float f(float i)
{

}

int main()
{
    return 0;
}

上面的函数，在C++中，编译器在编译后再库中的名字为_f_int和_f_float. 而在C语言中，编译器在编译后在库中的名字为_f 而且两个函数的名字都如此。在找名字链接时，在C语言种两个名字一样，就会在链接中报错，C++中名字不一样，所以不会报错，也就是C++支持重载的原因。

4：C++缺省：
定义：所谓缺省参数，顾名思义，就是在声明方法的某个参数的时候为之指定一个默认值，在调用该方法的时候如果采用该默认值，你就无须指定该参数。缺省参数使用主要规则：调用时你只能从最后一个参数开始进行省略，换句话说，如果你要省略一个参数，你必须省略它后面所有的参数。缺省参数的使用规则还包括：带缺省值的参数必须放在参数表的最后面。

例如：

#include <iostream>

using namespace std;
void add(int x,int y = 1)
{
    cout<<x+y<<endl;
}
void add1(int x = 10,int y = 20)
{
    cout<<x+y<<endl;
}
int main()
{
    add(1);
    add1();
    return 0;
}

add1()是全缺省，add()是半缺省。

5：指针与引用：

引用是一个全新的概念,是C++与C语言的一个区别，在概念上来讲，引用不是定义了一个新的变量，而是给已经存在的变量取了个别名，编译器不会为引用重新开辟一个空间，而是和它的引用对象共用同一块内存空间。但是，如果严格的来说，通过看引用的汇编语言，我们就会发现引用其实就是用指针实现的。

要使用引用，就必须注意几点：
1：引用在定义时必须初始化；
2：一个变量可以有多个引用；
3：引用一旦使用，就不能改变；
4：引用的访问范围不能大于被引用对象的范围；

#include <iostream>

using namespace std;
void test()
{
    int num = 5;
    int& a = num;
    cout<<a<<endl;
}
int main()
{
    test();
    return 0;
}

输出5；

a是变量num的别名；
不能使用常引用来改变变量的值；
例如：

void test()
{
    int num = 5;
    const int& a = num;
    //a = 3;//不允许
    num = 3;
    cout<<a<<endl;
}

a是常引用，所以不能通过常引用来改变变量的值。
长引用必须被常引用所引用；
例如：

void test()
{
    int num = 3;
    const int& a = num;
    int& b = a;//不被允许；
}

void test()
{
    double a = 0.0;
    const int& b = a;//可以
    int& b = a;//不被允许，因为b是int& ，而a是double，两个类型不匹配，在进行命名时会生成一个临时变量，而临时变量具有常属性，所以要用const int&
}
int main()
{
    test();
    return 0;
}

上面我们说过，引用是用指针实现的，那么它就具有一些指针的能力。比如它可以做函数的参数；
引用做参数有两个优点：
(1):可以在函数内部对外面传参过来的变量别名所对应的变量进行修改。
(2):提高函数调用和运行效率。

  void swap(int& a,int& b)
{
    int temp = 0;
    temp = a;
    a = b;
    b = temp;
}
int main()
{
    int num1 = 2;
    int num2 = 3;
    swap(num1,num2);
    return 0;
}

引用做返回值
(1): 以引用返回函数值，定义函数时需要在函数名前加上&。
(2): 用引用返回函数值是为了不在内存中产生被返回值的副本。

int& add(int a,int b)
{
    int c = a+b;
    return c;
}
int main()
{
    int num1 = 2;
    int num2 = 3;
    add(num1,num2);
    return 0;
}

这个例子就是引用做返回值。
最好不要返回局部变量的引用，因为在函数返回后，就不能通过引用找到对象。所以要尽量避免这样的问题。
但是，如果返回值字节较长，导致寄存器不能存下，这时候可以使用引用来提高效率。前提是你要确保函数返回后，原来函数栈帧里的数据不被修改。

6：指针与引用的区别：

相同点：指针和引用的底层实现类型，都是按照指针的方式来实现的。
不同点：
（1）：引用定义必须初始化，必须对应某个变量的，而且不能更改；而指针可以初始化成NULL；指针也可以改变。
（2）：sizeof（引用）是求被引用类型的大小。
而sizeof（指针）在32位平台下，始终是4个字节。
（3）：引用++可以使变量++，而指针++，则改变了指针的指向。
（4）：引用比指针相对安全。