一、内存四区

程序运行前

1.1 全局区

（1）用于存放全局变量和静态变量；
（2）里面细分有一个常量区，字符串常量和其它常量也存放在此。
（3）该区域是在程序结束后由操作系统释放。

1.2代码区

（1）存放CPU执行的机器指令；
（2）代码区是共享的，频繁执行的程序只需要内存中的一份代码；
（3）代码是只读的，防止意外修改。

程序运行后

1.3 栈区

（1）由编译器自动分配释放，存放函数的形参、局部变量等。
（2）注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。

1.4 堆区

一般由程序员手动分配释放（动态内存申请与释放），若程序员不释放，程序结束时可能由操作系统回收。

new操作符
作用：在堆区开辟数据；
delete操作符
作用：手动释放堆区开辟的数据。

二、引用

2.1 引用的基本语法

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

#include<iostream>
using namespace std;
int main()
{
//
基本语法
//数据类型 &别名 = 原名
int a = 10;
int &b = a;
cout<<"a="<<a<<endl;//10
cout<<"b="<<b<<endl;//10
//因为操作的是同一块内存
b = 100;
cout<<"a="<<a<<endl;//100
cout<<"b="<<b<<endl;//100
}

2.2 引用的注意事项

1 引用必须初始化
2 引用在初始化后，不可以改变

#include<iostream>
using namespace std;
int main()
{
int a = 10;
//
1 引用必须初始化
//
int &b;
int &b = a;
cout<<"b="<<b<<endl;//10
//
2 引用在初始化后，不可以改变
int c = 20;
b = c;//赋值操作，而不是更改引用
cout<<"a="<<a<<endl;//20，指向同一块内存，所以a也发生改变
cout<<"b="<<b<<endl;//20
cout<<"c="<<c<<endl;//20
}

2.3 引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参

通过值传递、地址传递、引用传递进行对比

#include<iostream>
using namespace std;
void MySwap01(int a,int b)
{
int temp = a;
a = b;
b = temp;
cout<<"01a1="<<a<<endl;//20
cout<<"01b1="<<b<<endl;//10
}
void MySwap02(int *a,int *b)
{
int temp = *a;
*a = *b;
*b = temp;
cout<<"02a1="<<*a<<endl;//20
cout<<"02b1="<<*b<<endl;//10
}
void MySwap03(int &a,int &b)
{
int temp = a;
a = b;
b = temp;
cout<<"03a1="<<a<<endl;//20
cout<<"03b1="<<b<<endl;//10
}
int main()
{
int a1 = 10;
int b1 = 20;
//值传递:可以想象改变的只是实参的“替身”的值，而实参本身不会被改变
MySwap01(a1,b1);
cout<<"a1="<<a1<<endl;//10
cout<<"b1="<<b1<<endl;//20
//地址传递 通过指针实现
int a2 = 10;
int b2 = 20;
MySwap02(&a2,&b2);
cout<<"a2="<<a2<<endl;//20
cout<<"b2="<<b2<<endl;//10
//引用传递 通过引用实现
int a3 = 10;
int b3 = 20;
MySwap03(a3,b3);
cout<<"a3="<<a3<<endl;//20
cout<<"b3="<<b3<<endl;//10
}

2.4 引用做函数返回值

1 不要返回局部变量的引用；
2 函数的调用可以作为左值。

#include<iostream>
using namespace std;
//1 不要返回局部变量的引用
int& test01()
{
int a = 10; //局部变量存放在栈区
return a;
}
//2 函数的调用可以作为左值
int& test02()
{
static int a = 10;//静态变量存放在全局区
return a;
}
int main()
{
int &ref = test01();
cout<<"ref="<<ref<<endl;//10,第一次结果正确，是因为编译器做了保留
cout<<"ref="<<ref<<endl;//0,a的内存已经释放
int &ref2 = test02();
cout<<"ref2="<<ref2<<endl;//10
cout<<"ref2="<<ref2<<endl;//10
}

2.5 引用的本质

本质：在C++内部实现一个指针常量

#include<iostream>
using namespace std;
//发现是引用转换为int* const ref = &a
void func(int& ref)
{
ref = 100;
}
int main()
{
int a = 10;
int& ref = a;
ref = 20;
cout<<"a:"<<a<<endl;//20
cout<<"ref:"<<ref<<endl;//20
func(a);
cout<<"ref:"<<ref<<endl;//100
return 0;
}

2.6 const 修饰引用形参

作用：常量引用用来修饰形参，防止误操作

#include<iostream>
using namespace std;
//打印数据
//用const修饰形参
void func(const int &a)
{
//
a = 1000;//报错，就是为了防止误操作
cout<<"01a="<<a<<endl;
}
int main()
{
//常量引用
//使用场景，用来修饰形参，防止误操作
//
int a = 10;
//
加上const后，编译器相当于int temp = 10; int &ref = temp;
//
int &ref = 10;//报错,应改为下面
//
const int &ref = 10;//引用必须引一块合法对的内存空间
//
ref = 20;//报错，加入const变成只读，不可修改
int a = 100;
func(a);
cout<<"a="<<a<<endl;//100
return 0;
}

三、函数高级

3.1 函数默认参数

如果传入了数据，那么就用传入的数据，否则就用默认参数

#include<iostream>
using namespace std;
//打印数据
int func(int a,int b=20 ,int c=30)
{
return a+b+c;
}
int main()
{
//
如果传入了数据，那么就用传入的数据，否则就用默认参数
cout<<func(10,30)<<endl;//70
}

注意：1 如果某个位置有了默认参数，那么从左到右必须有默认参数。

int func(int a,int b=20 ,int c)；错误
int func(int a,int b=20 ,int c=30)；正确

2 如果函数声明有默认参数，那么函数实现就不能有默认参数

int func(int a=10,int b=20 ,int c=30)；
int func(int a,int b ,int c)
{
return a+b+c;
}

3.2 函数占用参数

形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置。

#include<iostream>
using namespace std;
//语法：返回值类型 函数名（数据类型）{}
void func(int a,int)
{
cout<<"this is func!"<<endl;
}
int main()
{
//
调用时需要把参数写全
func(10,30);
}

3.3 函数重载

作用：函数名相同，提高复用性
条件：
（1）同一作用域下；
（2）函数名称相同；
（3）函数参数类型不同 或者 个数不同 或者顺序不同。

#include<iostream>
using namespace std;
void func()
{
cout<<"func()!"<<endl;//70
}
void func(int a)
{
cout<<"func(int a)!"<<endl;//70
}
void func(double a)
{
cout<<"func(double a)!"<<endl;//70
}
int main()
{
func();//func()!
func(10);//func(int a)!
func(3.14);//func(double a)!
}

函数重载的注意事项：
（1）引用作为重载条件
（2）函数重载碰到函数默认参数

#include<iostream>
using namespace std;
//1 引用作为重载条件
void func(int &a)//int &a = 10;不合法
{
cout<<"func(int &a)!"<<endl;
}
void func(const int &a)//const int &a = 10;合法，const让编译器创建临时空间
{
cout<<"func(const int &a)!"<<endl;
}
//2 函数重载碰到默认参数
void func2(int a,int b = 10)
{
cout<<"func(int a,int b = 10)!"<<endl;
}
void func2(int a)
{
cout<<"func(int a,int b = 10)!"<<endl;
}
int main()
{
int a = 10;
func(10);//func(const int &a)!
func(a);//func(int &a)!
//
func2(a);//当函数重载碰到默认参数，出现二义性，报错
}

最后

以上就是冷静月饼为你收集整理的C++学习笔记（6）：内存四区、引用、函数高级一、内存四区二、引用三、函数高级的全部内容，希望文章能够帮你解决C++学习笔记（6）：内存四区、引用、函数高级一、内存四区二、引用三、函数高级所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。