C++类和对象深度解析：定义、内存布局和this指针

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;


class Stack//Stack为类名 ==》类名就是这个类的类型
{
	void Push()
	{
	}
/*
函数内部可以添加  public:  来改变类内部成员的“状态”
一种“状态”会持续到下一个访问限定符 或者 } 就会结束
*/
public://表示公有
	void Pop()
	{
	}
private://表示私有，除此之外还有访问限定符protected表示保护

//一般情况下把数据放在类下方，函数放在类上方
	int* a;
	int top;
	int capacity;
};


class Date
{
	int dateInit(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	int Print()
	{
	cout<<_year<<"/"<<_month<<"/"<<_day<<endl;
	}
	
	//==》有的时候成员变量会和参数名一样
	//为了防止混淆与方便使用，在变量前面加 _ 或者 m
	int _year;
	int _month;
	int _day;
};

int main()
{
	Stack st;//用类名实例化对象
	//用st.访问
	st.Pop();//公有的可以调用
	//st.Push();//私有的不能调用
	
	return 0;
}

#include<iostream>
using namespace std;
// 计算⼀下A/B/C实例化的对象是多⼤？ 
class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
	int _i;
};

class B
{
public:
	void Print()
	{
		//...
	}
};

class C
{};

int main()
{
A a;
B b;
C c;
cout << sizeof(a) << endl;
cout << sizeof(b) << endl;
cout << sizeof(c) << endl;
return 0;
}

#include <iostream>
using namespace std;

class Date
{
public:
	int Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	int Print()
	{
	cout<<_year<<"/"<<_month<<"/"<<_day<<endl;
	}
	
	// 有的时候成员变量会和参数名一样
	// 为了防止混淆与方便使用，在变量前面加 _ 或者 m
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
 // Date类实例化出对象d1和d2 
 Date d1;
 Date d2;
 
 d1.Init(2024, 3, 31);
 d1.Print();
 d2.Init(2024, 7, 5);
 d2.Print();
 return 0;
}

void Init(int year, int month, int day)
 {
 _year = year;
 this->_month = month;//这里使用this指针是被允许的
 this->_day = day;
 }

#include<iostream>
using namespace std;
class A
{
public:
 void Print()
 {
 cout << "A::Print()" << endl;
 }
private:
 int _a;
};

int main()
{
 A* p = nullptr;
 p->Print();
 return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
 void Print()
 {
 cout << "A::Print()" << endl;
 cout << _a << endl;
 }
private:
 int _a;
};

int main()
{
 A* p = nullptr;
 p->Print();
 return 0;
}

A* p = nullptr;
p->Print();

A  d1;
A* p = &d1;
p = nullptr;
d1.Print();

void Print()
 {
 cout << "A::Print()" << endl;
 }

void Print()
 {
 cout << "A::Print()" << endl;
 cout << _a << endl;
 }

┌─────────────────────────────────────────────────────────────┐
│  内核空间（操作系统占用，用户程序不可访问）                     │
├─────────────────────────────────────────────────────────────┤
│  栈区（Stack）                                               │
│  存储内容：局部变量、函数形参、函数返回地址、this指针副本        │
│  特性：自动分配/释放（函数调用时分配，返回时释放）              │
│        地址从高到低增长 | 空间大小有限（通常几 MB）            │
├─────────────────────────────────────────────────────────────┤
│  内存映射段（Memory Mapping Segment）                        │
│  存储内容：动态库（.so/.dll）、共享内存、文件映射               │
│  特性：高效 IPC（进程间通信） | 按需加载/卸载                  │
├─────────────────────────────────────────────────────────────┤
│  堆区（Heap）                                                │
│  存储内容：动态分配的对象/数据（new/malloc 分配的内容）         │
│  特性：手动分配/释放（需 delete/free，否则内存泄漏）            │
│        地址从低到高增长 | 空间大小灵活（通常几 GB）             │
├─────────────────────────────────────────────────────────────┤
│  全局/静态存储区（Data Segment + BSS Segment）               │
│  细分 1：数据段（已初始化）                                   │
│          存储：已初始化的全局变量、已初始化的静态变量（static） │
│  细分 2：BSS 段（未初始化）                                   │
│          存储：未初始化的全局变量、未初始化的静态变量           │
│  特性：程序启动时分配，退出时释放 | 默认初始化为 0              │
├─────────────────────────────────────────────────────────────┤
│  代码段（Code Segment / Text Segment）                       │
│  存储内容：可执行指令（函数体、语句）、常量字符串（const char*） │
│  特性：只读（防止篡改指令） | 编译期确定内容                    │
└─────────────────────────────────────────────────────────────┘

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
 STDataType* a;
 int top;
 int capacity;
}ST;
void STInit(ST* ps)
{
 assert(ps);
 ps->a = NULL;
 ps->top = 0;
 ps->capacity = 0;
}
void STDestroy(ST* ps)
{
 assert(ps);
 free(ps->a);
 ps->a = NULL;
 ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
 assert(ps);
// 满了， 扩容 
 if (ps->top == ps->capacity)
 {
 int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
 STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
 if (tmp == NULL)
 {
 perror("realloc fail");
 return;
 }
 ps->a = tmp;
 ps->capacity = newcapacity;
 }
 ps->a[ps->top] = x;
 ps->top++;
}
bool STEmpty(ST* ps)
{
 assert(ps);
 return ps->top == 0;
}
void STPop(ST* ps)
{
 assert(ps);
 assert(!STEmpty(ps));
 ps->top--;
}
STDataType STTop(ST* ps)
{
 assert(ps);
 assert(!STEmpty(ps));
 return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
 assert(ps);
 return ps->top;
}
int main()
{
 ST s;
 STInit(&s);
 STPush(&s, 1);
 STPush(&s, 2);
 STPush(&s, 3);
 STPush(&s, 4);
 while (!STEmpty(&s))
 {
 printf("%d\n", STTop(&s));
 STPop(&s);
 }
 STDestroy(&s);
 return 0;
}

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
 // 成员函数 
 void Init(int n = 4)
 {
 _a = (STDataType*)malloc(sizeof(STDataType) * n);
 if (nullptr == _a)
 {
 perror("malloc申请空间失败");
 return;
 }
 _capacity = n;
 _top = 0;
 }
 void Push(STDataType x)
 {
 if (_top == _capacity)
 {
 int newcapacity = _capacity * 2;
 STDataType* tmp = (STDataType*)realloc(_a, newcapacity * 
sizeof(STDataType));
 if (tmp == NULL)
 {
 perror("realloc fail");
 return;
 }
 _a = tmp;
 _capacity = newcapacity;
 }
 _a[_top++] = x;
 }
 void Pop()
 {
 assert(_top > 0);
 --_top;
 }
 bool Empty()
 {
 return _top == 0;
 }
 int Top()
 {
 assert(_top > 0);
 return _a[_top - 1];
 }
 void Destroy()
 {
 free(_a);
 _a = nullptr;
 _top = _capacity = 0;
 }
private:
// 成员变量 
 STDataType* _a;
 size_t _capacity;
 size_t _top;
};
int main()
{
 Stack s;
 s.Init();
 s.Push(1);
 s.Push(2);
 s.Push(3);
 s.Push(4);
 while (!s.Empty())
 {
 printf("%d\n", s.Top());
 s.Pop();
 }
 s.Destroy();
 return 0;
}