精华内容
下载资源
问答
  • C++学习笔记之运算符重载(赋值运算符,关系运算符重载)C++运算符重载 运算符重载 重载运算符 赋值运算符重载 C++编译器至少要给一个类添加4个函数 默认构造函数 默认析构函数 默认拷贝构造函数 赋值运算符 ...

    C++学习笔记之运算符重载(赋值运算符,关系运算符重载)C++运算符重载 运算符重载 重载运算符
    赋值运算符重载
    C++编译器至少要给一个类添加4个函数

    • 默认构造函数
    • 默认析构函数
    • 默认拷贝构造函数
    • 赋值运算符 operator=对属性进行值拷贝
      如果类中有属性指向堆区,做赋值操作的时候会出现深浅拷贝的问题
      应该要先判断是否有属性在堆区,如果要先释放干净,然后再进行深拷贝

    if(m_Age != NULL){
    delete m_Age;
    m_Age = NULL;
    }

    #include <iostream>
    using namespace std;
    
    //C++编译器至少给一个类添加4个函数
    //1.默认构造函数(无参,函数体为空)
    //2.默认析构函数(无参,函数体为空)
    //3.默认拷贝构造函数,对属性进行值拷贝
    //4.赋值运算符operator=, 对属性进行值拷贝
    
    //如果类中有属性指向堆区,做赋值操作时也会出现深浅拷贝问题
    
    class Person
    {
    public:
    
    	Person(int age)
    	{
    		//将年龄数据开辟到堆区
    		m_Age = new int(age);
    	}
    
    	//重载赋值运算符 
    	Person& operator=(Person& p)
    	{
    		if (m_Age != NULL)
    		{
    			delete m_Age;
    			m_Age = NULL;
    		}
    		//编译器提供的代码是浅拷贝
    		//m_Age = p.m_Age;
    
    		//提供深拷贝 解决浅拷贝的问题
    		m_Age = new int(*p.m_Age);
    
    		//返回自身
    		return *this;
    	}
    
    	~Person()
    	{
    		if (m_Age != NULL)
    		{
    			delete m_Age;
    			m_Age = NULL;
    		}
    	}
    
    	//年龄的指针
    	int* m_Age;
    
    };
    
    
    void test01()
    {
    	Person p1(18);
    
    	Person p2(20);
    
    	Person p3(30);
    
    	p3 = p2 = p1; //赋值操作
    
    	cout << "p1的年龄为:" << *p1.m_Age << endl;
    
    	cout << "p2的年龄为:" << *p2.m_Age << endl;
    
    	cout << "p3的年龄为:" << *p3.m_Age << endl;
    }
    
    int main() {
    
    	test01();
    
    	//int a = 10;
    	//int b = 20;
    	//int c = 30;
    
    	//c = b = a;
    	//cout << "a = " << a << endl;
    	//cout << "b = " << b << endl;
    	//cout << "c = " << c << endl;
    
    	system("pause");
    
    	return 0;
    }
    

    关系运算符重载
    作用: 重载关系运算符,可以让两个自定义对象进行对比操作
    函数调用运算符重载
    由于重载之后使用的方法非常像函数的调用,因此称为仿函数
    仿函数没有固定写法,非常灵活。

    //函数调用运算符()也可以重载
    //由于重载后使用的方式非常像函数的调用,因此称为仿函数
    //仿函数没有固定写法,非常灵活
    #include <iostream>
    #include <string>
    using namespace std;
    class Person {
    	//默认构造函数
    	//默认析构函数
    	//默认拷贝构造函数
    	//赋值运算符重载
    public:
    	void operator() (string text){
    		cout << text << endl;
    	}
    };
    void test00() {
    	//重载的()操作符,也称为仿函数
    	Person xiaoming;
    	xiaoming("大家好,我是小明");
    	
    }
    
    class Myadd{
    public:
    	int operator()(int val1, int val2) {
    		return val1 + val2;
    	}
    };
    void test90() {
    	Myadd myadd;
    	int ret = myadd(10, 10);
    	cout << "ret = " << ret << endl;
    	//构建匿名对象 
    	cout << Myadd()(20, 20) << endl;
    }
    int main() {
    	test00();
    	test90();
    	return 0;
    }
    
    展开全文
  • 运算符重载

    2020-11-15 19:33:06
    运算符重载 定义: 重新定义运算符,使其能够用于特定的类对象完成特定操作的技术成为运算符重载运算符重载实质上就是函数重载。 运算符重载方法 C++运算符既可以重载为类的非静态成员函数,也可以重载为类的友元...

    运算符重载

    定义:

    重载的运算符是具有特殊名字的函数:它们的名字由关键字operator和其后要定义的运算符号共同组成。和其他函数一样,重载的运算符也包含返回类型、参数列表以及函数体。
    重新定义运算符,使其能够用于特定的类对象完成特定操作的技术成为运算符重载
    运算符重载实质上就是函数重载。

    运算符重载方法

    C++运算符既可以重载为类的非静态成员函数,也可以重载为类的友元函数。

    1. 运算符重载为非静态成员函数

    <返回值类型> operator<运算符>(<形式参数列表>);
    

    如果一个运算符函数是成员函数,则它的第一个运算对象绑定到隐式的this指针上,因此,成员运算符函数的显式参数比运算符的运算对象少一个。
    对于单目运算符重载函数不需要显示声明操作数,形式参数列表为空,所需的形参将由自引用参数提供。
    对于双目运算符重载函数只需要显示声明右操作数,左操作数由自引用参数提供。
    注意:在使用运算符做运算时,左运算符必须为类对象,否则会导致编译错误。因为使用运算符时,仍然是函数调用,成员函数必须要绑到具体对象上时才能运行。

    2.运算符重载为友元函数

    friend <返回值类型> operator<运算符>(<形式参数列表>);
    

    运算符重载为友元函数时,函数参数个数与运算符操作数个数相同。

    运算符重载规则

    1.不能创建行的操作符

    运算符重载只能对运算符重新定义,而不能创建新的运算符。

    2.运算符重载的限制

    C++中并不是所有运算符都可以被重载,下列的运算符不允许被重载。
    ::——域作用运算符
    .*——指针成员的成员运算符
    .——成员运算符
    sizeof
    typedef
    条件运算符

    (1)不能改变运算符的优先级和结合性

    C++运算符都具有特定的优先级和结合性,重载运算符后,运算符的优先级和结合性不能改变。

    (2)不能改变操作数个数

    运算符重载不能改变运算符操作数的个数

    (3)不要改变运算符的含义

    (4)某些运算符重载的特殊要求

    部分运算符由于操作本质只允许被重载为非静态成员函数。:
    [ ]:下标运算符
    =:赋值运算符
    ():调用运算符
    ->:指向运算符
    有两个运算符只能重载为类的友元函数:
    >>:输入运算符
    <<:输出运算符

    单目运算符重载

    以前自增与后自增操作为例,首先由于要直接对参数进行操作因此函数一定采用地址传递,又由于前自增操作符的对象与返回值是同一值,因此前自增运算符重载函数的参数与返回值一定是对象的引用。而后自增运算符返回值与对象不一致,所以后自增运算符重载函数的参数是对象的引用,返回值是对象值。

    <类型&> operator<运算符>(<类型&>);//前自增
    Ccomplex & operator++(Ccomplex& cobj){}
    <类型> operator<运算符>(<类型&>);//后自增
    Ccmplex operator++(Ccomplex& cobj,int)//为了区别两种运算符重载函数,C++要求后自增运算符函数必须增加一个int型参数
    

    双目运算符重载

    下标运算符重载

    下标运算符必须重载为非静态成员函数

    <类型&> operator[](int);
    

    赋值运算符重载

    一般来说,当类有指针成员时,必须为类自定义赋值运算符重载函数,以实现对对象的深复制。

    CmyString& CmyString::operator=(const CmyString& obj){
    if(this=&obj){
    return *this;
    }
    m_size=obj.m_size;
    if(mp_data!=0){
    delete []mp_data;
    }
    mp_data=new char[obj.m_size];  //根据对象大小重新申请空间
    strcpy(mp_data,obj.mp_data);
    return *this;
    }
    

    加法运算符重载

    Ccomplex operator+(const Ccomplex& c1, const Ccomplex& c2) //加法运算符重载
    {
    	Ccomplex temp(c1);
    	temp.m_real += c2.m_real;
    	temp.m_image += c2.m_image;
    	return temp;
    ]
    

    不同类型数据间的转换

    基本数据类型到类类型

    Ccomplex c1(1,3),c2;
    c2=c1+4;
    c2=4+c1;
    

    对于第二、三条语句,程序都给出了正确的结果。说明系统将4自动转化为了复数类中的对象。
    类Ccomplex中有一个带有两个默认参数值的构造函数,系统通过该函数将4转化为4+0i。这种将其他类型数据转换成类对象的构造函数称为转型构造函数
    类型转换构造函数必须遵守的规则:
    (1)类型转换构造函数必须是只有一个参数的构造函数。
    (2)类型转换只推导一次,如果遇到二义性则放弃推导。

    类类型到基本类型的转换

    operator <返回类型名>(){
    return <基本类型值>
    
    }
    
    展开全文
  • 运算符重载.py python运算符重载

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,255
精华内容 11,702
关键字:

运算符重载