友元函数与操作符重载入门+const修饰this指针

最新推荐文章于 2021-08-14 16:28:42 发布

隐无影

最新推荐文章于 2021-08-14 16:28:42 发布

阅读量886

点赞数

本文链接：https://blog.csdn.net/u011391093/article/details/42319785

版权

先对比一下成员函数与全局函数的区别

先对比下全局函数与普通的成员函数
#include<iostream>

class Test
{
public:
	//理解this指针的关键,站在测试程序的角度去思考
	//什么对象调用这个函数,this指针就是谁
	Test(int a, int b)//有参构造函数
	{
		this->a = a;
		this->b = b;
	}
	int getA()
	{
		return a;
	}
	int getB()
	{
		return b;
	}
public:
	Test add(Test&t2)//this指针指向一个对象
	{   
		this->a += t2.getA();
		this->b += t2.getB();

		return *this;   //*操作等于取指针地址,也就是
	}
	Test add2(Test&t2)//this指针指向一个对象
	{     //t3是局部变量,add调用完了就会销毁,所以需要拷贝一个对象,匿名对象
		Test t3(this->a+ t2.getA(),this->b+ t2.getA());
		return t3;//使用匿名对象返回
	}public:
	void printAB()
	{
		std::cout << "a=" << a << " " << "b=" << b << std::endl;
	}
protected:
private:
	int a;
	int b;
};
//全局函数
//结论如果把全局函数转成成员函数,少了一个操作数,通过this指针被隐藏
Test add(Test &t1, Test&t2)
{
	Test t3(t1.getA() + t2.getA(), t1.getB() + t2.getA());
	return t3;
}
//把成员函数转为全局函数,需要多一个参数
void printAB(Test *pthis)
{
	std::cout << "a=" << pthis->getA() << " " << "b=" << pthis->getB()<< std::endl;
}
void main()
{
	Test t1(1, 2);
	Test t2(3, 4);
	Test t3 = add(t1, t2);
	t1.add(t2);//相当于add(&t1,t2);
	t1.printAB();
	system("pause");
}

由之前我们可以看出成员函数有一个this指针,这个指针指向自己本身,一般编译器将this指针给隐藏起来

友元函数:关键字为friend

//friend 破坏了类的封装性。。。。
//friend关键字是一个关系户
//why 无奈之际 java class
//java---》1.class==》class==>java类
//java类的反射 sun jdk api

//cc++ 1预编译gcc -E 2汇编 gcc -i 3编译gcc -c 3、链接ld ===》汇编代码
//friend
//应用场景。。。。。
//const关键字冒牌货c
//register
//typedef 混号王

友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权

#include "iostream"
using namespace std;

class A1
{
public:
	A1()
	{
		a1 = 100;
		a2 = 200;
	}
	int getA1()
	{
		return this->a1;
	}
	//声明一个友元函数
	friend void setA1(A1 *p, int a1); //什么这个函数是这个类的好朋友
	
protected:
private:
	int a1;
	int a2;
};

void setA1(A1 *p, int a1)
{
	p->a1 = a1;
}
//friend 破坏了类的封装性。。。。
//friend关键字是一个关系户
//why 无奈之际 java class
//java---》1.class==》class==>java类
//java类的反射 sun jdk api

//cc++ 1预编译gcc -E 2汇编 gcc -i 3编译gcc -c 3、链接ld ===》汇编代码
//friend 
//应用场景。。。。。
//const关键字 冒牌货c
//register
//typedef 混号王 

void main11()
{
	A1 mya1;
	cout<<mya1.getA1()<<endl;
	setA1(&mya1, 300);
	cout<<mya1.getA1()<<endl;

	system("pause");
}

class A
{
	//b是a的好朋友	
	friend class B;
public:
	void display()
	{
		cout<<x<<endl;
	}

protected:
private:
	int x;
};

class B
{
public:
	void setA(int x)
	{
		Aobj.x = x;
	}
	void printA()
	{
		cout<<Aobj.x<<endl;
	}
protected:
private:
	A Aobj;

};

void main()
{
	B b1;
	b1.setA(100);
	b1.printA();
	system("pause");
}

运算符重载入门

1.为什么需要运算符重载

答:比如定义一个复数类,类的对象相加,编译器不知道如何进行加减,编译器给你提供了一种机制,让用于自己去完成,自定义类的加减操作

//这个机制就是运算符重载

#include "iostream"
using namespace std;

//a + bi //复数
class Complex
{
public:
	friend Complex operator+(Complex &c1, Complex &c2);//声明一个友元函数,
	Complex(int a, int b)
	{
		this->a = a;
		this->b = b;
	}
	void printCom()
	{
		cout<<a<<" + "<<b<<"i "<<endl;
	}

private:
	int a;
	int b;
};

/*
//通过全局函数完成对象加
Complex add(Complex &c1, Complex &c2)
{
	Complex c3(c1.a + c2.a, c1.b+c2.b);
	return c3;
}
*/
Complex operator+(Complex &c1, Complex &c2)//全局函数重载 这里operator+是一个关键字
{
	Complex c3(c1.a + c2.a, c1.b+c2.b);
	return c3;
}
void main()
{
	{
		int a = 0, b = 0;
		int c = a + b;
		//对于基础类型，编译已经知道如何进行加减
	}
	Complex c1(1, 2), c2(3, 4);
	//为什么要有运算符重载
	//原因 Complex是用户自定义类型。。编译器根本不知道如何进行加减。。。
	//编译器给你提供了一种机制，让用户自己去完成，自定义类型的加减操作。。。。。
	//这个机制就是运算符重载机制

	//Complex c3 = c1 + c2;

	//Complex c3 = add(c1, c2);
	//Complex c3 = operator+(c1, c2);


	Complex c3 = c1 + c2;
	c3.printCom();


	system("pause");
}

用2种方法实现运算符重载

//全局函数方法去实现操作符重载
//1 承认操作符重载是一个函数
//2 根据操作数，1个操作数 2个操作数，完成函数的参数
//3 根据函数原型，实现也需要业务

用类成员函数实现-运算符重载

#include "iostream"
using namespace std;

//a + bi //复数
class Complex
{
public:
	friend Complex operator+(Complex &c1, Complex &c2);
	friend Complex operator*(Complex &c1, Complex &c2);
	friend Complex& operator++(Complex &c1); //前置++
	Complex(int a, int b)
	{
		this->a = a;
		this->b = b;
	}
	void printCom()
	{
		cout<<a<<" + "<<b<<"i "<<endl;
	}
	//通过类成员函数完成-操作符重载
	Complex operator-(Complex &c2)
	{
		Complex tmp(a - c2.a, this->b - c2.b);
		return tmp;
	}
	//通过成员函数完成前置--
	Complex& operator--()
	{
		this->a--;
		this->b--;
		return *this;
	}

private:
	int a;
	int b;
};

Complex operator+(Complex &c1, Complex &c2)
{
	Complex tmp(c1.a + c2.a, c1.b + c2.b);
	return tmp;
}

Complex operator*(Complex &c1, Complex &c2)
{
	Complex tmp(c1.a*c2.a, c1.b*c2.b);
	return tmp;
}

//前置++ 
Complex& operator++(Complex &c1)
{
	c1.a ++;
	c1.b ++;
	return c1;
}

void main()
{

	Complex c1(1, 2), c2(3, 4);

	//全局函数方法去实现操作符重载
	//1 承认操作符重载是一个函数
	//2 根据操作数，1个操作数 2个操作数，完成函数的参数
	//3 根据函数原型，实现也需要业务
	//Complex c31 = operator+(c1, c2);
	Complex c3 = c1 + c2;

	//用类成员函数实现-运算符重载
	Complex c4 = c1 - c2;
	c4.printCom();
	//c1.operator-(c2);

	{
		//问题1 根据类型
		int a = 10, b = 1;
		int c = a + b;
	}

	//前置++ 全局函数
	++c1; 
	c1.printCom();

	//前置-- 成员函数
	--c1;
	c1.printCom();
	//c1.operator--()



	system("pause");
}

正规重载写法

#include "iostream"
using namespace std;

//a + bi //复数
class Complex
{
public:
	friend ostream& operator<<(ostream &out, Complex &c1);
	Complex(int a, int b)
	{
		this->a = a;
		this->b = b;
	}
	void printCom()
	{
		cout<<a<<" + "<<b<<"i "<<endl;
	}
	//通过类成员函数完成-操作符重载
	Complex operator-(Complex &c2)
	{
		Complex tmp(a - c2.a, this->b - c2.b);
		return tmp;
	}
	Complex operator+(Complex &c2)
	{
		Complex tmp(a + c2.a, this->b + c2.b);
		return tmp;
	}
	//通过成员函数完成前置--
	Complex& operator--()
	{
		this->a--;
		this->b--;
		return *this;
	}
	//通过成员函数完成前置--
	Complex& operator++()
	{
		this->a++;
		this->b++;
		return *this;
	}

	//通过类成员函数完成后置--
	Complex operator--(int)
	{
		Complex tmp = *this;
		this->a--;
		this->b--;
		return tmp;
	}
	//通过类成员函数完成后置--
	Complex operator++(int)
	{
		Complex tmp = *this;
		this->a++;
		this->b++;
		return tmp;
	}

private:
	int a;
	int b;
};

void main61()
{

	Complex c1(1, 2), c2(3, 4);

	//全局函数方法去实现操作符重载
	//1 承认操作符重载是一个函数
	//2 根据操作数，1个操作数 2个操作数，完成函数的参数
	//3 根据函数原型，实现需要业务
	//Complex c31 = operator+(c1, c2);
	Complex c3 = c1 + c2;

	//用类成员函数实现-运算符重载
	Complex c4 = c1 - c2;
	c4.printCom();
	//c1.operator-(c2);

	{
		//问题1 根据类型
		int a = 10, b = 1;
		int c = a + b;
	}

	//前置++ 全局函数
	++c1; 
	c1.printCom();

	//前置-- 成员函数
	--c1;
	c1.printCom();
	//c1.operator--()

	//后置++ 全局函数
	c1++; //operator++(c1);
	c1.printCom();

	//后置-- 类成员函数
	c1--;  //c1.operator--()
	c1.printCom();

	system("pause");
}

ostream& operator<<(ostream &out, Complex &c1)
{
	//out<<"12345，生活真是苦"<<endl;
	out<<c1.a<<" + "<<c1.b<<"i "<<endl;
	return out;
}
void main()
{
	Complex c1(1, 2), c2(3, 4);
	int a = 10;
	char *p = "addddd";
	cout<<"a"<<a<<endl;
	cout<<"p"<<p<<endl;

	//Complex自定义类型 。a + bi ab ba
	cout<<c1;

	//全局函数 
	//cout<<c1;
	//operator<<(cout, c1);

	//1
	//类成员函数
	//因为你没有方法拿到cout这个类的源码。。。。AOP C++
	//cout.operator<<(c1);

	//2 支持链式编程
	cout<<c1<<"abcc";

	//函数返回值当左值，要求返回一个引用。。。。。
	
	//cout.operator<<(c1).operator<<("abcd");

	//s<<"abcd"

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

	//s.operator<<("abcd");



	system("pause");

}

const修饰this指针

#include "iostream"
using namespace std;

//C 
class Test
{
public:
protected:
private:
	int a;
	const int A() //const // ====>int A(const this) 
	{ 
		//观点1：const是修饰a,但是通过测试，我们发现，b++也不能编译通过
		//这说明：const把a 和 b都修饰了。。。。

		//剖析：因为this作为函数的第一个参数，被隐藏。。。。const没有地方放。。。。
		//
		//const是修饰this

		a ++;
		//b++;
		return a; 
	}
	void A(int val) 
	{ 
		a = val; 
	}

	int BBB()
	{
		
		return a;
	}

	int b;
};


 int Aaaaa(const Test *pthis) 
{ 
	return 10; 
}
void main()
{
	Test t1;
	system("pause");
}