C++运算符重载

转载于：http://blog.chinaunix.net/uid-24219701-id-2128176.html

/*
 *
运算符重载
 *
运算符重载就是给已有运算符赋予更多的含义，
 *
使它能够用于特定类的对象，执行特定的功能，
 *
而且使用形式与基本类型数据类型的形式相同
 *
运算符重载实际上就是函数重载
 */
 
/*
 *
使用普通函数完成自定义的加法运算

 */
 
#include

using
namespace std;
 
class ClassA
{
private:
    int x, y;
public:
    ClassA(){}
    ClassA(int _x,
int _y):x(_x),y(_y){}
    ClassA add(ClassA &a, ClassA &b)
    {
        this->x = a.x + b.x;
        this->y = a.y + b.y;
        return *this;
    }
 
    void display(){cout<<x<<" "<
};
 
int main(void)
{
    ClassA a(1,1),b(2,2);
    ClassA c;
    c.add(a,b);
    c.display();
 
}

 

 

/*
 *
运算符重载
 *
运算符通常是针对类中的私有成员进行操作，因此重载运算符应该能够访问类中的私有成员
 *
所以运算符重载一般采用成员函数或友元函数的方式
 */
/*

 *
成员函数重载运算符"+"
 
 */
 
#include

using
namespace std;
 
class ClassA
{
private:
    int x, y;
public:
    ClassA(){}
    ClassA(int _x,
int _y):x(_x),y(_y){}
    ClassA operator + (ClassA &a)
    {
        ClassA c;
        c.x = this->x + a.x;
        c.y = this->y + a.y;
        return c;
    }
 
    void display(){cout<<x<<" "<
};
/*
 * obj3 = obj1 + obj2;
 *
运算符"+"可以访问两个对象：运算符左侧对象obj1是将要调用重载运算符函数的对象，
 *
右侧对象obj2作为函数的参数
 */
 
int main(void)
{
    ClassA a(1,1),b(2,2);
    ClassA c;
    c = a + b;
    c.display();
 
}

 

 

/*

 *
友元函数重载运算符"*"
 * Lzy      2011-8-8
 */
 
 
#include

using
namespace std;
 
class ClassA
{
private:
    int x, y;
public:
    ClassA(){}
    ClassA(int _x,
int _y):x(_x),y(_y){}   

    void display(){cout<<x<<" "<
 
    friend ClassA
operator * (ClassA &a1, ClassA &a2);
};
 
ClassA operator * (ClassA &a1, ClassA &a2)
{
    ClassA b;
    b.x = a1.x * a2.x;
    b.y = a1.y * a2.y;
    return b;
}
 
int main(void)
{
    ClassA a(2,2),b(2,2);
    ClassA c;
    c = a * b;
    c.display();
 
}
 

 

/*

 *
成员函数重载运算符前缀"++"
 * Lzy      2011-8-8
 */
 
#include

using
namespace std;
 
class CPoint
{
private:
    int x, y;
public:
    CPoint(int _x=0,
int _y=0):x(_x),y(_y){}
    void display(){cout<<x<<" "<
    CPoint operator ++ (void);
};
 
CPoint CPoint::operator ++ (void)
{
    ++x;
    ++y;
    return *this;
}
 
int main(void)
{
    CPoint c(1,1);
    c++;
    c.display();
    return 0;
}
 
 
/*

 *
成员函数重载运算符后缀"++"
 * Lzy      2011-8-8
 */
 
#include

using
namespace std;
 
class CPoint
{
private:
    int x, y;
public:
    CPoint(int _x=0,
int _y=0):x(_x),y(_y){}
    void display(){cout<<x<<" "<
    CPoint operator ++ (int);
};
 
CPoint CPoint::operator ++ (int)
{  
    return CPoint(x++, y++);
}
 
int main(void)
{
    CPoint a,c(1,1);
    a=c++;
    a.display();
    c.display();
    return 0;
}
 
 
/*

 *
友元函数重载运算符"++"
 * Lzy      2011-8-8
 */
 
#include

using
namespace std;
 
class CPoint
{
private:
    int x, y;
public:
    CPoint(int _x=0,
int _y=0):x(_x),y(_y){}
    void display(){cout<<x<<" "<
    friend CPoint
operator ++ (CPoint &c);     
//前缀
    friend CPoint
operator ++ (CPoint &c,
int);
//后缀
};
 
CPoint operator ++ (CPoint &c)
{  
    return CPoint(++c.x, ++c.y);
}
 
CPoint operator ++ (CPoint &c,int)
{  
    return CPoint(c.x++, c.y++);
}
 
int main(void)
{
    CPoint a,c(1,1);
    a=c++;
    a.display();
    c.display();
 
    a=++c;
    a.display();
    c.display();
 
    return 0;
}
 
 
/*

 *
重载运算符"="
 * Lzy      2011-8-8
 */
 
#include

using
namespace std;
 
class CPoint
{
private:
    int x, y;
public:
    CPoint(int _x=0,
int _y=0):x(_x),y(_y){}
    void display(){cout<<x<<" "<
    CPoint operator = (CPoint c);  

};
 
CPoint CPoint::operator = (CPoint c)
{  
    x= c.x;
    y= c.y;
    return *this;
}
 
int main(void)
{
    CPoint a,c(1,1);
    a=c;
    a.display();   
 
    return 0;
}
 
 
/*

 *
下标运算符[]的重载
 * Lzy      2011-8-8
 */
 
#include

using
namespace std;
 
class CStrArray
{
private:
    char *ptr;
    int len;
public:
    CStrArray(int i):len(i){ptr =
new
char[len];}
    ~CStrArray(){delete[] ptr;}
    int getlen(){return
len;}
    char &
operator[](int);
};
 
char & CStrArray::operator [] (int
i)
{
    static
char ch =
'\0';
 
    if(i<=len && i>=0)
        return *(ptr+i);
    else
    {
        cout<<"数组下标越界"<
        return ch;
    }
}
 
int main(void)
{
    CStrArray str(5);
    cout<<"输入个字符: ";
   
    for(int
i=0; i<5; i++)
        cin>>str[i];
   
 
    for(int
i=0; i<5; i++)
        cout<
   
 
    return 0;
}
 
 
 
/*

 *
重载运算符"<<" 和">>"
 * Lzy      2011-8-8
 */
 
#include

using
namespace std;
 
class CPoint
{
private:
    int x, y;
public:
    CPoint(int _x=0,
int _y=0):x(_x),y(_y){}
    friend ostream &
operator <<(ostream &,
const CPoint &);
    friend istream &
operator >>(istream &, CPoint &); 

};
 
ostream & operator <<(ostream &output,
const CPoint &c)
{
    output<<c.x<<" "<
    return output;
}
 
istream & operator >>(istream &input, CPoint &c)
{
// 
input.ignore();         //删除输入流中指定数目的字符，默认个数为
    input>>c.x;
    input>>c.y;
    return input;
}
 
int main(void)
{
    CPoint c;
    cin>>c;
    cout<<c;   
 
    return 0;
}
 
 
 
/*

 *
转换函数实现类型强制转换
 * Lzy      2011-8-8
 */
 
#include

using
namespace std;
 
class CPoint
{
private:
    float x;
public:
    CPoint(float _x=0):x(_x){}
    operator
int(){return (int)x;}
};
 
int main(void)
{
    CPoint c(12.5);
    int y = (int)c;
    cout<
 
    return 0;
}