C++运行符重载、友元函数

Complex.h

 1 #pragma once
 2 #include <iostream>
 3
 4 using namespace std;
 5 //表示一个复数
 6 class Complex
 7 {
 8 private:
 9     double x, y;
10 public:
11     Complex();    //默认构造函数
12     Complex(double x, double y); //构造函数重载
13     Complex operator+(Complex & cmx) const; //‘+‘号运算符重载
14     Complex operator-(Complex & cmx) const;    //‘-‘号运算符重载
15     Complex operator*(Complex & cmx) const;    //‘*‘号运算符重载
16     Complex operator/(Complex & cmx) const;    //‘/‘号运算符重载
17     Complex operator~() const;    //‘~‘号运算符重载
18     Complex operator*(double & n) const; //‘*‘号运算符重载
19     friend Complex operator*(double & n, Complex & cmx); //友元函数,可用于表示[4.0*Complex类型]
20     friend ostream & operator<<(ostream & os, Complex & cmx); //友元函数,可用于表示[cout << Complex类型]
21 ~Complex();
22 };

Complex.cpp

 1 #include "Complex.h"
 2
 3
 4
 5 Complex::Complex()
 6 {
 7 }
 8
 9 Complex::Complex(double x, double y)
10 {
11     this->x = x;
12     this->y = y;
13 }
14
15 Complex Complex::operator+(Complex & cmx) const
16 {
17     return Complex(x + cmx.x, y + cmx.y);
18 }
19
20 Complex Complex::operator-(Complex & cmx) const
21 {
22     return Complex(x - cmx.x, y - cmx.y);
23 }
24
25 Complex Complex::operator*(Complex & cmx) const
26 {
27     return Complex(x*cmx.x, y*cmx.y);
28 }
29
30 Complex Complex::operator/(Complex & cmx) const
31 {
32     return Complex(x / cmx.x, y / cmx.y);
33 }
34
35 Complex Complex::operator~() const
36 {
37     return Complex(x, -y);
38 }
39
40 Complex Complex::operator*(double & n) const
41 {
42     return Complex(x*n, y*n);
43 }
44
45 Complex operator*(double & n, Complex & cmx)
46 {
47     return cmx*n;
48 }
49
50 ostream & operator<<(ostream & os, Complex & cmx)
51 {
52     os << cmx.x << "," << cmx.y << endl;
53     return os;
54 }
55
56 Complex::~Complex()
57 {
58 }
时间: 2024-10-03 22:40:02

C++运行符重载、友元函数的相关文章

C++运算符重载(友元函数方式)

我们知道,C++中的运算符重载有两种形式:①重载为类的成员函数(见C++运算符重载(成员函数方式)),②重载为类的友元函数. 当重载友元函数时,将没有隐含的参数this指针.这样,对双目运算符,友元函数有2个参数,对单目运算符,友元函数有一个参数.但是,有些运行符不能重载为友元函数,它们是:=,(),[]和->. 重载为友元函数的运算符重载函数的定义格式如下: [cpp] view plaincopy 一.程序实例 [cpp] view plaincopy 1 //运算符重载:友元函数方式 2

C++ Primer 学习笔记_26_操作符重载与转换(1)--可重载/不可重载的操作符、成员函数方式重载、友元函数方式重载

C++ Primer 学习笔记_26_操作符重载与转换(1)--可重载/不可重载的操作符.成员函数方式重载.友元函数方式重载 引言: 明智地使用操作符重载可以使类类型的使用像内置类型一样直观! 一.重载的操作符名 像任何其他函数一样,操作符重载函数有一个返回值和一个形参表.形参表必须具有操作符数目相同的形参.比如赋值时二元运算,所以该操作符函数有两个参数:第一个形参对应着左操作数,第二个形参对应右操作数. 大多数操作符可以定义为成员函数或非成员函数.当操作符为成员函数时,它的第一个操作数隐式绑定

C++ 类模板二(类模版与友元函数)

//类模版与友元函数 #include<iostream> using namespace std; template<typename T> class Complex{ public: Complex(T a,T b); void Print() const//const修饰的是this指针 { cout << this->Real << ":" <<this->Image<< endl; } /*

4 C++基础4 类 const函数 转全局函数 返回*this 数组类。友元 函数 类 操作符重载

1,请问类中函数 const修饰的谁? [email protected]:~/c++$ cat main.cpp  #include <iostream> #include <stdlib.h> using namespace std; class A { public: //const的三种写法 //const void fun(int a,int b) //void const fun(int a,int b) //void fun(int a,int b) const vo

C++重载(主要介绍使用友元函数重载)

重载限制 多数C++运算符都可以用下面的方式重载.重载的运算符不必是成员函数,但必须至少有一个操作数是用户自定义的类型.下面详细介绍C++对用户定义的运算符重载的限制. 1 重载后的运算符必须至少有一个操作数是用户自定义的类型,这将防止用户为标准类型重载运算符.因此,不能将减法运算符(-)重载为double值的和,而不是它们的差.虽然这种限制将对创造性有所影响,但可以确保程序正常运行. 2 使用运算符时不能违反运算符原来的句法规则.例如,不能将求模运算符(%)重载成使用一个操作数. 同样,不能修

为什么operator&lt;&lt;&gt;&gt;运算符重载一定要为友元函数呢?

如果是重载双目操作符(即为类的成员函数),就只要设置一个参数作为右侧运算量,而左侧运算量就是对象本身...... 而 >>  或<< 左侧运算量是 cin或cout 而不是对象本身,所以不满足后面一点........就只能申明为友元函数了... 如果一定要声明为成员函数,只能成为如下的形式: ostream & operator<<(ostream &output) { return output; } 所以在运用这个<<运算符时就变为这种形

等号操作符重载为什么不能用友元函数大揭秘,以及函数没有等到重载的时候赋值会出现什么现象(盲点)

先看下面程序结果输出什么? 1 #include <iostream> 2 using namespace std; 3 4 class A 5 { 6 private: 7 int x; 8 public: 9 A(){ 10 x=99; 11 cout<<"看看这里是否会被调用"<<endl; 12 } 13 }; 14 15 int main() 16 { 17 A a; 18 a = 7; 19 } 这里面,会报错,显示没有等号匹配现象.只有

运算符重载三种形式(成员函数,友元函数,普通函数)详解

首先,介绍三种重载方式: 1 //作为成员函数重载(常见) 2 class Person{ 3 Private: 4 string name; 5 int age; 6 public: 7 Person(const char* name, int age):name(name),age(age){} 8 bool operator<(const Person& b); 9 10 }; 11 bool Person::operator<(const Person& b) 12 {

运算符重载和友元函数

1. 运算符重载 c++允许将运算符重载扩展到用户定义的类型,例如:允许使用+将两个对象相加,编译器将根据操作数的数目和类型决定使用哪种加法定义,重载运算符可以使代码看起来更加自然. 例:计算时间,一个运算符重载的实例: class Time { private: int hours; int minutes; public: Time() {} Time(int hours, int minutes) { this->hours = hours; this->minutes = minute