C++_核心编程_引用、内存分区

引用

一、引用的基本使用

作用：给变量起别名

语法：数据类型 &别名 = 实名

//
//  demo03.cpp
//  core-code
//
//  Created by 戴晗 on 2024/5/7.
//引用

#include <iostream>
using namespace std;

int main(){

    int a = 10;
    int &b = a;  // 引用，就是给变量a起一个别名

    cout << b << endl;

    b = 20;
    cout << b << endl;

    return 0;
}

二、引用的注意事项

1. 引用必须初始化

2. 引用在初始化后不可以改变

#include <iostream>
using namespace std;

int main(){

    int a = 10;
    int &b = a;  // 引用，就是给变量a起一个别名，引用之后就不可以改变
    int c = 50;
    cout << b << endl;

    b = 20;
    b = c;  //赋值操作，不是更改引用
    cout << "a = " << a << " b =" << b << " c = " << c << endl;
    return 0;
}

三、引用做函数参数

作用：函数传参时，可以引用作为形参修饰实参

优点：可以简化指针修改实参

int fun1(int a){  // 值传递
    a += 100;
    return a;
}

void fun2(int *a,int *b){ // 地址传递
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

void fun3(int &a,int &b){ // 引用传递
    int temp;
    temp = a;
    a = b;
    b = temp;
}

int main(){

    int a = 10;
    int &b = a;  // 引用，就是给变量a起一个别名，引用之后就不可以改变
    int c = 50;
    int m = 11,n=22;

    cout << fun1(b) << endl;
    cout << "m = " << m << " n =" << n << endl;

    fun2(&m, &n);  // 地址传递
    cout << "m = " << m << " n =" << n << endl;

    m = 11;
    n = 22;
    fun3(m, n);  // 引用传递
    cout << "m = " << m << " n =" << n << endl;

    return 0;
}
/*
m = 11 n =22
m = 22 n =11
m = 22 n =11

*/

四、引用做函数返回值

作用：引用是可以做函数的返回值存在的

注意：不要返回局部变量引用

用法：函数调用可以作为左值

// 1、引用做函数的返回值
int& test01(){  // 引用的方式返回
    int a = 10;
    return a;
}

// 2、函数调用可以作为左值
int& test02(){  // 引用的方式返回
    static int a = 10; // 静态变量，放在全局中，由系统释放
    return a;
}


int main(){

    int a = 10;
    int &b = a;  // 引用，就是给变量a起一个别名，引用之后就不可以改变
    int c = 50;
    int m = 11,n=22;

    // 1、引用做函数的返回值

    int &q = test01();
    cout << q << endl; // 第一次结果正确，因为编译器做了保留
    cout << q << endl ; // 错误，局部变量已经释放

    // 2、函数调用可以作为左值
    int &p = test02();
    cout << p << endl;  // 以下结果都正确
    cout << p << endl;
    cout << p << endl;

    test02() = 1000; // 如果函数的返回值是引用，这个函数的调用可以作为左值
    cout << p << endl;
    cout << p << endl;

    return 0;
}

讲解代码：函数的引用

int temp;
int fun1()
{
    temp = 10;
    return temp;
}

int& fun2()
{
    temp = 10;
    return temp;
}

int main() 
{
    int a = 0, b = 0;
    // 1. 返回函数的普通类型
    a = fun1();  // 有临时变量
    // 2. 返回函数的引用
    b = fun2();  // 没有临时变量，直接赋值
    // 3. 返回函数的引用去初始化一个新的引用
    int &c = fun2();  // c是 b  的别名

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;

    return 0;
}
// 编译结果：a = 10   b = 10   c = 10

五、引用本质

引用的本质：在C++内部，引用就是一个指针常量

   int &d = b;// 自动转换为int * const d = &b;也就是说明引用为什么不可以修改指向
    d = 100; //相当于 *d = 100，解引用

六、常量引用

作用：主要用来修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

//常量引用，修饰形参，防止误操作
    int dd = 100;
    const int &s1 = dd;
    s1 = 20;   // 加上const之后，s1 就是不可以修改，语句报错
    cout << s1 << endl;
    cout << dd << endl;

void showValue(const int &a ){
//    a = 99;
    cout << "打印的值为：" << a << endl;
}
int main(){

    //常量引用，修饰形参，防止误操作
    int dd = 100;
    showValue(dd);
    cout << dd << endl;
    return 0;
}

内存分区模型

C++程序在运行的时候，会大致将程序分成四个区域。代码区、全局区、栈区、堆区

不同区域存放的数据，赋予不同的生命周期。

一、程序运行前

在程序编译后，生成 .exe 可执行程序，未执行该程序前分为两个区域：代码区+全局区

代码区：存放CPU执行的机器指令

全局区：存放静态变量、全局变量、常量。该区域的数据在程序结束后由操作系统自动释放。

总结：

1. 代码区只能只读和共享

2. 全局中存放全局变量、静态变量和常量

3. 常量区中存放const修饰的全局常量、字符串常量

二、程序运行后

栈区：由编译器自动分配释放，存放函数的参数值、局部变量、形参等

注意事项：不要返回局部变量的地址。

int * fun(){  //形参也被放在栈区
    int a = 10;  //局部变量存放在栈区，栈区的数据在函数执行后自动的被释放
    return &a;
}

int main() {
    int a = 10;
    int b = 10;
    int *p = fun();

    cout << (long long)&a << endl;
    cout << (long long)&b << endl;

    cout << *p << endl;
    cout << *p << endl;




    return 0;
}

堆区：由程序员分配释放，若程序员不释放，则由操作系统释放

在C++中主要利用 new 在堆区开辟内存

int *func(){
    //利用new关键字可以将数据开辟到堆区
    int *p = new int(10); //new返回的内存地址
    return p;
}

int main() {

    //在堆区开辟内存
    int *s = func();
    cout << *s << endl;

    return 0;
}

三、new操作符

语法：new 数据类型（初始值）

利用new创建的数据，会返回该数据类型对应的指针

//1、new的基本语法
int *test01(){
    //在堆区创建数据
    int * p = new int(5);
    return p;
}

//2、在堆区利用new开辟数组
void test02(){
    //创建一个长度为10 的整型数组，在堆区
    int * arr = new int [10];  //10代表数组有10个元素
    for(int i = 0; i < 10 ; i++){
        arr[i] = i + 100;
    }
    for(int i = 0; i < 10 ; i++){
        cout << arr[i] << endl;
    }
    delete [] arr;  //释放数组
    for(int i = 0; i < 10 ; i++){
        cout << arr[i] << endl;
    }

}

int main() {

    int *c = test01();
    cout << *c << endl;  //堆区的数据由程序员开辟，管理和释放
    cout << *c << endl;
    // 释放堆区的数据用 delete
    delete c;
    cout << *c << endl;   //-1789984528 程序报错

    test02();

    return 0;
}