每日一点小知识

auto关键字

c++中的auto关键字是根据后面的值，来自己推测前面的类型是什么，初次见是再可用迭代器的对象中。

C++程序执行过程中，将内存划分为四个区域：分别是

• 代码区：存放函数的二进制代码，由操作系统进行管理。
• 全局区：存放全局变量、常量、静态变量
• 栈区：由编译器自动分配存放，存放函数的参数值、局部变量等。
• 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

内存四区意义：

​​​​​​​不同区域存放不同的数据，赋予不同的生命周期，灵活编程。

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

        代码区：

                存放CPU执行的机器指令

                代码区是共享的        

                代码区是只读的。

        全局区：

        全局变量和静态变量存放在此，全局区还包括常量区，字符串常量和其他常量（const修饰的变量）也存放于此。   

        该区域的数据在程序结束后由操作系统释放。             

        栈区：

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

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

        堆区：

                由程序员分配释放，程序员不释放时，由操作系统回收。

                在c++中主要利用new在堆区开辟内存。利用delete释放内存

#if 1
#include
using namespace std;
// 堆区创建一个变量
int* test1()
{
	int* p = new int(10); //new返回的是变量的地址，因此需要指针接收
	return p;
}
// 在堆区用new开辟数组
void  test0()
{
	int *arr=new int[10]; //数组有10个元素
	for (int i = 0; i < 10; i++)
	{
		arr[i] = 100 + i;
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;
	}
	//释放堆区数组的时候需要加[]
	delete[] arr;
}
int main()
{
	int* p = test1();
	cout << *p << endl;
	//堆区的释放用delete
	delete p;
	//cout << *p << endl;
	test0();
	return 0;
}
#endif

#if 1
#include
using namespace std;
// 堆区创建一个变量
int* test1()
{
	int* p = new int(10); //new返回的是变量的地址，因此需要指针接收
	return p;
}
// 在堆区用new开辟数组
int *  test0()
{
	int *arr=new int[10]; //数组有10个元素
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i + 100;
	}
	return arr;
}
int main()
{
	int* p = test1();
	cout << *p << endl;
	//堆区的释放用delete
	delete p;
	//cout << *p << endl;
	int *p1=test0();
	for (int i = 0; i < 10; i++)
	{
		cout << p1[i] << endl;
	}
	delete[] p;
	for (int i = 0; i < 10; i++)
	{
		cout << p1[i] << endl;
	}
	return 0;
}
#endif

作用：引用相当于给变量起别名

语法：（数据类型）&别名=原名 （指向同一块内存空间）

注意事项：（1）引用必须初始化；（2）引用一旦初始化就不可以更改。

引用的本质：指针常量

#include
using namespace std;
int main()
{
	int rats = 10;
	int& radents = rats;//引用 ==int * const radents=&a 
	cout<<"rats的地址是" << int(&rats)< 
 
引用做函数参数： 
作用：函数传参时，使函数中的变量名称为调用函数章的变量别名，这种方式称为按引用传递，按引用传递的时候，被调用函数的能够访问调用函数中的变量。
 
引用传递与值传递的不同：引用传递可以修改实参的值，但是值传递不行。
 
引用传递与地址传递的不同：引用传递简化了指针修改实参
 
#include
using namespace std;
//值传递
void swap1(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	//cout << "a=" << a << "，" << "b=" << b << endl;
}
// 引用传递
void swapr(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 10;
	int b = 8;
	swap1(a, b);// 调用值传递
	cout <<"调用值传递后：" << "a=" << a << "，" << "b=" << b << endl;
	swapr(a, b);
	cout << "调用引用传递后：" << "a=" << a << "，" << "b=" << b << endl;
}

 
 
引用做函数返回值： 
不能返回局部变量的引用，因为局部变量存放在栈区，编译器自主释放，函数执行结束后，局部变量的内存空间会释放，会导致引用失败。
函数的调用可以作为左值
int& test01()
{
	static int a = 10; //声明成静态变量，避免内存释放的问题
	return a;
}
int main()
{
	int &b = test01();
	cout << "b=" << b<#include
using namespace std;
//指针可以保存地址
int main()
{
	//1、定义一个指针
	//语法：数据类型 * 变量名称
	int* p; //定义一个指针
	int a = 10;
	//指针变量赋值
	p = &a;//p指向a的地址
	cout << "a的地址为：" << &a << endl;
	cout << "指针p为：" << p << endl;
	//2、使用指针
	//可以通过解引用的方式来找到指针指向的内存中的数据
	//指针前加* 代表解引用
	*p = 1000;
	cout << "a：" << a << endl;
	cout << "*p：" << *p << endl;

}
 
指针所占内存空间： 
32位操作系统下，指针（不管任何数据类型）占用4个字节空间，64位操作系统下，占8个字节。
 
空指针和野指针 
空指针和野指针都不是我们申请的内存空间，所以不能访问。
 
#include
using namespace std;
int main()
{
	//空指针
	// 1、空指针用于给指针变量进行初始化
	//int* p = NULL;
	//2、空指针是不可以访问的
	//内存中0-255是系统占用的，不允许访问
	/
	int row = sizeof(data)/sizeof(data[0]);
	int sum_value = SUM(data, row);
	cout << sum_value << endl;

	
}