运算符重载（二）

最新推荐文章于 2022-10-22 22:39:36 发布
最新推荐文章于 2022-10-22 22:39:36 发布
阅读量73 收藏
点赞数 1
分类专栏： 编程语言 文章标签： c++ 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/COOL_jack/article/details/119053980
版权

目录

++运算符重载

前置++运算符重载

1.成员函数的方式重载，原型为：
	函数原型 & operator ++();
	
2.友元函数的方式重载，原型为：
	friend 函数原型 & operator  ++(类类型 &);

后置自增和后置自减的重载

1.成员函数的方式重载，原型为：
	函数原型 operator ++(int);
	
2.友元函数的方式重载，原型为：
	friend 函数原型 operator  ++(类类型 &, int);

Interger.h

#pragma once

class Interger
{
public:
	Interger(int n);
	Interger(const Interger& other);
	~Interger();
	void Display() const;

	Interger& operator++();

	Interger operator++(int);
private:
	int n_;
};

Interger.cpp

#include "Interger.h"
#include <iostream>

using namespace std;

Interger::Interger(int n) : n_(n)
{
	cout << "Interger..." << endl;
}

Interger::Interger(const Interger& other)
{
	n_ = other.n_;
	cout << "copy Interger..." << endl;
}

Interger::~Interger()
{
	cout << "~Interger..." << endl;
}

void Interger::Display() const
{
	cout << n_ << endl;
}

Interger& Interger::operator++()	//	前置++
{
	++n_;
	return *this;
}

Interger Interger::operator++(int)		//	后置++
{
	Interger tmp(n_);
	n_++;
	return tmp;
}

main

#include "Interger.h"
#include <iostream>

using namespace std;

int main()
{
	Interger n(100);
	n.Display();

	Interger n2 = ++n;
	n.Display();
	n2.Display();

	Interger n3 = n++;
	n.Display();
	n3.Display();

	return 0;
}

在这里插入图片描述

赋值运算符重载

String.h

#pragma once
class String
{
public:

        explicit String(const char* str = "");
        String(const String& other);
        String& operator=(const String& other);
        String& operator=(const char* str);
        ~String();

        void Display() const;
private:
        char* str_;
        char* AllocAndCopy(const char* str);
};

String.cpp

#include "String.h"
#include <iostream>
#include <string.h>

using namespace std;

String::String(const char* str)
{
        str_ = AllocAndCopy(str);
}

String::String(const String& other)
{
        str_ = AllocAndCopy(other.str_);
}

String& String::operator=(const String& other)
{
        if (this == &other)     return *this;

        delete[] str_;

        str_ = AllocAndCopy(other.str_);
        
        return *this;
}

String& String::operator=(const char* str)
{
        delete[] str_;

        str_ = AllocAndCopy(str);
        return *this;
}

String::~String()
{
        delete[] str_;
}

char* String::AllocAndCopy(const char* str)
{
        int len = strlen(str) + 1;
        char* newstr = new char[len];
        memset(newstr, 0, sizeof(newstr));

        strncpy(newstr, str, len);

        return newstr;
}

void String::Display() const
{
        cout << str_ << endl;
}

main

#include "String.h"
#include <iostream>
using namespace std;

int main()
{
        String s1("AAA");
        s1.Display();

        String s2("BBB");
        s2.Display();

        String s3 = s2;
        s3.Display();

        String s4(s1);
        s4.Display();

        String s5;
        s5.Display();

        s5 = "xxxxxx";
        s5.Display();


        return 0;
}

运行结果：
在这里插入图片描述

!运算符重载

字符串为空，返回false；字符串不为空，返回true。

String.h

#pragma once
class String
{
public:

        explicit String(const char* str = "");
        String(const String& other);
        String& operator=(const String& other);
        String& operator=(const char* str);	//	xxxxxx
        bool operator!() const;
        ~String();

        void Display() const;
private:
        char* str_;
        char* AllocAndCopy(const char* str);
};

String.cpp

bool String::operator!() const
{
        return (strlen(str_) != 0);
}

test.cpp

		String s6;
        bool notempty;
        notempty = !s6;
        cout << notempty << endl;

        String s7("aaaaaa");
        notempty = !s7;
        cout << notempty << endl;

在这里插入图片描述

[]运算符重载

+运算符重载

+=运算符重载

流运算符

1.C++的I/O流库的一个重要特性就是能够支持新的数据类型的输出和输入。

2.用户可以通过对插入符（<<）和提取符（>>）进行重载来支持新的数据类型。

3.流运算符的重载只能使用友元函数进行重载（二元操作运算符）。

4.	friend istream& operator >>(istream&, 类类型&);

5.	friend ostream& operator <<(ostream&, const 类类型&);

<<运算符重载

>>运算符重载

String.h

#pragma once

#include <iostream>
using namespace std;

class String
{
public:
        /*explicit*/ String(const char* str = "");
        String(const String& other);
        String& operator=(const String& other);
        String& operator=(const char* str);
        bool operator!() const;
        char& operator[](unsigned int index);
        const char& operator[](unsigned int index) const;

        friend String operator+(const String& s1, const String& s2);
        String& operator+=(const String& other);

        friend istream& operator>>(istream& is, String& str);
        friend ostream& operator<<(ostream& os, const String& str);
        ~String();

        void Display() const;
private:
        char* str_;
        char* AllocAndCopy(const char* str);
};

String.cpp

#include "String.h"
#include <string.h>

String::String(const char* str)
{
	str_ = AllocAndCopy(str);
}

String::String(const String& other)
{
	str_ = AllocAndCopy(other.str_);
}

String& String::operator=(const String& other)
{
	if (this == &other)	return *this;

	delete[] str_;

	str_ = AllocAndCopy(other.str_);

	return *this;
}

String& String::operator=(const char* str)
{
	delete[] str_;
        
        str_ = AllocAndCopy(str);
	return *this;
}

bool String::operator!() const
{
	return (strlen(str_) != 0);
}

char& String::operator[](unsigned int index)
{
	//return str_[index];
	//non const version 调用const version
	return const_cast<char &>(static_cast<const String&>(*this)[index]);
}

const char& String::operator[](unsigned int index) const
{
	return str_[index];
}

String operator+(const String& s1, const String& s2)
{
/*
	int len = strlen(s1.str_) + strlen(s1.str_) + 1;
	char* newstr = new char[len];
	memset(newstr, 0, sizeof(newstr));
	strncpy(newstr, s1.str_, strlen(s1.str_));
	strcat(newstr, s2.str_);

	String tmp(newstr);
	delete newstr;
	return tmp;
*/

	String str = s1;
	str += s2;
	return str;
}

String& String::operator+=(const String& other)
{
	int len = strlen(str_) + strlen(other.str_) + 1;
	char* newstr = new char[len];
	memset(newstr, 0, sizeof(newstr));
	strncpy(newstr, str_, strlen(str_));
	strcat(newstr, other.str_);

	delete [] str_;
	str_ = (newstr);
	return *this;
}


String::~String()
{
	delete[] str_;
}

char* String::AllocAndCopy(const char* str)
{
	int len = strlen(str) + 1;
	char* newstr = new char[len];
	memset(newstr, 0, sizeof(newstr));

	strncpy(newstr, str, len);

	return newstr;
}

void String::Display() const
{
	cout << str_ << endl;
}

istream& operator>>(istream& is, String& str)
{
	char tmp[1024];
	cin >> tmp;
	str = tmp;	
	return is;
}

ostream& operator<<(ostream& os, const String& str)
{
	os << str.str_;	
	return os;
}

main

#include "String.h"

int main()
{
	String s1("AAA");
	s1.Display();

	String s2("BBB");
	s2.Display();

	String s3 = s2;
	s3.Display();

	String s4(s1);
	s4.Display();

	String s5;
	s5.Display();
	
	s5 = "xxxxxx";
	s5.Display();

	String s6;
	bool notempty;
	notempty = !s6;
	cout << notempty << endl;

	String s7("abcdefg");
	notempty = !s7;
	cout << notempty << endl;

	char ch = s7[2];
	cout << ch << endl;

	s7[2] = 'A';
	s7.Display();

	const String s8("uvwxyz");
	ch = s8[2];
	//s8[2] = 'M';	//	可以更改对象，存在隐患，所以返回const引用，使得编译不过
	s8.Display();

	s7.Display();
	s8.Display();
	String s9 = s7 + s8 + "23333" + "55556666";
	s9.Display();

	String s10 = "99999999";	//不声明为explicit可以使用	
	s10.Display();


	s9 += s10;
	s9.Display();
	
	cout << s9 << endl;
	
	String s11;
	cin >> s11;
	cout << s11 << endl;
	return 0;
}

运行结果：
在这里插入图片描述

jack学编程
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
运算符（一元 二元）
Martinti的博客
05-25 1558
运算符（一元 二元）
二元运算符重载
鬼谷子的博客
03-21 875
接上一篇：https://blog.csdn.net/weixin_43217963/article/details/88702153 二元运算符重载 二元运算符即有两个操作数参与运算。例如：+加号、<<等等。 以下展示两个较为典型的例子。 这里以“+”加号为例： “+”的重载，有友元函数重载（友元函数作为全局函数对其进行重载）和成员函数重载（定义一个类的成员函数）两种。 友元函数重载...
运算符重载2
qq_33858808的博客
05-11 51
#include<iostream> #include<string> #include<vector> using namespace std; #include<algorithm> #include<functional> #include<ctime> //重载递增运算符 class MyInteger { friend ostream& operator<<(ostream& cout,
C++进阶学习——（第八天）运算符重载2
JH_joker的博客
04-05 1103
前面我们说了加法运算符和左移运算符重载，本文讲继续讲解递增、赋值、关系和函数调用运算符重载。 递增运算符重载作用：通过重载递增运算符，实现自己的整型数据。 我们知道递增分为前置++和后置++，因此我们在重载时也要区分他们，前置使用operator++()，而且最后返回的是一个引用，而后置++则是operator++(int)，这个地方的int，就是我们前面所讲的占位参数，最后返回的是一个值，我们以此来区分前置和后置，下面来看示例。 示例1： #include<iostream> usi
运算符重载运算符重载
10-31
C++类的运算符重载，包括 = ++ -- -(负号运算符) + - * / % == != < > <= >= << >>
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
python 运算符重载
最新发布
10-10
运算符重载 以Rational class 为例，重载运算符 a/b a//b a += b a == b a a > b a != b a a >= b
复数运算符重载
03-26
在C#编程语言中，运算符重载是一种特殊的技术，允许程序员为自定义类型赋予标准运算符的新含义。当我们创建一个表示复数的类时，为了使得复数的加法、减法、乘法和除法等操作直观易用，就需要重载相应的运算符。复数...
运算符重载
01-08
加法运算符重载+ 乘法运算符与其相似这里就不举例子了 加法运算符的例子： #include using namespace std; class A{ public: A operator+(A &p) { A t; t.a=this->a+p.a; return t; } int a; }; int ...
c++文件操作
COOL_jack的博客
10-22 918
c++文件操作基础知识
c++11并发与多线程
COOL_jack的博客
11-07 566
第五节 互斥量概念、用法、死锁演示及解决详解 （1）互斥量（mutex）的基本概念 （2）互斥量的用法 （2.1）lock(),unlock() （2.2）std::lock_guard类模板 （3）死锁 （3.1）死锁演示 （3.2）死锁的一般解决方案 （3.3）std::lock()函数模板 （3.4）std::lock_guard的std::adopt_lock参数 第六节 unique_lock详解 （1）unique_lock取代lock_guard unique_lock是一个类模板，工作中
C++语言--类与对象（一）
COOL_jack的博客
06-23 353
目录类声明公有、私有、保护成员数据抽象和封装内联成员函数内联函数内联函数与带参数宏的区别新的类型转换运算符成员函数的重载及其缺省参数类与结构体隐含的this指针 类声明 公有、私有、保护成员 1.在关键字public后面声明，它们是类与外部的接口，任何外部函数都可以访问公有类型数据和函数。 2.在关键字private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。 3.在关键字protected后面声明，与private类似，其差别表现在继承与派生时对派生类的影响不同。 数据抽象和封装 内
static与单例模式
COOL_jack的博客
07-24 270
目录static与单例模式演示1演示2线程安全的单例模式类的实现 static与单例模式 1.保证一个类只有一个实例，并提供一个全局访问点 2.禁止拷贝 演示1 #include <iostream> using namespace std; class Singleton { public: static Singleton* GetInstance() { if (instance_ == NULL) { instance_ = new Singleton; }
boost智能指针
COOL_jack的博客
07-08 244
目录scoped_ptrshared_ptrshared_ptr与STL循环引用解决办法（打破循环引用）1 手动打破循环引用2 弱引用weak_ptrscoped_array/shared_array scoped_ptr 代码： #include <iostream> #include <boost/scoped_ptr.hpp> using namespace std; class X { public: X() { cout << "X..." <&lt
构造函数与析构函数（四）---深拷贝与浅拷贝
COOL_jack的博客
07-23 216
目录深拷贝与浅拷贝浅拷贝String.hString.cppmain深拷贝String.hString.cppmain赋值操作深拷贝String.hString.cppmain禁止拷贝空类默认产生的成员 深拷贝与浅拷贝 浅拷贝 String.h #ifndef _STRING_H #define _STRING_H class String { public: String(const char* str = nullptr); ~String(); void Display(); private
虚函数与多态（一）
COOL_jack的博客
07-26 213
这里写目录标题多态静态绑定与动态绑定虚函数虚析构函数虚表指针基类派生类object slicing与虚函数overload、override、overwrite 多态 1.多态性是面对对象程序设计的重要特征之一。 2.多态性是指发出同样的消息被不同类型的对象接收时可能导致完全不同的行为。 3.多态的实现： 3.1函数重载 3.2运算符重载 3.3模板 3.4虚函数 静态绑定与动态绑定 1.静态绑定 绑定过程出现在编译阶段，在编译期就已经确定要调用的函数。 2.动态绑定 绑定过程工作在程
Array.pptx（运算符重载，二分查找和倍增）
06-09
在这份文档中，主要介绍了关于数组的运算符重载、二分查找和倍增的内容。首先，提及了一个名为Array.pptx的文件，其中包含了关于运算符重载、二分查找和倍增的相关知识。 运算符重载是一种使数组能够进行各种操作的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值