hello朋友们，这里是勇子.虽说已经注册账号1年了，但真正踏上博客之路还是在这几天，我会把博客的内容做的尽可能的易懂，清晰。

OK，话不多说今天我来学习C++中的类与对象1。

文章目录

• 1.类的引入
• 2.类的定义
• 3.类的访问限定符
• 4.类访问限定符
• 5.类的实例化
• 6.类对象大小的计算
• 7.结构体内存对齐规则
• • 面试题：
  • 8.this指针
  • • this指针特性

      1.类的引入

      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 << s.Top() << endl;
      	s.Destroy();
      	return 0;
      }
      

      上面结构体的定义，在C++中更喜欢用class来代替。
      

      2.类的定义

      格式：

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

      class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
      类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
      

      类的两种定义方式：

      • 1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内

           联函数处理。

        //声明和定义全部放在类体里
        class Person
        {
        public:
        	void showInfo()
        	{
        		cout<<_name<<"-"<<_sex<<"-"<<_age< 
        2.类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::
        //声明放在person.h文件
        class Person
        {
        public:
        	void showInfo();
        public:
        		char* _name;
        		char* _sex;
        		int _age;
        };
        //定义放在类的视线文件person.cpp文件中
        #include<"person.h">
        void Person::showInfo()
        {
        	cout<<_name<<"-"<<_sex<<"-"<<_age< 
        一般情况下，更期望采用第二种方式。为了方便演示，笔者在此用方式一。
         
        成员变量命名规则的建议：
         
        class Date
        {
        public:
        	void Init(int year)
        	{
        		_year = year;
        	}
        private:
        	int _year;
        };
        // 或者这样
        class Date
        {
        public:
        	void Init(int year)
        	{
        		mYear = year;
        	}
        private:
        	int mYear;
        };
         
        一般C++成员前面加_都代表是内部的
        函数参数和成员变量尽量不要重命。以免弄混。
         
        3.类的访问限定符
         
         
        4.类访问限定符
         
        类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::作用域操作符指明成员属于哪个类域。
         
        class Person
        {
        public:
        	void PrintPersonInfo();
        private:
        	char _name[20];
        	char _gender[3];
        	int _age;
        };
        // 这里需要指定PrintPersonInfo是属于Person这个类域
        void Person::PrintPersonInfo()
        {
        	cout << _name << " " << _gender << " " << _age << endl;
        }
         
        5.类的实例化
         
        用类类型创建对象的过程，称为类的实例化
         
         
          
        类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。
        谜语：“年纪不大，胡子一把，主人来了，就喊妈妈” 谜底：山羊
         
         
          
        一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
         
        int main()
        {
        	Person._age = 100; // 编译失败：error C2059: 语法错误:“.”
        	return 0;
        }
         
        Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄。
         
         
          
        做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间.
         
        class Person
        {
        public:
        	void showInfo();
        public:
        		char* _name;
        		char* _sex;
        		int _age;
        };
        void Test()
        {
        	Person man;
        	man._name="jack";
        	man._age=10;
        //要先实例化出一个 man;然后这个实例化的对象才占空间，
        //才有name，age，sex；
        	......
        }
         
        6.类对象大小的计算
         
        类的大小通常由它的非静态成员变量决定。成员函数（包括静态和非静态成员函数）不占用类对象的大小，因为成员函数在内存中只有一份，它们不属于任何特定的对象实例，而是与类本身相关联。成员函数在编译时被转换为指向函数代码的指针，并存储在类的元信息中，而不是对象的内存布局中。
        要计算类对象的大小，可以使用sizeof运算符。sizeof运算符返回类型或对象在内存中的大小（以字节为单位）。
        分以下四种情况来介绍：
         
        空类
        结论：空类不含任何成员变量，大小通常为1字节，这1个字节的空间是系统为该类的对象创建的一个占位符，表示该对象仅仅是存在而已，而没有实际内容。在大多数编译器和平台上，即使类没有成员变量，也会为其分配至少1字节的空间。
         
        #include   
        using namespace std;  
        class EmptyClass {
        };  
        int main() {  
            cout << "Size of EmptyClass: " << sizeof(EmptyClass) << " bytes" << endl;  
            return 0;  
        }//打印结果为 1
         
        仅有常规函数、无成员变量类
        成员函数（包括静态和非静态成员函数）不会影响类对象的大小。成员函数只是类的接口，它们在类的元信息中存储为指向函数代码的指针，不占用对象内存。
         
        #include   
        using namespace std;  
          
        class FunctionOnlyClass {  
        public:  
        	 常规函数（非静态成员函数）  
            void printHello() {  
                cout << "Hello from FunctionOnlyClass!" << endl;  
            }  
        };  
          
        int main() {  
            cout << "Size of FunctionOnlyClass: " << sizeof(FunctionOnlyClass) << " bytes" << endl;  
            FunctionOnlyClass obj;  
            obj.printHello(); // 调用成员函数  
            return 0;  
        }
         
        含有一般成员变量类
        类的大小由其非静态成员变量的大小决定，并可能受到内存对齐的影响。内存对齐是编译器为了提高访问效率而进行的优化，它可能会在成员变量之间插入填充字节
         
        #include 
        using namespace std;
        class A {
        public:
        	A(int x=0) {
        		cout<<"A"<
        		cout<<"Hello A";
        	}
        private:
        	char Data1[3];
        	int Data2;
        };
        class B :public A{
        public:
        	B(int x=0) {
        		cout<<"B"<
        		cout<<"Hello B";
        	}
        private:
        	char Data1[3];
        	int Data2;
        };
         
        class C : public B{
        public:
        	C(int x=0) {
        		cout<<"C"<
        		cout<<"Hello C";
        	}
        private:
        	char Data1[3];
        	int Data2;
        };
         
        int main() {
        	A a;
        	B b;
        	C c;
        	cout<<"size of a:"< 
        含静态成员变量的类
        静态成员变量属于类本身，而非类的实例。因此，它们不占用类对象的大小，而是在类的外部静态存储区分配空间。
         
        #include   
        using namespace std;  
          
        class StaticMemberClass {  
        public:  
            static int staticVar; // 静态成员变量,加了static
        };  
          
        int StaticMemberClass::staticVar = 0; // 静态成员变量的定义  
          
        int main() {  
            cout << "Size of StaticMemberClass: " << sizeof(StaticMemberClass) << " bytes" << endl;  
            // 可以通过类名直接访问静态成员变量  
            cout << "StaticVar value: " << StaticMemberClass::staticVar << endl;  
            return 0;  
        }
         
        在这个例子中，即使StaticMemberClass有一个静态成员变量staticVar，类对象的大小仍然不受其影响。静态成员变量staticVar在程序的静态存储
        区分配空间，不属于任何对象实例。
         
        7.结构体内存对齐规则
         
        第一个成员在与结构体偏移量为0的地址处。
        其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
        注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
        VS中默认的对齐数为8
        结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
        如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
         
        另外这篇文章也写的非常详细——>内存对齐详解
         
        面试题：
         
        结构体怎么对齐？ 为什么要进行内存对齐？
        如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？
        什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景
         
        回答：
         
         
        问题1：
        结构体对齐是编译器在内存布局中自动处理的一个过程，确保结构体中的每个成员都按照特定的规则（通常是其类型大小的整数倍）进行对齐。这样做的主要原因有以下几点：
        硬件访问效率：大多数硬件平台在访问对齐的内存地址时效率更高。如果数据没有对齐，硬件可能需要进行额外的操作才能访问数据，这降低了性能。
        安全性：未对齐的内存访问可能导致硬件异常或未定义行为，尤其是在某些严格对齐要求的平台上。
        可移植性：不同的硬件平台或编译器可能有不同的对齐要求。确保结构体正确对齐有助于代码在不同平台上的可移植性。
         
         
        问题2：
        在C和C++中，可以使用编译器特定的属性或指令来控制结构体的对齐。例如，在GCC中，可以使用__attribute__((aligned(n)))来指定对齐参数。例如：
         
        struct MyStruct {  
            int a;  
            char b;  
        } __attribute__((aligned(4)));
         
        上述代码中的MyStruct结构体将按照4字节对齐。
        对于任意字节对齐，如3、4、5字节，这通常取决于编译器的支持。在某些编译器中，可以指定任意的对齐值。但是，需要注意的是，不是所有的对齐值都是有效的，特别是在某些硬件平台上，可能有一些限制。
        如果编译器不支持特定的对齐值，可能需要使用额外的填充字节或结构体成员来手动控制对齐。
         
        问题3：
        大小端（Endian）是描述计算机系统中字节序的一个术语。大端（Big-Endian）表示高位字节存储在内存的低地址处，而低位字节存储在内存的高地址处；小端（Little-Endian）则相反，低位字节存储在内存的低地址处，高位字节存储在内存的高地址处。
        //1.利用当前一个高类型的变量给其赋值，然后取到其低地址，查看其存储的数据。
        #include
        void CheckSystem1()
        {
        	int a = 1;
        	int num = (*(char*)&a);//&a 取出a的地址；  (char*)&a 代表a变量地址的第一个字节的地址
        	printf("%d\n", num);//(*(char*)&a) 解引用取出第一个字节保存的内容
        	if (num == 1)
        		printf("小端\n");
        	else
        		printf("大端\n");
        }
        int main()
        {
        	CheckSystem1();
        	getchar();
        	return 0;
        }
        //2.联合体特性
        int CheckSystem2()
        {
        	union check
        	{
        		int num;
        		char a;//2个变量公用一块内存空间，并且2个变量的首地址相等
        	}b;
        	b.num = 1;//1存放在变量num的低位
        	return (b.a == 1);//当变量a=1，相当于将数据的低位存到了内存的低地址处，即小端模式
        }
        int main()
        {
        	int c = CheckSystem2();
        	printf("c : %d\n", c);
        	getchar();
        	return 0;
        }
         
         
         
        解释： 这段代码首先定义了一个 int 类型的变量 a 并赋值为 1。在大多数现代系统上，int 类型通常至少为 4 字节（32> 位）。数字 1 在二进制表示中只有一个位是 1，其余位都是 0。 00000000 00000000 00000000 00000001 (32-bit int with value 1) 接着，代码将 a 的地址转换为一个 char 类型的指针，然后解引用这个指针来得到 a 的第一个字节。在 printf 语句中，这个字节的值被打印出来。 如果运行代码的机器是小端的，那么 int变量的最低有效字节将位于内存中的最低地址。对于数字 1，其最低有效字节是00000001，因此 num 的值将为 1。
        如果运行代码的机器是大端的，那么 int 变量的最高有效字节将位于内存中的最低地址。对于数字 1，其最高有效字节包含所有零，因此 num 的值将不是 1。 最后，根据num 的值判断并打印出是大端还是小端。
         
         
        第二段代码（CheckSystem2） 在这段代码中，定义了一个联合体（union）check，它包含一个 int 类型的成员 num 和一个 char 类型的成员 a。由于联合体的特性，num 和 a 共享同一块内存空间，并且它们的首地址是相同的。 当给 b.num 赋值为1 时，这个值在内存中的表示取决于机器的端序。如果机器是小端的，那么 int 变量的最低有效字节将位于内存的最低地址，并且这个字节的值将是 1。由于 b.a 与 b.num 的首地址相同，因此 b.a 的值也将是 1。 如果机器是大端的，那么 int
        变量的最高有效字节将位于内存的最低地址，并且这个字节的值不会是 1。因此，b.a 的值也不会是 1。 最后，通过比较 b.a 是否等于 1来返回一个布尔值，这个布尔值在 main 函数中被打印出来。如果返回 true（即 1），则表示机器是小端的；如果返回 false（即0），则表示机器是大端的。
         
         
        8.this指针
         
        C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。
         
        //所有的成员函数的参数 都比看到的多一个，  就是this指针
        #include
        using namespace std;
        class Date
        {
        public:
        	void Init(int year, int month, int day)
        	{
        		_year = year;//this->_year=year;
        		_month = month;
        		_day = day;
        	}
        	// 不能显示的写实参和形参
        	// void Print(Date* const this)
        	void Print()
        	{
        		//this = nullptr;
        		cout << this << endl;
        		// 但是可以在类里面显示的使用
        		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
        		cout << _year << "-" << _month << "-" << _day << endl;
        	}
        private:
        	int _year;     // 年
        	int _month;    // 月
        	int _day;      // 日
        };
        int main()
        {
        	Date d1;
        	d1.Init(2023, 10, 19);
        //编辑器视角下是 d1.Init(&d1,2023,10,19)
        //这里，&d1是d1对象的地址，它会被隐式地作为 this 指针传递给 Init 函数。然后，在 init 函数内部，编译器会像这样使用 this 指针:
        //       初始化函数里面     //this->_year=year;
        	Date d2;
        	d1.Print(); // d1.Print(&d1);
        	d2.Print();
        	return 0;
        }
         
        this指针特性
         
        1.this指针的类型:类类型* const，即成员函数中，不能给this指针赋值。
        2.只能在”成员函数”的内部使用
        3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
        4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递