例子一:重写二元操作符+(复数对象的+操作符与普通整型变量的+操作不一样,所以需要重写+)
实现代码一:通过友元函数来实现
//在vc 6.0中有可能不能通过,换个编译器就好了
#include <iostream>
using namespace std;
class Complex //复数
{
friend Complex &operator+(Complex &c1, Complex &c2);//利用友元函数,实现对私有成员变量的访问
public:
Complex(int a, int b)
{
this->a = a;
this->b = b;
}
void PrintComplex()
{
cout << this->a <<" + " << this->b << "i" << endl;
}
private:
int a;
int b;
};
Complex &operator+(Complex &c1, Complex &c2)
{
Complex tmp(c1.a + c2.a, c1.b + c2.b);
return tmp;
}
int main()
{
Complex c1(1, 2);
Complex c2(2, 3);
Complex c3 = c1 + c2; //通过返回一个引用,将引用直接转换成c3对象
c3.PrintComplex();
return 0;
}
实现方法二:通过类成员函数
//在vc 6.0中有可能不能通过,换个编译器就好了
#include <iostream>
using namespace std;
class Complex //复数
{
public:
Complex(int a, int b)
{
this->a = a;
this->b = b;
}
void PrintComplex()
{
cout << this->a <<" + " << this->b << "i" << endl;
}
Complex &operator+(Complex &c2)
{
Complex tmp(this->a + c2.a, this->b + c2.b);
return tmp;
}
private:
int a;
int b;
};
int main()
{
Complex c1(1, 2);
Complex c2(2, 3);
Complex c3 = c1 + c2; //通过返回一个引用,将引用直接转换成c3对象
c3.PrintComplex();
return 0;
}
例子二:重写一元操作符前置++
方法一:利用友元函数
//在vc 6.0中有可能不能通过,换个编译器就好了
#include <iostream>
using namespace std;
class Complex //复数
{
public:
friend void operator++(Complex &c1);
Complex(int a, int b)
{
this->a = a;
this->b = b;
}
void PrintComplex()
{
cout << this->a <<" + " << this->b << "i" << endl;
}
private:
int a;
int b;
};
void operator++(Complex &c1)
{
c1.a++;
c1.b++;
}
int main()
{
Complex c1(1, 2);
Complex c2(2, 3);
++c1;
c1.PrintComplex();
return 0;
}
方法二:利用类成员函数
//在vc 6.0中有可能不能通过,换个编译器就好了
#include <iostream>
using namespace std;
class Complex //复数
{
public:
Complex(int a, int b)
{
this->a = a;
this->b = b;
}
void PrintComplex()
{
cout << this->a <<" + " << this->b << "i" << endl;
}
void operator++()
{
this->a++;
this->b++;
}
private:
int a;
int b;
};
int main()
{
Complex c1(1, 2);
Complex c2(2, 3);
++c1;
c1.PrintComplex();
return 0;
}
例子三:重写一元操作符后置++
方法一:利用友元函数实现
//在vc 6.0中有可能不能通过,换个编译器就好了
#include <iostream>
using namespace std;
class Complex //复数
{
public:
friend Complex & operator++(Complex &c1, int);
Complex(int a, int b)
{
this->a = a;
this->b = b;
}
void PrintComplex()
{
cout << this->a <<" + " << this->b << "i" << endl;
}
private:
int a;
int b;
};
Complex & operator++(Complex &c1, int)
{
Complex tmp = c1;
c1.a++;
c1.b++;
return tmp;
}
int main()
{
Complex c1(1, 2);
Complex c2(2, 3);
c1++;
c1.PrintComplex();
return 0;
}
方法二:利用成员函数
//在vc 6.0中有可能不能通过,换个编译器就好了
#include <iostream>
using namespace std;
class Complex //复数
{
public:
Complex(int a, int b)
{
this->a = a;
this->b = b;
}
void PrintComplex()
{
cout << this->a <<" + " << this->b << "i" << endl;
}
Complex & operator++(int)
{
Complex tmp = *this;
this->a++;
this->b++;
return tmp;
}
private:
int a;
int b;
};
int main()
{
Complex c1(1, 2);
Complex c2(2, 3);
c1++;
c1.PrintComplex();
return 0;
}
例子四:重写操作符<<(>>右移操作符类似左移操作符,istream &input)
#include <iostream>
using namespace std;
class Complex
{
public:
friend ostream & operator<<(ostream &out, Complex c);
Complex(int a, int b)
{
this->a = a;
this->b = b;
}
private:
int a;
int b;
};
ostream & operator<<(ostream &out, Complex c) //串行调用
{
cout << c.a << "+" << c.b << "i" << endl;
return out;
}
int main()
{
Complex c(1, 2);
cout << c << "hello world"; //调用顺序 out.operator<<(c).operator<<("hello world")
return 0;
}
C++中不能使用友元函数重载的运算符: = () [] ->
例子五:=的重载(深copy)
结论:1.先释放一个旧的内存; 2.返回一个引用; 3.=操作符,从左往右
#include <iostream>
using namespace std;
class Name
{
private:
char *name;
int len;
public:
Name(const char *myp)
{
len = strlen(myp);
name =(char *) malloc(len + 1); //
strcpy(name, myp);
}
Name& operator=(Name &obj1)
{
//先释放旧的内存
if (this->name != NULL)
{
delete[] name;
len = 0;
}
//2 根据obj1分配内存大小
this->len = obj1.len;
this->name = new char [len+1];
//把obj1赋值
strcpy(name, obj1.name);
return *this;
}
~Name()
{
if (name != NULL)
{
free(name);
name = NULL;
len = 0;
}
}
};
void objDisplay()
{
Name n1("abcdef");
Name n2("abc");
n2 = n1;
}
int main()
{
objDisplay();
return 0;
}