Cpp || 类与对象(上)

1.类的引入

1.1 c语言中对结构体的引用

struct ListNode
{

    int data;

    struct ListNode* next;

    struct ListNode* prev;

};

//类型：struct ListNode

//c++兼容c语言

int main(){

    struct ListNode node;

    return 0;

}

1.2 c++中也可以编过

#include<iostream>

#include<windows.h>

using namespace std;

struct ListNode

{

  int data;

   ListNode* next;

   ListNode* prev;

     //两个程序中的不同引用方式

};

//类型： ListNode

//c++兼容c语言

 

int main(){

  struct ListNode node;

  system("pause");

  return 0;

}

1.3 struct的双重身份

• 1.3.1 c语言中表示结构体。类型：struct ListNode

• 1.3.2 C++中升级成了类。类型：ListNode 而 struct 为关键字，Listnode为类名,就可以当作类型

• struct 类里面既可以定义变量，也可以定义函数.

• struct 与 class的区别是啥？

• struct 在c语言阶段就是一个结构体，而在c++中做为类存在。

• class在c++中就是一个类，

• 两者作为类在c++中的区别是什么？

• struct 默认是公有的，class 默认是私有的

2.类的定义

2.1 类的定义方式：

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

• class 为关键字
• classname 为类的名字
• {}中的为类主体，注意类定义结束时后面的分号。

• 类中的元素称为类的成员：
• 类的数据称为类的属性或者成员变量；
• 类中的函数称为类的方法或者成员函数

2.2 类的两种定义方式

2.2.1 : 声明和定义全都放到类体中

	class A{
	     //成员函数
	   void fun(){
	    }
	     //成员变量
	     int a;
	     int b;
	     int  c;
    };

• 需要注意的是：
  成员函数如果在类中定义，编译器可能会将其当成内联函数处理

2.2.2 :在类里面声明在外定义

   class B{
       void fun();
    };

     void B::fun(){
         //::作用域限定符
    }

2.2.2:声明在.h中，类的定义在.cpp中

//b.h
 class B{
     void fun() ;
 };
 //b.cpp  #include "p.h"
 void B::fun(){
 //::作用域解析符
 }

3.类的访问限定符及封装

3.1 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

• 访问限定符；
• 1.public(公有)
• 2.protected(保护)
• 3.private (私有)

 	class A{
      public:
         //公有成员函数
          void fun(){
      }
      private:
         //私有成员变量
        int a;
        int b;
        int  c;
       };


     int main(){
      A x;
      x.fun(); //可以访问到
      x.b;//访问不到b
      return 0;
      }

• 被访问限定符修饰的变量或函数在类里面是通用的，在类外面private 修饰的变量或者函数在类外面不可以访问。
• 私有限定内容是你不能在类外修改类的，而在类内部可修改

【访问限定符说明】

---

1.public 修饰的成员在类外可以直接被访问

​ 2.protected 和 private 修饰的成员在类外不能直接被访问(此处 protected 和 private 是类似的)

3.访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. ​ class的默认访问权限为 private ， struct 为 public(因为struct要兼容C)

---

注意:

• 访问限定符只在编译时有用，当数据映射到内存后,没有任何访问限定符上的区别
• 而 struct 定义的变量还是函数都是公有的，但 class 类中有公有的也有私有的
• 所有的访问限定符只对类外部有效,对类内部来说都是透明的,随便使用

class SeqList{
    void PopBack();//不标明作用域,class类中默认是私有的
 public:
    void PushBack(int x){
        ++size;   //操作可以正确运行，
        //原因是访问限定符限制的类的外面，不限制类的里面
    } //将x 插到SeqList这个类中去
 private:
    int *a;
    size_t size;
    szie_t capacity;
};

int main(){
    SeqList s; //s叫做对象
    s.PushBack(1);//把 1 插入到SeqList这个顺序表中
    //s.size++;//语句错误，size 为私有成员
   //s.PopBack() //私有成员不可以访问
    return 0;
}

【面试题】

• 问题：C++中struct和class的区别是什么？

解答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。
另外C++中struct还可以用来定义类。 struct和class是定义类是一样的，
区别是struct的成员默认访问方式是public，class是struct的成员默认访问方式是private。

3.2 封装

3.2.1 【面试题】 面向对象的三大特性：封装、继承、多态。

封装就是为了方便管理

• ​在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

//封装
//C语言的结构体
struct SeqList{
    int *a;
    size_t size;
    ....
}

void PushBack(struct SeqList *ptr,int x)//将插到struct SeqList中
//c++中
class SeqList{
    void PushBack(int x);   //将x 插到SeqList这个类中去
    
    int *a;
    size_t size;
    szie_t capacity;
};

你看到的芯片就是一个黑色的方块,很不起眼.但实际上其内部的构造十分的复杂.其中每个模块都有自己独特的功能.但是其中的零件确实缺一不可的.为了不让使用者被其复杂的内部结构所困扰我们可以将其封装起来,只给出让用户使用的窗口,来完成芯片和客户的交互.

4.类的作用域

4.1:类定义了一个新的作用域，类的所有成员都在类的作用域中。

• 在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。

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.类的实例化

• 用类类型创建对象的过程，称为类的实例化

1. 类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量
3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间类在计算机当中不占内存，只有来定义的对象才占内存

int a; int—>变量类型 a---->int 类型的变量

class A( 楼房的设计图纸 )

A ra A —>类型 ra—> A类型的变量 —>类的对象(按照图纸建造的房子)

class SeqList{
    public:
    void PushBack(int x){//类内部的申明
        
    }
    private:
    int *_a;        //声明
    size_t size;
    size_t capacity;
}
 void SeqList::PushBack(int x)//定义
     
  int main(){
     SeqList s;//现在才被定义出来
     cout<<sizeof(SeqList)<<endl;//结果为12
     return 0;
 }

//声明只是告诉说明它的类型与名称
//定义是将声明的东西创建出来

拿着Person这个类定义man 这个对象

6.类对象模型

• 结论：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

7.结构体内存对齐的规则

7.1如何计算类对象的大小

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

问题：类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？如何计算一个类的大小

7.2 类对象的存储方式猜测

7.2.1对象中包含类的各个成员

7.2.2:只保存成员变量，成员函数存放在公共的代码段

// 类中既有成员变量，又有成员函数
class A1 {
public:
 void f1(){}
private:
 int _a;
};
// 类中仅有成员函数
class A2 {
public:
 void f2() {}
};//大小为1，不存储数据，占位，表示对象存在过
// 类中什么都没有---空类
class A3
{};

sizeof(A1) : 4 sizeof(A2) : 1 sizeof(A3) : 1
结论：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

7.3 内存对齐

7.3.1. 第一个成员在与结构体偏移量为0的地址处。

7.3.2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

• 注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8，gcc没有默认对齐数

7.3.3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

7.3.4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，

• 结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

#include <iostream>
#include<windows.h>
using namespace std;
class A1{
	char _ch;
	double _d;
};
class A2{
	double _d;
	char _ch;
};
int main(){
	cout << "A1的大小="<<sizeof(A1) << endl;
	cout << "A2的大小=" << sizeof(A2) << endl;
	system("pause");
	return 0;
}

8.this指针

8.1 this指针的引出

#include<iostream>
#include<windows.h>
using namespace std;
class Date{
public:
  void Print(){
    cout << _year << "-" << _month << "-" << _day << endl;
  }

  void SetDate(int year, int month, int day){
    //构造的函数类似于买门票才能看到兵马用内部的东西
      //公有函数提供了访问内部成员的机会
    _year = year;   // 加上"_"可以避免冲突
    _month = month;
    _day = day;
  }

private:
//类似与兵马俑里面的展品。
  int _year;
  int _month;
  int _day;
};

int main(){
  Date d1;
  Date d2;
    
  d1.SetDate(2019, 3, 9); 
  d2.SetDate(2018,3,9);
    
  d1.Print();//如何识别打印那个对象对应的日期-->引出this指针
  d2.Print();//如何识别打印那个对象对应的日期
    //this指针隐含在形参的首位，把d2的地址传给对应函数Print
  system("pause");
  return 0;
}

8.2 解释

//经过改造编译器后
     d1.Print(); ===>d1.Print(&d1);
     d2.Print();====>d2.Print(&d2);
void Print(){  \\ 改造后() 中间加入了 Date* this
             cout << _year << "-" << _month << "-" << _day << endl;
//这一句中语句变成了  
                year ==>this->year 
                month ==>this->month
                day ===> this ->day        
  }
//此时d1.Print(&d1) 或者 d2.Print(&d2); 谁调用 Print 函数 this  指针就指向谁；

• this 指针类似于形参，谁调用就指向谁。
• 所以其存储在栈上,且其可以为空。

• 是否可以为空，面试题

#include<iostream>
#include<windows.h>
using namespace std;
 
class Date{
public:
  void Func(){//此处this传过来的地址为空时不影响该函数的输出
    cout << "Date::Func()" << endl;
  }
  void Print(){  //此处this传过来的地址为空时this->_year出错
    cout << _year << "-" << _month << "-" << _day << endl;
    // cout <<this-> _year << "-" << _month << "-" << _day << endl;
  }

private:
  //类似与兵马俑里面的展品。
  int _year;
  int _month;
  int _day;
};


int main(){
  Date* p1 = NULL;//此处为空，this解引用没有访问，可以运行
  p1->Func(); //this指针隐含在形参的首位，把p1的地址传给对应函数
  Date* p2 = NULL;//此处为空，解引用this 时，
    //this为空不能被访问，程序奔溃
  p2->Print();
  system("pause");
  return 0;
}
//内存访问是按最大对齐数整数倍访问的

即：C++编译器给每个“成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

8.3 this指针的特性

• 8.3.1. this指针的类型：类型* const
• 8.3.2. 只能在“成员函数”的内部使用
• 8.3.3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，
• 将对象地址作为实参传递给this形参。所以对象中不存储this指针。
• 8.3.4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递this 指针可以为空