C++引用类型

一、bool类型 

int a=true;
int b=false;
bool bl=0;
bool al=5;

cout<<a<<" "<<b<<" "<<al<<" "<<bl<<" "<<endl;

 输出结果为：1 0 1 0 明明给al赋值为5，为什么输出的却是1呢？为什么赋值true，a却输出1？对于一系列疑问，在这里，我们可以看一下C++中的bool类型数据的相关规则：

bool类型:
    只占一个字节，只有 0 和 1
    0代表false   1代表true
    作用：用来做标记
    任何非零值都是ture，存在bool变量中输出均为1
    

C与C++的区别：
    C语言中，没有bool类型

 二、new运算符

new的用法

申请连续空间和一块空间时的用法。

int* fun1(){
    int* n = new int[3];//开辟数组，大小为3,[]
    //释放时需要delete[]
    return n;
}
int* fun2(){
    int* n = new int(1);//开辟元素，数值为1,()
    //释放时需要delete
    return n;
}

对于申请连续空间的数组时，想要对其进行初始化，操作方法：

int* fun(){
    int *n=new int[3]{1,2,3};//1 2 3
    int *m=new int[3]{0};//全为0
    return n;
}

内存泄漏

int* fun()
{
    int* n=new int[3];
    return n;
}
int main()
{
    //情况一：
    fun();//调用函数申请堆区空间，申请的空间没有释放
    //情况二：
    int *p=fun();//接收地址
    delete p;//释放地址，但申请时申请的是连续的多块地址，此处只释放数组首元素地址

    //正确写法：
    int *ptr=fun();
    delete[] ptr;
    return 0;
}

C与C++的申请堆区空间的区别： 

new: 在堆区申请内存空间
        如果申请的是数组返回的就是数组首元素地址
        如果申请的是一个元素，返回的就是元素的内存地址

new 和 malloc 的区别:
        1.malloc 需要返回强转返回值，new不需要
        2.malloc 需要传入具体的字节数，new不需要
        3.malloc 申请内存失败时会返回空指针，new申请内存失败时会抛出异常
        4.new是运算符，malloc是函数
        //5.new = malloc() + operator new + 异常处理

内存泄露:

        申请的空间没有手动释放

三、引用类型

引用类型:
     引用：给变量起别名
     语法：数据类型 &别名=原名
引用特点：
    必须初始化，且不能初始化为空
    引用不能改变引用关系
    //一旦初始化，不可再将这个别名赋给别的变量使用
引用的底层：
    DataType* const p;
    //指针指向不可改变 即 引用关系不可改
    //const修饰必须初始化 即 引用必须初始化

 引用作返回值

int& test01() {
	int a = 10;
	return a;
}
int& test02() {
	static int a = 10;
	return a;
}
int main() {
    int _b1=test01();
    for(int i=0;i<5;i++) cout<<_b1<<" ";
    cout<<endl;//将a的值返回赋给_b1，输出5个10

    int& b1=test01();
    for(int i=0;i<5;i++) cout<<b1<<" ";
    cout<<endl;//输出1~2个10，其余随机值
    //由于a被释放掉，返回a的引用，a不存在，所以是随机值
    //准确值是编译器保留的，使用过后就没有了，这个是伪·正确值

    int _b2=test02();
    for(int i=0;i<5;i++) cout<<_b2<<" ";
    cout<<endl;//输出5个10

    int& b2=test02();
    for(int i=0;i<5;i++) cout<<b2<<" ";
    cout<<endl;//由于a被static修饰，a不会被释放掉，b2就是a的别名，所以输出5个10
	return 0;
}

内存分区：C语言的内存知识_c语言内存-CSDN博客

静态变量：static修饰的变量

static修饰全局变量，该全局变量不能被extern声明

static修饰局部变量，该局部变量在定义的函数内一直存在，不被释放

 const的用法

int main() {
	int a = 3;
	const int* p1 = &a;//使用p1代表a,则a 只读不可写，p1不改指向
	int* const p2 = &a;//使用p2代表a,则a 可读可写，p2课改变指向
	const int* const p3 = &a;//使用p3代表a, 则a 只读不可写，p3不改指向
	return 0;
}

const int p=2;
int* p1=&p;//error
int* const p1=&p;//error
const int*p1=&p;//正确
//指针指向一个变量的时候，const属性不能删除
//假如变量为const修饰，指针指向该变量，我可以通过指针修改该变量的值，const修饰失效，不合理

int n=2;
const int* p1=&n;
//假设变量未被修饰，指针指向该变量时可以增加const属性，意义是使用指针时对变量进行只读操作


//也就是说指针指向变量时，cosnt属性不可删除，cosnt属性可添加

 左值与右值

//左值引用：DataType& _a;
//右值引用：DataType& &a;
//万能引用：const DataType & aa;
int test01() {
	int a = 10;
	return a;
	//返回：数值，右值
}
int& test02() {
	static int a = 10;
	return a;
	//返回：引用，左值
}
int main() {
	int _a = 2;//_a是左值
	int& a = _a;//（左值引用）引用左值
	int&& b = 2;//（右值引用）引用右值

	//int&& b2 = _a;//(右值引用)不能引用左值
	//int& a2 = 2;//(左值引用)不能引用右值

	const int& aa = test01();//（万能引用）引用右值
	const int& bb = test02();//（万能引用）引用左值
	return 0;
}

---

感谢大家！