C++-类与对象

类与对象(第一部分)

类与对象的初步认识

很多语言都有这方面的区分，比如C语言是面向过程的语言，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。但是C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

类的引入

在C语言中，结构体的使用只能定义变量，但是在C++中不一样，不仅可以定义变量还可以定义函数

但在C++结构体的定义中,更喜欢用classl来代替。

类的定义

class classname{
    
    //类体：由成员函数和变量组成

};//非常重要的分号

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

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

类的两种定义方法

1、声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会当成内联函数处理。

class skrskr
{
public:
    void showinfo(){
        cout<<"I like"<<_sing<<"-"<<_dance<<"-"<<_rap<<endl;
    }
public:
    char* _rap;
    char* _sing;
    char* _dance;
};

2、声明放在.h文件中，类的定义放在.cpp文件中

//skrskr.h
class skrskr
{
public:
    void showinfo();
public：
    char* _rap;
    char* _sing;
    char* _dance;
}

//skrskr.cpp
#include "skrskr.h"

void skrskr::showinfo()
{
    cout<<"I like"<<_sing<<"-"<<_dance<<"-"<<_rap<<endl;
}

一般情况下，更期望第二种，这种分离的方式，保护性更强

类的访问限定符及封装

类的访问限定符

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

访问限定符有三种类型，分别为公有，保护，私有

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

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

3、访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

4、class的默认访问权限为private，struct为public(因为public要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

【面试题~~~】C++中struct和class有什么区别？

C++需要兼容C语言，所以struct等多当结构体去使用，但是在C++中struct内可以定义函数和class定义类是一样的，区别是struct的成员默认访问方式是public，class的成员默认访问方式是private

封装

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

在类和对象阶段，我们更多只了解封装

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

类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外的定义成员，需要使用::作用域限制符指明成员属于哪个类域。

class skr
{
public:
    void skrinfo();
private:
    char _cxk[20];
    char _wyf[3];
    int _age;
};
//这里需要指明是属于哪个类中
void skr::skrinfo(){
    cout<<_cxk<<"+"<<_wyf<<"is"<<_age<<endl;
}

类的实例化

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

1、类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它

2、一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类的成员变量

3、类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图

类对象模型

平时所声明的类只是一种类型定义，它本身是没有大小可言的。 我们这里指的类的大小，其实指的是类的对象所占的大小。因此，如果用sizeof运算符对一个类型名操作，得到的是具有该类型实体的大小。

#include <iostream>    
    
class A1    
{    
public:    
  void f1(){    
    
  }    
private:    
  int _a;    
};    
    
class A2    
{    
  public:    
    void f2(){}    
};    
    
class A3    
{};    
    
    
int main(){    
  std::cout<<sizeof(A1)<<sizeof(A2)<<sizeof(A3)<<std::endl;    
  return 0;                                                                                                             
}

sizeof(A1)=4；sizeof(A2)=1；sizeof(A3)=1

结构体内存对齐规则

该规则在之前结构体写到过

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

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

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

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

4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是 所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

this指针

this指针的引出

我们先来定义一个日期类Date

class Date
{
public:
    void Display(){
        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, d2;
    d1.SetDate(2018,5,14);
    d2.SetDate(2019,5,14);
    d1.Display();
    d2.Display();
    return 0;
}

对于上述类，有这样的一个问题：

Date类中有SetDate与Display这样两个成员函数，函数体中没有关于不同对象的区分，那当d1调用SetDate函数时，该函数是如何知道设置d1对象，而不是设置d2对象呢？

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

this指针的特性

this指针的类型：类类型 const*

this指针只能在“成员函数”中使用

this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。

this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过exc寄存器自动传递，不需要用户传递

void Display(){
    cout<<_year<<endl;
}

//内置的this指针
void Display(Date* this){
    cout<<this->_year<<endl;
}

我们还要知道this指针参数则是存放在寄存器中。类的静态成员函数因为没有this指针这个参数，所以类的静态成员函数也就无法调用类的非静态成员变量。

那么还有最后一个问题，this指针能否为空指针呢？

//这是在某个类中的成员函数
void test(){
    cout << "test" <<endl;
}

void change(){
    cout<<"change"<<endl;
    cout<<_name<<endl;
}

当我们调用change()函数时就会出错

在第一个函数中，没有调用任何函数，可以执行。

但是在第二个函数中，此时为this（NULL)->_name，this指针此时为空，那么不能进行空指针的引用。

根据this的约定中：

如果参数个数确定，this指针通过ecx传递给被调函数，如果不参数确定，this指针所在的参数被压栈后压入堆栈。

所以总结一下，this指针可以为空，当函数内部不需要使用到this指针时，就是说此时不需要通过this指向当前对象并对其进行操作时才可以为空。但是调用的函数需要指向当前对象，并进行操作，则会发生错误，这跟C中调用空指针的引用错误性质一样。