引用
概念
引用是个别名
格式
数据类型 &引用名 = 同类型的变量名 （&引用符号）
数据类型 &引用名 = 同类型的变量名 （&引用符号）
int a = 10;
int &b = a; //给a取个别名叫b, b引用a数组引用
int a;
a=10;
int &b = a;
cout << a << " " << b << endl;
b=20;
cout << a << " " << b << endl;
int arr[5] = {10,20,30,40,50};
int (*p)[5] = &arr;
int (&str)[5] = arr;
cout << arr[3] << " " << str[3] << endl;
cout << (*p)[3] << endl;
cout << &arr << endl;函数引用
int max(int a,int b)
{
return a>b?a:b;
}
int main()
{
int (*p)(int,int) = max;
int (&fun)(int,int) = max;
cout << p(13,32) << endl;
cout << fun(12,53) << endl;
return 0;
}当结构体中有引用成员时
当结构体中有引用成员，使用该结构体类型，定义结构体变量时，就必须定义的同时初始化，就不可以先定义，后赋值。
struct student
{
string name;
int age;
double &score;
};
int main()
{
double a;
cout << "请输入" << endl;
cin >> a;
struct student stu = {"zhang",10,a};
stu.name = "zhang";
cout << stu.name << " " << stu.age << " " << stu.score << endl;
return 0;
}值传递，地址传递，引用传递
值传递：一定不改变原值
地址传递：可能改变原值
引用传递：可能改变原值
space std;
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 &b = b
{
int c = a;
b++;
}
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;
return 0;
}当引用作为函数的返回值的时候
要求返回的变量生命周期足够的长（static修饰或者malloc申请空间）
指针和引用的区别
指针和引用都可以修改变量的值，但本质不同：指针是通过地址改变目标的值，而引用就是目标本身
指针：
引用：
const
const修饰的为只读变量，也成为常变量
const修饰的局部变量在栈区，const修饰的全局变量在静态区的.ro段
const修饰的变量必须在定义的同时初始化
如果想要引用常变量，需要常引用（const int &b = a）
函数重载
概念
在同一个作用域下，两个以上的函数，取相同的函数名，其函数的形参类型或者形参个数不同，编译器会根据实参的参数类型或者个数自动调用匹配的函数，这就是函数重载。
注：返回值类型不同不算重载
例如以下三个函数为重载
int task(int x)
{
}
int task(char x)
{
}
int task(int x,int b)
{
}使用函数重载实现不同数据类型之和
#include <iostream>
using namespace std;
int add(int x, int y)
{
return x+y;
}
double add(double x, double y)
{
return x+y;
}
int add(char x, char y)
{
return x+y;
}
string add(string x, string y)
{
return x+y;
}
int main()
{
cout << add(1,2) << endl;
cout << add(1.24, 4.56) << endl;
cout << add('a', '1') << endl;
cout << add("hello", "world") << endl;
return 0;
}带有默认参数的函数定义和使用
#include <iostream>
using namespace std;
void fun(string name = "kity")
{
cout << name << endl;
}
int main()
{
fun();
fun("hello");
return 0;
}哑元（了解）
函数在定义形参时，只定义形参类型，不定义形参名，在函数中也不使用。
作用：没有作用，占位。
内联函数
在函数前面加上inline关键字，那么该函数就是内联函数
要求：
作用：提高代码的运行效率
原因：内联函数在编译时展开
内敛函数和带参宏的区别
内联函数：
带参宏：
C++中的结构体
C++中结构体和C语言中结构体的区别
C语言中的结构体在C++中依然适用
C++：
C语言：
*C++中结构体名一般首字母大写
类
概念
C++中的类由C++中的结构体演变而来，只是默认的访问权限和默认的继承方式，以及关键字不同，其他都相同。
一般构造数据类型中既有变量又有函数的类型，由类来完成。
C++中结构体和类的区别
默认访问权限：
C++中结构体的默认访问权限是：public共有的
C++中类的默认访问权限是：private共有的
默认继承方式：
C++中结构体的默认继承方式是：public共有的
C++中类的默认继承方式是：private共有的
关键字：
C++结构体：struct
C++类：class
访问权限：public共有的，private共有的，protected保护的
格式
class 类名
{
public:
公共的数据成员、成员函数
protected:
受保护的数据成员，成员函数
private:
私有的数据成员，成员函数
};访问权限的介绍
public：共有权限，表示该权限下的成员，表示该权限的属性（变量），方法（函数）在类内，子类，类外都能访问。
protected:该权限是受保护权限，表示该权限下的属性（变量）、方法（函数），在类内、子类可以被访问，而类外不能被访问。
private:该权限是私有权限，该权限下的属性（变量）、方法（函数），只能在类内被访问，子类、类外不可以被访问。
封装
类的三大属性：封装、继承、多态
封装：写一个类的过程，就是将数据和对数据的处理捆绑在一起的过程。
属性 + 方法
变量 + 函数
相关名称： 类内都可以成为成员，而成员可以具体分为 数据成员、成员函数。
#include <iostream>
using namespace std;
//封装一个 学生 类
class Stu
{
int a; //默认私有访问权限
private:
string name;
protected:
int age;
public:
double score;
public:
dan当成员函数的形参名和数据成员同名时
表明该数据成员属于哪个类，即加上类名和作用域限定符。
类里的每个非静态成员函数，都隐藏了一个this指针形参。
this指针
类里的每个非静态成员函数，都隐藏了一个this指针形参。
谁使用我，我就指向谁。
this指针的原型：
eg : Stu * const this; //指向不可变，指向里的值可变
类外定义成员函数
在类内声明函数
在类外定义成员函数，需要表明该函数属于哪个类的，即加上类名和作用域限定符
#include <iostream>
using namespace std;
//封装一个 学生 类
class Stu
{
int a; //默认私有访问权限
private:
string name;
protected:
int age;
public:
double score;
public:;
void init(string n, int a, double s);
void show();
};
//在类外定义成员函数
void Stu::init(string name, int age, double score) // Stu * const this
{
this->name = name;
this->age = age;
this->score = score;
//this = nullptr; // NULL this指针使用过程中 指向不可变
}
void Stu::show()
{
cout << this << endl;
cout << name << endl; //类内可以访问私有成员
cout << age << endl; //类内可以访问受保护成员
cout << score << endl; //类内可以访问共有成员
}
int main()
{
//使用学生这样的类 实例化一个学生对象
Stu s1;
//s1.name = "张三"; //类外不可以访问私有成员
//s1.age = 20; //类外不可以访问受保护成员
s1.score = 99; //类外可以访问公共的成员
s1.init("张三", 32, 78);
s1.show();
return 0;
}自己封装一个矩形类(Rect)，拥有私有属性:宽度(width)、高度(height)，
定义公有成员函数:
初始化函数:void init(int w, int h)
更改宽度的函数:set_w(int w)
更改高度的函数:set_h(int h)
输出该矩形的周长和面积函数:void show()
#include <iostream>
using namespace std;
//封装一个矩形类
class Rect
{
private:
int width;
int height;
public:;
void init(int w,int h);
void set_w(int w);
void set_h(int h);
void show();
};
//在类外定义成员函数
void Rect::init(int w,int h)
{
this->width = w;
this->height = h;
}
void Rect::set_w(int w)
{
this->width = w;
}
void Rect::set_h(int h)
{
this->height = h;
}
void Rect::show()
{
cout << "面积：" << width*height << endl;
cout << "周长：" << 2*width+2*height << endl;
}
int main()
{
Rect s1;
s1.init(4,5);
s1.show();
return 0;
}