【C++】重载运算符+-=＞/*[]==++-- MyString 智能指针(* -＞)

最新推荐文章于 2024-05-31 14:42:05 发布
最新推荐文章于 2024-05-31 14:42:05 发布
阅读量539 收藏
点赞数 1
分类专栏： C++基础 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61628700/article/details/127989384
版权

目录

15.重载运算符

15.1 eg.Person

15.2 eg.MyString

15.3 智能指针

15.重载运算符

  • 定义：给原有的运算符赋予新的意义。

  • 为什么重载<<或>>一定要用友元？

    如果是重载双目操作符（即为类的成员函数），就只要设置一个参数作为右侧运算量，而左侧运算量就是对象本身。

    而 >> 或<< 左侧运算量是 cin或cout 而不是对象本身，所以不满足左侧运算量就是对象本身的特点。所以要申明为友元函数。

    如果一定要声明为成员函数，只能成为如下的形式：

    ostream & operator<<(ostream &output){
　　return output;
}

    所以在运用这个<<运算符时就变为：data<<cout;

    不符合习惯。

15.1 eg.Person

#include<iostream>
using namespace std;
class Person {
private:
     string name;
     int age;
     float weight;
public:
     Person();
     Person(string, int, float);
     ~Person();
​
     friend ostream& operator<<(ostream& out, Person& ob);
     friend istream& operator>>(istream& in, Person& ob);
     friend Person operator+(Person& ob1, Person& ob2);
     friend Person operator-(Person& ob1, Person& ob2);
     friend Person operator*(Person& ob1, Person& ob2);
     friend Person operator/(Person& ob1, Person& ob2);
     friend Person operator++(Person& ob);//前置++
     friend Person operator++(Person& ob,int t);//后置++
     friend Person operator--(Person& ob);//前置--
     friend Person operator--(Person& ob,int t);//后置--
     friend bool operator==(Person& ob1, Person& ob2);
};
​
Person::Person() {
     name = "YY";
     age = 19;
     weight = 55.5;
}
​
Person::Person(string _name, int _age, float _weight) {
     name = _name;
     age = _age;
     weight = _weight;
}
​
Person::~Person() {
     //cout << "~Person" << endl;
}
​
ostream& operator<<(ostream& out, Person& ob) {
     cout << "name:" << ob.name <<" "
          <<"age:" <<ob.age<<" "
          <<"weight:"<<ob.weight<< endl;
     return out;
}
istream& operator>>(istream& in, Person& ob) {
     Person(ob.name, ob.age, ob.weight);
     return in;
}
Person operator+(Person& ob1, Person& ob2) {
     Person ob3;
     ob3.age=ob1.age + ob2.age;
     ob3.weight = ob1.weight + ob2.weight;
     ob3.name = ob1.name + ob2.name;
     return ob3;
}
​
Person operator-(Person& ob1, Person& ob2) {
     Person ob3;
     ob3.age = ob1.age - ob2.age;
     ob3.weight = ob1.weight - ob2.weight;
     return ob3;
}
Person operator*(Person& ob1, Person& ob2) {
     Person ob3;
     ob3.age = ob1.age * ob2.age;
     ob3.weight = ob1.weight * ob2.weight;
     return ob3;
}
​
Person operator/(Person& ob1, Person& ob2) {
     Person ob3;
     ob3.age = ob1.age / ob2.age;
     ob3.weight = ob1.weight / ob2.weight;
     return ob3;
}
​
Person operator++(Person& ob) {
     ob.age++;
     ob.weight++;
     ob.name += ob.name;
     return ob;
}
​
Person operator++(Person& ob, int t) {
     Person old = ob;
     ++ob;
     return old;
}
​
Person operator--(Person& ob) {
     ob.age--;
     ob.weight--;
     return ob;
}
​
Person operator--(Person& ob, int t) {
     Person old = ob;
     --ob;
     return old;
}
​
bool operator==(Person& ob1, Person& ob2){
     if (ob1.age == ob2.age && ob1.weight == ob2.weight) {
          return true;
     }
     return false;
}
​
int main() 
{
     Person ob1;
     Person ob2("CC", 20, 66.66);
     Person temp;
​
     cout << "Test <<:" << endl;
     cout << ob1 << endl;
     cout << ob2 << endl;
​
     cout << "\nTest >>:" << endl;
     cin >> temp ;
​
     cout << "\nTest -:" << endl;
     temp = ob2 - ob1;
     cout << temp << endl;
​
     cout << "\nTest +:" << endl;
     temp = ob2 + ob1;
     cout << temp << endl;
​
     cout << "\nTest a++:" << endl;
     ob1++;
     cout<< ob1 << endl;
​
     cout << "\nTest ++a:" << endl;
     ++ob1;
     cout << ob1 << endl;
​
     cout << "\nTest a--:" << endl;
     ob2--;
     cout << ob2 << endl;
​
     cout << "\nTest --a:" << endl;
     --ob2;
     cout << ob2 << endl;
​
     cout << "\nTest ==:" << endl;
     bool f=(ob1==ob2);
     cout << f << endl;
}

 

15.2 eg.MyString

#include<iostream>
#include<string>
using namespace std;
​
class MyString {
private:
     int size;
     char* str;
public:
     MyString();
     MyString(const char*s); //一定要有const
     ~MyString();
​
     friend ostream& operator<<(ostream& out, MyString ob);
     friend istream& operator>>(istream& in, MyString &ob);//一定要有&
     MyString operator+(MyString ob);
     MyString operator=(MyString ob);
     bool operator>(MyString ob);
     char &operator[](int i);//获取字符串中的一个字符
};
​
MyString::MyString() {
     size = 0;
     str = NULL;
}
​
MyString::MyString(const char* _str){
     size = strlen(_str);
     str = new char[size + 1];
     strcpy(str, _str);
}
​
MyString::~MyString() {
     //cout << "\n~MyString" << endl;
}
​
ostream& operator<<(ostream& out, MyString ob) {
     out << ob.str;
     return out;
}
​
istream& operator>>(istream& in, MyString &ob) {
     char temp[99];
     cin >> temp;
     if (ob.str != NULL) {
          delete[]ob.str;
          ob.str = NULL;
     }
     ob.size = strlen(temp);
     ob.str = new char[ob.size + 1];
     strcpy(ob.str, temp);
     return in;
}
​
MyString MyString::operator+(MyString ob) {
     MyString temp;
     temp.size=size + ob.size;
     temp = new char[temp.size + 1];
     strcpy(temp.str, str);
     strcat(temp.str, ob.str);
     return temp;
}
​
MyString MyString::operator=(MyString ob) {
     size = ob.size;
     if (str != NULL) {
          delete[]str;
          str = NULL;
     }
     str = new char[size+1];
     str = ob.str;
     return *this;
}
​
bool MyString::operator>(MyString ob) {
     if (strcmp(str, ob.str)) {
          return true;
     }
     return false;
}
​
char& MyString::operator[](int i) {
     return str[i];
}
​
int main() 
{
     MyString ob1;
     MyString ob2("YY");
     MyString temp;
​
     cout << "Test <<" << endl;
     cout << ob2 << endl;
​
     cout << "\nTest >>" << endl;
     cin >> temp;
     cout << temp << endl;
​
     cout << "\nTest =" << endl;
     ob1 = ob2;
     cout << ob1 << endl;
​
     cout << "\nTest +" << endl;
     temp = ob1 + ob2;
     cout << temp << endl;
​
     cout << "\nTest >" << endl;
     bool f=temp>ob1;
     cout << f<< endl;
}

 

  • 析构函数的调用顺序：

    #include<iostream>
#include<string>
using namespace std;
​
class MyString {
private:
     int size;
     char* str;
     string name;
public:
     MyString();
     MyString(const char*s,string _name); //一定要有const
     ~MyString();
​
     friend ostream& operator<<(ostream& out, MyString ob);
     friend istream& operator>>(istream& in, MyString &ob);//一定要有&
     MyString operator+(MyString ob);
     MyString operator=(MyString ob);
     bool operator>(MyString ob);
     char &operator[](int i);//获取字符串中的一个字符
};
​
MyString::MyString() {
     size = 0;
     str = NULL;
}
​
MyString::MyString(const char* _str,string _name){
     cout << "Create:" << _name << endl;
     size = strlen(_str);
     str = new char[size + 1];
     strcpy(str, _str);
     name = _name;
}
​
MyString::~MyString() {
     cout << "\n~MyString："<<this->name << endl;
}
​
ostream& operator<<(ostream& out, MyString ob) {
     out << ob.str;
     return out;
}
​
istream& operator>>(istream& in, MyString &ob) {
     char temp[99];
     cin >> temp;
     if (ob.str != NULL) {
          delete[]ob.str;
          ob.str = NULL;
     }
     ob.size = strlen(temp);
     ob.str = new char[ob.size + 1];
     strcpy(ob.str, temp);
     return in;
}
​
MyString MyString::operator+(MyString ob) {
     MyString temp;
     temp.size=this->size + ob.size;
     temp.str = new char[temp.size+1];
     strcpy(temp.str, this->str);
     strcat(temp.str, ob.str);
     return temp;
}
​
MyString MyString::operator=(MyString ob) {
     size = ob.size;
     if (str != NULL) {
          delete[]str;
          str = NULL;
     }
     str = new char[size+1];
     str = ob.str;
     return *this;
}
​
bool MyString::operator>(MyString ob) {
     if (strcmp(str, ob.str)) {
          return true;
     }
     return false;
}
​
char& MyString::operator[](int i) {
     return str[i];
}
​
int main() 
{
     MyString ob1("S","ob1");
     MyString ob2("YY","ob2");
     MyString temp("T","temp");
​
     cout << "Test <<" << endl;
     cout << ob2 << endl;
​
     cout << "Test >>" << endl;
     cin >> temp;
     cout << temp << endl;
​
     cout << "Test =" << endl;
     ob1 = ob2;
     cout << ob1 << endl;
​
     cout << "Test +" << endl;
     temp = ob1 + ob2;
     cout << temp << endl;
​
     cout << "Test >" << endl;
     bool f=temp>ob1;
     cout << f<< endl;
}

     

15.3 智能指针

（指针运算(*、->)重载）

  • 作用：解决 堆区空间的对象 释放问题。（手动怕忘）

    智能指针就是帮我们C++程序员管理动态分配的内存的，它会帮助我们自动释放new出来的内存，从而避免内存泄漏！

#include<iostream>
using namespace std;
​
class Data {
private:
     int a;
public:
     Data();
     Data(int);
     ~Data();
     void Datafuc();
};
​
class smartpoint {
private:
     Data* p;
public:
     smartpoint();
     smartpoint(Data* p);
     ~smartpoint();
​
     Data* operator->();
     Data& operator*();
};
​
Data::Data() {}
Data::Data(int _a) {
     a = _a;
}
Data::~Data() {
     cout << "~Data" << endl;
}
void Data::Datafuc() {
     cout << "smartpoint调用Datafuc" << endl;
}
​
smartpoint::smartpoint() {
     *p = NULL;
}
smartpoint::smartpoint(Data* _p) {
     p = _p;
}
smartpoint::~smartpoint() {
     cout << "~smartpoint" << endl;
}
​
Data& smartpoint::operator*() {
     cout << "重载运算符*" << endl;
     return *p;
}
Data* smartpoint::operator->() {
     cout << "重载运算符->" << endl;
     return this->p;
}
​
int main()
{
     Data da(5);
     smartpoint sp(&da);
​
     //重载运算符调用函数
     sp->Datafuc();
     (*sp).Datafuc();
}

 

吧啦吧啦嘭
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
86.指针运算符重载
augfun的博客
09-08 1614
智能指针实现 Person类有showAge 成员函数 如果new出来的Person对象，就要让程序员自觉的去释放 delete 有了智能指针，让智能指针托管这个Person对象，对象的释放就不用操心了，让智能指针管理 为了让智能指针想普通的Person*指针一样使用 就要重载 -> 和* // 53.指针运算符重载.cpp : 定义控制台应用程序的入口...
34. 指针的重载(智能指针)
qq_41583263的博客
10-15 511
智能指针
C++——智能指针
New_User_Ling的博客
12-26 474
为什么要使用智能指针？ 为了防止程序员遗忘释放指针，使用智能指针可以帮助我们管理内存,防止内存泄漏 智能指针的原理？ 一、从较浅的层面看，智能指针是对普通的指针进行了封装，这使得智能指针实质其实是一个对象，只是表现的却像一个指针。 二、由于智能指针是一个类对象，在被调函数执行完，对象将会被删除。同时，它指向的内存也会被删除的因此实现了指针的释放。 三、智能指针重载了->符和=符，重载这两个符...
智能指针--C++
qq_63412763的博客
10-08 606
指针我们都不陌生，我们在存放或指向一个地址空间时都需用到指针。而今天我们要谈的智能指针主要将问题集中到了空间（内存）的安全使用的方面。我们在堆上申请空间后，被告知一定要进行空间的释放，否则会造成内存泄漏的问题。长期的内存泄漏会造成进程卡死的情况，这要是在一款投入使用的软件上发生了，那造成的损失就不是个人可以承担的了（亲，可以拍拍屁股走人了哈🤔）。
c++运算符重载Mystring＜,＜=,＞.＞=,+,+=
m0_67695275的博客
05-21 622
小编犯的错误是： 1. 对象的指针比较大小，要使用strcmp(s1.ptr, s2.ptr); 2. +，+= 运算符重载时，内存需要创建新的空间，建议使用 ”换杯子“ 的方法进行 例题如下： class MyString{ char *ptr; public: int size()const{ return strlen(ptr); } MyString(){ ptr=new char[1]; ptr[0]='\0'; } MyString(const char *p)
C++:运算符重载（=/==）
WolvenSec的博客
05-02 1037
在赋值运算符的重载函数中，首先进行了数值的赋值操作，即将右侧对象的整数成员变量值赋给了左侧对象的相应成员变量。类中包括了两个构造函数：一个是默认构造函数，另一个是带有三个参数的构造函数，用于初始化对象的成员变量。通过重载赋值运算符，可以自定义对象的赋值操作，以便适应特定的需求和语义。注意：使用重载后的赋值运算符时不能将对象的声明与赋值运算符写在一行代码中，即不能在声明对象时初始化对象，如。注意：使用重载后的赋值运算符时不能将对象的声明与赋值运算符写在一行代码中，即不能在声明对象时初始化对象，如。
C++:运算符重载-加号（+）
WolvenSec的博客
04-30 713
接下来就以加号（+）为例子，阐述如何对双目运算符进行重载。
C++运算符重载
m0_58495729的博客
10-22 763
C++学习路径之运算符重载
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
12-31
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数  编写类String 的构造函数、析构函数和赋值函数，已知类String 的原型为： class String { public: String(const char *str = NULL); // 普通...
小班作业-MyString类
11-19
这周的小班作业第一题捏。这题算是图书馆管理系统的热身训练吧，但是还是费了一番功夫。先发个exe出来给大伙看看，有什么毛病尽管提，说实话bug还是挺多的...
c++ 编程练习 014:MyString
01-07
补足MyString类，使程序输出指定结果 #include #include #include using namespace std; class MyString { char * p; public: MyString(const char * s) { if( s) { p = new char[strlen(s) + 1]; strcpy...
zig-string:用Zig制作的字符串库
05-25
Zig字符串（UTF-8字符串库） 我这样做的唯一目的是增进我对zig的...// Create your Stringvar myString = String. init ( & arena.allocator);defer myString. deinit ();// Use functions providedtry myString. co
C++中的智能指针类别
最新发布
GOLOJO的博客
05-31 669
C++中的智能指针是用来管理动态内存的对象，避免我们手动管理内存时可能会带来的复杂性和错误。C++标准库提供了几种不同类型的智能指针，包括``、``和`- 优先使用``和``来创建智能指针，避免手动使用`new`，可以提高代码的安全性和性能。- 在使用``时要特别小心循环引用的问题。可以使用``来打破循环引用。- 确保智能指针的生命周期管理正确，避免悬空指针和内存泄漏。- 虽然智能指针极大地简化了内存管理，但也带来了额外的开销，如引用计数的维护。因此，在性能敏感的代码中，应慎重使用`
精通C++ STL（二）：string类的模拟实现
Russ_Leo的博客
05-27 805
string类各函数接口。
【如何在Qt C++中使用SSL和TLS加密传输数据？】
m0_45463480的博客
05-28 172
在这个示例中，我们创建了一个简单的Qt应用程序，向指定的HTTPS地址发送请求，并显示响应。信号来处理响应数据。您可以从响应中读取数据并进行进一步处理。来配置SSL/TLS连接，包括对证书进行验证和加密要求等。为您要访问的实际URL，并根据需要进一步配置SSL策略。在发送请求之前，可设置SSL配置。确保您的Qt项目已经链接了网络模块（对象发送网络请求，并接收响应。对象指定要访问的URL。
C语言——指针
weixin_45725380的博客
05-31 498
存储类型 数据类型 *指针变量名；例如：int *p;//定义了一个整数型指针变量pint a=5;int *p=&a;char b='v';char *q=&b;访问指针所指的空间里的内容时，需要用取内容运算符*来获取此时，变量p存放的就是a的地址，变量q存放的就是b的地址；符号*可以访问地址指向的空间里面的内容。指针与变量之间的关系如下：int i=3;本质还是指针，指向的是数组。（又称为行指针）所谓指针数组就是由若干个具有相同类型的指针变量组成的集合。
用c++方法解决下列问题：编写字符串运算符“+=”的重载函数，使运算符“+=”用于字符串的拼接运算，实现字符串的S1+=S2操作运算。分别用友元函数和成员函数实现。
06-13
好的，以下是代码示例： ```c++ #include <iostream> #include <cstring> using namespace std; class MyString { private: char* str; // 字符串指针 public: MyString(const char* s) { str = new char[strlen(s) + 1]; strcpy(str, s); } ~MyString() { delete [] str; } // 友元函数实现 friend MyString operator+=(MyString& s1, const MyString& s2) { char* temp = new char[strlen(s1.str) + strlen(s2.str) + 1]; strcpy(temp, s1.str); strcat(temp, s2.str); delete [] s1.str; s1.str = temp; return s1; } // 成员函数实现 MyString& operator+=(const MyString& s) { char* temp = new char[strlen(str) + strlen(s.str) + 1]; strcpy(temp, str); strcat(temp, s.str); delete [] str; str = temp; return *this; } void print() { cout << str << endl; } }; int main() { MyString s1("Hello"), s2("World"); s1 += s2; s1.print(); // 输出 HelloWorld s2 += "!"; s2.print(); // 输出 World! return 0; } ``` 以上代码定义了一个 MyString 类，其中包含了两个实现“+=”运算符的方法：一个是友元函数，一个是成员函数。在 main 函数中，我们可以看到对于两个 MyString 对象的“+=”操作，都可以实现字符串的拼接运算。 需要注意的是，在代码中我们使用了动态内存分配，需要在适当的时候进行 delete 操作，避免内存泄漏。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值