c++操作符重载与友元函数 单目 双目 左移右移 ==号操作符重载 自定义数组

最新推荐文章于 2022-11-24 00:33:59 发布
最新推荐文章于 2022-11-24 00:33:59 发布
阅读量304 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/user_define_race/article/details/73196227
版权 
#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;


class Complex
{
public:
	Complex(int a, int b) {
		this->a = a; 
		this->b = b;
	}

	void printC()
	{
		cout << "(" << this->a << "+" << this->b << "i" << ")"<<endl;//(1+2i)
	}



	Complex AddComplex(Complex &another)
	{
		Complex temp(this->a + another.a, this->b + another.b);

		return temp;
	}

	Complex operator+(Complex &another)
	{
		Complex temp(this->a + another.a, this->b + another.b);

		return temp;
	}

	friend Complex AddComplex(Complex&c1, Complex &c2);
	//friend Complex operator+(Complex &c1, Complex &c2);

private:
	int a;//实数
	int b;//虚数
};

//全局

Complex AddComplex(Complex&c1, Complex &c2)
{
	Complex temp(c1.a + c2.a, c1.b + c2.b);

	return temp;
}

//operator 操作符重载的关键字
#if 0
Complex operator+(Complex &c1, Complex &c2)
{
	Complex temp(c1.a + c2.a, c1.b + c2.b);

	return temp;
}
#endif




int main(void)
{
	Complex c1(1, 2);
	Complex c2(2, 3);




	//Complex c3 = AddComplex(c1, c2);
	//Complex c3 = c1.AddComplex(c2);
	//Complex c3 = operator+(c1, c2); 调用全局的方式
	//Complex c3 = c1.operator+(c2); 调用成员的方式
	Complex c3 = c1 + c2;

	c3.printC();


	return 0;
}



双目运算符


#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

class Complex
{
public:
	Complex(int a, int b) {
		this->a = a;
		this->b = b;
	}

	void printC()
	{
		cout << "(" << this->a << "+" << this->b << "i" << ")" << endl;//(1+2i)
	}

	//friend Complex & operator+=(Complex &c1, Complex &c2);
	//friend Complex & operator-=(Complex &c1, Complex &c2);

	Complex & operator+=(Complex &another)
	{
		this->a += another.a;
		this->b += another.b;

		return *this;
	}

	Complex &  operator-=(Complex &another)
	{
		this->a -= another.a;
		this->b -= another.b;

		return *this;
	}

private:
	int a;//实数
	int b;//虚数
};

//全局
#if 0
Complex & operator+=(Complex &c1, Complex &c2)
{
	c1.a += c2.a;
	c1.b += c2.b;

	return c1;
}

Complex &operator-=(Complex &c1, Complex &c2)
{
	c1.a -= c2.a;
	c1.b -= c2.b;

	return c1;
}
#endif

int main(void)
{
	
	Complex c1(1, 2);
	Complex c2(2, 4);

	//c2 += c1; operator+=（c2, c1)
	(c1 += c2) += c2; //(  c1.operator+=(c2) ).operator+=(c2)
	//c1 += c2;       // operator+=( ( opertor+=(c1,c2) ), c2)

	c1.printC();


	(c1 -= c2)-=c2;

	c1.printC();


	return 0;
}

单目运算符 

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

class Complex
{
public:
	Complex(int a, int b) {
		this->a = a;
		this->b = b;
	}

	void printC()
	{
		cout << "(" << this->a << "+" << this->b << "i" << ")" << endl;//(1+2i)
	}
	//friend Complex & operator++(Complex &c);
	//friend const  Complex  operator++(Complex &c, int);

#if 1

	//前++
	Complex & operator++()
	{
		this->a++;
		this->b++;

		return *this;
	}

	//后++
	const Complex operator++(int)
	{
		Complex temp(this->a, this->b);
		this->a++;
		this->b++;

		return temp;
	}
#endif

private:
	int a;//实数
	int b;//虚数
};


//全局的  前++ ,如果直接重载++ 默认是重载   前++ 运算符
#if 0
Complex & operator++(Complex &c)
{
	c.a++;
	c.b++;

	return c;
}
//想制定后 ++ 运算  后--
const Complex operator++(Complex &c, int) //亚元  用来区分 前++ 和 后++ 的接口的不同
{
	Complex temp(c.a, c.b);
	c.a++;
	c.b++;

	return temp;
}
#endif


int main(void)
{


	Complex c1(1, 2);


	c1++++;

	c1.printC();

	return 0;
}

左移右移运算符 


#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

class Complex
{
public:
	Complex(int a, int b) {
		this->a = a;
		this->b = b;
	}

	void printC()
	{
		cout << "(" << this->a << "+" << this->b << "i" << ")" << endl;//(1+2i)
	}


	friend ostream & operator<<(ostream & os, Complex &c);
	friend istream & operator>>(istream &is, Complex &c);


	//重载<<运算符 不能够写在成员函数中， 否则的只能c1<<cout 反向调用 ， 语义不通
#if 0
	ostream & operator<<(ostream &os)
	{
		os << "(" << this->a << "+" << this->b << "i" << ")";
		return os;
	}
#endif

private:
	int a;//实数
	int b;//虚数
};

#if 1
ostream & operator<<(ostream & os, Complex &c)
{
	os << "(" << c.a << "+" << c.b << "i" << ")";

	return os;
}

istream & operator>>(istream &is, Complex &c)
{
	cout << "a:";
	cin >> c.a;
	cout << "b:";
	cin >> c.b;

	return is;
}
#endif

int main(void)
{
	Complex c1(1, 2);
	

	cin >> c1;

	cout << c1 << endl;


	//cout << a << endl; // operator<<(cout, int);
	 // operator<<(cout, c1)

	//cout << c1;//cout.operator<<(c1)
				//c1.operator<<(cout)
	//c1 << cout; 

	return 0;
}


==号操作符重载i

#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;

class Student
{
public:

	Student()
	{
		this->id = 0;
		this->name = NULL;
	}

	Student(int id, char *name)
	{
		this->id = id;

		//求出name的长度
		int len = strlen(name);
		this->name = new char[len + 1];
		strcpy(this->name, name);
	}

	Student(const Student &another)
	{
		this->id = another.id;

		//name 深拷贝
		int len = strlen(another.name);
		this->name = new char[len + 1];
		strcpy(this->name, another.name);
	}

	Student& operator=(const Student &  another)
	{
		//1 判断是否是自身赋值
		if (this == &another) {
			return *this;
		}

		//2 回收之前应该释放的内存
		if (this->name != NULL) {
			//原理name 有额外的内存，需要释放
			delete[] this->name;
			this->name = NULL;
			this->id = 0;
		}

		//3 再执行深拷贝
		this->id = another.id;

		int len = strlen(another.name);
		this->name = new char[len + 1];
		strcpy(this->name, another.name);


		//4 返回自身
		return *this;
	}


	void printS() {
		cout << "id = " << this->id << ", name = " << this->name << endl;
	}



	~Student() {
		if (this->name != NULL) {
			delete[]this->name;
			this->name = NULL;
			this->id = 0;
		}
	}
private:
	int id;
	char *name;
};

int main(void)
{
	Student s1(10, "zhang3");

	Student s2 = s1;//s2的拷贝构造函数 Studetn s2(s1)

	s2.printS();

	Student s3(10, "li4");


	
	s3 = s1; //s3.operator=(s1); //会有一个默认的operator= 函数

	s3.printS();

	
	return 0;
}


自定义数组

#pragma once
#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>

using namespace std;



//int 类型的数组类
class MyArray
{
public:
	MyArray();
	MyArray(int len);
	~MyArray();
	MyArray(const MyArray & another);

	void setData(int index, int value);
	int getData(int index) const;

	int getLen() const
	{
		return this->len;
	}
	
	//  = 号 重载
	MyArray & operator=(const MyArray &another);

	// [] 重载
	int& operator[](int index) const;

	// <</ >> 重载

	friend ostream& operator<<(ostream &os,const MyArray &array);
	friend istream& operator>>(istream &is, MyArray &array);

	// == !=
	bool operator==(MyArray &another);
	bool operator!=(MyArray &another);

private:
	int len; //这个连续数组空间目前能够存放的元素个数
	int *space; //space 在堆上开辟连续数组空间的首地址
};




#include "MyArray.h"


MyArray::MyArray()
{
	this->space = NULL;
	this->len = 0;
}

MyArray::MyArray(int len)
{
	if (len <= 0) {
		this->len = 0;
		return;
	}
	else {
		this->len = len;

		//给space 开辟内存
		this->space = new int[this->len];

		cout << "调用了数组有参构造函数MyArray(int len)" << endl;
	}
}

MyArray::MyArray(const MyArray & another)
{
	if (another.len >= 0)
	{
		this->len = another.len;

		//深拷贝
		this->space = new int[this->len];
		for (int i = 0; i < this->len; i++)
		{
			this->space[i] = another.space[i];
		}

		cout << "执行了拷贝构造函数MyArray(const MyArray & another)" << endl;
	}
}

MyArray::~MyArray()
{
	//目的是释放 array 额外开辟的space空间
	if (this->space != NULL)
	{
		delete[] this->space;
		this->len = 0;
		this->space = NULL;
	}
	cout << "调用了数组的析构函数~MyArray()" << endl;
}


void MyArray::setData(int index, int value)
{
	if (this->space != NULL)
	{
		this->space[index] = value;
	}
}

int MyArray::getData(int index) const
{
	return this->space[index];
}

MyArray & MyArray::operator=(const MyArray &another)
{
	//判断是否是自身赋值
	if (this == &another) {
		return *this;
	}

	//回收之前的数据
	if (this->space != NULL) {
		delete[] this->space;
		this->space = NULL;
		this->len = 0;
	}

	//深拷贝
	if (another.len > 0) {
		this->len = another.len;

		this->space = new int[this->len];
		for (int i = 0; i < this->len; i++) {
			this->space[i] = another.space[i];
		}
	}

	cout << "执行了 operator=操作符" << endl;

	return *this;
}

int& MyArray::operator[](int index) const
{
	return this->space[index];
}


//全局函数
//如果一个const修饰的对象，或者const修饰的对象指针， 如果通过这个对象 调用对象的成员方法。
//那么这个成员方法的this指针一定要是const类型的。
ostream& operator<<(ostream &os, const MyArray &array)
{
	os << "遍历整个数组" << endl;

	//MyArray*this =  (MyArray*)&array;
	//int getLen(const MyArray *this) // this = &array;
	// getLen() const
	array.getLen();// getLen(&array)
	//array.getLen();//getLen(&array); const MyArray*const this = &array;
	for (int i = 0; i < array.getLen(); i++) {
		//os << array[i]  << endl; //array.operator[](i)
		os << array.getData(i) << endl;
	}

	os << "调用了 《《 重载" << endl;


	return os;
}

 istream& operator>>(istream &is, MyArray &array)
{
	 cout << "请输入 " << array.len << "个数" << endl;

	 for (int i = 0; i < array.len; i++) {
		 cin >> array[i];
	 }

	 return is;
}

 bool MyArray::operator==(MyArray &another)
 {
	 if (this->len != another.len) {
		 return false;
	 }
	 else {
		 for (int i = 0; i < this->len; i++) {
			 if (this->space[i] != another.space[i]) {
				 return false;
			 }
		 }
		 return true;
	 }
 }

 bool MyArray::operator!=(MyArray &another)
 {
	 return !(*this == another);
 }


#define  _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include "MyArray.h"

using namespace std;

int main(void)
{
	MyArray array1(10);

	
	array1[0]= 10;  //array1.operator[](0)--->array1.space[0] = 10;

	cin >> array1;



	cout << array1 << endl; // operator<<(cout, array1) 

	MyArray array2 = array1; //Myarray array2(array1);

	cout << array2 << endl;

	cout << " ----- " << endl;

	MyArray array3;

	array3 = array2;


	cout << array3 << endl;

	if (array1 != array3) { // array1.operator==(array2)
		cout << "不等" << endl;
	}
	else {
		cout << "想等" << endl;
	}

	return 0;
}























user_define_race
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 左移右移操作符重载
一个正在路上的学生
06-22 1742
#include &lt;iostream&gt; using namespace::std; class MyClass { public: MyClass(int a, int b) { this-&gt;a = a; this-&gt;b = b; } void print_Myclass() { co...
C语言左移操作符(＜＜)、右移操作符（＞＞）以及按位取反单目操作符(~)讲解
weixin_53811859的博客
12-08 1375
手把手带你拿捏C语言左移操作符(
C语言学习之路（基础篇）—— 内存管理
最新发布
cdtaogang's blog
11-24 978
类型作用域生命周期存储位置auto变量一对{}内当前函数栈区static局部变量一对{}内整个程序运行期初始化在data段，未初始化在BSS段extern变量整个程序整个程序运行期初始化在data段，未初始化在BSS段static全局变量当前文件整个程序运行期初始化在data段，未初始化在BSS段extern函数整个程序整个程序运行期代码区static函数当前文件整个程序运行期代码区register变量一对{}内当前函数运行时存储在CPU寄存器字符串常量。
Array类及其重载的运算符
SS
08-06 1084
Array.h #ifndef ARRAY_H #define ARRAY_H #include using namespace std; class Array { friend ostream &operator<<(ostream &,const Array &); friend istream &operator>>(istream &,Array &); public: Arra
cpp代码-结构体运算符重载
07-16
注意，为了保持非成员操作符的左右操作数都能是`Complex`对象，我们通常会将一个运算符重载为成员函数，另一个为友元函数。 除了成员函数，我们还可以使用友元函数来重载运算符： ```cpp friend Complex operator+...
2.14_C++.docx
03-26
5. **位运算**：C++支持位运算，包括按位与(&)，按位或(|)，按位异或(^)，按位非(~)，左移()和右移(>>),这些在低级别编程，如硬件接口编程中很有用。 6. **运算符优先级**：理解并掌握运算符的优先级有助于写出准确...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
*3.4.1 输入流与输出流的基本操作 *3.4.2 在输入流与输出流中使用控制符 3.4.3 用getchar和putchar函数进行字符的输入和输出 3.4.4 用scanf和printf函数进行输入和输出 3.5 编写顺序结构的程序 3.6 关系运算和逻辑...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar )
06-13
*3.4.1 输入流与输出流的基本操作 *3.4.2 在输入流与输出流中使用控制符 3.4.3 用getchar和putchar函数进行字符的输入和输出 3.4.4 用scanf和printf函数进行输入和输出 3.5 编写顺序结构的程序 3.6 关系运算和逻辑...
文件缓冲区刷新规则
user_define_race的专栏
04-22 1187
c语言基础总结
user_define_race的专栏
05-22 591
零： 声明、定义、初始化： 声明：前面加上 extern, 表示变量或函数在其他文件中定义了。 extern int a; // 前面加上了extern extern int func(int a, double b); // extern 可置于变量和函数前面，表示变量或者函数的定义是在其他文件中， // 提示编译器遇到这个变量或者函数的时候，在其他文件/模块中寻找它的定义
realloc动态数组以及作用域
user_define_race的专栏
04-20 567
#include #include #define SIZE 20 int *p ; int m = SIZE; int n = 0;//多少个元素 int main(){ p = malloc(SIZE); scan_input(); printArray(); free(p); return 0; } void scan_input(){ //scanf("%d",p[]);
标识符的作用范围，变量的声明和定义,auto,register自动变量，代码作用域的静态变量
user_define_race的专栏
03-17 549
文件作用范围 int total; int max(); 作用范围：从声明的位置开始，到文件末尾 函数作用范围 程序块作用范围 函数原型作用范围 变量的声明 声明：给编译器看的，告知有这么一个变量，但是此变量是在别的文件里定义的。方便编译器做类型检测 extern int a;//正确的写法 extern 声明的关键字 定义：为变量要开辟内存空间 一个全局变量
录入学生信息排序fwrite fread 冒泡
user_define_race的专栏
05-02 536
#include #include #include #define N 2 struct STU { int id; char name[20]; char sex; int score; }; void show_stu(struct STU *s, int n) { int i; for (i = 0; i < n; i++)
二进制转换（负数的原码，反码，补码）
user_define_race的专栏
02-07 518
指针7题目
user_define_race的专栏
05-18 467
1. 利用随机函数获取十个1-100的整数并打印，然后再反序打印一遍。(通过指针获取下标的值) #include #include #include #define N 10 void func(int *num) // 形参 num 接收数组首地址 { srand((unsigned int)time(NULL)); // 设置系统时间为随机数种子 for (int i =
fseek 扩展文件
user_define_race的专栏
04-24 428
#include int main(void) { FILE *fp; fp = fopen("xxx.avi", "w"); fseek(fp, 4*1000*1000-1, SEEK_END); //必须跟一次写操作，才能真正的拓展文件 fputc('a', fp); fclose(fp); return 0; }
基本文件操作&fopen函数&FILE指针&ftell &fseek&rewind&fgets文件复制&feof
user_define_race的专栏
04-22 424
一行一行读取:   #include int main(){ FILE *file ; char buf[1024]; file = fopen("student.txt","r"); while(fgets(buf,sizeof(buf),file) !=NULL){ fputs(buf,stdout); } fclose(file); fclose(file);
stroke 文件 以及文件io返回值
user_define_race的专栏
05-02 353
#include #include int main(int argc, char *argv[]) { char buf[4096], *p, *delim = ",.\n;-()& "; //注意里面有一个空格 FILE *fp; if (argc < 2) { printf("./a.out filename\n"); retur

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值