c++学习笔记2

内存分区模型

c++程序执行时将内存划为四个区域

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

2.全局区：存放全局变量和静态变量以及常量

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

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

程序运行前

在程序编译后，生成exe可执行程序，未执行该程序前分为两个区域

代码区：共享、只读

        存放cpu执行的机器指令
        代码区是共享的，共享的目的是对于频繁执行的程序，只需在内存中存一份
        代码区是只读的，防止程序意外的修改了它的指令

全局区：全局变量、静态变量、字符串常量、全局常量

        全局变量和静态变量存方位置
        全局区还包含了常量区，字符串常量和其他常量也存放在这里
        该区域的数据在程序结束后有操作系统释放

实验代码：

#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 << "const修饰的局部变量c_l_a的地址为：" << (int)&c_l_a << endl;
	cout << "const修饰的局部变量c_l_b的地址为：" << (int)&c_l_b << endl;


	system("pause");
	return 0;
}

运行结果：

程序运行后

栈区：

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

实验代码：

#include<iostream>
using namespace std;

//栈区数据注意事项----不要返回局部变量的地址
//栈区数据由编译器管理开辟和释放

int* func(int b) {//形参数据也会放在栈区
	b = 100;
	int a = 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;//返回局部变量的地址
}
int main() {
	//接受func函数的返回值
	int* p = func(1);
	//解引用
	cout << *p << endl;//第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p << endl;//第二次这个数据就不再保留了
	system("pause");
	return 0;
}

运行结果：

堆区：

        由程序员分配释放，若程序员不释放程序结束时由操作系统回收
        在c++中主要靠new在堆区中开辟内存

实验代码：

#include<iostream>
using namespace std;

int * func() {
	//利用new关键字可以将数据开辟到堆区
	//指针 本质上也是一个局部变量，放在栈上，指针保存的数据是放在了堆区
	int *p=new int(10);
	return p;
}
int main() {
	//在堆区开辟数据
	int* p = func(); 
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	system("pause");
	return 0;
}

代码示意图：

运行结果：

new关键字

实验代码：

#include<iostream>
using namespace std;

//1.new	的基本语法
int* func() {
	//在堆区创建整形的数据
	//new 返回的是该数据类型的指针
	int* p= new int(10);
	return p;
}

void test01() {
	int* p = func();
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	cout << *p << endl;
	//堆区的数据由程序员管理开辟，管理释放
	//如果想释放堆区的数据，利用关键字delete
	delete p;//把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;//给这是个元素赋值 100~109
	}

	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() {
	//test01();
	test02();
	system("pause");
	return 0;
}

引用

引用的基本使用

给变量起别名

示意图：

代码：

#include<iostream>
using namespace std;

int main() {
	//引用的基本语法
	//数据类型 &别名 = 原名

	int a = 10;
	//创建引用
	int& b = a;

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

	b = 100;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	system("pause");
	return 0;
}

结果：

引用的注意事项

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

图示

代码：

#include<iostream>
using namespace std;
int main() {
	int a = 10;

	//1.引用必须初始化
	//int& b;//错误，必须初始化
	int& b = a;
	//2.引用一旦初始化，就不可以改变
	int c = 20;
	
	b = c;//赋值操作，而不是更改引用
	
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	cout << "c=" << c << endl;

	system("pause");
	return 0;

}

引用做函数参数

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

#include<iostream>
using namespace std;

//交换的函数

//1.值传递
void swap01(int a, int b) {
	int temp = a;
	a = b;
	b = temp;
}
//2.地址传递
void swap02(int *a, int *b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}
//3.引用传递
void swap03(int &a,int &b) {//&a是a的别名 &b是b的别名
	int temp = a;
	a = b;
	b = temp;
}
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;
}

结论：

通过引用传递的效果和地址传递一样，引用的语法更清楚更简单

引用做函数返回值

代码：

#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;//第一次结果正确，是因为编译器做了保留
	//cout << "ref=" << ref << endl;//第二次结果错误，因为a的内存已经释放

	int& ref2 = test02();
	cout << "ref2=" << ref2 << endl;
	cout << "ref2=" << ref2 << endl;
	cout << "ref2=" << ref2 << endl;
	
	test02() = 1000;//如果一个函数的返回值是引用 那么这个函数可以作为左值

	cout << "ref2=" << ref2 << endl;
	cout << "ref2=" << ref2 << endl;
	cout << "ref2=" << ref2 << endl;

	system("pause");
	return 0;
}

注意事项：

1.不要返回局部变量的引用
2.如果一个函数的返回值是引用 那么这个函数可以作为左值

引用的本质

本质：

引用的本质再c++内部实现是一个指针常量

图示：

#include<iostream>
using namespace std;
//发现是引用，转换为 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);
	cout << "ref:" << ref << endl;
	system("pause");
	return 0;
}

结论：

c++推荐使用引用，所有指针的操作都是由编译器做

常量引用

作用：

加在形参上面为了防止函数内部编写时，误操作修改了数据

代码：

#include<iostream>
using namespace std;

//打印数据函数
void showValue(const int & val) {
	//val = 1000;
	cout << "val=" << val << endl;
}
int main() {
	//常量引用
	//使用场景：用来修饰形参，防止误操作

	//int a = 10;

	//加上const之后 编译器将代码修改为 int temp=10; const int &ref=temp;
	//const int& ref = 10;//引用必须引用一块合法的内存空间
	//ref = 20;//加入const之后变为只读，不可修改

	int a = 100;
	showValue(a);
	cout << "a=" << a << endl;
	system("pause");
	return 0;
}