重点运算符重载总结

class Integer {
public:
Integer();
Integer(int value);
Integer operator+(int value);
void operator=(int value);
operator int() const; //int 转换运算符
operator++(); //
operator++(int value);//
private:
int m_value;

friend Integer operator+(int value, Integer integer);
};

//Integer operator +(Integer integer, int value);  //不能声明该函数，否则会和成员函数冲突

Integer operator+(int value, Integer & integer) {

int tmpValue = integer.m_value + value;
return Integer(tmpValue);
}

Integer::Integer() {
m_value = ;
}
Integer::Integer( value) {
m_value = value;
}

Integer Integer::operator+( value) {
tmpValue = m_value + value;
Integer(tmpValue);
}

void Integer::operator=( value) {
m_value = value;

}

Integer& Integer::operator++() {

++m_value;
return *this;
}
Integer Integer::operator++( value) {
Integer tmpInteger;
tmpInteger = m_value++;
tmpInteger;
}

下面看第二类，讲述下标运算符[]的重载！
class Array{
private:
int *p;
unsigned int size;
public:
Array(int length);
Array(const Array&);
void setData(int index, int value);
int getData(int index)const;
public:
int & operator[](int index);
friend ostream& operator<<(ostream &os, const Array & a);
Array& operator=(Array &a2);
};
Array::Array(int length){
size = length;
p = new int[length];
}
Array::Array(const Array& t){
size = t.size;
p = new int[size];
for (int i = 0; i <size; i++)
{
*(p + i) = *(t.p + i);
}
}
void Array::setData(int index, int value){
p[index] = value;
}
int Array::getData(int index)const{
return *(p + index);
}

}
ostream& operator<<(ostream &os, const Array & a){
for (int i = 0; i < a.size; i++)
{
os << a.getData(i) << endl;
}
return os;
}
Array&  Array::operator=(Array &a2)
{
if (this-p != NULL)
{
delete[]p;
size = 0;
}
this->size = a2.size;
this->p = new int[this->size];

for (int i=0; i<this->size; i++)
{
p[i] = a2[i];
}
return *this;
}
int main(){
Array ar(5);
for (int i = 0; i < 5; i++){
ar[i] = i+1;
}
cout << ar << endl;
system("pause");
return 0;
}
两种重载形式的比较:
在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点：
(1) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
(2)
(3) 类型转换函数只能定义为一个类的成员函数而不能定义为类的友元函数。
(4) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。
(5) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。
(6)
(7)