C++语法基础（C）- 类封装和函数重载

最新推荐文章于 2024-11-04 23:11:51 发布
最新推荐文章于 2024-11-04 23:11:51 发布
阅读量404 收藏 10
点赞数 9
分类专栏： C/C++开发 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42077965/article/details/136019981
版权
本文详细讲解了C++中的类封装，特别是如何重载数组的[]运算符以及自定义类型的运算符如加法、左移、赋值等。同时涉及智能指针的指针运算符重载，以及如何处理浅拷贝和深拷贝的问题，以及字符串类的封装和相关运算符重载。
摘要由CSDN通过智能技术生成

类封装和运算符重载

（一）数组类封装及重载[]运算符

重载[]运算符：可以通过[]设置和获取数据

//MyArray.h
class MyArray//指处理int类型
{
public:
    //默认构造
    MyArray();
    //有参构造
    MyArray(int capacity);
    //拷贝构造
    MyArray(const MyArray &arr);
    //尾插
    void pushBack(int val);
    //根据位置设置数据
    void setData(int index, int val);
    //根据位置获取数据
    int getData(int index);
    //获取数组大小
    int getSize();
    //获取数组容量
    int getCapacity();
    // 重载[]运算符，这里需要返回引用，因为函数调用不能作为左值（arr[] = 1000;不能使用）
    int& operator[] (int index);
    //析构函数
    ~MyArray();
private:
    //指向堆区的数据指针
    int* pAddress;
    //数组容量
    int m_Capacity;
    //数组大小
    int m_Size;
};

//MyArray.cpp
#include "MyArray.h"
MyArray::MyArray()
{
    cout << "默认构造函数调用" << endl;
    this->m_Capacity = 100;
    this->m_Size = 0;
    this->pAddress = new int[this->m_Capacity];
}
MyArray::MyArray(int capacity)
{
    cout << "有参构造函数调用" << endl;
    this->m_Capacity = capacity;
    this->m_Size = 0;
    this->pAddress = new int[this->m_Capacity];
}
MyArray::MyArray(const MyArray& arr)
{
    cout << "拷贝构造函数调用" << endl;
    this->m_Size = arr.m_Size;//注：这里可以访问arr.m_Size(private)，同类可以访问私有内容
    this->m_Capacity = arr.m_Capacity;

    //深拷贝
    this->pAddress = new int[arr.m_Capacity];
    for (int i = 0; i < arr.m_Size; i++)
    {
        this->pAddress[i] = arr.pAddress[i]; 
    }
}
void MyArray::pushBack(int val)
{
    this->pAddress[this->m_Size] = val;
    this->m_Size++; 
}
void MyArray::setData(int index, int val)
{
    this->pAddress[index] = val;
}
int MyArray::getData(int index)
{
    return this->pAddress[index];
}
int MyArray::getSize()
{
    return this->m_Size;
}
int MyArray::getCapacity()
{
    return this->m_Capacity;
}
int& MyArray::operator[] (int index)
{
    return this->pAddress[index];
}
MyArray::~MyArray()
{
    cout << "析构函数调用" << endl;
    if (this->pAddress != NULL)
    {
        delete[] this->pAddress;
        this->pAddress = NULL;
    }
}

（二）运算符重载

问题：
对于内置类型，编译器知道运算符应该如何计算（不可能改变），但对于自定义数据类型，编译器并不知道；

说明：
运算符重载（operator overloading）只是一种语法上的方便，也就是它只是另一种函数调用的方式。

  • 利用成员函数进行加号运算符重载
  • 利用全局函数进行加号运算符重载
  • 运算符重载可以进行函数重载

语法：

  • 重载运算符被定义为全局函数：对于一元是一个参数，对于二元是两个参数
  • 重载运算符被定义为成员函数：对于一元没有参数，对于二元是一个参数

1.加号运算符重载

目的： 可以用+进行对象间相加

class Person
{
public:
    Person() {}
    Person(int a, int b):m_A(a),m_B(b) {}
    //利用成员函数进行 加号运算符重载
    Person operator+(Person &p)
    {
        Person temp;
        temp.m_A = this->m_A + p.m_A;
        temp.m_B = this->m_B + p.m_B;
        return temp;
    }
    int m_A;
    int m_B;
};

//利用全局函数进行 加号运算符重载
Person operator+(Person& p1, Person& p2)
{
    Person temp;
    temp.m_A = p1.m_A + p2.m_A;
    temp.m_B = p1.m_B + p2.m_B;
    return temp;
}

//加号运算符重载 进行函数重载
Person operator+(Person& p, int a)
{
    Person temp;
    temp.m_A = p.m_A + a;
    temp.m_B = p.m_B + a;
    return temp;
}

2.左移运算符重载

目的： 可以使用cout <<和<< endl输出对象

class Person
{
    //将全局函数-左移运算符重载变为Person的友元函数，可以使成员变量私有化
    friend ostream& operator<< (ostream& cout, Person& p);
public:
    Person() {};
    Person(int a, int b)
    {
        this->m_A = a;
        this->m_B = b;
    }
    //void operator<<(ostream &cout){}左移运算符重载只能使用全局函数才能出现cout<<
private:
    int m_A;
    int m_B;
};
//返回值需要是ostream，才能使用endl
ostream& operator<< (ostream& cout, Person& p)
{
    cout << "p.m_A:" <<p.m_A << "p.m_B:" << p.m_B;
    return cout;
}

3.前置++和后置++运算符重载

目的： 自己写的MyInteger对象可以使用前置++和后置++

前置++和后置++优先使用前置++

class MyInteger
{
friend ostream& operator<<(ostream& cout, const MyInteger& myInteger);
public:
    //默认构造函数
    MyInteger() { m_Int = 0; }
    //前置++：这里只能返回引用，返回值多次使用++导致只使用了一次++
    MyInteger& operator++()
    {
        //先 + 1
        m_Int = m_Int + 1;
        //后返回
        return *this;
    }
    //后置++：这里只能返回值，因为返回的是临时变量，属于局部变量
    MyInteger operator++(int)
    {
        //先 保留当前状态
        MyInteger temp = *this;
        //后 +1 
        m_Int = m_Int + 1;
        //再返回
        return temp;
    }
private:
    int m_Int;
};

//这里的const：（E0349没有与这些操作数匹配的"<<"运算符）
//如果返回的是一个临时变量，临时变量属于纯右值，它不能绑定到左值引用，你需要使用常量左值引用或右值引用来绑定
ostream& operator<<(ostream& cout,const MyInteger& myInteger) 
{
    cout << "m_Int:" <<myInteger.m_Int;
    return cout;
}
void test01()
{
    MyInteger myinteger;
    cout << ++(++myinteger) << endl;
    cout << myinteger << endl;
}
void test02()
{
    MyInteger myinteger;
    cout << myinteger++ << endl;
    cout << myinteger << endl;
}

4.指针运算符重载-智能指针

目的： 用来托管new出来的对象的释放
如果想智能指针对象像指针一样调用变量和函数，需要重载->和*

class Person
{
public:
    Person()
    {
        m_Age = 0;
    }
    Person(int age)
    {
        this->m_Age = age;
    }
    ~Person(){}
    void showAge()
    {
        cout << "m_Age: " << this->m_Age << endl;
    }
private:
    int m_Age;
};
class SmartPointer//智能指针
{
public:
    SmartPointer(Person* person)
    {
        this->person = person;
    }
    ~SmartPointer()
    {
        if (this->person != NULL)
        {
            delete this->person;
            this->person = NULL;
        }
    }
    //重载->运算符，返回指针
    Person* operator->()
    {
        return this->person;
    }
    //重载*运算符，返回本体-引用
    Person& operator*()
    {
        return (*this->person);
    }
private:
    Person* person;
};
void test()
{
    /*Person* person = new Person();
    person->showAge();
    (*person).showAge();
    delete person;*/

    SmartPointer sp = SmartPointer(new Person(18));
    //如果项sp对象像指针一样调用变量和函数，需要重载->和*
    sp->showAge();//sp->->showAge();编译器简化为sp->showAge();
    (*sp).showAge();
}

5.赋值运算符=重载

目的： 为了处理类中默认的=的运算符的浅拷贝问题

  • 系统会默认给一个类添加4个函数：默认构造、析构、拷贝构造（浅拷贝）、operator=(浅拷贝)
  • 由于系统提供的operator=会进行简单的值拷贝，如果成员属性中有堆区的数据，会导致重复释放–需要重载operator=
class Person
{
public:
    Person(const char* name, int age)
    {
        this->m_Age = age;
        this->m_Name = new char[strlen(name) + 1];
        strcpy(this->m_Name,name);
    }
    Person(const Person &p)
    {
        this->m_Name = new char[strlen(p.m_Name) + 1];
        strcpy(this->m_Name, p.m_Name);
        this->m_Age = p.m_Age;
    }
    //系统会默认给一个类创建至少3个函数：默认构造、析构、拷贝构造（浅拷贝）、operator=(浅拷贝)
    Person& operator=(const Person &person)
    {
        //先判断原来的堆区是否有数据，如果有先释放
        if (this->m_Name != NULL)
        {
            delete[] this->m_Name;
            this->m_Name = NULL;
        }
        //再重新创建name
        this->m_Name = new char[strlen(person.m_Name) + 1];
        strcpy(this->m_Name, person.m_Name);
        this->m_Age = person.m_Age;
        return *this;
    }
    ~Person()
    {
        if(this->m_Name != NULL)
        {
            delete [] this->m_Name;//这里是数组，[]不能丢
            this->m_Name = NULL;
        }
    }
    int m_Age;
    char *m_Name;//注：这里的值是堆区的数据，拷贝构造函数和operator=都存在浅拷贝问题
};
void test()
{
    Person p1("A", 10);
    Person p2("B", 20);
    p1 = p2;//这里需要重载=运算符
    cout << "p1.m_Name" << p1.m_Name << "age:" << p1.m_Age << endl;
    cout << "p2.m_Name" << p2.m_Name << "age:" << p2.m_Age << endl;
    Person p3(" ", 0);
    p3 = p1 = p2;//这里的重载的=运算符 需要返回对象
    cout << "p3.m_Name" << p3.m_Name << "age:" << p3.m_Age << endl;
    Person p4(p3);
    cout << "p4.m_Name" << p4.m_Name << "age:" << p4.m_Age << endl;
}

6.关系运算符==重载

class Person
{
public:
    Person(string name, int age)
    {
        this->name = name;
        this->age = age;
    }
    bool operator== (Person &p)//重载==运算符
    {
        return this->name == p.name && this->age == p.age;
    }
private:
    string name;
    int age;
};

7.函数调用运算符()重载-仿函数

class Myfunc
{
public:
    void operator() (string s)
    {
        cout << s << endl;
    }
};
void test()
{
    Myfunc myfunc;//STL 仿函数
    myfunc("");
}

8.符号重载总结

  • = [] () ->运算符只能通过成员函数进行重载
  • << >>运算符只能通过全局函数结合友元函数进行重载
  • 不要重载&& || 运算符，因为无法实现短路规则

（三）字符串类封装

  1. 设计类MyString
  2. 成员属性
    • char* pString 维护指向堆区指针
    • int m_Size 字符串长度
  3. 成员函数
    • 有参构造
    • 拷贝构造
    • 析构
  4. <<重载
  5. >>重载
  6. []重载 进行[]字符读写
  7. =重载 防止浅拷贝问题出现
  8. +重载 字符串拼接
  9. ==重载 对比
@阿飞
关注
专栏目录
C++高级编程02-函数重载和类的封装
莫浅子的博客
07-05 546
1、内联函数 2、函数的默认参数和占位参数 4、函数的重载 5、extern C 浅析 6、封装
C++基础-内联函数inline，重载，extern “C“ 及封装
weixin_41865866的博客
08-10 408
内联函数inline，重载，extern "C" 及封装
从C到C++ 命名空间---函数重载---内联函数---混合编程
ershiyidian的博客
07-20 1756
这是因为 C++ 取消了原来的限制，变量只要在使用之前定义好即可，不强制必须在函数开头定义所有变量。//在for循环的条件语句内部定义变量ii>n;return 0;运行结果：Total: 55在C语言中，动态分配内存用 malloc() 函数，释放内存用 free() 函数。//分配10个int型的内存空间free(p);//释放内存在C++
C++基础语法----多态
一个非常Cool的人
02-10 1886
一文带你搞懂C++中的多态,看完本篇博客你至少会使用简单的例子模拟多态,以及明白多态、抽象类、函数重载、重写、重定义等基本概念与原理,希望本篇博客对你有所帮助。
C/C++ - 类的友元与运算符重载
0xCC说逆向
01-27 1317
全局函数方式的运算符重载函数可以在函数定义中访问类的私有成员，通过将类声明为友元来实现。全局函数方式的运算符重载是将运算符重载函数定义为全局函数，而不是类的成员函数。运算符重载函数作为成员函数时，隐含地访问了类的成员变量和成员函数。成员函数方式的运算符重载是将运算符重载函数定义为类的成员函数。算术运算符：+、-、*、/、%​​​等。=、>、=、
C++必备知识--类和对象
zy1215058242的博客
07-30 998
class是类的关键字，Stack是类的名字(自己定义的)，在{}中定义类的主体。C++中类的出现是为了替代C语言中的结构体，所以类的结构与结构体类似，{}之后需要加分号。类体中的内容称为类的成员，类中(声明)的变量称为类的属性或成员变量，类中的函数称为类的方法或成员函数。在C++中也兼容了C语言中结构体的用法，并将 struct 升级成了类，也就是说C++中的 struct 内也可以定义函数，但是一般情况下我们还是优先使用class。除此之外，定义在类里的成员函数默认是inline内联函数。
C++基础语法——类和对象
qq_73201597的博客
05-12 1323
构造函数是一个特殊的成员函数，名字与类名相同创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。注：构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)
C++第七章-类-封装
weixin_42605616的博客
02-08 257
1 内存分区模型 代码区：存放函数体的二进制代码，由操作系统进行管理的**(程序执行前）** 全局区：存放全局变量和静态变量以及常量, 该区域的数据在程序结束后由操作系统释放**.(程序执行前）** 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等**（程序执行时）** 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收**（程序执行时）** 内存四区意义： 不同区域存放的数据，赋予不同的生命周期, 给我们更大的灵活编程 ​ 栈区： ​ 由编译器自动分配释放, 存放函数的参数值,局
C++语法——详解运算符重载
热门推荐
weixin_61857742的博客
07-28 3万+
运算符重载是C++的一个重要特性。有了运算符重载，在代码编写时能更好的实现封装。 一.运算符重载介绍 运算符重载，就是让原本已经存在的运算符有了新的用法和意义。 比如我们熟知的减号（-），原本是用来进行数字的相减处理。但经过运算符重载后，它可以用来进行其他类型的相减，像时间相减、日期相减、字符相减等等。只要是你能想到的，通过运算符重载基本都能够实现。 对于C++而言，运算符重载一般是作为类的成员函数出现。因为当我们需要运算符重载时，往往是类中一种特殊的类型需要处理或者类本身需要处理。就像我们可能会把.
C++学习笔记22-类模板与数组类封装案例
拒绝任何因懒惰而生的省略号
03-19 1769
类模板22.0 前言22.1 类模板语法22.2 类模板和函数模板区别22.3 类模板中成员函数创建时机22.4 类模板对象做函数参数（有查看数据类型语法小知识）22.5 类模板与继承22.6 22.0 前言 之前已学习了函数模板的相关知识，接下来学习类模板的相关知识。 22.1 类模板语法 类模板作用： 建议一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表。 语法： template<typename T,typename U,typename V,...> //类中
C++（包括c语言基础、数据类型、函数、指针、面向对象、类与对象、多态继承、重载等等）
11-10
这些基础知识是学习C++的基础，因为C++保留了C语言的大部分语法。 接下来，数据类型是编程中的核心元素。C++支持多种基本数据类型，如int、float、char等，以及自定义的数据类型，如结构体和联合体。此外，C++还...
C++语法基础各章习题.zip
04-10
这个"C++语法基础各章习题.zip"压缩包包含了一系列针对C++初学者的练习题，适用于指导少儿编程教学和CSP（中国青少年信息学奥林匹克竞赛）的备考训练。这些习题覆盖了C++基础语法的各个方面，旨在帮助学生逐步掌握并...
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 626
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 314
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
最新发布
ChoSeitaku的博客
11-04 1107
表A，B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的值往后移，若元素值相等，则创建一个值等于两节点的元素值的新节点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾。一个工作指针cura用来遍历链表A，一个工作指针curb用来遍历链表B，一个工作指针curc用来建立链表C，一个指针new用来创建共同节点的新节点尾插到C链表上。循环结束后，如果curb指向NULL，表示链表B的curb都等于对应的cura，链表B是链表A的连续子序列。
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 101
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
每日OJ题_牛客_排序子序列_模拟_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-02 370
每日OJ题_牛客_排序子序列_模拟_C++_Java（根据题意用指针模拟即可）
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1041
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值