c++类和对象入门

_the_sun

已于 2023-10-26 10:35:57 修改

阅读量407

点赞数 13

分类专栏： c++ 文章标签： c++ 开发语言

于 2023-10-23 13:30:29 首次发布

本文链接：https://blog.csdn.net/2303_79336820/article/details/133987146

版权

c++ 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

一、面向对象和面向过程的比较

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

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

二、类的引入

在c语言的结构体中，我们只能定义变量，但是在c++中，结构体被升级成为了类，类中不仅可以定义成员变量还可以定义成员函数，在本篇文章中，我们会以栈来举例。

三、类的定义

class 类名
{

//成员变量和成员函数

}； //注意这里有分号

class是c++中定义类的关键字，类体中的变量和函数我们称为成员变量和成员函数。

类的两种定义方式：

1.声明和定义全部都放在类体中，但是我们需要注意的是：如果在类体中定义了成员函数，则有可能会被编译器当做内联函数处理。

2.类的声明放在.h文件中，而成员函数的定义放在.cpp文件中，注意成员函数在类外边定义的时候是需要加上类名和作用域限定符号的，如void Person：：showinfo（）{ }

注意：对于这种成员函数的声明在类中，但是其定义不在类中的情况，我们在外面定义该成员函数的时候，

1.要有作用域限制符号和类名 Perosn：：

2.要把返回类型放在前面，而不能写成 Person ：：void showinfo（）{ }

3.一般情况下，我们推荐使用后者。

成员变量的命名建议：

// 我们看看这个函数，是不是很僵硬？
class Date
{
    public:
        void Init(int year)
        {
        // 这里的year到底是成员变量，还是函数形参？
        year = year;
        }
    private:
        int year;
};
// 所以一般都建议这样

class Date
{
    public:
        void Init(int year)
        {
            _year = year;
        }
    private:
        int _year;
};

因为我们如果不把形参和实参加以区分的话，由于作用域的原则，成员函数中的year默认就是他的形参中的year，那么这样的话year=year就没有了意义，并不会对成员变量造成任何影响了，所以我们一般都会把成员函数稍加修改，比如加上_或者m作为前缀，当然这个并不要求统一，具体还是看我们的使用习惯和工作单位的要求

四、类的访问限定符号和封装

4.1访问限定符

c++实现封装的方式是：用类将对象的属性和方法结合在一起，让对象更加完善，而访问限定符的存在则是让对象的访问更加安全简便。通过访问权限选择性的将其接口提供给外部用户使用。

访问限定符的说明：

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

2.protected和private在类的外部不能直接访问

3.访问限定符的作用范围是，直到下一个访问限定符出现或类的结束

4.class的默认访问权限是private，而struct的默认访问权限是public（因为struct需要兼容c语言）

【面试题】
问题：C++中struct和class的区别是什么？

解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别，后序给大家介绍。

4.2封装

    我们说，面向对象的三大特点：封装，继承和多态，在本节，我们主要关注封装，那么什么是封装呢？

        封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
        封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
        在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。这样就提高了类中对象的安全性，降低了用户的使用成本。

五、类的作用域

我们说，每一个{ }这样的括号都是一个作用域，类也不会例外，类所有的成员都存在于该作用域内，在类中可以直接访问任意一个成员，但是在类的外部，需要访问成员时，我们需要加上类名和作用域操作符：：来指明该成员属于哪一个类。

六、类的实例化

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

1.类是对对象的一个描述，而不是真是存在的对象，（在内存中不会占据空间），类就好比一个图纸，在没有实例化之前并没有具体的空间来存放该对象。

2.一个类可以实例化出多个对象，（这一点与我们之前的struct并无差异），一旦实例化出来后，该对象就会在内存中占据一定的空间。

就比方说，类实例化出的对象就好比拿着图纸造出来的房子，而类就是设计图，并没有具体的空间，但是实例化出来的对象（房子）的一些属性都是类（图纸）所决定好的，所以类也能反映对象的属性。

像这样才是通过类（图纸）实例化出来了一个对象（房子）

七、类对象模型

7.1如何计算类对象的大小

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

缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一
个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么
如何解决呢？
// 类中既有成员变量，又有成员函数
class A1 
{
    public:
      void f1(){}
    private:
      int _a;
};
// 类中仅有成员函数
class A2 
{
    public:
    void f2() {}
};
// 类中什么都没有---空类
class A3
{

};
那么对于这三种猜测，计算机中真正采用的是哪一种方式呢？

我们不妨分别用sizeof来求出各自的大小，结果告诉我们，

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

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

那么我们就可以知道了，计算机其实采用的是第三种方式，因为如果是第二种方式计算出的大小会包含指针，但是结果并没有。

7.2回顾结构体内存对齐规则

规则如下：

1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的对齐数为8
3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
【面试题】
1. 结构体怎么对齐？为什么要进行内存对齐？
2. 如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？
3. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景

八、this指针

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

8.1this指针的引出

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

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

data中的有成员函数init，函数体中并没有关于不同对象的区分，那么当d1调用init的时候，他是如何知道该设置的是d1的成员变量而不是d2的成员变量呢？

c++中通过引入了this指针来解决这一问题，即：c++编译器会给每一个成员函数增加了一个隐藏的指针，让该指针去指向调用函数的对象，从而明确是对哪一个实例化对象做出动作，只不过该指针是编译器完成的，不需要我们用户去显示的写出来

8.2this指针的特性

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

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
        public:
                void Print()
                {
                        cout << "Print()" << endl;
                }
        private:
                int _a;
};
int main()
{
        A* p = nullptr;
        p->Print();
        return 0;
}

在这里，有人会认为答案是运行崩溃，但其实并不是的，我们在前面说到了，类的成员函数并没有存在于对象中，而是独立于对象，另外存储在公共代码区的，所以这里即使对象是一个空指针nullptr，也不会对成员函数的调用起到任何影响。

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
    public:
        void PrintA()
         {
            cout<<_a<<endl;
         }
    private:
        int _a;
};

int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

而这里的情况就和上面一种不同了，因为这里的成员函数用到了对象的变量_a,而该对象又是一个空指针nullptr不存在，所以会发生运行崩溃。

8.3c++通过类实现栈

在用C语言实现时，Stack相关操作函数有以下共性：
1.每个函数的第一个参数都是Stack*
2.函数中必须要对第一个参数检测，因为该参数可能会为NULL
3.函数中都是通过Stack*参数操作栈的
4.调用时必须传递Stack结构体变量的地址
5.结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack *参数是编译器维护的，C语言中需用用户自己维护。

由此我们可以看出c++有了封装后，对于函数的书写是变得极为简单的，而且从某些角度来说封装不仅降低了程序员书写的错误概率，而且提高了数据的安全性（因为只能通过提供的接口来操作）