内存四区--搞清楚你写的代码是写在哪个地方的

内存分为四个区域：代码区，全局区，堆区，栈区

1.全局区

全局区存放的是 全局变量
静态变量 ，即static关键字，后面会讲解静态成员变量
常量，常量又可分为字符串常量，const修饰的全局变量（全局常量）
在程序结束后系统释放。

2.栈区

由编译器自动分配释放，开辟的数据由编译器自动释放
堆区存放的是 局部变量，形参
注意，不要返回局部变量的地址，因为栈区的数据在函数执行完后就会自动释放

#include<iostream>
using namespace std;
int* func();
int* func()
{
	int a = 10;
	return &a;
}
int main()
{
	int* ptr = func();
	cout << *ptr << endl;   //这一次能正确打印是因为编译器做了保留
	cout << *ptr << endl;   //之后就不再保留了
	return 0;
}

运行后发现两次输出的值不一样

3.堆区

由程序员分配释放，若不释放，程序结束之后由操作系统回收。
在c++中主要利用new在堆区开辟内存，是四个区域中最大的。

4.代码区

存放函数体的二进制代码

静态成员变量

1.所有对象共享同一份数据，静态变量是跟全局变量一样存放在全局区，所以是共享使用的
2.在编译阶段分配内存，即在程序还没有运行之前就已经分配好了。
3.类内声明，类外初始化

#include<iostream>
#include<string.h>
using namespace std;

class person
{
public:
	int getB( )
	{
		return m_B;
	}
	static int m_A;  //类内声明
private:
	static int m_B; //静态变量也是有访问权限的；
};
int person::m_A = 10;//类外初始化，：：是为了说明实在person的作用域下，而不让它成为全局变量
int person::m_B = 10;

int main()
{
	person p1;
	cout << p1.m_A << endl;
	person p2;
	p2.m_A = 520;    //通过对象访问，或者 person::m_A通过类名来访问
	cout << p1.m_A << endl;    //p1.m_A的值会发生改变，是因为静态变量是所有对象共享的
	cout << p2.getB() << endl;  //要获取私人权限的静态变量B，需要通过函数接口
}

静态成员函数

静态成员函数特点：
1 程序共享一个函数 ，这个跟静态成员变量是一个意思
2 静态成员函数只能访问静态成员变量

#include<iostream>
#include<string.h>
using namespace std;

class Person
{

public:

	static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;
		//m_B = 100; //错误，不可以访问非静态成员变量，因为这个函数是共享的，但非静态成员变量在每个对象里的值都不一样，调用的时候不知道调用哪一个m_B；
	}

	static int m_A; //静态成员变量
	int m_B; // 
private:

	//静态成员函数也是有访问权限的
	static void func2()
	{
		cout << "func2调用" << endl;
	}
};
int Person::m_A = 10;


void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.func();

	//2、通过类名
	Person::func();  


	//Person::func2(); //私有权限访问不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

静态成员变量和成员函数都不属于类的对象上，很容易理解，在定义类的函数时，每个对象调用时运行过程都是一样的，只不过传的参数不同。

#include<iostream>
#include<string.h>
using namespace std;

class Person
{
}; 
class People
{
	int m_a;
};
class pear
{
	int m_b;
	void printf()
	{
		cout << "this a function!" << endl;
	}
};
class pig
{
	static int m_c;
};
int pig::m_c = 5;  //类外初始化
class pag
{
	static int m_c;
	static void print()
	{
		m_c = 10;
	}
};
int pag::m_c = 5;  //类外初始化
int main()
{
	Person p1;
	cout << sizeof(p1) << endl;    //空对象也占有一个字节
	People p2;
	cout << sizeof(p2) << endl;    //一个非静态变量的大小，四个字节
	pear p3;
	cout << sizeof(p3) << endl;    //函数不占用对象空间，四个字节
	pig p4;
	cout << sizeof(p4) << endl;    //静态成员变量也不占对象空间
	pag p5;
	cout << sizeof(p5) << endl;    //静态成员函数也不占对象空间，就非静态成员变量占了对象空间

}