C++学习心得第二期 内存四区+new+引用+函数高级

一、内存四区

1.内存分区模型

C++程序在执行时,将内存大方向划分为4个区域
代码区:存放函数体的二进制代码,由操作系统进行管理的
全局区:存放全局变量和静态变量以及常量
栈区:由编译器自动分配释放, 存放函数的参数值,局部变量等
堆区:由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

2.程序运行前全局区和代码区

​ 在程序编译后,生成了exe可执行程序,未执行该程序前分为两个区域
​ 代码区:
​ 存放 CPU 执行的机器指令
​ 代码区是共享的,共享的目的是对于频繁被执行的程序,只需要在内存中有一份代码即可
​ 代码区是只读的,使其只读的原因是防止程序意外地修改了它的指令
​ 全局区:
​ 全局变量和静态变量存放在此.
​ 全局区还包含了常量区, 字符串常量和其他常量也存放在此.
该区域的数据在程序结束后由操作系统释放.

C++中在程序运行前分为全局区和代码区
代码区特点是共享和只读
全局区中存放全局变量、静态变量、常量
常量区中存放 const修饰的全局常量 和 字符串常量

#include<iostream>
using namespace std;

//全局变量
int g_a = 10;
int g_b = 10;

//const 修饰的全局变量
const int c_g_a = 10;
const int c_g_b = 10;

int main()
{
	//全局区
	//全局变量 静态变量、常量

	//创建普通局部变量
	int a = 10;
	int b = 10;
	cout <<"局部变量a的地址" <<(int)&a<< endl;
	cout <<"局部变量b的地址" <<(int)&b<< endl;
	//打印全局变量
	cout << "全局变量g_a的地址" << (int)&g_a << endl;
	cout << "全局变量g_b的地址" << (int)&g_b << endl;
	//静态变量 在普通变量前面加static,属于静态变量
	static int s_a = 10;
	static int s_b = 10;
	cout << "静态变量s_a的地址" << (int)&s_a << endl;
	cout << "静态变量s_b的地址" << (int)&s_b << endl;
	//常量
	//字符串常量
	cout <<"字符常量的地址为:" <<(int)&"Hello world"<<endl;
	//const修饰的常量
	//const修饰的全局变量

	cout << "全局常量c_g_a的地址" << (int)&c_g_a << endl;
	cout << "全局常量c_g_b的地址" << (int)&c_g_b << endl;
	//const修饰的局部变量

	const int c_l_a = 10;
	const int c_l_b = 10;
	cout << "局部常量c_l_a的地址" << (int)&c_l_a << endl;
	cout << "局部常量c_l_b的地址" << (int)&c_l_a << endl;


	system("pause");
	return 0;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.程序运行后 栈区和堆区

由编译器自动分配释放, 存放函数的参数值,局部变量等
注意事项:不要返回局部变量和形式参数的地址,栈区开辟的数据由编译器自动释放

#include<iostream>
using namespace std;

int* fun()
{
	int a = 10; //局部变量 存放在栈区 栈区的数据在函数执行完之后自动释放 
	return &a;  //返回局部变量
}

int* xingcan(int a)
{
	a = 100;
	return &a;
}

int main()
{
	//不能返回局部变量
	int* a = fun();
	cout << *a<< endl;  //第一可以打印是因为打印正确的数字,是因为编译器做了正确的保留
	cout << *a << endl; //第二次这个数据不再保存了
	//不能返回函数中的形式参数
	int test = 10;
	int* xc = xingcan(test);

	//读不出正确的数据
	cout << *xc << endl;
	cout << *xc << endl;

	system("pause");
	return 0;
}

由程序员分配释放,若程序员不释放,程序结束时由操作系统回收
在C++中主要利用new在堆区开辟内存
堆区数据由程序员管理开辟和释放
堆区数据利用new关键字进行开辟内存

#include<iostream>
using namespace std;

int* fun()
{
	//利用new关键字  可以将数据开辟到堆区
	//指针 本质是局部变量,放在栈上,指针保存的数据是放在堆区
	int *p = new int(10);
	return p;
}

int main()
{
	//在堆区开辟数据
	int *p = fun();

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

	system("pause");
	return 0;
}

在这里插入图片描述

在这里插入图片描述

二、new关键字

​ C++中利用new操作符在堆区开辟数据
​ 堆区开辟的数据,由程序员手动开辟,手动释放,释放利用操作符 delete
​ 语法: new 数据类型
​ 利用new创建的数据,会返回该数据对应的类型的指针

1.基本语法

#include<iostream>
using namespace std;

int* fun()
{
	//利用new关键字  可以将数据开辟到堆区
	//指针 本质是局部变量,放在栈上,指针保存的数据是放在堆区
	int *p = new int(10);
	return p;
}

int main()
{
	//在堆区开辟数据
	int *p = fun();

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

	//释放堆区数据
	delete p;
	cout << *p << endl; //程序报错
	system("pause");
	return 0;
}

2.开辟数组

#include<iostream>
using namespace std;
int main()
{
	int *arr = new int[10];

for (int i = 0; i < 10; i++)
{
	arr[i] = i + 100;
}
for (int i = 0; i < 10; i++)
{
	cout << arr[i] << endl;
}
//释放数组 delete 后加 []
delete [] arr;

system("pause");

return 0;
}

二、引用

1.引用的基本使用

**作用: **给变量起别名
语法: 数据类型 &别名 = 原名

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int &b = a;

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

	b = 20;

	cout << "改变之后的a=" << a << endl;
	cout << "改变之后的b=" << b << endl;

	system("pause");

	return 0;
}

在这里插入图片描述

2.引用注意事项

引用必须初始化
引用在初始化后,不可以改变

#include<iostream>
using namespace std;

int main()
{
	//在本质上 引用是指针常量 可以修改数值 但是不能修改指向
	//对于引用必须初始化。而且因为是指针常量,则初始化后不能改变。
	int a = 20;
	//int &b;  错误,引用必须要初始化
	int &b = a;
	int c = 100;
	//&b = c;  错误,显示左值不能修改,引用一旦初始化后就不能修改
	b = c;//正确,赋值操作,上边的式子是更改引用

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

	system("pause");
	return 0;
}

3.引用做函数参数

**作用:**函数传参时,可以利用引用的技术让形参修饰实参
**优点:**可以简化指针修改实参
通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单

#include<iostream>
using namespace std;

//值传递
void swapByValue(int a,int b)
{
	int temp=a;
	a = b;
	b = temp;
}
//地址传递
void swapByAddress(int* a,int* b )
{
	int temp = *a;
	 *a = *b;
	 *b = temp;
}
//引用传递
void  swapByYinyong(int& a,int& b)
{
	int temp = a;
	a = b;
	b = temp;
}

int main()
{
	//实现交换数据
	int a = 10;
	int b = 20;
	//值传递
	swapByValue(a, b);
	cout <<"a="<<a<<"b="<<b<< endl;
	//地址传递
	int c = 10;
	int d = 20; 
	
	swapByAddress(&c,&d);
	cout << "c=" << c << "d=" << d << endl;
	//引用传递
	int e = 10;
	int f = 20;
	swapByYinyong(e,f);
	cout << "e=" << e << "f=" << f << endl;

	system("pause");
	return 0;
}

在这里插入图片描述

4.引用做函数返回值

作用:引用是可以作为函数的返回值存在的
注意:不要返回局部变量引用
用法:函数调用作为左值

#include<iostream>
using namespace std;
//不能返回局部变量的引用
int& localVariety()
{
	int a = 10;
	return a;
}
//返回静态变量的引用
int& staticvariety()
{
	int static a = 100;
	return a;
}

int main()
{
	int &a = localVariety();
	//不能返回局部变量的引用
	cout <<"a=" <<a<< endl;  //第一次有数值
	cout << "a=" << a << endl; //由于局部变量存放在栈区,函数使用完毕,系统自动释放。

	//可以返回静态变量的引用
	//静态变量属于全局变量  系统结束的时候释放
	int &b = staticvariety();
	cout << "返回静态变量	的数值"<<b<< endl;
	cout << "返回静态变量	的数值"<<b << endl;
	//函数做左值 必须返回引用
	staticvariety() = 1000;
	
	cout << "函数做左值修改后	的数值" << b << endl;

	system("pause");
	return 0;
}

在这里插入图片描述

5.引用的本质

本质:引用的本质在c++内部实现是一个指针常量.
结论:C++推荐用引用技术,因为语法方便,引用本质是指针常量,但是所有的指针操作编译器都帮我们做了

//发现是引用,转换为 int* const ref = &a;
void func(int& ref){
	ref = 100; // ref是引用,转换为*ref = 100
}
int main(){
	int a = 10;
    
    //自动转换为 int* const ref = &a; 指针常量是指针指向不可改,也说明为什么引用不可更改
	int& ref = a; 
	ref = 20; //内部发现ref是引用,自动帮我们转换为: *ref = 20;
    
	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;
    
	func(a);
	return 0;
}

6.常量引用

**作用:**常量引用主要用来修饰形参,防止误操作
在函数形参列表中,可以加const修饰形参,防止形参改变实参
对于常量引用只能以数字进行赋值

#include<iostream>
using namespace std;
//函数中利用常量引用防止误操作使形式参数修改实际参数
void showValue(const int& v)
{
	//v++;  错误,因为加了const防止误操作形式参数,修改实际参数。输出没有写的权限。
	cout <<v << endl;
}

int main()
{
	//int& ref = 100; 引用本身需要一个合法的内存空间,因此错误
	//加入 const就可以了,编译器将代码转化为 int temp=10;const int& ref=temp;
	const int ref = 100;

	//ref = 1000; 加入const之后就不能修改变量


	system("pause");
	return 0;
}

四、函数提高

1、函数默认参数

在C++中,函数的形参列表中的形参是可以有默认值的。
语法: 返回值类型 函数名 (参数= 默认值){}

  1. 如果某个位置参数有默认值,那么从这个位置往后,从左向右,必须都要有默认值
  2. 如果函数声明有默认值,函数实现的时候就不能有默认参数
#include<iostream>
using namespace std;

//1.如果某个位置参数默认值,那么从这个位置往后,从左向右,必须要有默认值

/*
在b处有默认值,那么必须要从b之后都要有默认值
int func(int a,int b=10,int c)
{
	return a + b + c;
}
*/
// 正确形式
int func(int a,int b=10,int c=10)
{
	return a + b + c;
}

//对于函数声明和函数调用只能有一块有默认参数
//int func1(int a = 1, int b = 2, int c = 3);
int func1(int a=1,int b=2,int c=3)
{
	return a + b + c;
}

int main()
{
	//在调用函数的时候,可以使用默认参数,也可以将默认参数使用形式参数抵消掉
	cout << func(1,1,1)<< endl;
	cout << func(1)<< endl;

	func1();
	system("pause");
	return 0;
}

2、 函数占位参数

C++中函数的形参列表里可以有占位参数,用来做占位,调用函数时必须填补该位置
语法: 返回值类型 函数名 (数据类型){}
在现阶段函数的占位参数存在意义不大,但是后面的课程中会用到该技术

#include<iostream>
using namespace std;

void func(int a,int)
{
	cout <<"函数执行完毕" << endl;
}

int main()
{

	func(10,10);
	
	system("pause");
	return 0;
}

3.函数重载概述

**作用:**函数名可以相同,提高复用性
函数重载满足条件:
同一个作用域下
函数名称相同
函数参数类型不同 或者 个数不同 或者 顺序不同
注意: 函数的返回值不可以作为函数重载的条件

#include<iostream>
using namespace std;

void func()
{
	cout <<"fun() 的调用"<< endl;
}

void func(int a)
{
	cout <<"func(int a)"<< endl;
}
void func(double a)
{
	cout <<"func(double a)" << 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)
{
	return a;
}
*/
int main()
{
	func();
	func(1);
	func(3.14);
	func(1,3.14);
	func(3.14,1);
	
	system("pause");
	return 0;
}

4.函数重载注意事项

引用作为重载条件 通过引用和常量引用做为形式参数来进行函数重载
函数重载碰到函数默认参数 (int a)与(int a,int b=20)在func(10)时存在二义性,不能进行函数重载。

#include<iostream>
using namespace std;
//引用作为重载   引用可以通过const作为区别进行重载
void func(int &a)
{
	cout <<"func(int &a)" << endl;
}

void func(const int& a)
{
	cout <<"func(const int& a)"<< endl;
}

//函数重载碰到默认参数产生歧义,需要避免。
void func1(int a,int b=10)
{
	cout <<"func1(int a,int b=10)" << endl;
}
void func1(int a)
{
	cout <<"func2(int a)" << endl;
}

int main()
{
	
	//对于形式参数为引用的只需要传入变量就可以,对于形式参数为常量引用的直接由数字赋值。
	int a = 10;
	func(a);    //调用func(int &a)
	func(10);   //调用func(const int& a)

	//报错 重载函数不明确,有二义性。
	//func1(1);

	system("pause");
	return 0;
}
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页