C++基础

1.C++ 的命名空间

1.1使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字
污染，namespace关键字的出现就是针对这种问题的。

#include<iostream>
using namespace std;
//std是C++标准库的命名空间，标准库的东西都放到std里。

（1）在项目中，尽量不要使用using namespace std；

（2）在日常练习中使用using namespace std；

（3）在项目中，指定命名空间访问+展开常用。

eg：

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

//或者

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

//其中<<是流插入运算符，可以自动识别类型
//    >>是流提取运算符。

1.2命名空间域，防止名字冲突，可以嵌套

::是域作用限定符

#include<stdio.h>
int a=0; //定义一个全局变量
int main()
{ 
    int a=1;
    printf("%d",a);   //1 局部优先原则
    printf("%d",::a); //0 ::域作用限定符，“ ::”前若是空白则表示全局
    return 0;
}

2.缺省参数

概念：缺省参数是声明或定义函数时为函数的参数指定一个缺省值

从左往右传，不能只传中间

void Func(int a = 0)
{
    cout<<a<<endl;
}
int main()
{
    Func(); // 没有传参时，使用参数的默认值
    Func(10); // 传参时，使用指定的实参
    return 0;
}

2.1缺省参数分类

2.1.1全缺省参数

void Func(int a = 10, int b = 20, int c = 30)

{}

2.1.2半缺省参数

void Func(int a, int b = 10, int c = 20)

{}

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现

3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

3.函数重载(返回值相同)

函数重载概念：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

#include<iostream>
using namespace std;
// 1、参数类型不同
int Add(int left, int right)
{
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}
double Add(double left, double right)
{
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}
// 2、参数个数不同
void f()
{
    cout << "f()" << endl;
}
void f(int a)
{
    cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
void f(int a, char b)
{
    cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
    cout << "f(char b, int a)" << endl;
}
int main()
{
    Add(10, 20);
    Add(10.1, 20.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

4.引用

4.1 概念：引用不是新定义一个变量，而是给已存在变量取了一个别名（外号），编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

类型& 引用变量名(对象名) = 引用实体；

int a=0;
int &b=a;          //& 引用，取别名
cout<<&b<<endl;    //& 取地址

注意：引用类型必须和引用实体是同种类型的

4.2 引用特性

4.2.1.引用在定义时必须初始化    eg：int &a；//err 编译时会出错
4.2.2. 一个变量可以有多个引用
4.2.3. 引用一旦引用一个实体，再不能引用其他实体 

int a=1;
int &b=a;
int x=10;
b=x; //这里表示将x赋值给b。

4.3常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a; // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

4.3.1使用场景

1.做参数

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

a.输出型参数   b.大对象传参，提高效率。

2.做返回值

int& Count()
{
    static int n = 0;
    n++;
    // ...
    return n;
}

a.传值返回--生成一个返回对象拷贝作为函数调用返回值。

b.传引用返回--引用返回的语法含义返回返回对象的别名。

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。（因为引用返回是未定义的，出了函数作用域，返回对象就销毁了，所以不能用引用返回要用传值返回）

好处：

1.输出型返回对象，调用者可以修改返回对象

2.减少拷贝，提高效率。

使用引用尽量使用const

//权限不能放大

const int c=20;
//int &d=c;      //err
const int& d=c;

int i = 1;
double n = i;  //强制类型转换中间会产生一个临时变量，是double的临时变量，临时变量具有常性。
double n = (double)i;
//变量i还是int类型	
//强制类型转化并不会改变原变量类型，中间都会产生一个临时变量，临时变量具有常性
//double& rn = i;
const double& rn = i;
 

//如果使用引用传参，函数内如果不改变n，尽量使用const引用传参。
void func(const int &n)
{}
int main()
{
    int a=10;
    const int &b=20;
    func(a);
    func(b);
    func(30);
    return 0;
}


//权限可以缩小
int a=10;
const int &b=a;

4.4引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间，而指针开了4 or 8 byte。

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
    int a = 10;
    int& ra = a;//语法角度，ra没有开空间
    ra = 20;

    int* pa = &a;//语法角度，pa开了4 or 8 byte
    *pa = 20;

    return 0;
}

引用和指针的汇编代码对比：

引用和指针的不同点:
1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全