运算符重载

 1 #pragma once
 2 #include<iostream>
 3 using namespace std;
 4 class A
 5 {
 6     int data;
 7     static int x;
 8     int arr[10];
 9 public:
10     A(int data = 0);//构造函数，可缺省
11     A(const A&other);//调用拷贝构造
12     ~A();
13     int getData();
14     void setData(int data);
15     friend int addA(const A&a, const A&b);//在申明的时候使用友元在类外定义 
16     friend A operator+(const A&a, const A&b);//通过友元 运算符加法重载
17 
18     A operator-(const A&b);//通过成员的方法重载减号运算符通过this
19     A operator-()//重载负号运算符
20     {
21         A C;
22         C.data = -this->data;
23         return 0;
24     }
25 
26     A& operator++(){//前加加运算符 通过返回值修改这个对象
27         ++this->data;
28         return *this;//返回当前对象
29     }
30     A operator++(int)//区分于前++ 里面放一个参数表示后++
31     {
32         A c(this->data);//c保存A的数据
33         ++this -> data;//data自增
34         return c;//c返回之前保存的数据
35     }
36     //重载输出输入运算符 
37     friend ostream& operator<<(ostream& os,const A& a)//引用a防止被修改加上const
38     {
39         os << a.data;
40         return os;
41     }
42     friend istream& operator>>(istream& is, A& a)//不加const表可以修改a的值，a的值为键盘输入的值
43     {
44         is >> a.data;
45         return is;
46     }
47     int& operator*()        //重载解引用运算符
48     {
49         return *arr;
50     }
51     int& operator[](int index)    //重载下标运算符
52     {
53         return arr[index];
54     }
55 
56     operator bool()    //强转bool类型   没有返回值类型
57     {
58         return arr[0] == 0;//函数体按照自己的需求写就行 
59     }
60     friend A operator*(const A& a, const A& b)//使用友元方法对乘法运算符重载
61 {
62     A c;
63     c.data = a.data * b.data;
64     return c;
65 }
66 };

 1 #include "A.h"
 2 
 3 
 4 A::A(int data)
 5 {
 6     this->data = data;//将形参值给类中私有变量使用
 7 }
 8 A::A(const A&other)
 9 {
10     data = other.data;//调用不可修改的other给类内赋值
11 }
12 
13 
14 A::~A()
15 {
16 }
17 int A::getData()    //get方法
18 {
19     return data;
20 }
21 
22 void A::setData(int data)//set方法
23 {
24     this->data = data;
25 }
26 int addA(const A& a, const A& b)
27 {
28     return a.data + b.data;//通过对象访问私有成员返回私有成员 类似于两个对象相加 引入加发运算符的重载
29 }
30 
31 A operator+(const A& a, const A& b)//使用友元方法对加法运算符重载
32 {
33     A c;
34     c.data = a.data + b.data;
35     return c;
36 }
37 A A::operator-(const A&b)//利用成员方法 对运输符进行重载
38 {
39     A c;
40     c.data = this->data - b.data;
41     return c;
42 }

 1 #include<iostream>
 2 #include"A.h"
 3 #include<string>//存放字符串
 4 int main()
 5 {
 6 
 7     A a(3);    //调用普通构造
 8     A b = a;//调用拷贝构造    隐式调用
 9     A c(b); //调用拷贝构造    显式调用
10     
11 
12     //得到a和b的data 相加之后 交给新的变量 
13     c;//c的值是a中的值和b中的值的相加
14     c.setData(a.getData() + b.getData());//如果需要经常使用到私有成员
15     //利用set方法将a中的值和b中的值相加
16     c.setData(addA(a, b));    //a+b两个类相加
17 
18     c = a - b;            //使用的时候直接用运算符此处的运算符是重载减号运算符
19     c = a.operator-(b);    //不用函数调用的形式
20     
21     c++;//重载后++运算符
22     ++c;//重载前++运算符
23     c = a*b;    //尝试重载* 运算符
24     cout <<"a+b的结果是"<< c.getData() << endl;
25     cout << c << endl;
26     cout << "输入一个data" << endl;
27     cin >> c;
28 
29     cout << "输入的结果是" << c << endl;
30     //运算符和函数
31 
32     A d;
33     *d=1;//  d.arr[0]
34     d[0] = 1;
35     d[2] = 0;
36 
37     (int)3.14;//  前面是类型  后面值 这样进行强转
38     
39     if (d)//此时d是布尔值 可以直接放置判断是否执行
40     {
41 
42     }
43     cin.get();
44     return 0;
45 }