【C++】类和对象（上篇）

文章目录

• 🛟一、面向过程和面向对象初步认识
• 🛟二、类的引入
• 🛟三、类的定义
• • 📝1、类的两种定义方式
  • 📝2、成员变量命名规则的建议
  • 🛟四、类的访问限定符及封装
  • • 🍩1、访问限定符
    • 🍩2、封装
    • 🛟五、类的作用域
    • 🛟六、类的实例化
    • 🛟七、类对象模型
    • • 🍟1、如何计算类对象的大小
      • 🍟2、结构体内存对齐规则
      • 🛟八、this指针
      • • 🍔1、this指针的引出
        • 🍔2、this指针的特性

          

          🛟一、面向过程和面向对象初步认识

          🚩C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题

          🚩C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成

          🌰比如：

          

          

          🛟二、类的引入

          C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

          🌰举个栗子看一下：👇

          typedef int DataType;
          struct Stack
          {
          	void Init(size_t capacity)
          	{
          		_array = (DataType*)malloc(sizeof(DataType) * capacity);
          		if (nullptr == _array)
          		{
          			perror("malloc申请空间失败");
          			return;
          		}
          		_capacity = capacity;
          		_size = 0;
          	}
          	void Push(const DataType& data)
          	{
          		// 扩容
          		_array[_size] = data;
          		++_size;
          	}
          	DataType Top()
          	{
          		return _array[_size - 1];
          	}
          	void Destroy()
          	{
          		if (_array)
          		{
          			free(_array);
          			_array = nullptr;
          			_capacity = 0;
          			_size = 0;
          		}
          	}
          	DataType* _array;
          	size_t _capacity;
          	size_t _size;
          };
          int main()
          {
          	Stack s;
          	s.Init(10);
          	s.Push(1);
          	s.Push(2);
          	s.Push(3);
          	cout 
          	// 类体：由成员函数和成员变量组成
          };  // 一定要注意后面的分号
          
          public:
          	//打印基本信息
          	void Print()
          	{
          		cout _name 
          public:
          	//打印基本信息
          	void Print();
          	
          private:
          	char* _name;
          	char* _sex;
          	int age;
          }
          
          	cout _name 
          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;
          };
          
          public:
          	void PrintPersonInfo();
          private:
          	char _name[20];
          	char _gender[3];
          	int  _age;
          };
          // 这里需要指定PrintPersonInfo是属于Person这个类域
          void Person::PrintPersonInfo()
          {
          	cout 
          public:
          	void f1() {}
          private:
          	int _a;
          };
          // 类中仅有成员函数
          class A2 {
          public:
          	void f2() {}
          };
          // 类中什么都没有---空类
          class A3
          {};
          int main()
          {
          	cout 
          public:
          	void Init(int year, int month, int day)
          	{
          		_year = year;
          		_month = month;
          		_day = day;
          	}
          	
          	void Print()
          	{
          		cout 
          	Date d1, d2;
          	d1.Init(2022, 1, 11);
          	d2.Init(2022, 1, 12);
          	d1.Print();
          	d2.Print();
          	return 0;
          }
          
          public:
          	void PrintA()
          	{
          		cout 
          	A* p = nullptr;
          	p-PrintA();
          	return 0;
          }
          
          public:
          	void Show()
          	{
          		cout 
          	A* p = nullptr;
          	p-Show();
           
          	return 0;
          }