【C++】类和对象的基本知识梳理

1.什么是面向过程和面向对象？

        举例说明：

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

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

2.类

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

2.1类的定义

        在C++中，有和struct相似的class，也就是类：

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

}; // 一定要注意后面的分号

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

2.2成员函数的定义方式：

        1.声明和定义不分离：

class stu
{
public:
        void Showinfo()
        {
            cout << _name << '-' << _number << '-' << _sex << endl;
        }
private:
    char _name[10];
    int _number[10];
    char _sex[5];
};

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

        2.声明和定义分离：

        类声明放在.h文件中，成员函数定义放在.cpp文件中：

// stu.h文件中
class stu
{
public:
        void Showinfo();//只有声明
private:
    char _name[10];
    int _number[10];
    char _sex[5];
};

// stu.cpp文件中

stu::void Showinfo()//此时要用域限定符前加类名指定
{
    cout << _name << '-' << _number << '-' << _sex << endl;
}

        当成员函数的声明和定义分离时，要定义函数时要前加 ‘ 类名:: ’ 。

2.3成员函数的特性

        比起C语言中在结构体外部定义函数，C++在类中定义函数有什么优势呢？

        2.3.1定义函数时比C语言更加便利直观

        举例说明：

class Date
{
public:                                    //如果是C语言
    void InitDate()                        //void InitDate(Date * d)//需要传指针
    {                                      //{
        _year = 1; //直接写成员变量就可以修改        d->_year = 1
                                           //    d->_month = 1
                                           //    d->_day = 1//需要用成员访问符
        _month = 1;                        //}
        _day = 1;
    }
    void Print()
    {
        cout << _year << '-' << _month << '-' << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};


int main()
{
    Date d1;
    d1.InitDate();
    d1.Print();
    return 0;
}

可以看到，类的成员函数的内部是可以直接写类的成员变量的，只要在调用时指定类（例如d1.InitDate()）编译器就能找到相应的类，而在C语言的结构体中，想要更改成员变量，往往我们都要传结构体的指针，就很麻烦。而且最大的优势在于成员函数定义时可以直接直观的写成员变量，而没有“->”, "." 之类的成员访问符号。

        由此也引出了一个成员变量和传入参数的名称产生歧义的问题

        2.3.2成员函数的便利对命名产生的影响

        注意：类的成员变量需要有特殊的取名，加以区分形参和成员变量，例如 _前缀，否则就会出现示例问题：

class Date
{
public:
    void InitDate(int year,int month,int day)
    {
        year = year;//这时究竟是谁在给谁赋值呢？
        month = month;
        day = day;
    }
private:
    int year;
    int month;
    int day;
};


int main()
{
    Date d1;
    d1.InitDate(1,1,1);
    return 0;
}

可以看到，如果成员变量不加特别的修饰，就会和函数的参数名产生歧义，发生错误，而给成员变量加上特殊的修饰后，就会变得更加直观和清晰。除此之外，成员函数的命名也可以更加简洁，因为成员函数在调用时要先指定类名（例如d1.InitDate(1,1,1)）,由此就区分了不同类型，初始化的命名就可以统一为Init，更加简短。

例如：

class Date
{
public:
    void Init(int year,int month,int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

class Num
{
public:
    void Init(int a, int b, int c)
    {
        _a = a;
        _b = b;
        _c = c;
    }
private:
    int _a;
    int _b;
    int _c;
};

int main()
{
    Date d1;
    Num  n1;
    d1.Init(1, 1, 1);
    n1.Init(1, 1, 1);
    return 0;
}

相当于类也起到了一个名字隔离的作用，同名不同类的成员函数名不会相互影响，使得整体的命名更加规整简洁。

2.4类的实例化

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

        1.类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出来未实例化的类并没有分配实际的内存空间来存储它（类比自定义类型变量的定义）。

        2.一个类可以实例化出多个对象实例化出的对象 占用实际的物理空间，存储类成员变量。（类比结构体变量的创建）。

        具体怎么实例化呢，其实和变量创建很类似，例如：

class stu
{
public:
        void Showinfo()
        {
            cout << _name << '-' << _number << '-' << _sex << endl;
        }
private:
    char _name[10];
    int _number[10];
    char _sex[5];
};

int main()
{
    stu st1;
    stu st2;//这就是类的实例化，用类stu实例化出了对象st1和st2
}

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

3.1封装

        首先，面向对象有三大特性：封装、继承、多态。

        其中之一，封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以
及键盘插孔等，让用户可以与计算机进行交互即可。

        在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

        接下来就具体说说访问限定符。

3.2类的访问限定符

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

        访问限定符有如下关键字组成：

        1.public(公有)

        

        2.protected(保护)

        3.private(私有)

        

        具体使用如下：

class cl
{
    public:


    private:


    protected://记得后加 :

}

访问限定符使用规则： 

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

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

4.如何计算类对象的大小

        类中同时可以存储成员变量和成员函数，那么类的大小如何计算呢？

        假若我定义了一个有成员函数的类，实例化出了三个不同的对象，那么是否我每次实例化都需要为成员函数开辟相应的空间呢？显然这很浪费空间资源，因为尽管他们是三个不同的对象，他们使用的都是统一的成员函数，不需要在每个对象中都开空间储存，咱举例说明：

class cl
{
public:
	void Print()
	{
		cout << _a << endl;
	}
	int _a;
};

int main()
{
	cl cl1;
	cl cl2;
	cl cl3;
	cl1._a = 1;
	cl2._a = 2;
	cl3._a = 3;
	cl1.Print();
	cl2.Print();
	cl3.Print();

	return 0;
}

        可以看到，三次函数调用都是调用的同一地址的函数，并没有在每个对象中开辟空间存储函数。 

        同样我们也可以通过sizeof（）计算类的大小。

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

4.1结构体内存对齐

        类的成员变量内存对齐方式和结构体一直，所以我又把结构体内存对齐规则搬来了（我在结构体的相关知识梳理一篇中详细讲过）：

1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
           VS中默认的对齐数为8
3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

5.this指针

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

        这个隐藏的指针参数就是this，其类型为： 类名 * const 

        举例说明：

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;
}

如果把成员函数中的this形参显式写出来就是这样：

 void Print(Data * const this)//注意const这样修饰的意义（不能修改this的指向）
{
    cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}

但是，这样写是不符合规定的，C++中成员函数的形参中不能显式地写出this。

在上面例子中的成员函数调用中，d1的对象地址传给形参this，实际在函数中是通过this指针来访问成员变量的，这一步由编译器自动实现，但是我们也可以显式写出来，例如：

 void Print()
{
    cout <<this->_year<< "-" <<this->_month << "-"<< this->_day <<endl;
}  // 这里是可以正常运行的，虽然我们不能在形参列表里写this，但是在函数内部是可以使用的

 编译器就是通过成员访问符前的对象名确定所传的是哪个对象的地址的，例如d1.Print()，我们写的‘d1’就相当于在写给this传的参数。