类和对象（上）

类的引入 

在C语言中，有一个类似于“类”的概念——结构体，使用结构体定义一个结构体类型，如下：

以栈为例(C)：

struct Stack

{

        DataType*  array;
        size_t         capacity;
        size_t         size;

};

可以发现在C语言中，结构体中只能定义变量，而C++兼容了C中struct的用法，还将struct升级成了类，不仅可以定义变量（成员变量），也可以定义函数（成员函数），如下：

以栈为例(C++)：

struct Stack

{

        //成员函数

        void Init(int n = 4)
        {
                _array = (DataType*)malloc(sizeof(DataType) * n);
                if (nullptr == _array)
                {
                        perror("malloc申请空间失败");
                                return;
                }
                _capacity = n;
                _capacity = 0;
        }

        //成员函数可以直接使用同类的成员变量如_array，无需传参，减少代码量

        

        //成员变量

        DataType*  _array; //成员变量命名建议：名称前/后加 _ 或者使用 m_ 前缀
        size_t         _capacity;
        size_t         _size;
};

int main()

{

        //1个类    实例化    N个对象

        struct Stack s1;//C++兼容C语言关于struct的用法

        Stack s2;          //C++中结构体名称就可以代表类型

        //函数调用

        s1.Init();

        s2.Init(1);

        return 0;
}

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

类的访问限定符及封装

访问限定符：

访问限定符分类：

public        (公有)

protected（保护）

private    （私有）

访问限定符说明：

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到 } 即类结束。
5. class的默认访问权限为private，struct为public(因为struct要兼容C)

 访问限定符例子：

class Stack

{

public:

        //成员函数一般设置为公有

        void Init(int n = 4)
        {
               //...
        }

private:

        //成员变量一般设置为私有

        DataType*  _array;
        size_t         _capacity;
        size_t         _size;
};

int main()

{

        //可以使用class Stack 的形式创建对象

        //class Stack s1;

        Stack s2;

        //可以调用公有的成员函数

        s2.Init();

        //无法访问私有的成员变量

        //s2._array;

        return 0;
} 

 封装： 

面向对象的三大特性：封装、继承、多态

在C++中实现封装，可以通过类将变量和方法结合，通过访问权限（访问限定符）来控制哪些变量/方法可以在类外部使用
 

类的定义

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名 ::

 声明与定义分离的方法：

声明放在类的头文件test.h中                                                                                                      class Stack                                                               

{                                                                       
 public:                                                                         
     void Init();                                                                
 private:
      DataType*  _array;
      size_t         _capacity;
      size_t         _size;
};

定义放在类的实现文件test.cpp中 

#include "test.h"

void Stack::Init()

{

        _array = nullptr;

        _capacity = 0;

        _size  = 0;
}

分析1：如果Init()未使用Stack::，则Init()成为了未在头文件声明，只在实现文件中定义的全局函数

分析2：假设Init()是全局函数，无法使用_array等声明在类域的成员变量（Init()无法使用类声明的成员变量，只能使用实例化对象定义的成员变量）

类的实例化：

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没
有分配实际的内存空间来存储它。

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

实例化对象存储方式：

思考：同类的不同实例化对象，成员变量是否相同？成员函数是否相同？

答案：同类的不同实例化对象，成员变量不同，成员函数相同。

猜测实例化对象存储方式：

1.同时存储类成员变量和类成员函数

2.同时存储类成员变量和类成员函数地址

3.只存储类成员变量，类成员函数存储在公共代码区

通过简单的测试判断计算机存储对象的方案（注意内存对齐）：

// 类中既有成员变量，又有成员函数

class A1

{
public:
        void f1(){}
private:
        int _a;
};

// 类中仅有成员函数
class A2

{
public:
        void f2() {}
};

// 类中什么都没有---空类
class A3
{};

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

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

this指针

this指针的引出：

上文提到实例化对象不保存成员函数，那同类的不同对象是如何调用公共代码段的成员函数实现不同操作的？

//定义一个日期类 Date

class Date
{
public:
        void Init(int year, int month, int day)
        {
                _year = year;
                _month = month;
                _day = day;
        }
        void Print()
        {
                cout <<_year<< "-" <<_month << "-"<< _day <<endl;
        }

private:

        int _year;
        int _month;
        int _day;

};
int main()
{
        Date d1, d2;
        d1.Init(2022,1,11);
        d2.Init(2022,1,12);
        d1.Print();
        d2.Print();
        return 0;
}

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

this指针的特性：

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
2. 用户只可以让this指针在“成员函数”的内部出现和使用
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给
this形参。所以对象中不存储this指针。
4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器或压栈方式传递，不需要用户传递

 

this指针面试题： 

1.this指针存在哪里?

通过传参的方式传递对象地址给this指针，this指针是函数传参压栈产生的，一般存储在栈区，但是有的会将其放入ecx寄存器中，便于访问。

2.下面程序编译运行结果是？

class A
{
public:
        void Print()
        {
                cout << "Print()" << endl;
        }
private:
        int _a;
};
int main()
{
        A* p = nullptr;
        p->Print();//不需要到对象里去找函数，本质上不是解引用
        return 0;
}

正常运行 

3.下面程序编译运行结果是？

class A

{
public:
        void PrintA()
        {
                cout<<_a<<endl;
        }
private:
        int _a;
};
int main()
{
        A* p = nullptr;
        p->PrintA();
        return 0;
}

运行崩溃