类和对象（高级）

于 2024-08-23 10:37:03 发布
阅读量290 收藏 2
点赞数 1
分类专栏： C++ 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57907966/article/details/141459655
版权

类和对象（高级）

一、运算符重载

运算符重载是对已有的运算符 指定新功能。不能创建新运算。
运算符重载关键字operator
思路：
1、弄懂运算符的运算对象的个数。（个数决定了 重载函数的参数个数）
2、识别运算符左边的运算对象 是类的对象还是其他.
类的对象：成员函数实现（推荐，少一个参数），全局函数实现（不推荐）
其他：只能是全局函数实现

1、重载<<运算符（全局函数实现）

#include <iostream>
#include<string>
using namespace std;
class Person{
    friend ostream& operator <<(ostream &out,Person &ob );
private:
    int  num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score):num(num),name(name),score(score){

    }
};
//返回cout的引用类型（可以链式输出）
ostream& operator <<(ostream &out,Person &ob ){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score;
    return out;
}
int main(int argc, char *argv[])
{
   Person lucy(100,"lucy",19.2f);
      Person bob(102,"bob",19.3f);
   cout<<lucy<<endl;
   //链式 输出
   cout<<lucy<<bob<<endl;
    return 0;
}

2、重载输入>>运算符

#include <iostream>
#include<string>
using namespace std;
class Person{
    friend ostream& operator<<(ostream &out,Person &ob );
    friend istream& operator>>(istream &in,Person &ob);
private:
    int  num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score):num(num),name(name),score(score){

    }

};
//返回cout的引用类型（可以链式输出）
ostream& operator<<(ostream &out,Person &ob ){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score;
    return out;
}
istream &operator>>(istream &in,Person &ob){
in>>ob.num>>ob.name>>ob.score;
return in;
}
int main(int argc, char *argv[])
{
   Person lucy;
   cin>>lucy;
   cout<<lucy<<endl;

    return 0;
}

如果使用全局函数 重载运算符 必须将全局函数设置成友元。

3、可以重载的运算符

在这里插入图片描述

4、重载加法运算符+（全局函数实现）

#include <iostream>
#include<string>
using namespace std;
class Person{
    friend ostream& operator<<(ostream &out,Person ob );
    friend istream& operator>>(istream &in,Person &ob);
    friend Person operator +(Person ob1,Person ob2);
private:
    int  num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score):num(num),name(name),score(score){

    }



};
//返回cout的引用类型（可以链式输出）
ostream& operator<<(ostream &out,Person ob ){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score;
    return out;
}
istream &operator>>(istream &in,Person &ob){
in>>ob.num>>ob.name>>ob.score;
return in;
}
//返回值不能为引用，因为temp是局部变量
Person operator +(Person ob1,Person ob2){
    Person temp;
    temp.num=ob1.num+ob2.num;
    temp.name=ob1.name+ob2.name;
    temp.score=ob1.score+ob2.score;
    return temp;

}
int main(int argc, char *argv[])
{
     Person lucy(100,"lucy", 88.8f);
     Person bob(101,"bob", 99.9f);
     Person tom(102,"tom", 77.7f);

     cout<<lucy+bob+tom<<endl;
     return 0;
}

5、重载加法运算符+（成员函数实现 推荐）

#include <iostream>
#include<string>
using namespace std;
class Person{
    friend ostream& operator<<(ostream &out,Person ob );
    friend istream& operator>>(istream &in,Person &ob);
private:
    int  num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score):num(num),name(name),score(score){

    }
//成员函数实现重载
  Person operator +(Person ob2){
      Person temp;
      temp.num=this->num+ob2.num;
      temp.name=this->name+ob2.name;
      temp.score=this->score+ob2.score;
      return temp;

  }


};
//返回cout的引用类型（可以链式输出）
ostream& operator<<(ostream &out,Person ob ){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score;
    return out;
}
istream &operator>>(istream &in,Person &ob){
in>>ob.num>>ob.name>>ob.score;
return in;
}

int main(int argc, char *argv[])
{
     Person lucy(100,"lucy", 88.8f);
     Person bob(101,"bob", 99.9f);
     Person tom(102,"tom", 77.7f);

     cout<<lucy+bob+tom<<endl;
     return 0;
}

6、重载==运算符（成员函数实现 推荐）

#include <iostream>
#include<string>
using namespace std;
class Person{
    friend ostream& operator<<(ostream &out,Person ob );
    friend istream& operator>>(istream &in,Person &ob);
private:
    int  num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score):num(num),name(name),score(score){

    }

  Person operator +(Person ob2){
      Person temp;
      temp.num=this->num+ob2.num;
      temp.name=this->name+ob2.name;
      temp.score=this->score+ob2.score;
      return temp;

  }
  //成员函数重载==运算符
  bool operator ==(Person &ob){
      if(num==ob.num&&name==ob.name&&score==ob.score){
          return true;
      }
      else{
          return false;
      }
  }


};
//返回cout的引用类型（可以链式输出）
ostream& operator<<(ostream &out,Person ob ){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score;
    return out;
}
istream &operator>>(istream &in,Person &ob){
in>>ob.num>>ob.name>>ob.score;
return in;
}

int main(int argc, char *argv[])
{
     Person lucy(100,"lucy", 88.8f);
//     Person bob(101,"bob", 99.9f);
          Person bob(100,"lucy", 88.8f);
if(lucy==bob){
cout<<"相等"<<endl;
}
else{

cout<<"不相等"<<endl;
}
     return 0;
}

7、重载++运算符

++a(前置++)，它就调用operator++(a),
a++（后置++），它就会去调用operator++(a,int)

案例1：重载后置++

类名称 operator++(int)
{
 old=//先保存旧的值
//自增++
 return old;//返回旧值
 }

#include <iostream>
#include<string>
using namespace std;
class Person{
    friend ostream& operator<<(ostream &out,Person ob );
    friend istream& operator>>(istream &in,Person &ob);
private:
    int  num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score):num(num),name(name),score(score){

    }

  Person operator +(Person ob2){
      Person temp;
      temp.num=this->num+ob2.num;
      temp.name=this->name+ob2.name;
      temp.score=this->score+ob2.score;
      return temp;

  }
  bool operator ==(Person &ob){
      if(num==ob.num&&name==ob.name&&score==ob.score){
          return true;
      }
      else{
          return false;
      }
  }

//后置++
  Person  operator ++(int a){
      Person old;
      old.num=num;
      old.name=name;
      old.score=score;

      num+=1;
      name+=name;
      score+=score;
      return old;
  }



};
//返回cout的引用类型（可以链式输出）
ostream& operator<<(ostream &out,Person ob ){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score;
    return out;
}
istream &operator>>(istream &in,Person &ob){
in>>ob.num>>ob.name>>ob.score;
return in;
}

int main(int argc, char *argv[])
{
    Person lucy(100,"lucy", 88.8f);
    Person bob;
     //先使用后++
     bob = lucy++;
     cout<<bob<<endl;
     cout<<lucy<<endl;
     return 0;
}

案例2：重载前置++

#include <iostream>
#include<string>
using namespace std;
class Person{
    friend ostream& operator<<(ostream &out,Person ob );
    friend istream& operator>>(istream &in,Person &ob);
private:
    int  num;
    string name;
    float score;
public:
    Person(){}
    Person(int num,string name,float score):num(num),name(name),score(score){

    }

  Person operator +(Person ob2){
      Person temp;
      temp.num=this->num+ob2.num;
      temp.name=this->name+ob2.name;
      temp.score=this->score+ob2.score;
      return temp;

  }
  bool operator ==(Person &ob){
      if(num==ob.num&&name==ob.name&&score==ob.score){
          return true;
      }
      else{
          return false;
      }
  }


  Person  operator ++(int a){
      Person old;
      old.num=num;
      old.name=name;
      old.score=score;

      num+=1;
      name+=name;
      score+=score;
      return old;
  }
//前置++
  Person operator ++(){
      num+=1;
      name+=name;
      score+=score;
      return *this;//返回自身的值
  }


};
//返回cout的引用类型（可以链式输出）
ostream& operator<<(ostream &out,Person ob ){
    out<<ob.num<<" "<<ob.name<<" "<<ob.score;
    return out;
}
istream &operator>>(istream &in,Person &ob){
in>>ob.num>>ob.name>>ob.score;
return in;
}

int main(int argc, char *argv[])
{
    Person lucy(100,"lucy", 88.8f);
     Person bob;
     //先++ 后使用
     bob = ++lucy;
     cout<<bob<<endl;
     cout<<lucy<<endl;
     // bob等于lucy
    
     return 0;
}

在这里插入图片描述

8、重载()运算符

重载（）运算符 一般用于 为算法 提供策略。

#include <iostream>
using namespace std;
class Print{
public:
    void operator()(char *str){
        cout<<str<<endl;
    }

};



int main()
{
    Print ob;
    //对象和()结合 触发operator()成员函数 调用
    ob("Hello World");
    //匿名成员
    Print()("hello world");
    return 0;
}

二、自定义string类

重载构造函数

#include <iostream>
#include<string.h>
using namespace std;

class MyString{

private:
    int  size;
    char *str;
public:
    MyString();//无参构造
    MyString(char *str);//带参构造
    MyString(const MyString &ob);//深拷贝
    ~MyString();//析构函数
};

MyString::MyString(){

    str=NULL;
    size=0;
}
MyString::MyString(char *str){
    size=strlen(str);
    this->str=new char[size+1];
    memset(this->str,0,size+1);
    strcpy(this->str,str);
}


MyString::MyString(const MyString &ob){
    size=ob.size;
    str=new char[size+1];
    memset(str,0,size+1);
    strcpy(str,ob.str);
    
}

MyString::~MyString(){
    if(str!=NULL){
        delete[]str;
        str=NULL;
    }
}

int main(int argc, char *argv[])
{

    return 0;
}

重载输入输出（全局函数实现）

设为友元函数

friend ostream& operator<<(ostream &out,MyString ob);
friend istream& operator >>(istream &in,MyString &ob);

全局函数实现

ostream& operator<<(ostream &out,MyString ob){
    out<<ob.str;
    return out;
}
istream& operator >>(istream &in,MyString &ob){
    char  buff[1024]="";
    cin>>buff;
    if(ob.str!=NULL){
        delete[]ob.str;
        ob.str=NULL;
    }
    ob.size=strlen(buff);
    ob.str=new char[ob.size+1];
    memset(ob.str,0,ob.size+1);
    strcpy(ob.str,buff);
    return in;
}

重载括号运算符

在这里插入图片描述
类中声明，类外定义

 char& MyString::operator [](int pos){
     if(pos<0||pos>=size){
         cout<<"元素位置不合法"<<endl;
         exit(-1);
     }
     return str[pos];
 }

重载+运算符

在这里插入图片描述

类外实现

 MyString MyString::operator +(MyString ob){
     MyString temp;
     temp.size=size+ob.size;
     temp.str=new char[temp.size+1];
    memset( temp.str,0,temp.size+1);
    strcpy(temp.str,str);
    strcat(temp.str,ob.str);
    return temp;

 }

 MyString MyString::operator +(char *str)
 {
     MyString temp;
     temp.size=this->size+strlen(str);
     temp.str=new char[temp.size+1];
     memset(temp.str,0,temp.size+1);
     strcpy(temp.str,this->str);
     strcat(temp.str,str);
     return temp;
 }

重载=赋值运算符（深拷贝）

在这里插入图片描述

 MyString &MyString::operator =(MyString ob)
 {
     if(this->str!=NULL){
         delete[]this->str;
         this->str=NULL;
     }
     this->size=ob.size;
     this->str=new char[this->size+1];
     memset(this->str,0,this->size+1);
     strcpy(this->str,ob.str);
     return *this;
 }
 
 MyString &MyString::operator =(char *str)
 {
     if(this->str!=NULL){
         delete[]this->str;
         this->str=NULL;
     }
     this->size=strlen(str);
     this->str=new char[this->size+1];
     memset(this->str,0,this->size+1);
     strcpy(this->str,str);
     return *this;
 }

重载>运算符

在这里插入图片描述

 bool MyString::operator>(MyString ob)
 {
     if(str==NULL||ob.str==NULL){
         exit(-1);
     }
     if(strcmp(this->str,ob.str)>0){
         return  true;
     }
     else{
         return false;
     }
 }



 bool MyString::operator >(char *str)
 {
     if(str==NULL||this->str==NULL){
         exit(-1);
     }
     if(strcmp(this->str,str)>0){
         return  true;
     }
     else{
         return false;
     }
 }

三、智能指针

智能指针：解决 堆区空间的对象释放问题

前言：

#include <iostream>
using namespace std;
class Data{
public:
    Data(){
        cout<<"无参构造"<<endl;
    }
    ~Data(){
        cout<<"析构函数"<<endl;
    }
    void func(){
        cout<<"func函数"<<endl;
    }
};



int main()
{
    Data *ob=new Data();//通过new申请堆区空间


    return 0;
}

结果：只打印了无参构造，并没有调用析构函数

无参构造

设置智能指针

#include <iostream>
using namespace std;
class Data{
public:
    Data(){
        cout<<"无参构造"<<endl;
    }
    ~Data(){
        cout<<"析构函数"<<endl;
    }
    void func(){
        cout<<"func函数"<<endl;
    }
};

class SmartPointer{

private:
    Data *p;
public:
    SmartPointer(){}
    SmartPointer(Data *p){
        this->p=p;
    }
    ~SmartPointer(){
        delete p;
    }


};

int main()
{
    SmartPointer ob(new Data);


    return 0;
}


无参构造
析构函数

结果是调用了析构函数，运用的原理就是生命周期

我们在类中

    //重载*运算符
    Data& operator*(){
        return *p;
    }
    //重载->运算符
    Data* operator->(){
        return p;
    }

#include <iostream>
using namespace std;
class Data{
public:
    Data(){
        cout<<"无参构造"<<endl;
    }
    ~Data(){
        cout<<"析构函数"<<endl;
    }
    void func(){
        cout<<"func函数"<<endl;
    }
};

class SmartPointer{

private:
    Data *p;
public:
    SmartPointer(){}
    SmartPointer(Data *p){
        this->p=p;
    }
    ~SmartPointer(){
        delete p;
    }

    //重载*运算符
    Data& operator*(){
        return *p;
    }
    //重载->运算符
    Data* operator->(){
        return p;
    }

};

int main()
{
    SmartPointer ob(new Data);

//访问通过SmartPointer访问p
    ob.operator *().func();
    ob.operator->()->func();

    (*ob).func();
    ob->func();
    return 0;
}
白小筠
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java高级知识及类和对象知识
04-29
java高级知识及类和对象知识
第四章-Java类和对象的高级特征-重庆工商大学PPT优秀资料.ppt
11-13
Java类和对象的高级特征 Java类和对象的高级特征是Java编程语言的核心概念之一，涵盖了抽象类、接口、包等高级特征。 抽象类 抽象类是Java语言中的一种特殊的类，它使用abstract关键字来修饰。抽象类可以包含抽象...
JAVA类和对象的高级特征.doc
06-10
"JAVA类和对象的高级特征" 本资源主要讲述了Java语言中面向对象的高级特征，包括抽象类、接口和包的特性。通过本资源的学习，同学们可以使用Java语言中较为深入的技术编写面向对象程序。 知识点： 4.1 抽象类 * ...
第十章 类与对象
01-07
- 类是用于描述一组具有相似特性和行为的对象的模板或蓝图。 - 类定义了对象的结构和行为。它包括数据成员（即对象的状态）和成员函数（即对象的行为）。 - 例如，`int` 类型在 C++ 中虽然是基本类型，但从面向对象...
C#编程自学之类和对象
09-03
面向对象编程（OOP）是C#的核心，它的基础是类和对象。 1. **类与对象的概念** - **类**：类是面向对象编程中的基本构造块，它是一个模板或蓝图，定义了一组特性和行为。在C#中，类通过关键字`class`声明。类可以...
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 245
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法日记day 45（单调栈之每日温度|接雨水）
最新发布
m0_74980681的博客
08-22 385
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
四十一、【人工智能】【机器学习】- Bayesian Logistic Regression算法模型
技术分享、程序员趣事、行业趋势等内容！
08-19 902
监督学习（Supervised Learning）是机器学习中的一种主要方法，其核心思想是通过已知的输入-输出对（即带有标签的数据集）来训练模型，从而使模型能够泛化到未见的新数据上，做出正确的预测或分类。在监督学习过程中，算法“学习”的依据是这些已标记的例子，目标是找到输入特征与预期输出之间的映射关系。Bayesian Logistic Regression是一种统计建模方法，它结合了Logistic回归的原理和贝叶斯统计的框架。
C语言——函数递归
2406_83392683的博客
08-18 399
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 651
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
noip2001数的划分
no_play_no_games的博客
08-18 205
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 489
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
湖北师范大学-Python程序设计-3.1 中国古代数学问题(project)
柠檬喝汽水的博客
08-19 710
唐朝时，一斗酒的斗所采用的度量是小斗，也就是4斤，当时一斤取值范围大约在500多到600克左右，换算一下可知唐朝一斗酒的重量取值范围在2000克到2400克左右。有一座八层宝塔，每一层都有一些琉璃灯，每一层的灯数都是上一层的二倍，已知共有 765 盏琉璃灯，计算并输出每层各有多少盏琉璃灯。输出不超过 n 且满足条件的物品个数 m，如果有多个解，则分行输出，每行一个解；第二行输出 2 个浮点数，依次为小鼠和大鼠打洞的距离，单位为尺，保留小数点后 1 位数字。一个浮点数 f，表示李白的酒壶原来有 f 斗酒。
最小区间00
青釉Oo的博客
08-21 291
最小区间
1087：级数求和
如果没有特别说明，c++都是基于GCC-4.9.2运行的
08-22 133
【代码】：1087：级数求和
代码随想录day46 647. 回文子串 516.最长回文子序列
weixin_45461296的博客
08-22 217
【代码】代码随想录day46 647. 回文子串 516.最长回文子序列。
【算法基础实验】排序-最小索引优先队列IndexMinPQ
Greyplayground
08-19 614
在算法和数据结构中，优先队列是一种特殊的队列数据结构，每个元素都有一个优先级。当你从优先队列中删除元素时，通常会删除具有最高（或最低）优先级的元素。在最小优先队列中，优先级最低的元素最先被删除。索引最小优先队列 是优先队列的一种变体，允许你通过索引（或键）快速地更新、插入、删除和访问最小元素。它的典型应用包括网络流、图算法（如Dijkstra最短路径算法）等。该代码实现了一个索引最小优先队列，支持插入、删除最小元素、更改优先级等操作，并用堆结构来高效地实现这些操作。
贪心算法3
2301_79555067的博客
08-14 936
贪心算法leetcode题解包括：134. 加油站 135. 分发糖果 860.柠檬水找零 406.根据身高重建队列
华为OD机试-We Are A Team（Java&Python&C++）100%通过率，最新E卷题目
qq_52994629的博客
08-18 146
华为od机考题目，100%通过率
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值