内存分区模型、引用、函数的默认、站位参数及重载二.引用

50 阅读 0 评论 33 点赞

我是靠谱客的博主长情老师，最近开发中收集的这篇文章主要介绍内存分区模型、引用、函数的默认、站位参数及重载二.引用，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

C++程序在执行时大概分为四个区域：

1.代码区：存放函数体的二进制代码，由操作系统进行管理；

2.全局区：存放全局变量、静态变量、常量；

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

4.堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统释放；

不同区域的数据，赋予不同的生命周期，给我们带来了更大的灵活编程。

程序运行前

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

代码区的特点是“共享的”、“只读的”；存放cpu执行的机器指令；

全局区：存放了全局变量（在函数体外的变量）、静态变量（在普通变量之前添加static变成静态变量）、常量【（分为字符串常量）、（const就是的变量）】，该区域的数据在程序结束后由操作系统释放。

程序运行后

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

注意事项：不要返回局部变量的地址，栈开辟的数据由编译器自动释放

堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统释放；

在C++中主要利用new在堆区开辟内存，释放时使用delete操作符

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

#include <iostream>
using namespace std;
int* func()
{
//在堆区创建整形数据
//利用指针接收new返回的地址
int* p = new int(10);
return p;
}
//1.new的基本语法
void test01()
{
int* p = func();
cout << *p << endl;
//如果要释放程序员开辟的数据，利用关键字delete
delete p;
//cout << *p << endl; //内存被释放，再次访问属于非法操作，会报错
}
//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;
}
}
int main() {
test01();
test02();
system("pause");
return 0;
}

二.引用

1.引用的作用：给变量起别名基本语法：数据类型 &别名 = 原名

引用必须初始化，且初始化之后不能更改

#include <iostream>
using namespace std;
int main() {
//引用的基本语法 ：数据类型
&别名 = 原名
int a = 10;
//创建引用
int& b = a; //属于引用的初始化，且不能再出现&b = c的情况
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}

2.值传递、地址传递、引用传递却别

#include <iostream>
using namespace std;
void swap01(int a, int b)
{
a = 20;
b = 10;
}
void swap02(int *a, int *b)
{
*a = 20;
*b = 10;
}
void swap03(int & a, int & b)
{
a = 20;
b = 10;
}
int main() {
int a = 10;
int b = 20;
//swap01(a, b);
//值传递形参不会修饰实参
//swap02(&a, &b);
//地址传递形参会修饰实参
swap03(a, b);
//引用传递形参也可以修饰实参
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}

3.常量引用

在函数列表中，用const修饰形参，防止形参改变实参。

#include <iostream>
using namespace std;
void swap01( const int &a)
{
//a = 20; //在加上const之后，再去修改形参便会报错；
cout << "a = " << a << endl;
}
int main() {
int a = 10;
swap01(a);
system("pause");
return 0;
}

函数的默认参数

C++中函数的形参列表中形参时可以有默认值的

语法：返回值类型函数名（形参=默认值） {}

#include <iostream>
using namespace std;
//函数的默认参数
//在形参有默认值的情况下，如果我们自己传入数据，那么用我传入的数据，如果没有传入数据就用默认值
//语法： 返回值类型
函数名
（形参 = 默认值） {}
int func(int a ,int b=20,int c=30)
{
return a + b + c;
}
//注意事项：如果某个位置有了默认参数，那么这个位置以后，从左到右必须有默认值
//即如果参数b有了默认值，那么c必须有默认值，a可有可无，，如果c有了，a,b可有可无
//如果声明有了默认参数，那么实现就不能有默认参数，反之亦然
// 声明与实现两者只能有一个默认参数
int func2(int a = 10, int b = 10);
//函数的声明
int func2(int a, int b)
//函数的实现
{
return a + b;
}
int main() {
func(10, 10, 30);
func2();
system("pause");
return 0;
}

函数的占位参数

C++函数的形参列表中可以有占位参数，用来占位，调用时必须填补该位置

语法：返回值类型函数名（数据类型） {}

现阶段占位参数的意义不大，后面会深入讲解

#include <iostream>
using namespace std;
void func(int a, int)
{
cout << "占位参数" << endl;
}
int main() {
func(10, 10);
//调用函数时必须将参数补全
system("pause");
return 0;
}

函数的重载

函数名可以相同，提高复用性

函数重载满足条件：

1.同一作用域下 2.函数名相同 3.函数参数的类型不同或个数不同或顺序不同

注意：函数的返回值不同不可以作为函数重载的条件

#include <iostream>
using namespace std;
void func(int a)
{
cout << "调用func（int a）函数" << endl;
}
void func()
{
cout << "调用func函数" << endl;
}
void func(double a, int b)
{
cout << "func(double a,int b)" << endl;
}
void func(int a, double b)
{
cout << "func(int a ,double b)" << endl;
}
//int func(int a, double b)
{} //返回值类型不能做重载的条件
int main() {
func(10);
//调用第一个函数
func();
//调用第二个函数
func(10, 20.1);
//调用第四个函数
func(20.1,10);
//调用第三个函数
system("pause");
return 0;
}

函数重载的注意事项：
1.引用作为函数重载的条件

2.当函数重载遇到默认参数时，容易产生二义性，尽量在函数重载时使用默认参数

#include <iostream>
using namespace std;
//引用作为函数重载的条件
void func(int &a)
{
cout << "func(int &a)" << endl;
}
void func(const int& a)
{
cout << "func(const int &a )" << endl;
}
//两者可以形成重载，条件是形参的数据类型不同
int main() {
int a = 10;
func(a);
//调用第一个函数
func(10);
//调用第二个函数
system("pause");
return 0;
}