AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C++之类和对象的初步认识

2023-05-23 56
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本文将讲述c++类和对象的初步认识，包括“类的访问限定符及封装”“类的作用域""类的实例化”“类的对象大小的计算”“类成员函数的this指针”等等。

前言

本文将讲述c++类和对象的初步认识，包括“类的访问限定符及封装”“类的作用域""类的实例化”“类的对象大小的计算”“类成员函数的this指针”等等。


🕺作者： 迷茫的启明星


😘欢迎关注：👍点赞🙌收藏✍️留言


🏇家人们，码字不易，你的👍点赞🙌收藏❤️关注对我真的很重要，有问题可在评论区提出，感谢阅读！！！


持续更新中~


1.面向过程和面向对象初步认识

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


比如说：洗衣服，使用面向过程的思想来分析就是，拿个盆子—>放水—>放衣服—>放洗衣服—>手搓—>换水—>放洗衣粉—>手搓—>拧干—>晾衣服


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


成。


使用面向对象的思想来分析就是：


总共有三个对象：人、衣服、洗衣粉、洗衣机


整个洗衣服的过程：人将衣服放进洗衣粉，倒入洗衣粉，启动洗衣机，洗衣机就会完成洗衣过程并且甩干


整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的，人不需要关心洗衣机具体是如何洗衣服的，是如何甩干的。


2.类的引入

C语言结构体中只能定义变量，而在C语言的升级版，C++中，结构体内不仅可以定义变量，也可以定义函数。


比如说：


在使用C语言实现的顺序表，结构体中只能定义变量；


现在以C++的方式实现，会发现struct中也可以定义函数。

#include <iostream>
using namespace std;
typedef int SLDateType;
struct SeqLList
{
    void SeqListInit()
    {
        _a=nullptr;
        _size=0;
        _capacity=0;
    }
    void SeqListPushBack(const SLDateType& x)
    {
        if (_size ==_capacity)
        {
            int newCapacity =_capacity == 0 ? 4 : _capacity * 2;
            auto* tmp=(SLDateType*)realloc(_a,newCapacity*sizeof(SLDateType));
            if (tmp == nullptr)
            {
                printf("realloc fail\n");
                return;
            }
            _a = tmp;
            _capacity = newCapacity;
        }
        _a[_size]=x;
        (_size)++;
    }
    void SeqListPrint()
    {
        for (int i = 0; i < _size; ++i) {
            printf("%d",_a[i]);
        }
    }
    void SeqListDestroy()
    {
        _capacity=0;
        _size=0;
        free(_a);
    }
    SLDateType* _a;
    int _size;
    int _capacity;
};
int main()
{
    SeqLList s{};
    s.SeqListInit();
    s.SeqListPushBack(1);
    s.SeqListPushBack(2);
    s.SeqListPushBack(3);
    s.SeqListPrint();
    s.SeqListDestroy();
    return 0;
}



在C++中，更喜欢用class来代替struct，毕竟C++已经是一门新的语言，但是也能使用struct定义类，这是因为C++兼容C。

3.类的定义

那么类是怎么定义的呢？


和C语言的结构体非常相似，是这样的


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

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

号不能省略。

类体中内容称为类的成员；


类中的变量称为类的属性或成员变量;


类中的函数称为类的方法或者成员函数。

类的两种定义方式：


声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理，也就是说给编译器一个建议。

class Person
{
  public:
  void showinfo()
  {
    cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;
  }
  public:
  char*_name;
  char*_sex;
  int _age;
};


类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

//声明放在类的头文件person.h中
class Person
{
  public:
  void showinfo();
  public:
  char*_name;
  char*_sex;
  int _age;
//定义放在类的实现文件person.cpp中
#include"person.h"
void Person::showinfo()
{
  cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;
}


一般情况下，更期望采用第二种方式。


成员变量命名规则的建议：


// 我们看看这个函数，是不是很僵硬？
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;
};


或者这样


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

一般都是加个前缀或者后缀标识区分就行了


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

4.1 访问限定符

C++实现封装的方式：


用类将对象的属性与方法结合在一块，让对象更加完善，

通过访问权限选择性的将其接口提供给外部的用户使用

image.png

【访问限定符说明】


public,很好理解对吧，中文意思“公共的”，见词知意，public修饰的成员在类外可以直接被访问。

protected和private，中文意思分别是“受保护的”“私有的”，它们修饰的成员在类外不能直接被访问，这里的protected和private是类似的。

访问权限的作用符的作用域是哪到哪呢？

显而易见，从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。

如果后面没有访问限定符，作用域就到 } 即类结束。

既然C++兼容C语言的话，那么我们使用struct既可以定义结构体，也能定义类，同时也能使用C++特有的class来定义类，它们分别定义的类的区别是什么呢？

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


这是什么意思呢？举个例子


image.png


使用class默认的访问权限是private，不支持外部访问，如果使用struct呢？


image.png


完全正常，这就是struct和class在访问权限上的区别，也让我们看到public和private的区别


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


4.2 封装

我们知道面向对象有三大特性：封装、继承、多态。


但是在类和对象阶段，主要是研究类的封装特性，


那什么是封装呢？


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


举个例子：


对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、


通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，


完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。



image.png

但对于计算机使用者而言，不用关心内部核心部件，


比如主板上线路是如何布局的，CPU内部是如何设计的等，


用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。


因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，


仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

image.png



所以封装本质上是一种管理，让用户更方便使用类。


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


5.类的作用域

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


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


就像这样


class Person
{
    public:
      void PrintPersonInfo();
    private:
        char _name[20];
        char _gender[3];
        int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
  cout << _name << " "<< _gender << " " << _age << endl;
}



6.类的实例化

什么是类的实例化？


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


这是什么意思？


类是对对象进行描述的，是一个模型一样的东西，


限定了类有哪些成员，定义出一个类并没有分配实际


的内存空间来存储它；


比如：入学时填写的学生信息表，


表格就可以看成是一个类，来描述具体学生信息。


也可以这样理解


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


类就像是设计图，只设计出需要什么东西，


但是并没有实体的建筑存在，同样类也只是一个设计，


实例化出的对象就是建出来的房子，所以对象才能实际存储数据，占用物理空间


所以这样理解的话，一个类可以实例化出多个对象，


实例化出的对象占用实际的物理空间，存储类成员变量

image.png


image.png



7.类的对象大小的计算

前面说实例化出的对象占用实际的物理空间，存储类成员变量，


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


那么它是怎么存储的？我们应该怎么计算呢？


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


试着推导一下

假设一

假设对象中包含类的各个成员


image.png


我们会发现，如果对象包含了类所有的成员变量和函数，会造成空间的浪费，因为每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。那么如何解决呢？这就引出假设二。


假设二

假设代码只保存一份，在对象中保存存放代码的地址

image.png



诶，好像有点意思，等会儿测试一下，这里还有一种可能


假设三

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

image.png





假设有了，现在我们来验证一下

// 类中既有成员变量，又有成员函数
class A1 {
    public:
      void f1(){}
    private:
      int _a;
};
// 类中仅有成员函数
class A2 {
    public:
     void f2() {}
};

对上面代码，我们分别使用sizeof计算一下它的大小，


但是在此之前，我们先试着推导一下，类之前就是结构体的升级版嘛


所以按照结构体内存对齐规则计算一下，


这里我们简单复习一下它是什么


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

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

注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

VS中默认的对齐数为8

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

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

按照这样说的话，函数一般是以地址的形式存储的，也就是4字节，我们先猜它是这样。


那么A1就是8，A2就是4，A3就是0


验证一下

image.png



哦豁，怎么和我们猜的不一样？我们把A1、A2的函数去掉看一下


image.png


不变


现在就可以总结一下了，


类中既有成员变量，又有成员函数，它的实际大小就是成员变量之和，当然也要注意内存对齐

类中仅有成员函数或者类中什么都没有（空类），会比较特殊，编译器给了空类一个字节来唯一标识这个类的对象

懂了吧


8.类成员函数的this指针

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



class Date
{
public:
  void Init(int year, int month, int day)
  {
  Date::year = year;//和上面代码效果一样，也可以这样理解
  _month = month;
  _day = day;
  }
private:
  int year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  d1.Init(2022, 1, 15);
  return 0;
}


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

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


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


8.2 this指针的特性

this指针的类型：类类型 const*，即成员函数中，不能给this指针赋值。


image.png


只能在“成员函数”的内部使用


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


真实情况就像这样


image.png


this指针是“成员函数”第一个隐含的指针形参，一般情况是在栈中（形参），有些编译器会通过ecx寄存器自动传递，不需要用户传递

image.png


根据上述结论，我们看看下面两段代码


// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行

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



// 2.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行

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


是不是感觉两段代码差不多？哈哈这就是陷阱！


它们的运行结果是什么呢？


结果是，1正常运行，2运行崩溃


为什么呢？


这与this->a 对空指针的解引用有关


第一段代码中的p虽然是空指针，但是p调用成员函数不会编译报错，


因为空指针不是语法错误，编译器检查不出来，


而且也不会出现空指针访问，因为成员函数里面没有调用对象，


所以它不会报错，而第二段代码却报错了，


对了这里p会作为实参传递给隐藏的this指针哦


8.3. C语言和C++实现Stack的对比

1. C语言实现

typedef int DataType;
typedef struct Stack
{
    DataType* array;
    int capacity;
    int size;
}Stack;
void StackInit(Stack* ps)
{
    assert(ps);
    ps->array = (DataType*)malloc(sizeof(DataType) * 3);
    if (NULL == ps->array)
    {
        assert(0);
        return;
    }
    ps->capacity = 3;
    ps->size = 0;
}
void StackDestroy(Stack* ps)
{
    assert(ps);
    if (ps->array)
    {
        free(ps->array);
        ps->array = NULL;
        ps->capacity = 0;
        ps->size = 0;
    }
}
void CheckCapacity(Stack* ps)
{
    if (ps->size == ps->capacity)
    {
        int newcapacity = ps->capacity * 2;
        DataType* temp = (DataType*)realloc(ps->array,
        newcapacity*sizeof(DataType));
        if (temp == NULL)
        {
            perror("realloc申请空间失败!!!");
            return;
        }
        ps->array = temp;
        ps->capacity = newcapacity;
     }
}
void StackPush(Stack* ps, DataType data)
{
    assert(ps);
    CheckCapacity(ps);
    ps->array[ps->size] = data;
    ps->size++;
}
int StackEmpty(Stack* ps)
{
    assert(ps);
    return 0 == ps->size;
}
void StackPop(Stack* ps)
{
    if (StackEmpty(ps))
      return;
    ps->size--;
}
DataType StackTop(Stack* ps)
{
    assert(!StackEmpty(ps));
    return ps->array[ps->size - 1];
}
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->size;
}
int main()
{
    Stack s;
    StackInit(&s);
    StackPush(&s, 1);
    StackPush(&s, 2);
    StackPush(&s, 3);
    StackPush(&s, 4);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackPop(&s);
    StackPop(&s);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackDestroy(&s);
    return 0;
}



总结：


可以看到，在用C语言实现时，Stack相关操作函数有以下共性：


每个函数的第一个参数都是Stack*

函数中必须要对第一个参数检测，因为该参数可能会为NULL

函数中都是通过Stack*参数操作栈的

调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据

的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出

错。


2. C++实现

typedef int DataType;
class Stack
{
public:
    void Init()
    {
        _array = (DataType*)malloc(sizeof(DataType) * 3);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
      }
        _capacity = 3;
        _size = 0;
    }
    void Push(DataType data)
    {
        CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    void Pop()
    {
        if (Empty())
          return;
        _size--;
    }
    DataType Top(){ return _array[_size - 1];}
    int Empty() { return 0 == _size;}
    int Size(){ return _size;}
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
    private:
    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            int newcapacity = _capacity * 2;
            DataType* temp = (DataType*)realloc(_array, newcapacity *
            sizeof(DataType));
            if (temp == NULL)
            {
                perror("realloc申请空间失败!!!");
                return;
            }
            _array = temp;
            _capacity = newcapacity;
      }
  }
private:
    DataType* _array;
    int _capacity;
    int _size;
};
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Pop();
    s.Pop();
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Destroy();
    return 0;
}



总结：


C++中通过类可以将数据 以及 操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。

而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack *参数是编译器维护的，C语言中需用用户自己维护。


respect !


下篇见！

文章标签：
C++
C语言
存储
编译器
关键词：
C++对象
C++类和对象
幼稚十一
目录
相关文章
禁默
|
1月前
|
编译器 C++
C++之类与对象（完结撒花篇）（上）
C++之类与对象（完结撒花篇）（上）
禁默
35 0
ephemerals__
|
11天前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
40 4
ephemerals__
|
12天前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
35 4
白子寰
|
1月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
27 4
白子寰
|
1月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
24 4
努力学习的小廉
|
1月前
|
存储 编译器 C++
【C++类和对象（下）】——我与C++的不解之缘（五）
【C++类和对象（下）】——我与C++的不解之缘（五）
努力学习的小廉
20 1
努力学习的小廉
|
1月前
|
编译器 C++
【C++类和对象（中）】—— 我与C++的不解之缘（四）
【C++类和对象（中）】—— 我与C++的不解之缘（四）
努力学习的小廉
20 1
徐霞客320
|
1月前
|
C++
C++番外篇——对于继承中子类与父类对象同时定义其析构顺序的探究
C++番外篇——对于继承中子类与父类对象同时定义其析构顺序的探究
徐霞客320
53 1
徐霞客320
|
1月前
|
编译器 C语言 C++
C++入门4——类与对象3-1（构造函数的类型转换和友元详解）
C++入门4——类与对象3-1（构造函数的类型转换和友元详解）
徐霞客320
20 1
白子寰
|
1月前
|
存储 编译器 C语言
【C++打怪之路Lv3】-- 类和对象（上）
【C++打怪之路Lv3】-- 类和对象（上）
白子寰
17 0