（黑马C++）L05 运算符重载

最新推荐文章于 2024-08-25 06:11:42 发布
最新推荐文章于 2024-08-25 06:11:42 发布
阅读量480 收藏 1
点赞数
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43697646/article/details/127276730
版权

一、强化训练---数组类封装

实现数组的功能，成员变量包括数组的容量，大小；实现的功能包括根据位置添加元素、获取指定位置的数据、尾插法、获得数组的长度。

//MyArray.h
#pragma once //防止头文件进行重复编译
#include <iostream>

using namespace std;
class MyArray {
public:
	MyArray(); //默认构造函数，100个容量
	MyArray(int capacity); //用户提供容量
	MyArray(const MyArray& array); //拷贝构造

	~MyArray(); //析构

	//尾插法
	void push_back(int val);

	//根据索引获取值
	int getVal(int index);

	//根据索引设置值
	void setVal(int index, int val);

	//获取数组的大小
	int getSize();

	//获取数组的容量
	int getCapacity();

private:
	int* pAddress; //指向真正存储数据的指针
	int m_size; //数组大小
	int m_capacity; //数组容量
};


//MyArray.cpp
#include "MyArray.h"

//默认构造
MyArray::MyArray()
{
	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& array)
{
	this->pAddress = new int[array.m_capacity];
	this->m_capacity = array.m_capacity;
	this->m_size = array.m_size;
	for (int i = 0; i < array.m_capacity; i++) {
		this->pAddress[i] = array.pAddress[i];
	}
}

//析构
MyArray::~MyArray()
{
	//cout << "析构函数调用" << endl;
	if (this->pAddress != NULL) {
		delete[] this->pAddress;
		this->pAddress = NULL;
	}
}

void MyArray::push_back(int val)
{
	this->pAddress[this->m_size] = val;
	this->m_size++;
}

int MyArray::getVal(int index)
{

	return this->pAddress[index];
}

void MyArray::setVal(int index, int val)
{
	this->pAddress[index] = val;
}

int MyArray::getSize()
{
	return this->m_size;
}

int MyArray::getCapacity()
{
	return this->m_capacity;
}



//数组类的封装.cpp
#include<iostream>
#include "MyArray.h"

void test() {
	MyArray* myArray = new MyArray(10);
	//MyArray* myArray2(myArray); 这是声明一个指针和myArray地址相同，不会调用拷贝构造
	MyArray* myArray2 = new MyArray(*myArray); //new方式调用构造函数
	//尾插测试
	for (int i = 0; i < 5; i++) {
		myArray2->push_back(i);
	}
	//获取数据测试
	for (int i = 0; i < 5; i++) {
		int tmp = myArray2->getVal(i);
		cout << tmp << endl;
	}
	//设置数据测试
	myArray2->setVal(0, 20);
	cout << myArray2->getVal(0) << endl;
	//获取数组大小测试
	cout << "数组的大小为：" << myArray2->getSize() << endl;
	//获取数组容量的测试
	cout << "数组的容量为：" << myArray2->getCapacity() << endl;
}

using namespace std;
int main() {
	test();
	system("pause");
	return 0;
}

二、加号运算符的重载

对于内置的数据类型，编译器知道如何做运算，通过运算符重载可以实现对其他类型的数据进行运算，运算符的重载可以有多个版本。

（1）成员函数实现相加

例如：实现两个Person对象相加，常规写法如下：

Person plusPerson(Person &p) {
    Person tmp;
    tmp.m_A = this->m_A + p.m_A;
    tmp.m_B = this->m_B + p.m_B;
    return tmp;
}

以上方法实现两个Person对象相加时，需要用p1.plusPerson(p2)进行运算。

加号重载的实现方法：

1.将函数名改为operator+；2.此时两成员进行运算可以直接写成p1+p2。

（2）全局函数实现相加

Person operator+ (Person& p1, Person& p2) {
    Person tmp;
    tmp.m_A = p1.m_A + p2.m_A;
    tmp.m_B = p1.m_B + p2.m_B;
    return tmp;
}

三、左移运算符重载

重载左移运算符直接输出Person类型，而不是只能输出里面的成员变量。

#include <iostream>
using namespace std;

class Person{
public:
    Person() {}; //默认构造
    Person(int a, int b) { //有参构造
        this -> m_A = a;
        this -> m_B = b;
    };
    int m_A;
    int m_B;

};

//重载左移运算符不可写在成员函数中
//如果在成员函数中调用需要写成p<<
ostream& operator<< (ostream& cout, Person& p) { //第一个参数cout 第二个参数p
    cout << "m_A = " << p.m_A << "m_B = " << p.m_B << endl;
    return cout; //return cout后test中才能拼接换行
}

void test() {
    Person p1(10, 10);
    cout << p1 << endl; //左移运算符重载后可以直接输出Person类型
}

int main() {
    test();
    system("pause");
    return 0;
}

四、前置后置递增运算符重载

class MyInt{
public:
    MyInt() {
        num = 0;
    };

    int num;
    
    //前置++重载
    MyInt& operator++() {
        this->num++;
        return *this;
    }

    //后置++重载
    MyInt operator++(int) { //与前置++区分
        MyInt tmp = *this;
        this->num++;
        return tmp;
    }
};

ostream& operator<< (ostream& cout, MyInt& myint) {
    cout << myint.num;
    return cout;
}

void test() {
    MyInt myint;
    //前置++
    cout << ++myint << endl;

    //后置++
    cout << myint++ << endl;

    //myint结果
    cout << myint << endl;
}

int main() {
    test();
    system("pause");
    return 0;
}

前置和后置形式语义上是等价的，输入工作量也相当，只是前置的效率会更高一些，因为前置会少创建一个临时对象。

五、指针运算符重载

#include <iostream>
using namespace std;

class Person{
public:
    void showAge() {
        cout <<"年龄为：" << m_age << endl;
    }

    Person(int age) {
        m_age = age;
    }

    ~Person() {
        cout << "析构函数的调用" << endl;
    }
    int m_age;
};

//智能指针
//用来托管自定义的对象，让对象自动释放
class smartPerson{
public:
    smartPerson(Person* person) {
        this->person = person;
    }
    
    //重载->让智能指针的对象可以和person对象一样去使用
    Person* operator->() {
        return this->person;
    }
    
    //重载*
    Person& operator*() {
        return *(this->person);
    }
    

    ~smartPerson() {
        cout << "智能指针的析构" << endl;
        if(this->person != NULL) {
            delete this->person;
            this->person = NULL;
        }
    }

private:
    Person* person;
};

void test() {
    //开辟在栈上，自动析构
    Person p1(10); 
    //开辟在堆上，需要delete
    Person* p2 = new Person(10); 
    delete p2;
    //智能指针
    smartPerson sp(new Person(10)); //sp开辟到了栈上，会自动析构
    sp->showAge();
    (*sp).showAge();
}

int main() {
    test();
    system("pause");
    return 0;
}

六、赋值运算符重载

#include <iostream>
using namespace std;

//一个类默认创建 默认构造、析构、拷贝构造、operator=赋值运算符 进行简单的值传递
class Person{
public:
    Person(int a) {
        m_a = a;
    }

    int m_a;
};


void test() {
    Person p1(10); 
    Person p2(20); 
    //赋值运算符,会调用默认的重载
    p1 = p2;
    cout << "p2的m_a为：" << p2.m_a << endl;
}


class Person2{
public:
    Person2(char* name) {
        this->p_name = new char[strlen(name)+1];
        strcpy(this->p_name, name);
    }
    
    //重载=赋值运算符
    //返回Person2的引用后才可以连等
    Person2& operator= (Person2& p) {
        //判断原来堆区的内容
        if(this->p_name != NULL) {
            delete[] this->p_name;
            this->p_name = NULL;
        }
        //重新开辟一段空间
        this->p_name = new char[strlen(this->p_name)+1];
        strcpy(this->p_name, p.p_name);
        return *this;
    }

    ~Person2() {
        if(this->p_name != NULL) {
            delete[] this->p_name;
            this->p_name = NULL;
        }
    }

    char* p_name;
};

void test02() {
    Person2 p1("狗蛋")；
    Person2 p2("狗剩");
    p2 = p1; //如果不进行重载，在析构时会出现深拷贝浅拷贝的问题
    cout << "p2的名字为：" << p2.p_name << endl;
}


int main() {
    test();
    test02();
    system("pause");
    return 0;
}

七、[]运算符重载

//MyArray.h
#pragma once //防止头文件进行重复编译
#include <iostream>

using namespace std;
class MyArray {
public:
	MyArray(); //默认构造函数，100个容量
	MyArray(int capacity); //用户提供容量
	MyArray(const MyArray& array); //拷贝构造

	~MyArray(); //析构

	//尾插法
	void push_back(int val);

	//根据索引获取值
	int getVal(int index);

	//根据索引设置值
	void setVal(int index, int val);

	//获取数组的大小
	int getSize();

	//获取数组的容量
	int getCapacity();

    //[]运算符重载
    //直接通过索引获取值
    int& operator[](int index);

private:
	int* pAddress; //指向真正存储数据的指针
	int m_size; //数组大小
	int m_capacity; //数组容量
};


//MyArray.cpp
#include "MyArray.h"

//默认构造
MyArray::MyArray()
{
	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& array)
{
	this->pAddress = new int[array.m_capacity];
	this->m_capacity = array.m_capacity;
	this->m_size = array.m_size;
	for (int i = 0; i < array.m_capacity; i++) {
		this->pAddress[i] = array.pAddress[i];
	}
}

//析构
MyArray::~MyArray()
{
	//cout << "析构函数调用" << endl;
	if (this->pAddress != NULL) {
		delete[] this->pAddress;
		this->pAddress = NULL;
	}
}

void MyArray::push_back(int val)
{
	this->pAddress[this->m_size] = val;
	this->m_size++;
}

int MyArray::getVal(int index)
{

	return this->pAddress[index];
}

void MyArray::setVal(int index, int val)
{
	this->pAddress[index] = val;
}

int MyArray::getSize()
{
	return this->m_size;
}

int MyArray::getCapacity()
{
	return this->m_capacity;
}
//返回引用之后可以进行设置
int& MyArray::operator[](int index) {
    return this->pAddress[index];
}

//数组类的封装.cpp
#include<iostream>
#include "MyArray.h"

void test() {
	MyArray* myArray = new MyArray(10);
	//MyArray* myArray2(myArray); 这是声明一个指针和myArray地址相同，不会调用拷贝构造
	MyArray* myArray2 = new MyArray(*myArray); //new方式调用构造函数
	//尾插测试
	for (int i = 0; i < 5; i++) {
		myArray2->push_back(i);
	}
	//获取数据测试
	for (int i = 0; i < 5; i++) {
		int tmp = myArray2->getVal(i);
		cout << tmp << endl;
	}
	//设置数据测试
	myArray2->setVal(0, 20);
	cout << myArray2->getVal(0) << endl;
	//获取数组大小测试
	cout << "数组的大小为：" << myArray2->getSize() << endl;
	//获取数组容量的测试
	cout << "数组的容量为：" << myArray2->getCapacity() << endl;
    //获取数组内容，直接用[]进行设置访问
    cour << myarray2[0] << endl;
}

using namespace std;
int main() {
	test();
	system("pause");
	return 0;
}
Entral_yddd!
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++笔记10：运算符重载
weixin_38665351的博客
08-25 485
123
C++_day06_运算符重载_智能指针
weixin_30332241的博客
04-04 108
1.只有函数运算符可以带缺省函数，其他运算符函数主要由操作符个数确定 2.解引用运算符和指针运算符 示例代码： #include <iostream> using namespace std; class A{ public: A(int data = 0):m_data(data)　　{　　　　cout << "A构造" <<...
c++学习笔记之运算符重载与智能指针
09-26 462
ps::赋值操作会调用构造函数 友元的位置 不在乎 public private s+=s2 s.operator+=(s2)
黑马：C++运算符重载（121~126)
至臻卡比兽的博客
10-06 214
概念：对已有的运算符重新定义，赋予另一种功能，以适应不同的数据类型 1.加号运算符重载 #include<iostream> using namespace std; #include<string> #include<vector> #include<deque> #include<iterator> #include<list> #include<algorithm> #include<numeric&g
芯片78L05相关问题
12-09
1、用78L05稳压后的5V电路上还要加多大的电解电容   网友回复：看你负载电流了，一二百MA加个几百微法的就可以，要是达到接受1A输出，就得加到2200微法或更高，总之大点没关系不要太小。记得最好再大电容两端并接...
78L05稳压模块芯片资源PDF
05-10
LM78L05在microSMD封装中的特点包括：在温度范围内输出电压容忍度为±5%，输出电流为100mA，内部热过载保护，输出晶体管安全区域保护，内部短路电流限制，塑料TO-92和塑料SO-8低轮廓封装可用，无需外部组件，输出...
MC78L05ABPRAG的技术参数
12-12
MC78L05ABPRAG是一款常用的三端正电压稳压器，它的设计目标是为电子设备提供稳定、可靠的5伏电源。以下是对这款芯片的主要技术参数的详细解释： 1. **输出电压**：5V 这意味着MC78L05ABPRAG能够输出一个固定的5伏...
MC78L05ACPRMG的技术参数
12-12
产品型号:MC78L05ACPRMG输出电压(V):5输出电流最大值(mA):100输入偏置电流(mA)典型值:3.800输入电压最大值(V):30保护过流热关断:Yes封装/温度(℃):3TO-92/-40~125描述:三端正固定电压的稳压器价格/1片(套):￥1.10 
TL750L05CLP的技术参数
12-12
产品型号:TL750L05CLP输出电压(V):5输出电流典型值(mA):150输入电压最小值(V):6输入电压最大值(V):26压差典型值(mV):600静态电流典型值(mA):10容限(%):4关断功能:No输出电容(μF):10输出电容类型:钽封装/温度(℃):3...
86.指针运算符重载
augfun的博客
09-08 1635
智能指针实现 Person类有showAge 成员函数 如果new出来的Person对象，就要让程序员自觉的去释放 delete 有了智能指针，让智能指针托管这个Person对象，对象的释放就不用操心了，让智能指针管理 为了让智能指针想普通的Person*指针一样使用 就要重载 -> 和* // 53.指针运算符重载.cpp : 定义控制台应用程序的入口...
C++运算符重载（二）简单易懂的智能指针教程，指针类运算符重载。-＞运算符重载，*运算符重载，【】运算符重载。最后附带完整实现代码。
qq_51004011的博客
06-27 1647
在C++中使用new实例化一个该类的对象时，使用完这个对象后我们需要自己去释放这一块向堆区申请的空间。 那么如果我们忘记释放某一个new出来的对象，那么就可能造成内存泄漏的情况。为了避免这样的情况出现，就出现了智能指针这个概念。...
C++智能指针与重载操作符
if(代码==人生)
07-18 2827
简单记录一下C++的智能指针和重载操作符智能指针C++的智能指针是克服C++大坑的非常有用的的手段，之所以说它智能，是因为它为程序员克服了重要的编程问题——悬挂指针重载操作符重载操作符，在一定程度上，我觉得不是必要的。当然，为了更好地体现C++代码的简介特性还有面向对象特性，重载操作符确实起了非常重要的作用。在重载操作符的基础上，C++的一些类可以设计得非常复杂，但使用起来会非常人性化。把智能指针和
【C++】链表
qq_38801607的博客
08-22 705
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
最新发布
lly202406的博客
08-25 600
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1429
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
C++ 基础
weixin_51883798的博客
08-22 285
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
APL78L05低电流正电压稳压器技术规格
"APL78L05是一款三端口低电流正电压稳压器，由ANPEC Electronics Corp.制造。该器件适用于各种应用，包括消除噪声和解决单点调节带来的分布问题，并能与功率传递元件配合形成高电流电压调节器。其特点包括内置限流和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值