C++运算符重载的心得

最新推荐文章于 2022-05-07 19:34:19 发布
最新推荐文章于 2022-05-07 19:34:19 发布
阅读量1.6k 收藏 2
点赞数
文章标签： c++ null struct delete c class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyjhx0105/article/details/7420701
版权

第一次写这种技术的博客,如果有大牛经过,请指导:

 

说到C++运算符重载,不得不先说说C++都有哪些运算符,C++包含以下运算符:

能重载的有:::::==(等于),   !=(不等于),  <(小于), >(大于),<=(小于等于),>=(大于等于), +(加),-(减),*(乘),/(除),%(取模),||(逻辑或),&&(逻辑与),!(逻辑非),+(正),-(负),*(指针),&(取地址),

++(自增),--(自减),|(按位或),&(按位与),~(按位取反),^(按位异或),<<(左移).>>(右移),=(等于),+=(加等于),-=(减等于),*=(乘等于),/=(除等于),%=(取模等于),&=(按位于等于),|=(按位或等于),

^=(按位异或等于),<<=(左移等于),>>=(右移等于),new,delete,new[],delete[] ,()(函数调用),->(成员访问),->*(成员指针访问),,(逗号),[](下标),>>(输入流),<<(输出流),

不能重载的五个:::::?:(条件运算符),.(成员访问运算符),.*(成员指针访问运算符),::(域运算符),sizeof(长度运算符)

还有一种比较特殊的可重载运算符:::强制类型转换运算符 格式为(类型名)(表达式)如int(a);

以下为各个运算符重载格式,代码没有任何意义,主要是注释里面的格式:

new,delete,new[],delete[] 的重载比较特殊,这里代码虽然有,但是我会在下一次blog更新的时候写new,delete,new[],delete[] 的详细说明.

重载为成员函数格式代码为:

/********************************************************************
 filename:  f:\work\testOperatorOverload\testOperatorOverload\MBString.h
 file path: f:\work\testOperatorOverload\testOperatorOverload
 file base: MBString
 file ext: h
 author:  dyj
 
 purpose: 学习重载运算符，且运算符作为成员函数
                .  .*  :: sizeof ?: 不能被重载

                本类实现的都是重载运算符作为成员函数
*********************************************************************/

#pragma once

#include <iostream>
using namespace std;

struct _structson_
{
    int j;
};

struct _struct_//测试MBString类重载->使用
{
    int i;
    _structson_ *son;
    _structson_* operator -> ()
    {
        return son;
    };
};


class MBString
{
public:
    MBString(void);
    ~MBString(void);

public:
    /******************复制构造函数*******************/
    MBString(MBString&src);

public:
    /************************************************************************/
    /**********************************隐式转换******************************/
    /************************************************************************/
    explicit MBString(int i);//explicit 需要显示调用该构造函数进行转换,阻止隐式转换

    explicit MBString(char c);

    explicit MBString(char* p);

    explicit MBString(short int i);

    explicit MBString(_struct_& s);

    MBString(long long l);   

public:
    /************************************************************************/
    /********************以下4个运算符重载时必须作为成员函数*****************/
    /************************************************************************/

    /************* =号重载格式为 T operator = (T1),其中T和T1可以为任意类型，也可为引用*************/
    MBString& operator = (const MBString& srcObj);

    /************************ []号重载，格式为  T operator [] (T1)***************************/
    //const char& operator [] (int i);//返回值可以作为左值
    //char& operator [] (int i);//返回值可以作为左值
    char operator [] (int i);//返回值不能作为左值

    /************************ ()号重载,格式为 T operator () (T1, T2,...)唯一一个参数可以为0-多个的运算符***************************/
    //char* operator () (char c);
    //char* operator () (int i, char c);
    const char* operator () ();

    /**************** ->重载, 格式为 T operator -> () 参数必须为空,返回值必须含有->对象***************/
    //_struct_* operator -> ()//这个也是正确的
    //{       
    //    return m_pStruct;
    //};

    _struct_& operator -> ();
    //{
    //    return *m_pStruct;
    //};

 

    /************************************************************************/
    /***************以下运算符即可重载为成员函数,又可为友元函数**************/
    /************************************************************************/
public:
    /************************************************************************/
    /***************************双目算术运算符重载***************************/
    /************************************************************************/

    /*************** +号重载,格式为 T operator + (T1)****************/
    MBString operator + (const MBString& ms2);
   
    /*************** -号重载,格式为 T operator - (T1)****************/
    MBString operator - (const MBString& ms2);

    /*************** *号重载,格式为 T operator * (T1)****************/
    MBString operator * (const MBString& ms2);

    /*************** /号重载,格式为 T operator / (T1)****************/
    MBString operator / (const MBString& ms2);

    /*************** %号重载,格式为 T operator % (T1)****************/
    MBString operator % (const MBString& ms2);

public:
    /************************************************************************/
    /****************************关系运算符重载******************************/
    /************************************************************************/

    /***************** ==号重载, 格式为 T operator == (T1)*****************/
    bool operator == (const MBString& ms2);

    /***************** !=号重载, 格式为 T operator != (T1)*****************/
    bool operator != (const MBString& ms2);

    /***************** <号重载, 格式为 T operator < (T1)*****************/
    bool operator < (const MBString& ms2);

    /***************** <=号重载, 格式为 T operator <= (T1)*****************/
    bool operator <= (const MBString& ms2);

    /***************** >号重载, 格式为 T operator > (T1)*****************/
    bool operator > (const MBString& ms2);

    /***************** >=号重载, 格式为 T operator >= (T1)*****************/
    bool operator >= (const MBString& ms2);

public:
    /************************************************************************/
    /******************************逻辑运算符重载****************************/
    /************************************************************************/

    /************* ||号重载,一般不重载,格式为 T operator || (T1)************/
    bool operator || (const MBString& ms2);

    /***************** &&号重载, 一般不重载,格式为 T operator && (T1)*****************/
    bool operator && (const MBString& ms2);

    /***************** !号重载,格式为 T operator ! ()*****************/
    bool operator ! ();

public:
    /************************************************************************/
    /****************************单目运算符重载******************************/
    /************************************************************************/

    /***************** +(正)号重载, 格式为 T operator + ()*****************/
    MBString& operator + ();
   
    /***************** -(负)号重载, 格式为 T operator - ()*****************/
    MBString& operator - ();

    /***************** &号重载, 格式为 T operator & ()*****************/
    MBString* operator & ();

    /***************** *号重载, 格式为 T operator * ()*****************/
    MBString& operator * ();

public:
    /************************************************************************/
    /***************************自增自减运算符重载***************************/
    /************************************************************************/

    /***************** 前置++号重载, 格式为 T operator ++ ()*****************/
    MBString& operator ++ ();

    /***************** 后置++号重载, 格式为 T operator ++ (int)*****************/
    MBString operator ++ (int);

    /***************** 前置--号重载, 格式为 T operator ++ ()*****************/
    MBString& operator --();

    /***************** 后置--号重载, 格式为 T operator ++ (int)*****************/
    MBString operator -- (int);

public:
    /************************************************************************/
    /******************************位运算符**********************************/
    /************************************************************************/

    /***************** |号重载, 格式为 T operator | (T1)*****************/
    MBString operator | (const MBString& ms2);

    /***************** &号重载, 格式为 T operator & (T1)*****************/
    MBString operator & (const MBString& ms2);

    /***************** ^号重载, 格式为 T operator ^ (T1)*****************/
    MBString operator ^ (const MBString& ms2);

    /***************** <<号重载, 格式为 T operator << (T1)*****************/
    MBString operator << (int i);
    //friend ostream& operator >> (ostream&, MBString&);

    /***************** <<号重载, 格式为 T operator << (T1)*****************/
    MBString operator >> (int i);
    //friend istream& operator >> (istream&, MBString&);

    /***************** ~号重载, 格式为 T operator ~ ()*****************/
    MBString operator ~ ();

public:
    /************************************************************************/
    /******************************赋值运算符********************************/
    /************************************************************************/

    /***************** +=号重载, 格式为 T operator += (T1)*****************/
    MBString& operator += (const MBString& ms2);

    /***************** -=号重载, 格式为 T operator -= (T1)*****************/
    MBString& operator -= (const MBString& ms2);

    /***************** *=号重载, 格式为 T operator *= (T1)*****************/
    MBString& operator *= (const MBString& ms2);

    /***************** /=号重载, 格式为 T operator /= (T1)*****************/
    MBString& operator /= (const MBString& ms2);

    /***************** %=号重载, 格式为 T operator %= (T1)*****************/
    MBString& operator %= (const MBString& ms2);

    /***************** &=号重载, 格式为 T operator &= (T1)*****************/
    MBString& operator &= (const MBString& ms2);

    /***************** |=号重载, 格式为 T operator |= (T1)*****************/
    MBString& operator |= (const MBString& ms2);

    /***************** ^=号重载, 格式为 T operator ^= (T1)*****************/
    MBString& operator ^= (const MBString& ms2);

    /***************** <<=号重载, 格式为 T operator <<= (T1)*****************/
    MBString& operator <<= (int i);

    /***************** >>=号重载, 格式为 T operator >>= (T1)*****************/
    MBString& operator >>= (int i);

public:
    /************************************************************************/
    /***************************new,new[]和delete,delete[]的重载****************************/
    /************************************************************************/

    /**************重载格式 void* operator new(size_t size, T1,T2.....)***************/
    void *operator new(size_t size);

    void *operator new(size_t size, int i);

    void *operator new[](size_t size);

    void operator delete(void*p);

    void operator delete(void*p, int i, int j);

    void operator delete [](void* p);

public:
    /************************************************************************/
    /********类型转换函数格式为operator <const>type () <const>只能为成员函数********/
    /************************************************************************/

    /********** 强制转换为char* *********/
    operator char* () const;//or operator char* const() or operator char* ()

    /*********** 强制转换为int ***********/
    operator int ();

    /*********** 强制转换为char ************/
    operator const char () const;

    /*********** 强制转换为短整形 ************/
    operator short int () const;

    /*********** 强制转换为长整形 ************/
    operator long long () const;

    /*********** 强制转换为_struct_ *************/
    operator _struct_ () const;

    /*********** 强制转换为void *************/
    operator void* () const;

public:
    /************************************************************************/
    /*****************************其他运算符重载*****************************/
    /************************************************************************/

    /************* ,运算符重载,一般不重载该运算符, 格式为 T operator , (T1)***************/
    MBString& operator , (int i/*const MBString& ms*/);


    /************成员指针运算符重载格式为 T operator ->* (T1)************/
    MBString& operator ->* (char c);


    const char* operator ->* (char c) const;


    int fun() const
    {
        return 0;
    };

    //typedef int (MBString::*pmf)() const;

private:
    _struct_* m_pStruct;
    long long m_lLong;
    int m_nInt;
    short int m_nShort;
    char* m_pChar;
    char m_cChar;
    void* m_vVoid;
};

#include "MBString.h"

/************************************************************************/
/**************************构造函数和析构函数****************************/
/************************************************************************/
MBString::MBString(void)
{
    m_pStruct = (_struct_*)malloc(sizeof(_struct_));
    m_pStruct->i = 1;
    m_pStruct->son = (_structson_*)malloc(sizeof(_structson_));
    m_pStruct->son->j = 2;
    m_lLong = 0x0100000000000000;
    m_nInt = 0x01000000;
    m_nShort = 0x0100;   
    m_cChar = 0x01;
    m_pChar = (char*) malloc(10);
    memset(m_pChar, 0, 10);
    m_vVoid = NULL;
}

MBString::~MBString(void)
{
    if (NULL != m_pChar)
    {
        free(m_pChar);
        m_pChar = NULL;
    }


    if (NULL != m_vVoid)
    {
        free(m_vVoid);
        m_vVoid = NULL;
    }

    if (NULL != m_pStruct)
    {
        if (NULL != m_pStruct->son)
        {
            free(m_pStruct->son);
            m_pStruct->son = NULL;
        }

        free(m_pStruct);
        m_pStruct = NULL;
    }
}

/************************************************************************/
/*******************************复制构造函数*****************************/
/************************************************************************/

MBString::MBString(MBString& src)
{
   
    m_lLong = src.m_lLong;
    m_nInt = src.m_nInt;
    m_nShort = src.m_nShort;
   
    m_cChar = src.m_cChar;

    if (NULL == src.m_pChar)
    {
        m_pChar = NULL;
    }
    else
    {
        m_pChar = (char*)malloc(strlen(src.m_pChar)+1);
        memcpy(m_pChar, src.m_pChar, strlen(src.m_pChar));
        m_pChar[strlen(src.m_pChar)] = 0;
    }
   
    if (NULL == src.m_vVoid)
    {
        m_vVoid = NULL;
    }
    else
    {
        m_vVoid = malloc(strlen((char*)src.m_vVoid)+1);
        memcpy(m_vVoid, src.m_vVoid,strlen((char*)src.m_vVoid));
        ((char*)m_vVoid)[strlen((char*)src.m_vVoid)] = 0;
    }

    if (NULL == src.m_pStruct)
    {
        m_pStruct = NULL;
    }
    else
    {
        m_pStruct = (_struct_*)malloc(sizeof(_struct_));
        m_pStruct->i = src.m_pStruct->i;
        if (NULL == src.m_pStruct->son)
        {
            m_pStruct->son = NULL;
        }
        else
        {
            m_pStruct->son = (_structson_*)malloc(sizeof(_structson_));
            m_pStruct->son->j = src.m_pStruct->son->j;
        }
    }   
}

/************************************************************************/
/********************************隐式转换********************************/
/************************************************************************/

MBString::MBString(int i)
{   
    m_pStruct = NULL;
    m_lLong = 0;
    m_nInt = i;
    m_nShort = 0;
    m_pChar = NULL;
    m_cChar = 0;
    m_vVoid = NULL;
}

MBString::MBString(char c)
{
    m_pStruct = NULL;
    m_lLong = 0;
    m_nInt = 0;
    m_nShort = 0;
    m_pChar = NULL;
    m_cChar = c;
    m_vVoid = NULL;
}

MBString::MBString(char* p)
{
    m_pStruct = NULL;
    m_lLong = 0;
    m_nInt = 0;
    m_nShort = 0;   
    m_cChar = 0;
    m_vVoid = NULL;

    m_pChar = (char*)malloc(strlen(p)+1);
    memcpy(m_pChar, p, strlen(p));
    m_pChar[strlen(p)] = 0;
}

MBString::MBString(short int i)
{
    m_pStruct = NULL;
    m_lLong = 0;
    m_nInt = 0;
    m_nShort = i;
    m_pChar = NULL;
    m_cChar = 0;
    m_vVoid = NULL;
}

MBString::MBString(_struct_& s)
{ 
    m_lLong = 0;
    m_nInt = 0;
    m_nShort = 0;
    m_pChar = NULL;
    m_cChar = 0;
    m_vVoid = NULL;
    m_pStruct = (_struct_*)malloc(sizeof(_struct_));
    m_pStruct->i = s.i;

    if (NULL == s.son)
    {
        m_pStruct->son = NULL;
    }
    else
    {
        m_pStruct->son = (_structson_*)malloc(sizeof(_structson_));
        m_pStruct->son->j = s.son->j;
    }
}

MBString::MBString(long long l)
{
    m_pStruct = NULL;
    m_lLong = l;
    m_nInt = 0;
    m_nShort = 0;
    m_pChar = NULL;
    m_cChar = 0;
    m_vVoid = NULL;
}

/************************************************************************/
/********************以下4个运算符重载时必须作为成员函数*****************/
/************************************************************************/

MBString& MBString::operator = (const MBString& srcObj)
{
    if (this != &srcObj)
    {
        m_lLong = srcObj.m_lLong;
        m_nInt = srcObj.m_nInt;
        m_nShort = srcObj.m_nShort;       
        m_cChar = srcObj.m_cChar; 

        if (NULL != m_pChar)
        {
            free(m_pChar);
            m_pChar = NULL;
        }
        if (NULL == srcObj.m_pChar)
        {
            m_pChar = NULL;
        }
        else
        {
            m_pChar = (char*)malloc(strlen(srcObj.m_pChar)+1);
            memcpy(m_pChar, srcObj.m_pChar, strlen(srcObj.m_pChar));
            m_pChar[strlen(srcObj.m_pChar)] = 0;
        }

        if (NULL != m_vVoid)
        {
            free(m_vVoid);
            m_vVoid = NULL;
        }
        if (NULL == srcObj.m_vVoid)
        {
            m_vVoid = NULL;
        }
        else
        {
            m_vVoid = malloc(strlen((char*)srcObj.m_vVoid)+1);
            memcpy(m_vVoid, srcObj.m_vVoid,strlen((char*)srcObj.m_vVoid));
            ((char*)m_vVoid)[strlen((char*)srcObj.m_vVoid)] = 0;
        }

        if (NULL != m_pStruct)
        {
            if (NULL != m_pStruct->son)
            {
                free(m_pStruct->son);
            }
            free(m_pStruct);
            m_pStruct = NULL;
        }
        if (NULL == srcObj.m_pStruct)
        {
            m_pStruct = NULL;
        }
        else
        {
            m_pStruct = (_struct_*)malloc(sizeof(_struct_));
            m_pStruct->i = srcObj.m_pStruct->i;
            if (NULL == srcObj.m_pStruct->son)
            {
                m_pStruct->son = NULL;
            }
            else
            {
                m_pStruct->son = (_structson_*)malloc(sizeof(_structson_));
                m_pStruct->son->j = srcObj.m_pStruct->son->j;
            }
        }  
    }

    return *this;
}

char MBString::operator [] (int i)
{
    if (NULL == m_pChar)
    {
        return '\0';
    }

    if (i > (strlen(m_pChar)-1))
    {
        return '\0';
    }
    else
    {
        return m_pChar[i];
    }
}

const char* MBString::operator () ()
{
    return m_pChar;
}

_struct_& MBString::operator -> ()
{
    return *m_pStruct;
}

/************************************************************************/
/***************以下运算符即可重载为成员函数,又可为友元函数**************/
/************************************************************************/

/************************************************************************/
/***************************双目算术运算符重载***************************/
/************************************************************************/

/*************** +号重载,格式为 T operator + (T1)****************/
MBString MBString::operator + (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt+ms2.m_nInt;
    tmp.m_lLong = m_lLong+ms2.m_lLong;
    tmp.m_nShort = m_nShort+ms2.m_nShort;
    return tmp;
}

/*************** -号重载,格式为 T operator - (T1)****************/
MBString MBString::operator - (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt-ms2.m_nInt;
    tmp.m_lLong = m_lLong-ms2.m_lLong;
    tmp.m_nShort = m_nShort-ms2.m_nShort;
    return tmp;
}

/*************** *号重载,格式为 T operator * (T1)****************/
MBString MBString::operator * (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt*ms2.m_nInt;
    tmp.m_lLong = m_lLong*ms2.m_lLong;
    tmp.m_nShort = m_nShort*ms2.m_nShort;
    return tmp;
}

/*************** /号重载,格式为 T operator / (T1)****************/
MBString MBString::operator / (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt/ms2.m_nInt;
    tmp.m_lLong = m_lLong/ms2.m_lLong;
    tmp.m_nShort = m_nShort/ms2.m_nShort;
    return tmp;
}

/*************** %号重载,格式为 T operator % (T1)****************/
MBString MBString::operator % (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt%ms2.m_nInt;
    tmp.m_lLong = m_lLong%ms2.m_lLong;
    tmp.m_nShort = m_nShort%ms2.m_nShort;
    return tmp;
}

/************************************************************************/
/****************************关系运算符重载******************************/
/************************************************************************/

/***************** ==号重载, 格式为 T operator == (T1)*****************/
bool MBString::operator == (const MBString& ms2)
{
    return m_nInt == ms2.m_nInt;
}

/***************** !=号重载, 格式为 T operator != (T1)*****************/
bool MBString::operator != (const MBString& ms2)
{
    return m_nInt != ms2.m_nInt;
}

/***************** <号重载, 格式为 T operator < (T1)*****************/
bool MBString::operator < (const MBString& ms2)
{
    return m_nInt < ms2.m_nInt;
}

/***************** <=号重载, 格式为 T operator <= (T1)*****************/
bool MBString::operator <= (const MBString& ms2)
{
    return m_nInt <= ms2.m_nInt;
}

/***************** >号重载, 格式为 T operator > (T1)*****************/
bool MBString::operator > (const MBString& ms2)
{
    return m_nInt > ms2.m_nInt;
}

/***************** >=号重载, 格式为 T operator >= (T1)*****************/
bool MBString::operator >= (const MBString& ms2)
{
    return m_nInt >= ms2.m_nInt;
}

/************************************************************************/
/******************************逻辑运算符重载****************************/
/************************************************************************/

/***************** ||号重载, 格式为 T operator || (T1)*****************/
bool MBString::operator || (const MBString& ms2)
{
    return (NULL == m_pChar || NULL == ms2.m_pChar);
}

/***************** &&号重载, 格式为 T operator && (T1)*****************/
bool MBString::operator && (const MBString& ms2)
{
    return (NULL == m_pChar && NULL == ms2.m_pChar);
}

/***************** !号重载, 格式为 T operator ! ()*****************/
bool MBString::operator ! ()
{
    return !m_pChar;
}

/************************************************************************/
/****************************单目运算符重载******************************/
/************************************************************************/

/***************** +(正)号重载, 格式为 T operator + ()*****************/
MBString& MBString::operator + ()
{
    return *this;
}

/***************** -(负)号重载, 格式为 T operator - ()*****************/
MBString& MBString::operator - ()
{
    m_nInt = - m_nInt;
    return *this;
}

/***************** &号重载, 格式为 T operator & ()*****************/
MBString* MBString::operator & ()
{
    return this;
}

/***************** *号重载, 格式为 T operator * ()*****************/
MBString& MBString::operator * ()
{
    return *this;
}

/************************************************************************/
/***************************自增自减运算符重载***************************/
/************************************************************************/

/***************** 前置++号重载, 格式为 T operator ++ ()*****************/
MBString& MBString::operator ++ ()
{   
    m_lLong++;
    m_nInt++;
    m_nShort++;
    m_pChar++;
    return *this;
}

/***************** 后置++号重载, 格式为 T operator ++ ()*****************/
MBString MBString::operator ++ (int)
{
    MBString tmp(*this);
    m_lLong++;
    m_nInt++;
    m_nShort++;
    m_pChar++;
    return tmp;
}

/***************** 前置--号重载, 格式为 T operator ++ ()*****************/
MBString& MBString::operator --()
{
    m_lLong--;
    m_nInt--;
    m_nShort--;
    m_pChar--;
    return *this;
}

/***************** 后置--号重载, 格式为 T operator ++ ()*****************/
MBString MBString::operator -- (int)
{
    MBString tmp(*this);
    m_lLong--;
    m_nInt--;
    m_nShort--;
    m_pChar--;
    return tmp;
}

/************************************************************************/
/******************************位运算符**********************************/
/************************************************************************/

/***************** |号重载, 格式为 T operator | (T1)*****************/
MBString MBString::operator | (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt|ms2.m_nInt;
    tmp.m_lLong = m_lLong|ms2.m_lLong;
    tmp.m_nShort = m_nShort|ms2.m_nShort;
    return tmp;
}

/***************** &号重载, 格式为 T operator & (T1)*****************/
MBString MBString::operator & (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt&ms2.m_nInt;
    tmp.m_lLong = m_lLong&ms2.m_lLong;
    tmp.m_nShort = m_nShort&ms2.m_nShort;
    return tmp;
}

/***************** ^号重载, 格式为 T operator ^ (T1)*****************/
MBString MBString::operator ^ (const MBString& ms2)
{
    MBString tmp;
    tmp.m_nInt = m_nInt^ms2.m_nInt;
    tmp.m_lLong = m_lLong^ms2.m_lLong;
    tmp.m_nShort = m_nShort^ms2.m_nShort;
    return tmp;
}

/***************** <<号重载, 格式为 T operator << (T1)*****************/
MBString MBString::operator << (int i)
{
    MBString tmp(*this);
    tmp.m_nInt = m_nInt<<i;
    tmp.m_lLong = m_lLong<<i;
    tmp.m_nShort = m_nShort<<i;
    return tmp;
}
//friend ostream& operator >> (ostream&, MBString&);

/***************** <<号重载, 格式为 T operator << (T1)*****************/
MBString MBString::operator >> (int i)
{
    MBString tmp(*this);
    tmp.m_nInt = m_nInt>>i;
    tmp.m_lLong = m_lLong>>i;
    tmp.m_nShort = m_nShort>>i;
    return tmp;
}
//friend istream& operator >> (istream&, MBString&);

/***************** ~号重载, 格式为 T operator ~ ()*****************/
MBString MBString::operator ~ ()
{
    MBString tmp(*this);
    tmp.m_nInt = ~m_nInt;
    tmp.m_lLong = ~m_lLong;
    tmp.m_nShort = ~m_nShort;
    return tmp;
}

/************************************************************************/
/******************************赋值运算符********************************/
/************************************************************************/

/***************** +=号重载, 格式为 T operator += (T1)*****************/
MBString& MBString::operator += (const MBString& ms2)
{
    m_lLong+=ms2.m_lLong;
    m_nInt+=ms2.m_nInt;
    m_nShort+=ms2.m_nShort;
    return *this;
}

/***************** -=号重载, 格式为 T operator -= (T1)*****************/
MBString& MBString::operator -= (const MBString& ms2)
{
    m_lLong-=ms2.m_lLong;
    m_nInt-=ms2.m_nInt;
    m_nShort-=ms2.m_nShort;
    return *this;
}

/***************** *=号重载, 格式为 T operator *= (T1)*****************/
MBString& MBString::operator *= (const MBString& ms2)
{
    m_lLong*=ms2.m_lLong;
    m_nInt*=ms2.m_nInt;
    m_nShort*=ms2.m_nShort;
    return *this;
}

/***************** /=号重载, 格式为 T operator /= (T1)*****************/
MBString& MBString::operator /= (const MBString& ms2)
{
    m_lLong/=ms2.m_lLong;
    m_nInt/=ms2.m_nInt;
    m_nShort/=ms2.m_nShort;
    return *this;
}

/***************** %=号重载, 格式为 T operator %= (T1)*****************/
MBString& MBString::operator %= (const MBString& ms2)
{
    m_lLong%=ms2.m_lLong;
    m_nInt%=ms2.m_nInt;
    m_nShort%=ms2.m_nShort;
    return *this;
}

/***************** &=号重载, 格式为 T operator &= (T1)*****************/
MBString& MBString::operator &= (const MBString& ms2)
{
    m_lLong&=ms2.m_lLong;
    m_nInt&=ms2.m_nInt;
    m_nShort&=ms2.m_nShort;
    return *this;
}

/***************** |=号重载, 格式为 T operator |= (T1)*****************/
MBString& MBString::operator |= (const MBString& ms2)
{
    m_lLong|=ms2.m_lLong;
    m_nInt|=ms2.m_nInt;
    m_nShort|=ms2.m_nShort;
    return *this;
}

/***************** ^=号重载, 格式为 T operator ^= (T1)*****************/
MBString& MBString::operator ^= (const MBString& ms2)
{
    m_lLong^=ms2.m_lLong;
    m_nInt^=ms2.m_nInt;
    m_nShort^=ms2.m_nShort;
    return *this;
}

/***************** <<=号重载, 格式为 T operator <<= (T1)*****************/
MBString& MBString::operator <<= (int i)
{
    m_lLong<<=i;
    m_nInt<<=i;
    m_nShort<<=i;
    return *this;
}

/***************** >>=号重载, 格式为 T operator >>= (T1)*****************/
MBString& MBString::operator >>= (int i)
{
    m_lLong>>=i;
    m_nInt>>=i;
    m_nShort>>=i;
    return *this;
}

/************************************************************************/
/***************************new,new[]和delete,delete[]的重载****************************/
/************************************************************************/

void* MBString::operator new(size_t size)
{
    //return ::operator new(size);
    return malloc(size);
};

void* MBString::operator new(size_t size, int i)
{
    return malloc(size);
}

void* MBString::operator new[](size_t size)
{
    return malloc(size);
}

void MBString::operator delete(void*p)
{
    free(p);
};

void MBString::operator delete(void*p, int i, int j)
{
    free(p);
}

void MBString::operator delete [](void* p)
{
    free(p);
}

/************************************************************************/
/**************类型转换函数格式为operator type () <const>*************/
/************************************************************************/

/********** 强制转换为char* *********/
MBString::operator char* () const
{
    return m_pChar;
}//or operator char* const() or operator char* ()

/*********** 强制转换为int ***********/
MBString::operator int ()
{
    return m_nInt;
}

/*********** 强制转换为char ************/
MBString::operator const char () const
{
    return m_cChar;
}

/*********** 强制转换为短整形 ************/
MBString::operator short int () const
{
    return m_nShort;
}

/*********** 强制转换为长整形 ************/
MBString::operator long long () const
{
    return m_lLong;
}

/*********** 强制转换为_struct_ *************/
MBString::operator _struct_ () const
{
    return *m_pStruct;
}

/*********** 强制转换为void *************/
MBString::operator void* () const
{
    return m_vVoid;
}


/************************************************************************/
/*****************************其他运算符重载*****************************/
/************************************************************************/

MBString& MBString::operator , (int i)
{
    return *this;
}

MBString& MBString::operator ->* (char c)
{
    return *this;
}

const char* MBString::operator ->* (char c) const
{
    return m_pChar;
}

重载为友元函数为:

/********************************************************************
 created: 2012/03/28
 created: 28:3:2012   15:23
 filename:  f:\work\testOperatorOverload\testOperatorOverload\FBString.h
 file path: f:\work\testOperatorOverload\testOperatorOverload
 file base: FBString
 file ext: h
 author:  dyj
 
 purpose: 学习重载运算符,本类实现的都是重载运算符作为友元函数
*********************************************************************/
#pragma once

#include <iostream>
using namespace std;

struct _structFB_//测试FBString类重载->使用
{
    int i;
};

class FBString
{
public:
    FBString(void);
    ~FBString(void);

public:
    /*复制构造函数*/
    FBString(const FBString& src);

public:
    /************************************************************************/
    /********************以下2个运算符重载时必须作为友元函数*****************/
    /************************************************************************/

    /*************流输入运算符格式为 friend istream& operator >> (istream& , T& src) ****************/
    friend istream& operator >> (istream& inputs, FBString& src);

    //friend istream& operator >> (istream& inputs, _structFB_ i);//这个也行不过cin>>_structFB_类型的

    /*************流输出运算符格式为 friend ostream& operator << (ostream& , <const>T& src) ****************/   
    friend ostream& operator << (ostream& outputs, const FBString& src);

public:
    /************************************************************************/
    /****************双目算术运算符重载T1和T2必须有一个是类对象****************/
    /************************************************************************/

    /*************** +号重载,格式为 friend T operator + (T1, T2)****************/
    friend FBString operator + (const FBString& fs1,const FBString& fs2);

    /*************** -号重载,格式为 friend T operator - (T1, T2)****************/
    friend FBString operator - (const FBString& fs1,const FBString& fs2);

    /*************** *号重载,格式为 friend T operator * (T1, T2)****************/
    friend FBString operator * (const FBString& fs1,const FBString& fs2);

    /*************** /号重载,格式为 friend T operator / (T1, T2)****************/
    friend FBString operator / (const FBString& fs1,const FBString& fs2);

    /*************** %号重载,格式为 friend T operator % (T1, T2)****************/
    friend FBString operator % (const FBString& fs1,const FBString& fs2);

public:
    /************************************************************************/
    /****************关系运算符重载T1和T2必须有一个是类对象******************/
    /************************************************************************/

    /***************** ==号重载, 格式为 friend T operator == (T1,T2)*****************/
    friend bool operator == (const FBString& fs1, const FBString& fs2);

    /***************** !=号重载, 格式为 friend T operator != (T1,T2)*****************/
    friend bool operator != (const FBString& fs1, const FBString& fs2);

    /***************** <号重载, 格式为 friend T operator < (T1,T2)*****************/
    friend bool operator < (const FBString& fs1, const FBString& fs2);

    /***************** <=号重载, 格式为 friend T operator <= (T1,T2)*****************/
    friend bool operator <= (const FBString& fs1, const FBString& fs2);

    /***************** >号重载, 格式为 friend T operator > (T1,T2)*****************/
    friend bool operator > (const FBString& fs1, const FBString& fs2);

    /***************** >=号重载, 格式为 friend T operator >= (T1,T2)*****************/
    friend bool operator >= (const FBString& fs1, const FBString& fs2);

public:
    /************************************************************************/
    /*****************逻辑运算符重载T1和T2必须有一个是类对象*****************/
    /************************************************************************/

    /************* ||号重载,一般不重载,格式为 friend T operator || (T1,T2)************/
    friend bool operator || (const FBString& fs1, const FBString& fs2);

    /***************** &&号重载, 一般不重载,格式为 friend T operator && (T1,T2)*****************/
    friend bool operator && (const FBString& fs1, const FBString& fs2);

    /***************** !号重载,格式为 friend T operator ! (T1)*****************/
    friend bool operator ! (const FBString& fs);

public:
    /************************************************************************/
    /****************************单目运算符重载******************************/
    /************************************************************************/

    /***************** +(正)号重载, 格式为 friend T operator + (T1)*****************/
    friend FBString operator + (FBString& fs);

    /***************** -(负)号重载, 格式为 friend T operator - (T1)*****************/
    friend FBString operator - (FBString& fs);

    /***************** &号重载, 格式为 friend T operator & (T1)*****************/
    friend FBString* operator & (FBString& fs);

    /***************** *号重载, 格式为 friend T operator * (T1)*****************/
    friend FBString operator * (FBString& fs);

public:
    /************************************************************************/
    /***************************自增自减运算符重载***************************/
    /************************************************************************/

    /***************** 前置++号重载, 格式为 friend T operator ++ (T1)*****************/
    friend FBString& operator ++ (FBString& fs);

    /***************** 后置++号重载, 格式为 friend T operator ++ (T1,int)*****************/
    friend FBString operator ++ (FBString& fs,int);

    /***************** 前置--号重载, 格式为 friend T operator ++ (T1)*****************/
    friend FBString& operator --(FBString& fs);

    /***************** 后置--号重载, 格式为 friend T operator ++ (T1,int)*****************/
    friend FBString operator -- (FBString& fs,int);

public:
    /************************************************************************/
    /**********************位运算符T1,T2必须有个类对象***********************/
    /************************************************************************/

    /***************** |号重载, 格式为 friend T operator | (T1,T2)*****************/
    friend FBString operator | (const FBString& fs1, const FBString& fs2);

    /***************** &号重载, 格式为 friend T operator & (T1,T2)*****************/
    friend FBString operator & (const FBString& fs1, const FBString& fs2);

    /***************** ^号重载, 格式为 friend T operator ^ (T1,T2)*****************/
    friend FBString operator ^ (const FBString& fs1, const FBString& fs2);

    /***************** <<号重载, 格式为 friend T operator << (T1,T2)*****************/
    friend FBString operator << (const FBString& fs1, int i);
    //friend FBString operator << (int i,const FBString& fs1);//这种也没问题,只要你会玩

    /***************** <<号重载, 格式为 friend T operator << (T1,T2)*****************/
    friend FBString operator >> (const FBString& fs1, int i);   

    /***************** ~号重载, 格式为 friend T operator ~ (T1)*****************/
    friend FBString operator ~ (const FBString& fs1);

public:
    /************************************************************************/
    /*********************赋值运算符T1,T2必须有个类对象**********************/
    /************************************************************************/

    /***************** +=号重载, 格式为 friend T operator += (T1,T2)*****************/
    friend FBString& operator += (FBString& fs1, const FBString& fs2);

    /***************** -=号重载, 格式为 friend T operator -= (T1,T2)*****************/
    friend FBString& operator -= (FBString& fs1, const FBString& fs2);

    /***************** *=号重载, 格式为 friend T operator *= (T1,T2)*****************/
    friend FBString& operator *= (FBString& fs1, const FBString& fs2);

    /***************** /=号重载, 格式为 friend T operator /= (T1,T2)*****************/
    friend FBString& operator /= (FBString& fs1, const FBString& fs2);

    /***************** %=号重载, 格式为 friend T operator %= (T1,T2)*****************/
    friend FBString& operator %= (FBString& fs1, const FBString& fs2);

    /***************** &=号重载, 格式为 friend T operator &= (T1,T2)*****************/
    friend FBString& operator &= (FBString& fs1, const FBString& fs2);

    /***************** |=号重载, 格式为 friend T operator |= (T1,T2)*****************/
    friend FBString& operator |= (FBString& fs1, const FBString& fs2);

    /***************** ^=号重载, 格式为 friend T operator ^= (T1,T2)*****************/
    friend FBString& operator ^= (FBString& fs1, const FBString& fs2);

    /***************** <<=号重载, 格式为 friend T operator <<= (T1,T2)*****************/
    friend FBString& operator <<= (FBString& fs1, int i);

    /***************** >>=号重载, 格式为 friend T operator >>= (T1,T2)*****************/
    friend FBString& operator >>= (FBString& fs1, int i);

public:
        /************************************************************************/
        /*****************************其他运算符重载*****************************/
        /************************************************************************/

        /************* ,运算符重载,一般不重载该运算符, 格式为 friend T operator , (T1,T2)***************/
        friend FBString& operator , (FBString& fs1, FBString& fs2);


        /************成员指针运算符重载格式为 friend T operator ->* (T1,T2)************/
        friend const _structFB_* operator ->* (const FBString& fs1, char c);       

public:
    friend void* operator new (size_t size) throw(bad_alloc)//相当于全局的重载
    {
        return NULL;
    }

    void* operator new (size_t size)//和上面的friend同时拥有该类的new会屏蔽上面的friend
    {
        return malloc(size);
    }

    //friend void* operator new (size_t t, void* location)
    //{
    //    return location;
    //}

    //void* operator new[] (size_t t)
    //{
    //    return NULL;
    //}

    //void* operator new[] (size_t t, void* location)
    //{
    //    return location;
    //}
private:
    int m_nInt;

    short int m_stShort;
    _structFB_ m_fbs;
};

#include "FBString.h"

FBString::FBString(void)
{
    m_nInt = 8;
    m_stShort = 2;
    m_fbs.i = 5;
}

FBString::~FBString(void)
{
    int j = 0;
}

FBString::FBString(const FBString& src)
{
    m_nInt = src.m_nInt;
    m_stShort = src.m_stShort;
}

/************************************************************************/
/********************以下2个运算符重载时必须作为友元函数*****************/
/************************************************************************/

/*************流输入运算符格式为 friend istream& operator >> (istream& , T& src) ****************/
istream& operator >> (istream& inputs, FBString& src)
{
    cout << "请输入2个整形数据:"<<endl;
    inputs >> src.m_nInt >> src.m_stShort;
    return inputs;
}

/*************流输出运算符格式为 friend ostream& operator << (ostream& , <const>T& src) ****************/
ostream& operator << (ostream& outputs, const FBString& src)
{
    outputs << "src.m_nInt = " <<src.m_nInt << endl;
    outputs << "src.m_stShort = " << src.m_stShort << endl;
    return outputs;
}

/************************************************************************/
/****************双目算术运算符重载T1和T2必须有一个是类对象****************/
/************************************************************************/

/*************** +号重载,格式为 friend T operator + (T1, T2)****************/
FBString operator + (const FBString& fs1,const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt + fs2.m_nInt;
    c.m_stShort = fs1.m_stShort + fs2.m_stShort;
    return c;
}

/*************** -号重载,格式为 friend T operator - (T1, T2)****************/
FBString operator - (const FBString& fs1,const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt - fs2.m_nInt;
    c.m_stShort = fs1.m_stShort - fs2.m_stShort;
    return c;
}

/*************** *号重载,格式为 friend T operator * (T1, T2)****************/
FBString operator * (const FBString& fs1,const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt * fs2.m_nInt;
    c.m_stShort = fs1.m_stShort * fs2.m_stShort;
    return c;
}

/*************** /号重载,格式为 friend T operator / (T1, T2)****************/
FBString operator / (const FBString& fs1,const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt / fs2.m_nInt;
    c.m_stShort = fs1.m_stShort / fs2.m_stShort;
    return c;
}

/*************** %号重载,格式为 friend T operator % (T1, T2)****************/
FBString operator % (const FBString& fs1,const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt % fs2.m_nInt;
    c.m_stShort = fs1.m_stShort % fs2.m_stShort;
    return c;
}

/************************************************************************/
/****************关系运算符重载T1和T2必须有一个是类对象******************/
/************************************************************************/

/***************** ==号重载, 格式为 friend T operator == (T1,T2)*****************/
bool operator == (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt == fs2.m_nInt) && (fs1.m_stShort == fs2.m_stShort));
}

/***************** !=号重载, 格式为 friend T operator != (T1,T2)*****************/
bool operator != (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt != fs2.m_nInt) && (fs1.m_stShort != fs2.m_stShort));
}

/***************** <号重载, 格式为 friend T operator < (T1,T2)*****************/
bool operator < (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt < fs2.m_nInt) && (fs1.m_stShort < fs2.m_stShort));
}

/***************** <=号重载, 格式为 friend T operator <= (T1,T2)*****************/
bool operator <= (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt <= fs2.m_nInt) && (fs1.m_stShort <= fs2.m_stShort));
}

/***************** >号重载, 格式为 friend T operator > (T1,T2)*****************/
bool operator > (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt > fs2.m_nInt) && (fs1.m_stShort > fs2.m_stShort));
}

/***************** >=号重载, 格式为 friend T operator >= (T1,T2)*****************/
bool operator >= (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt>= fs2.m_nInt) && (fs1.m_stShort >= fs2.m_stShort));
}

/************************************************************************/
/*****************逻辑运算符重载T1和T2必须有一个是类对象*****************/
/************************************************************************/

/************* ||号重载,一般不重载,格式为 friend T operator || (T1,T2)************/
bool operator || (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt|| fs2.m_nInt) && (fs1.m_stShort || fs2.m_stShort));
}

/***************** &&号重载, 一般不重载,格式为 friend T operator && (T1,T2)*****************/
bool operator && (const FBString& fs1, const FBString& fs2)
{
    return ((fs1.m_nInt && fs2.m_nInt) && (fs1.m_stShort && fs2.m_stShort));
}

/***************** !号重载,格式为 friend T operator ! (T1)*****************/
bool operator ! (const FBString& fs)
{
    return ((!fs.m_nInt) && (!fs.m_stShort));
}

/************************************************************************/
/****************************单目运算符重载******************************/
/************************************************************************/

/***************** +(正)号重载, 格式为 friend T operator + (T1)*****************/
FBString operator + (FBString& fs)
{
    return fs;
}

/***************** -(负)号重载, 格式为 friend T operator - (T1)*****************/
FBString operator - (FBString& fs)
{
    FBString c;
    c.m_nInt = (-fs.m_nInt);
    c.m_stShort = (-fs.m_stShort);
    return c;
}

/***************** &号重载, 格式为 friend T operator & (T1)*****************/
FBString* operator & (FBString& fs)
{
    return &fs;
}

/***************** *号重载, 格式为 friend T operator * (T1)*****************/
FBString operator * (FBString& fs)
{
    return fs;
}

/************************************************************************/
/***************************自增自减运算符重载***************************/
/************************************************************************/

/***************** 前置++号重载, 格式为 friend T operator ++ (T1)*****************/
FBString& operator ++ (FBString& fs)
{
    ++fs.m_nInt;
    ++fs.m_stShort;
    return fs;
}

/***************** 后置++号重载, 格式为 friend T operator ++ (T1,int)*****************/
FBString operator ++ (FBString& fs,int)
{
    FBString c = fs;
    ++fs.m_nInt;
    ++fs.m_stShort;
    return c;
}

/***************** 前置--号重载, 格式为 friend T operator ++ (T1)*****************/
FBString& operator --(FBString& fs)
{
    --fs.m_nInt;
    --fs.m_stShort;
    return fs;
}

/***************** 后置--号重载, 格式为 friend T operator ++ (T1,int)*****************/
FBString operator -- (FBString& fs,int)
{
    FBString c;
    --fs.m_nInt;
    --fs.m_stShort;
    return c;
}

/************************************************************************/
/**********************位运算符T1,T2必须有个类对象***********************/
/************************************************************************/

/***************** |号重载, 格式为 friend T operator | (T1,T2)*****************/
FBString operator | (const FBString& fs1, const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt | fs2.m_nInt;
    c.m_stShort = fs1.m_stShort | fs2.m_stShort;
    return c;
}

/***************** &号重载, 格式为 friend T operator & (T1,T2)*****************/
FBString operator & (const FBString& fs1, const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt & fs2.m_nInt;
    c.m_stShort = fs1.m_stShort & fs2.m_stShort;
    return c;
}

/***************** ^号重载, 格式为 friend T operator ^ (T1,T2)*****************/
FBString operator ^ (const FBString& fs1, const FBString& fs2)
{
    FBString c;
    c.m_nInt = fs1.m_nInt ^ fs2.m_nInt;
    c.m_stShort = fs1.m_stShort ^ fs2.m_stShort;
    return c;
}

/***************** <<号重载, 格式为 friend T operator << (T1,T2)*****************/
FBString operator << (const FBString& fs1, int i)
{
    FBString c;
    c.m_nInt = fs1.m_nInt << i;
    c.m_stShort = fs1.m_stShort << i;
    return c;
}
//friend FBString operator << (int i,const FBString& fs1);//这种也没问题,只要你会玩

/***************** <<号重载, 格式为 friend T operator << (T1,T2)*****************/
FBString operator >> (const FBString& fs1, int i)
{
    FBString c;
    c.m_nInt = fs1.m_nInt >> i;
    c.m_stShort = fs1.m_stShort >> i;
    return c;
}


/***************** ~号重载, 格式为 friend T operator ~ (T1)*****************/
FBString operator ~ (const FBString& fs1)
{
    FBString c;
    c.m_nInt = ~fs1.m_nInt;
    c.m_stShort = ~fs1.m_stShort;
    return c;
}

/************************************************************************/
/*********************赋值运算符T1,T2必须有个类对象**********************/
/************************************************************************/

/***************** +=号重载, 格式为 friend T operator += (T1,T2)*****************/
FBString& operator += (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt+=fs2.m_nInt;
    fs1.m_stShort+=fs2.m_stShort;
    return fs1;
}

/***************** -=号重载, 格式为 friend T operator -= (T1,T2)*****************/
FBString& operator -= (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt-=fs2.m_nInt;
    fs1.m_stShort-=fs2.m_stShort;
    return fs1;
}

/***************** *=号重载, 格式为 friend T operator *= (T1,T2)*****************/
FBString& operator *= (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt*=fs2.m_nInt;
    fs1.m_stShort*=fs2.m_stShort;
    return fs1;
}

/***************** /=号重载, 格式为 friend T operator /= (T1,T2)*****************/
FBString& operator /= (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt/=fs2.m_nInt;
    fs1.m_stShort/=fs2.m_stShort;
    return fs1;
}

/***************** %=号重载, 格式为 friend T operator %= (T1,T2)*****************/
FBString& operator %= (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt%=fs2.m_nInt;
    fs1.m_stShort%=fs2.m_stShort;
    return fs1;
}

/***************** &=号重载, 格式为 friend T operator &= (T1,T2)*****************/
FBString& operator &= (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt&=fs2.m_nInt;
    fs1.m_stShort&=fs2.m_stShort;
    return fs1;
}

/***************** |=号重载, 格式为 friend T operator |= (T1,T2)*****************/
FBString& operator |= (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt|=fs2.m_nInt;
    fs1.m_stShort|=fs2.m_stShort;
    return fs1;
}

/***************** ^=号重载, 格式为 friend T operator ^= (T1,T2)*****************/
FBString& operator ^= (FBString& fs1, const FBString& fs2)
{
    fs1.m_nInt^=fs2.m_nInt;
    fs1.m_stShort^=fs2.m_stShort;
    return fs1;
}

/***************** <<=号重载, 格式为 friend T operator <<= (T1,T2)*****************/
FBString& operator <<= (FBString& fs1, int i)
{
    fs1.m_nInt<<=i;
    fs1.m_stShort<<=i;
    return fs1;
}

/***************** >>=号重载, 格式为 friend T operator >>= (T1,T2)*****************/
FBString& operator >>= (FBString& fs1, int i)
{
    fs1.m_nInt>>=i;
    fs1.m_stShort>>=i;
    return fs1;
}

/************************************************************************/
/*****************************其他运算符重载*****************************/
/************************************************************************/

/************* ,运算符重载,一般不重载该运算符, 格式为 friend T operator , (T1,T2)***************/
FBString& operator , (FBString& fs1, FBString& fs2)
{
    return fs2;
}


/************成员指针运算符重载格式为 friend T operator ->* (T1,T2)************/
const _structFB_* operator ->* (const FBString& fs1, char c)
{
    return &(fs1.m_fbs);
}

 

 

dyjhx0105
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
浅度解析C++运算符重载
10-01
踏入C++的世界已经两年了，但一直在黑夜中前行，最近看到了由Lostmouse 译的Scott Meyers的著作《EffectiveC++》的中文版电子书，犹如一盏指路明灯，...遂对重载操作符也有一点心得，不敢独享，特拿出来与大家共賞。
运算符重载总结
程序员凯小白的博客
05-27 875
重载运算符一，知识点总结重载运算符函数可以对运算符做出新的解释，即定义用户所需要的各种操作。但运算符重载后，原有的基本语义不变，包括：○不改变运算符的优先级○不改变运算符的结合性○不改变运算符所需要的操作数○不能创建新的运算符优先级和结合性主要体现在重载运算符的使用上，而操作数的个数不但体现在重载运算符的使用上，更关系到函数定义时的参数设定。C++ 允许在同一作用域中的某个函数和运算符指定多个定义...
C++运算符重载心得
m0_61548518的博客
05-07 863
//安全计数器 //重载运算符（++、--、（）） /*#include<iostream> using namespace std; class x{ private: unsigned int value; public: x(){value=0;} void operator++(); void operator--(); unsigned int operator ()(); }; int main() { x x1; int i; for(i=0;i<5;i++)
c++学习心得第二期 友元+运算符重载
qq_37448336的博客
10-04 184
c++学习心得第二期 友元+运算符重载一、友元1 、全局函数做友元2. 类做友元3. 成员函数做友元二、运算符重载1.加号运算符重载2.左移运算符重载3.递增运算符重载4.赋值运算符重载5. 关系运算符重载6. 函数调用运算符重载 在程序里，有些私有属性 也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术 友元的目的就是让一个函数或者类 访问另一个类中私有成员 友元的关键字为 friend 友元的三种实现 全局函数做友元 类做友元 成员函数做友元 一、友元 1 、全局函数做友元 #incl
关于运算符重载的总结
qq_40680676的博客
05-22 1023
运算符重载
C# 运算符的重载（学习心得 21）
AItrust的博客
06-27 554
可以重定义或重载 C# 中内置的运算符。 也可以使用用户自定义类型的运算符。 通过关键字 operator 后跟运算符的符号来定义的。 文章目录一、运算法重载的实现二、可重载和不可重载运算符 一、运算法重载的实现 例：重载 + 运算符，把我们需要的对象属性相加 using System; namespace OperatorOvlApplication { class Box { private double length; // 长度 private dou
实验二 运算符重载的应用.doc
02-25
含实验心得，非常详细
运算符重载和函数重载
08-08
如运算符重载和函数重载 字符串连接，+=运算符重载 求子串: 左边几个字符，，， Left(int nCount) 右边几个，， Right(int nCount) 某个位置开始的几个字符 Mid(int nPos,int nCout) 2..进一步熟悉掌握对类的构造...
C++编程思想亲身体会
05-20
全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚...
高质量C++编程指南
09-16
8.4 运算符重载 64 8.5 函数内联 65 8.6 一些心得体会 68 第9章 类的构造函数、析构函数与赋值函数 69 9.1 构造函数与析构函数的起源 69 9.2 构造函数的初始化表 70 9.3 构造和析构的次序 72 9.4 示例：类STRING的...
运算符重载实验仅供参考
12-24
大学实验c++运算符重载，需要的可以参考。
重载运算符学习心得
qq_41549459的博客
05-25 1014
运算符重载一   运算符重载的限制有几种不能能重载运算符，：： .* ？： sizeof 重载运算符函数 可以重新定义运算符函数，但是原有的基本语义不变：1.   不改变运算符的优先级2.   不改变运算符的结合性3.   不改变运算符所需要的操作数4.   不能创建新的运算符5.   运算符函数可以重载为成员函数或者友元函数 语法形式类型 类名：：operator op（参数表）{//结构体}类...
C++ 输入输出运算符重载 感想
Xiaowo
03-14 5975
在C++中，经常会对输入输出运算符进行重载，而在重载的时候用到了友元（Friends）和引用返回（Returning References），这里对为什么会这么用发表一些思考。 比如，下面的类是一个简单的Student类，其中重载了<<和>>。// // Created by lgl on 17-3-14. // #include <iostream> #include <string> #inc
关于运算符重载和stl的心得体会
Hui_Sir_的博客
05-27 616
    在最近的c++学习中，我接触到了类学习中的重载运算符，还有c++中的stl。下面写一下关于这两个内容的心得体会。    首先是重载运算符，通过以前的学习可以知道，定义的变量可以比较大小，无论是整数型（int）变量还是字符型（string）变量，都能比较大小。不仅仅是比较大小，还可以进行运算。那么就有问题了，我们定义的类可以进行这些操作吗?答案是肯定的。其实，所谓的起始的变量类型的运算法则是...
关于C++运算符重载的一些个人总结
qq_43557177的博客
06-19 347
C++中常见的运算符重载 作为一个C++的菜鸡初学者，每次用到运算符重载的时候都需要再重新查一遍。不如一次总结好，把运算符重载相关的部分写成一个例子： #include<iostream> using namespace std; class complex { public: double real; double imag; complex(double a,double b...
运算符重载的注意事项
ltimaginea的博客
10-08 1329
在 C++ 中进行运算符重载时的注意事项： 运算符重载的实质是将运算符重载为一个函数，使用运算符的表达式就被解释为对“运算符函数”的调用。 C++ 规定，运算符重载不改变运算符的优先级。 一下运算符不能被重载："."，".*"，"::"，"?:"，sizeof 。 重载运算符 “()”、"[]"、"->"或者赋值运算符 “=” 时，只能将它们重载为成员函数，不能重载为全局函数。 必要时需要重载赋值运算符 “=” ,以避免两个对象内部的指针指向同一片存储空间。 类型的名字可以作为强制类型转换运算符，也
C++学习记录与心得（二） 运算符重载
不要加糖的初体验
06-28 1104
学习任务中，有几道程序题，自己写的拿出来记录一下。 1.）声明一个复数类 Complex，重载运算符“+”，“-”，“*”，“/”，使之能用于复数的加、减、乘、 除，运算符重载函数作为 Complex 类的成员函数。编程序，分别求两个复数之和、差、积和商。 思考：你编的程序能否用于一个整数与一个复数的算术运算？如 4+(5-2i)。 #include<iostream> #include<string> using namespace std; clas...
运算符重载
weixin_34326429的博客
09-03 248
前言 1、重载运算符的定义 定义一个重载运算符就像定义一个函数，只是该函数的名字是operator@，这里@代表运算符。比如返回类型 operator << (const class &c){} 2、重载运算符函数参数 重载运算符表中参数的个数取决于两个因素： 运算符本身因素 运算符是一元的（一个参数）还是二元的（两个参数） 运算符定义因素 ...
C++运算符重载总结
qq_43148810的博客
10-31 3821
@著作权归作者所有：来自CSDN博客作者大胡子的艾娃的原创作品，如需转载，请注明出处https://blog.csdn.net/qq_43148810，否则将追究法律责任。 如有错误的地方欢迎指正，谢谢! 更多内容请关注个人博客：https://blog.csdn.net/qq_43148810 ...
c++运算符重载知识点
最新发布
11-29
C++中的运算符重载是指对C++中的运算符进行重新定义，使得运算符可以用于类的对象。下面是一些C++运算符重载的知识点： 1. 运算符重载是通过函数来实现的，函数名是由关键字operator和要重载的运算符符号组成的。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值