1.引用

引用就是给变量起别名

格式：

数据类型 &引用名 = 同类型的变量名 （& 引用符号）

eg: int a = 10; int &b = a;     //b引用a,或者给a变量取个别名叫b

    int *p;  //指针可以先定义 后指向
    p = &a;
    
    //int &bb; 引用必须定义的同时初始化 指定目标
    //bb = b;
    
    p = &b;
    
    //int &aa = b; 引用一旦指向目标，就不可以改变了

数组的引用

给数组起别名

    int a[5] = {1,2,3,4,5};

    //数组指针
    int (*p)[5] = &a;

    //数组引用
    int (&b)[5] = a;

    cout << a[3] << endl;
    cout << b[3] << endl; // b[3] == a[3]

    b[4] = 99;
    cout << a[4] << endl;

函数的引用

给函数起别名

int max(int x, int y)

{ return x>y?x:y; }

//函数引用

int (&fun)(int, int) = max;

cout << fun(6,8) << endl;

// fun(6,8) == max(6, 8)

结构体中有引用成员

当结构体中有引用成员的时候，使用该结构体类型定义变量时，必须定义的时候初始化，否则报错。

struct student

{         int &id;

          string name;

};

int num=1;

struct student stu={num,"张三"}；//当结构体有引用成员时，必须定义的时候初始化

当引用作为函数的返回值

要求返回的变量的生命周期要长

静态局部变量或者堆区申请的变量

int &fun() // int &num = num
{
    static int num = 10;
    return num;
}

int main()
{
    int a;

    a = fun(); // a = num
    cout << a << endl;

传值、传址、传引用（重点）

传值一定不会改变目标的值。

传址可能会，可能不会。

传引用可能会，可能不会。

void fun(int a, int b) //int a = a
{
    a++;
    b++;
}
void fun2(int *a, int *b)//int *a = &a
{
    *a++;
    *b++;
}
void fun3(int &a, int &b)// int &a = a
{
    int c = a;
}
int main()
{
    int a = 10, b = 20;
    fun(a,b);//值传递
    cout << "main: a = " << a << " b = " << b << endl;

    fun2(&a, &b);//址传递
    cout << "main: a = " << a << " b = " << b << endl;

    fun3(a,b);//引用传递
    cout << "main: a = " << a << " b = " << b << endl;

指针与引用的区别（重点）

指针：存放地址变量。

引用：变量的别名。

1.指针可以先定义后指向，引用必须定义的时候同时初始化。

2.指针后期可以改变指向，引用一旦指定目标就无法改变。

3.指针要申请空间存放指针变量的地址，引用不需要。

4.有指针数组没有引用数组（引用不是数据类型）。

5.有二级指针没有二级引用（引用不是数据类型）。

2.const

修饰变量时，表示该变量是常变量，其值不能被修改

int a = 10;
int const b = 20; // const int b = 20  
int *pa = &a; //合法
int *pb = &b; //不合法
int const *pbb = &b; //可以  (int cosnt * const p)

int a = 10；
int const b = 20;
int &ppa = a; //合法
int &ppb = b; //不合法
int const &pppb = b; //合法  int const &pppb ---->常引用

3.函数重载

c++中，在同一作用域下，两个以上函数，取相同函数名，其形参的个数或者类型不同，编译器会根据实参的类型或个数，自动调用相应函数，这就是函数重载。

注意：不以返回值作为标准

默认参数的函数定义和使用

void fun(string name = "zhangsan")
{
    cout << name << endl;
}

哑元（了解）

定义函数的时候，只定义类型，不定义形参名，在函数中也不使用。

作用：没有作用，占位

内联函数

内联函数就是在函数定义前 加 inline 关键字。

要求：

1> 内联函数体积要小

2> 一般代码不超过5行

3> 不能有复杂的语句，比如循环，递归

作用：提高代码的运行效率

内联函数和带参宏替换的区别：

1> 内联函数是函数调用，带参宏替换是替换

2> 内联函数是在编译的时候展开，带参宏替换是在预处理展开。

4.C++中的结构体

1> C语言中的结构体在C++中依然适用。

2> C++中的结构体可以有函数，而C语言不可以。

3> C++中的结构体可以给变量赋初始值，而C语言中不可以。

4> C++中的结构体在定义结构体变量时，可以省略关键字struct不写，而C语言中不可以。

5> C++中的结构体中有访问权限，而C语言中的结构体没有访问权限。

6> C++中的结构体有特殊的成员函数，而C语言中的结构体没有。

7> C++中的结构体存在继承，而C语言中的结构体没有继承。

C++中的结构名一般首字母大写。

C++结构体的默认访问权限是共有的，--->public

访问权限：private: 私有权限 protected:保护权限 public:共有权限

5.类

一般又有变量又有函数的构造数据类型，用类来完成，C++中的类是由C++中的结构体演变而来，只是默认访问权限和默认继承方式以及关键字不同。

默认访问权限： private 私有的

默认继承方式：private 私有的

关键字：class

类内都可以成为成员，成员可以分为数据成员、成员函数

格式

class 类名

{

 public：

        公共的数据成员、成员函数

protected：

        受保护的数据成员、成员函数

private：

        私有的数据成员、成员函数

}；

访问权限的介绍

public: 该权限是公共权限，表示该权限下的属性（变量）、方法（函数）,可以在类内、子类、类外被访问。

protected: 该权限是受保护权限，表该权限下的属性（变量）、方法（函数），可以在类内、子类被访问，类外不可以被访问。

private: 该权限是私有权限，表示该权限下的属性（变量）、方法（函数），只能在类内被访问，子类、类外不可以被访问。

封装

类的三大属性：封装、继承、多态

封装就是将数据和对数据的处理捆绑在一起的过程，称为封装。

属性（变量）+ 方法（函数）

当成员函数形参名和数据成员同名时

表明数据成员属于哪个类的，即加上类名和作用域限定符

this指针

1> 类里的每个非静态成员函数，都有隐藏了一个this指针形参

2> this指针，谁使用我，我就指向谁

3> this指针的原型

eg：

Stu * const this

类外定义成员函数

1> 在类内声明函数

2> 在类外定义成员函数的实现，需要表名改函数属于哪个类的，即加上类名和作用域限定符。

作业