【C++】类和对象(一) -- 类的定义、实例化、this指针详解及C++和C语言实现Stack对比

#define _CRT_SECURE_NO_WARNINGS 1

//C++面向对象的三大特性:封装、继承、多态
//在类和对象这一块我们主要看封装
//在C语言中体现出来的就是:数据和方法是分离的
// 封装的本质体现了更严格的规范管理
//C++封装特点:
//1) 数据和方法封装放到了一起，都在类里面
//
class Stack//class下没给的成员默认私有
{
//从第一个访问限定符到下一个出现为止全都是public
//如果没有下一个访问限定符就到作用域结束为止
public:
	//成员函数
	void Init()
	{
		a = nullptr;
		top = 0;
		capacity = 0;
	}

	void Push(int x)
	{

	}
private:
	//成员变量
	int* a;
	int top;
	int capacity;
};

//兼容C struct用法
typedef struct A
{
	void func();

	int a1;
	int a2;
}AA;

//升级成了类
//struct默认是公有的
struct B
{
	void Init()
	{

	}

private:
	int b1;
	int b2;
};

struct ListNode
{
	int val;
	//C语言中需要加上struct
	//struct ListNode* next;
	//C++中可以直接定义
	ListNode* next;

};

int main()
{
	struct A aa1;
	AA a2;

	B bb1;
	bb1.Init();

	Stack s1;///类的变量
	Stack s2;

	//公有的可以直接访问
	s1.Init();
	s1.Push(1);

	//私有的不可以直接访问
	//s1.top++

	return 0;
}

#include<iostream>
using namespace std;
class Stack
{
public:
	// 成员函数 
	void Init(int n = 4);
private:
	// 成员变量 
	int* array;
	size_t capacity;
	size_t top;
};
// 声明和定义分离，需要指定类域 
void Stack::Init(int n)
{
	array = (int*)malloc(sizeof(int) * n);
	if (nullptr == array)
	{
		perror("malloc申请空间失败");
		return;
	}
	capacity = n;
	top = 0;
}
int main()
{
	Stack st;
	st.Init();
	return 0;
}

#include<iostream>
using namespace std;
class Stack
{
public:
	//成员函数
	void Init(int n = 4)
	{

	}
private:
	//成员变量，声明
	//这里并没有开辟空间
	int* array;
	size_t capacity;
	size_t top;
};
int main()
{
	//定义，类实例化对象
	Stack s1;
	s1.Init();

	Stack s2;
	s2.Init(100);

	//sizeof是在编译时运算的可以传对象或者类型
	cout << sizeof(s1) << endl;
	cout << sizeof(Stack) << endl;


	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()
{

	cout << sizeof(A) << endl;
	//开1byte为了占位，不存储实际数据，表示对象存在过
	cout << sizeof(B) << endl;
	cout << sizeof(C) << endl;

	B b1;
	B b2;
	cout << &b1 << endl;
	cout << &b2 << endl;

	return 0;
}

#include<iostream>
using namespace std;
class Date
{
public:
	//编译器会将函数处理成如下:
	// void Init(Date* const this, int year, int month, int day)
	void Init(int year, int month, int day)
	{
		// 编译报错：error C2106: “=”: 左操作数必须为左值 
		// cout << this << endl
		// const保护this不能被修改
		// this = nullptr;
	
		// this->_year = year;
		///这里this可以写可以不写，例如第一个就没写，后俩个就写了
		_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	// 这⾥只是声明，没有开空间 
	int _year;
	int _month;
	int _day;
};
int main()
{
	// Date类实例化出对象d1和d2 
	Date d1;
	Date d2;
	// d1.Init(&d1, 2024, 3, 31);
	d1.Init(2024, 3, 31);
	d1.Print();
	d2.Init(2024, 7, 5);
	d2.Print();
	return 0;
}

#include<iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	//空指针、野指针是运行报错不会编译报错(最多给个警告)
	A* p = nullptr;
	p->Print();
	(*p).Print();
	//不要被语法表象迷惑
	return 0;
}

//成员函数的指针不存在对象 
//成员变量是存在对象里面的，所以就会有解引用
#include<iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "A::Print()" << endl;
		cout << _a << endl;
		//在成员的前面都会加this
		//运行时就要到this指向的对象里面去找_a
		//但是_a是空指针，所以就会报错
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

class A {
public:
    void Print1() { 
        cout << "A::Print1()" << endl; // 不访问成员变量，this没用上
    }
    void Print2() { 
        cout << _a << endl; // 访问成员变量，等价于 this->_a
    }
private:
    int _a;
};

int main() {
    A* p = nullptr;
    p->Print1(); // 正常运行！没有解引用，只是调用Print1()代码
    p->Print2(); // 崩溃！试图解引用nullptr访问 _a（this->_a）
    return 0;
}

#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>
#include<assert.h>
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;
}