C++ class与内存

//类名 变量名 栈区

//类名 *指针名 = new 类名 堆区

//类的静态成员 静态区

//类的成员函数，静态函数都在代码区，类的函数都是共享的

//代码共享，所有的类对象共享代码

//const变量在类的外部，一开始必须初始化，用常量强行替换，不读内存

//const变量在类的内部，必须构建一个类才能初始化，const与C语言里的const是一样的

//常规创建类对象的时候在栈上，new创建对象的时候，在堆上

//引用本质上就是变量的别名，4个字节，本质上是一个指针

//引用变量跟其他变量一样，常规创建类对象的时候在栈上，new创建对象的时候，在堆上

//static const int dashu;//静态常量区

//静态常量区可以访问，但是不能修改,可以用注射的方式修改

#include <iostream>
#include <functional>
using namespace std;
using namespace placeholders;
class myclass
{
public:
int num;
int data;
int *p;
const int coint;
int &myint;
static int shu;
static const int dashu;//静态常量区
public:
static void go()
{
cout << "hehehe" << endl;
}
void run()
{
cout << "runrunrun" << endl;
}
myclass(int a, int b) :coint(a), myint(b)
{
cout << &a << "  " << &b << endl;
cout << &coint << "  " << &myint << endl;
const int *p = &coint;
cout << *p << "  " << coint << endl;
int *px = const_cast<int*>(p);
*px = 12;
cout << coint << "  " << *px << endl;
}
~myclass()
{

}
};
int myclass::shu = 0;//初始化
const int myclass::dashu = 20;
void main()
{
myclass myclass1(10,9);

void(myclass::*p)() = &myclass::run;//传统函数指针调用,代码共享，所有的类对象共享代码

void(*p1)() = &myclass::go;//函数指针调用静态函数，go

auto func1 = bind(&myclass::run, &myclass1);//仿函数调用run
func1();

const int *px = &myclass::dashu;
int *ppx = const_cast<int*>(px);
*ppx = 12;//静态常量区可以访问，但是不能修改,可以用注射的方式修改
cout << *ppx << "  " << *px << "  " << myclass::dashu << endl;

cin.get();
}