码迷,mamicode.com
首页 > 其他好文 > 详细

操作符的重载

时间:2015-10-28 17:09:44      阅读:202      评论:0      收藏:0      [点我收藏+]

标签:


1.基本
输入和输出
  1. cout << "hello" << endl << "world";
  2. 输出:
  3. hello world
    可见,输出,endl 是换行的作用
  1. int x;
  2. cout << "input the num what you want:";
  3. cin >> x;
  4. cout << "the num you input is:";
  5. cout << x;
    从键盘输入一个数值,赋值给 x,然后将数值再打印到屏幕。
    上面的 << >> 左移和右移,居然实现了输入输出的例子,所以说左移和右移的运算符是被重载的,在不同的上下文,操作符有不同的功能;

C++操作符的重载:operator + 运算符
  1. struct Complex
  2. {
  3. int a;
  4. int b;
  5. };
  6. // 操作符的重载
  7. Complex operator+ (Complex &c1, Complex &c2)
  8. {
  9. Complex k;
  10. k.a = c1.a + c2.a;
  11. k.b = c1.b + c2.b;
  12. return k;
  13. }
  14. int main()
  15. {
  16. Complex a1 = { 1, 2 };
  17. Complex a2 = { 3, 4 };
  18. Complex a3 = operator+(a1, a2);
  19. // 也可以直接:Complex a3 = a1 + a2;
  20. cout << "a3.a=" << a3.a << endl;
  21. cout << "a3.b=" << a3.b << endl;
  22. while (1);
  23. }
    操作符的重载实现了复数的加法运算,必须记得操作的重载的关键字:operator,
问题: 操作符的重载能不能在类里面实现?答案是可以的:
  1. class Complex
  2. {
  3. int a; // 默认的是私有的
  4. int b;
  5. public:
  6. Complex(int a = 0, int b = 0)
  7. {
  8. this->a = a;
  9. this->b = b;
  10. }
  11. int getA()
  12. {
  13. return a;
  14. }
  15. int getB()
  16. {
  17. return b;
  18. }
  19. ~Complex()
  20. {
  21. }
  22. // 指定朋友,友元函数
  23. friend Complex operator+ (Complex &c1, Complex &c2);
  24. };
  25. // 操作符的重载
  26. Complex operator+ (Complex &c1, Complex &c2)
  27. {
  28. Complex k;
  29. // 这样可以通过对象访问到private成员
  30. //k.a = c1.getA() + c2.getA();
  31. //k.b = c1.getB() + c2.getB();
  32. k.a = c1.a + c2.a; // 通过对象直接访问
  33. k.b = c1.b + c2.b;
  34. return k;
  35. }
  36. int main()
  37. {
  38. Complex a1(1, 2);
  39. Complex a2(3, 4);
  40. Complex a3 = a1 + a2;
  41. cout << "a3.a = " << a3.getA() << endl;
  42. cout << "a3.b = " << a3.getB() << endl;
  43. while (1);
  44. }
    private成员,是不可以通过对象访问到private成员变量的,但是加上 friend关键字之后,就上上面的代码,指定了一个友元的函数,那么这个函数就可以通过对象访问private成员了,
    
  1. ostream& operator<< (ostream& out, Complex &c)
  2. { // 这个地方看不懂
  3. out << c.a << " and " << c.b << endl;
  4. return out;
  5. }
  6. int main()
  7. {
  8. Complex a1(1, 2);
  9. Complex a2(3, 4);
  10. Complex a3 = a1 + a2;
  11. cout << a3 << endl;
  12. while (1);
  13. }

操作符重载在类内实现:
  1. class Complex
  2. {
  3. int a; // 默认的是私有的
  4. int b;
  5. public:
  6. Complex(int a = 0, int b = 0)
  7. {
  8. this->a = a;
  9. this->b = b;
  10. }
  11. int getA()
  12. {
  13. return a;
  14. }
  15. int getB()
  16. {
  17. return b;
  18. }
  19. ~Complex()
  20. {
  21. }
  22. // 这里第一个对象有传入 this 指针,所以只需要一个就可以了,
  23. Complex operator+ (Complex &c2);
  24. };
  25. Complex Complex :: operator + (Complex &c2)
  26. {
  27. Complex k;
  28. k.a = this->a + c2.a;
  29. k.b = this->b + c2.b;
  30. return k;
  31. }
  32. int main()
  33. {
  34. Complex a1(1, 2);
  35. Complex a2(3, 4);
  36. Complex a3 = a1 + a2;
  37. cout << a3.getA() << endl;
  38. cout << a3.getB() << endl;
  39. while (1);
  40. }
    这里需要注意,操作符的重载是可以在类的内部实现的,这里需要注意的是,传入的参数的个数,我们这里只需要传入第二个参数,原因是因为编译器会把第一个对象的地址传入 this 指针,所以传入一个就对了,传入两个,反而会出错,
    在类的内部实现操作符的重载的好处:
    (1)比全局的操作符重载函数少了一个参数嘛,因为传到 this 指针了
    (2)不需要使用 friend 关键字































































































操作符的重载

标签:

原文地址:http://www.cnblogs.com/qxj511/p/4917694.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!