（C++ 复习笔记）类和对象

命名空间

解决命名冲突的问题。

命名空间定义语法：

namespace 空间名{

//命名空间中可以定义变量、函数、类型

        int a=0；

        int Add(int x1,int x2){

                return x1+x2;

        }

        struct Node{

                int data;

                struct Node* next;

        }

}

命名空间使用:

空间名::a / 空间名::A(1,2) / struct 空间名:: Node 变量名;

using namespace 空间名；展开命名空间（全部展开）

using  空间名::Add; (部分展开命名空间)

命名空间可以嵌套

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

缺省参数

void Func(int a=1){

        cout << a << endl;

}

int main(){

        Func(2);// 2

        Func();// 1

        return 0;

}

//全缺省

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

        cout << " a = " << a << endl;

        cout << " b =" << b << endl;

        cout << " c =" << c << endl;

}

int main(){

        Func();//1,2,3

        //显示传参，从左往右显示传参

        Func(1);//1 20 30

        Func(1,2);//1 2 30

        Fun c(1,2,3);//1 2 3 

        return 0;

}

//半缺省--必须从右往左，给缺省值

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

        cout << " a = " << a << endl;

        cout << " b =" << b << endl;

        cout << " c =" << c << endl;

}

注意：1.半缺省参数必须从右往左依次来给出，不能间隔着给

        2.缺省参数不能在函数声明和定义中同时出现，声明给，定义不给

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

函数重载

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

void Swap(int* x,int* y)

void Swap(double* x ,double* y)

int main(){

        int i=1,j=2;

        double n=1.1,m=2.2;

         Swap(&i,&j);

        Swap(&n,&m);

        return 0;

}

编译过程：预处理、编译、汇编、链接

test.cpp

预处理： 头文件展开、宏替换、去掉注释、条件编译

--> test.i

编译：检查语法、生产汇编代码（指令级代码）

-->test.s

汇编：将汇编代码生成二进制机器码

-->  test.o

链接：合并链接，生成可执行程序

--> a.out/xxx.ext

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

引用

引用不是定义了一个新变量，而是给已经存在的变量去了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量公用一块内存空间

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

引用特性：1.引用在定义时必须初始化 

                  2.一个变量可以有多个引用

                  3.引用一旦引用一个实体，再不能引用其他实体

int a= 1;

int& b=a;

int& c=a;

void swap(int& x, int& y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int x = 1, y = 2;
    swap(x, y);//  x=2 y=1
    return 0;
}
需要输出型参数的场景可以用引用

引用可以做返回值，如果函数返回时，出了函数作用域，如果返回对象还在（还没还给系统），则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

传引用传参（任何时候都能使用）

1.提高效率 2.输出型参数（形参的修改，影响实参）

传引用返回（出了函数的作用域对象还在才可以使用）

1.提高效率 2.修改返回对象

c的接口设计

读取第i个位置的值

int SLAT(struct SeqList* ps ,int i){

        ........

        return ps->a[i];

}

修改第i 个位置的值

void SLModify(struct SeqList* ps,int i , int x){

        .....

        ps->a[i]=x;

}

/

//读 或 修改 第i个位置的值      c++接口设计

int& SLAT(struct SeqList& ps, int i){

        ........

        return ps.a[i];

}

int main(){

        struct SeqList s;

        .......

        SLAT(S,0)=1;

        cout << SLAT(S,0) << endl;

        return 0;

}

在引用过程中，权限可以平移，权限可以缩小，权限不能放大

int main(){

        const int a = 0;

        //权限放大  (错误)

        int& b = a;

        //权限的平移

        const int& c = a ;

        //权限的缩小

        int x = 0 ;

        const int& y = x;

        return 0;

}

临时对象具有常性

引用和指针的不同点

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

指针开空间，引用不开空间。

在底层引用和指针是一样的。

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

内联函数

宏（宏常量、宏函数）直接替换

#define 名字 表达式

缺点：1.容易出错，语法错误多 2.不能调试 3.没有类型安全的检查

优点：1.没有类型的严格限制 2.针对频繁调用小函数，不需要再建立栈帧，提高了效率

C++有哪些技术替代宏?
1.常量定义换用const enum
2.短小函数定义换用内联函数

由宏衍生出内联函数

 1.inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷:可能会使目标文件变大，优势:少了调用开销，提高程序运行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议: 将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。                                                      3.inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

 

内联函数在符号表里没有地址，调用的时候直接展开，内联函数不生产指令，在调用地方直接展开 。

 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

auto

 使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的”占位符”，编译器在编译期会将auto替换为变量实际的类型。

 

 

 

 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

范围for

 -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

指针空值nullptr

值等于0，类型是void*