类和对象（上）、类的定义、类的访问限定符及封装、类的作用域 、类的实例化、类对象模型 、this指针

// C++兼容C中struct的用法
// 类和对象
// 1个类 实例化 N个对象

// C++兼容C中struct的用法
struct Stack
{
	void Init(int n = 4)
	{
		_array = (int*)malloc(sizeof(int) * n);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
	
		_capacity = n;
		_top = 0;
	}

	int* _array;
	size_t _capacity;
	size_t _top;
};

int main()
{
	struct Stack s1;// 结构体定义方式（向下兼容）
 	s1.Init(10);
	Stack s2;// 类的定义方式
	s2.Init(10);

	return 0;
}

class Stack
{
// 只要不加入访问限定符，就是私有
public:
	// 成员函数
	void Init(int n = 4)
	{
		array = (int*)malloc(sizeof(int) * n);
		if (nullptr == array)
		{
			perror("malloc申请空间失败");
			return;
		}

		capacity = n;
		top = 0;
	}

	void Push(int x)
	{
		// ...扩容
		array[top++] = x;
	}

	int Top()
	{
		assert(top > 0);

		return array[top - 1];
	}

// 一般来说，将变量设为私有，函数设为公有
private:
	// 成员变量，这里仅仅是声明
	int* array;
	size_t capacity;
	size_t top;
};

// 封装
// 先把数据和方法放到一起
// 借助访问限定符，设置公有和私有
int main()
{
	//class Stack st1;
	Stack st2;// 使用
	st2.Init();
	st2.Push(1);
	st2.Push(2);
	st2.Push(3);
	st2.Push(4);

	// cout << st2.array[st2.top] << endl;
    // array 和 top 成员变量在 Stack 类中被声明为 private，
    // 这意味着它们不能从类的外部直接访问。

	cout << st2.Top() << endl;

	return 0;
}

// 空类 -> 1
// 这一个字节，不存储有效数据，标识对象被定义出来
class A3
{};

// 1byte
class A2 {
public:
	void f2() {}
};

int main()
{
	// 类 -> 对象   1->多
	// 对象的实例化
	// 对象的占用的大小，只考虑成员变量
	Stack st1;
	Stack st2;
	st1.Init();
	st2.Init();
	st1._top++;
	st2._top--;

	cout << sizeof(st1) << endl;
	cout << sizeof(Stack) << endl;
	cout << sizeof(A3) << endl;
	A3 aa1;
	A3 aa2;

	return 0;
}

class className
{
 // 类体（类域）：由成员函数和成员变量组成
 
};  // 一定要注意后面的分号

// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
 void Init(int year)
 {
 // 这里的year到底是成员变量，还是函数形参？
 year = year;
 }
private:
 int year;
};

class Date
{
public:
	void Init(int year)
	{
		_year = year;
	}
private:
	int _year;
};
// 或者这样
class Date
{
public:
	void Init(int year)
	{
		mYear = year;
	}
private:
	int mYear;
};
// 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age << endl;
}

int main()
{
 Person._age = 100;   // 编译失败：error C2059: 语法错误:“.”
 return 0;
}

class A
{
public:
void PrintA()
{
   cout<<_a<<endl;
}
private:
char _a;
};

// 类中既有成员变量，又有成员函数
class A1 {
public:
    void f1(){}
private:
    int _a;
};
// 类中仅有成员函数
class A2 {
public:
   void f2() {}
};
// 类中什么都没有---空类
class A3
{};

class A4
{
	//private:
	char _ch;
	int _i;
};

int main()
{
	cout << sizeof(A4) << endl;

	return 0;
}

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

	//void Print(Date* const this)
	void Print()
	{
		// this = nullptr;
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};

int main()
{
	Date d1;
	Date d2;
	d1.Init(2024, 4, 2);
	d2.Init(2024, 4, 3);

	//d1.Print(&d1);
	d1.Print();

	//d2.Print(&d2);
	d2.Print();
	return 0;
}

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

// 定义栈中存储的数据类型为整数  
typedef int DataType;  
  
// 定义栈结构体  
typedef struct Stack {  
    DataType* array;  // 指向动态分配的数组的指针  
    int capacity;     // 栈的最大容量  
    int size;         // 栈的当前元素数量  
} Stack;  
  
// 初始化栈，为栈分配初始内存并设置初始容量及大小  
void StackInit(Stack* ps) {  
    assert(ps);  
    // 动态分配内存，初始容量为3个DataType大小  
    ps->array = (DataType*)malloc(sizeof(DataType) * 3);  
    // 检查内存是否分配成功  
    if (ps->array == NULL) {  
        assert(0);  
        return;  
    }  
    ps->capacity = 3;  // 设置初始容量  
    ps->size = 0;      // 初始化栈大小为0  
}  
  
// 销毁栈，释放内存并重置栈的状态  
void StackDestroy(Stack* ps) {  
    // 断言指针不为空  
    assert(ps);  
    if (ps->array) {  
        free(ps->array);  // 释放内存  
        ps->array = NULL;  
        ps->capacity = 0;  
        ps->size = 0;  
    }  
}  
  
// 检查栈的容量，并在必要时进行扩容  
void CheckCapacity(Stack* ps) {  
    if (ps->size == ps->capacity) {  
        int newcapacity = ps->capacity * 2;  // 容量翻倍  
        // 使用realloc尝试扩容  
        DataType* temp = (DataType*)realloc(ps->array, newcapacity * sizeof(DataType));  
        if (temp == NULL) {  
            perror("realloc申请空间失败!!!");  
            return;  
        }  
        ps->array = temp;  
        ps->capacity = newcapacity;  
    }  
}  
  
// 向栈中添加一个元素  
void StackPush(Stack* ps, DataType data) {
    assert(ps);  
    CheckCapacity(ps);  // 检查并扩容  
    ps->array[ps->size] = data;  // 将数据放入栈顶  
    ps->size++;  // 更新栈大小  
}  
  
// 检查栈是否为空  
int StackEmpty(Stack* ps) {  
    assert(ps);  
    return ps->size == 0;  // 如果栈大小为0，则返回真（栈空）  
}  
  
// 从栈中移除一个元素  
void StackPop(Stack* ps) {  
    if (!StackEmpty(ps)) {  // 如果栈不为空  
        ps->size--;  // 减小栈大小，相当于移除栈顶元素  
    } 
}  
  
// 获取栈顶元素的值  
DataType StackTop(Stack* ps) {  
    // 断言栈不为空  
    assert(!StackEmpty(ps));  
    return ps->array[ps->size - 1];  // 返回栈顶元素的值  
}  
  
// 获取栈的当前元素数量  
int StackSize(Stack* ps) {  
    // 断言指针不为空  
    assert(ps);  
    return ps->size;  // 返回栈的大小  
}  
  
int main() {  
    Stack s;  // 声明一个栈变量  
    StackInit(&s);  // 初始化栈  
    // 向栈中添加元素1, 2, 3, 4  
    StackPush(&s, 1);  
    StackPush(&s, 2);  
    StackPush(&s, 3);  
    StackPush(&s, 4);  
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s)); 
    StackPop(&s);  // 弹出栈顶元素  
    StackPop(&s);  // 弹出栈顶元素  
    printf("%d\n", StackTop(&s));  
    printf("%d\n", StackSize(&s)); 
    StackDestroy(&s);  // 销毁栈，释放内存  
    return 0;  
}

#include <iostream>
#include <cstdlib>
using namespace std;

// 定义一个别名 DataType
typedef int DataType;

// 定义一个栈类
class Stack
{
public:
    // 初始化栈
    void Init()
    {
        _array = (DataType*)malloc(sizeof(DataType) * 3);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = 3;
        _size = 0;
    }

    // 压入元素
    void Push(DataType data)
    {
        CheckCapacity();  // 检查并扩容
        _array[_size] = data;
        _size++;
    }

    // 弹出元素
    void Pop()
    {
        if (Empty())
            return;
        _size--;
    }

    // 获取栈顶元素
    DataType Top() { return _array[_size - 1]; }

    // 判断栈是否为空
    int Empty() { return 0 == _size; }

    // 获取栈的大小
    int Size() { return _size; }

    // 销毁栈
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }

private:
    // 检查并扩容栈
    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            int newcapacity = _capacity * 2;
            DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
            if (temp == NULL)
            {
                perror("realloc申请空间失败!!!");
                return;
            }
            _array = temp;
            _capacity = newcapacity;
        }
    }

private:
    DataType* _array;  // 动态数组，用于存储栈元素
    int _capacity;     // 栈的容量
    int _size;         // 栈的当前大小
};

int main()
{
    Stack s;
    s.Init();
    s.Push(1);       
    s.Push(2);       
    s.Push(3);
    s.Push(4);

    printf("%d\n", s.Top());    // 打印栈顶元素
    printf("%d\n", s.Size());   // 打印栈的大小
    s.Pop();        // 弹出栈顶元素
    s.Pop();        // 再次弹出栈顶元素
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Destroy();    // 销毁栈
    return 0;
}