第四周学习

4.1运算符重载

• 对已有的运算符赋予多重的含义
• 使同一运算符作用于不同类型的数据时能够有不同的功能
• 扩展c++中运算符的功能
  5+4=9
  5+6i+7+3i=12+9i
• 运算符重载的实质是函数的重载
  返回值类型 operator 运算符(形参表){…}

class complex{public:    complex(int a,int b){real=a;imag=b;}    int real,imag;    complex operator+(const complex& a){    return complex(real+a.real,imag+a.imag)}//重载为成员函数的时候只需要一个参量。};    complex::complex operator+(const complex &a,const complex &b){    return complex(a.real+b.real,a.imag+b.imag)}//重载为普通函数的时候为两个参量，为运算符目数。两者是等价的

4.2赋值运算符 = 的重载

• 可以将赋值运算符重载为想要的功能，比如把int赋值给complex等。
• 赋值运算符 = 只能重载为成员函数

e.g 自己的string类

#include <iostream>using namespace std;class String{private:    char *str;public:    String():str(NULL){}    const char *c_str(){return str;}    char *operator =(const char *s);    ~String();    String(const char *s1){        str=new char[strlen(s1)+1];        strcpy(str,s1);//用*char可以完成，strcpy做的是拷贝的工作，将后者拷贝给前者    }};char *String::operator=(const char *s){    if(str) delete[] str;    if(s){        str=new char[strlen(s)+1];        strcpy(str,s);    }else{        str=NULL;    }    return str;}String::~String(){    if(str) delete[] str;}int main(){    String s;    s="good sdf";//为了满足这个等号，需要对赋值运算符进行重载    String s2="hello lsidfh";    cout<<s.c_str()<<endl;//s.c_str()目的是返回一个*char    cout<<s2.c_str()<<endl;    return 0;}

深拷贝和浅拷贝

• 当自己不定义复制构造函数的时候，系统会自动生成一个复制构造函数，将原有的内容一字节一字节的拷贝给新的对象。
• 但有时候，我们并不希望如此，当对象的成员变量有指针的时候，会出现以下情况：a对象和b对象的指针内容在相同的内存空间中，则可以通过b对象的成员指针改变a对象的内容，这不是我们想要的
• 于是有了深拷贝，需要对新对象的指针对象开辟新的空间，并复制原来对象的内容进去，这样，虽然先后两个对象的指针变量指的内容是一致的，但在内存空间中是不同的位置，不会相互影响

4.3运算符重载为友元函数

• 成员函数不能满足使用需求，而普通函数不能访问类私有成员
  例如，现有一个类名叫complex，要实现complex+5，可以通过成员函数的重载实现，这句话等于complex.+(5),但若想要实现5+complex，需要对整体的 + 进行重载，就不能是成员函数，而是要普通函数，而普通函数不能访问类的私有成员，所以只能是友元函数才可以。

class complex{private:    double real,imag;public:    complex(double r, double i):real(r),imag(i){};    complex operator+ (double r){        return complex(real+r,imag);    }//对于后置的加号，只要通过成员函数即可实现};int main(){    complex a(2,3),b(1,1);    b=a+5;//完成后置加号的重载    return 0;}

对于前置加号，只能通过重载为友元实现

class complex{private:    double real,imag;public:    complex(double r, double i):real(r),imag(i){};    complex operator+ (double r){        return complex(real+r,imag);    }friend complex operator+ (double r,const complex& c);//申明友元函数};complex operator+ (double r,const complex& c){    return complex(c.real+r,c.imag);}//定义普通函数operator+int main(){    complex a(2,3),b(1,1);    b=a+5;    b=5+a;    return 0;}

4.4 e.g.可变长整形数组

• 需求，编写一个程序，完成动态可变数组，需要多大的数组，就可以扩大成为那么大的。
  需要实现的c++主程序：

int main(){    CArray a;//创建一个可变数组对象    for(int i=0;i<5;++i){        a.push_back(i);//支持push_back函数加入新的元素    }    CArray a2,a3;    a2=a;//可以通过等号进行深拷贝    for(int i=0;i<a.length();++i){        cout<<a2[i]<<" ";//支持流输出运算符    }    a2=a3;    for(int i=0;i<a2.length();++i){        cout<<a2[i]<<" ";    }    cout<<endl;    a[3]=100;//支持直接调用    CArray a4(a);//支持这样构造    for(int i=0;i<a4.length();++i){        cout<<a4[i]<<" ";    }    return 0;}

实现：

#include <iostream>using namespace std;class CArray{public:    int *a1;    int size;    void push_back(const int &a){//将新的地址加上新的元素赋值给旧的        int *p2;        int *p1;        int *a3;        a3=a1;        p1=new int[size+1];        p2=p1;        for(int i=0;i<size;++i){            *p2=*a3;            ++p2;            ++a3;        }        *p2=a;        ++size;        a1=p1;        delete p1;    }    CArray (CArray &a){//深拷贝        size=a.size;        int *p1;        int *p2;        p1=new int[size];        p2=p1;        for(int i=0;i<size;++i){            *p2=*(a.a1+i);            ++p2;        }        a1=p1;        delete [] p1;    }    CArray(){size=0;}    int length(){return size;}    int & operator[](int i){//实现[]调用        return a1[i];    }    ~CArray(){//检查是否还有未删除的指针    if(a1){delete [] a1;}    }};int main(){    CArray a;    for(int i=0;i<5;++i){        a.push_back(i);    }    CArray a2,a3;    a2=a;    for(int i=0;i<a.length();++i){        cout<<a2[i]<<" ";    }    a2=a3;    for(int i=0;i<a2.length();++i){        cout<<a2[i]<<" ";    }    cout<<endl;    a[3]=100;    CArray a4(a);    for(int i=0;i<a4.length();++i){        cout<<a4[i]<<" ";    }    return 0;}

4.5流插入运算符和流提取运算符的重载

• 若想输出或者输入某个类，就要对其进行重载，重载为ostream/istream的引用
  e.g.
  假设c是complex复数类的对象，现在希望写 “cout<

#include <iostream>using namespace std;class Complex{private:    double real,imag;public:Complex(int a=0,int b=0):real(a),imag(b){}friend ostream &operator<<(ostream & o,const Complex &s);friend istream &operator>>(istream & o,Complex &s);//申明友元的重载};ostream &operator<<(ostream & o,const Complex &s){    o<<s.real<<"+"<<s.imag<<"i";    return o;}istream &operator>>(istream & o,Complex &c){    string s;    o>>s;    int pos=s.find("+",0);    string stmp=s.substr(0,pos);    c.real=atof(stmp.c_str());    stmp=s.substr(pos+1,s.length()-pos-2);    c.imag=atof(stmp.c_str());    return o;}int main(){    Complex c;    int n;    cin>>c>>n;    cout<<c<<","<<n;    return 0;}

4.6自加/自减运算符的重载

• 自加自减运算符分前置后置分别进行重载
• 前置运算符作为一元运算符重载

• 重载为成员函数时，变量减一

  • T operator++();
  • T operator–();

• 重载为全局函数，变量为一

  • T operator++(T);
  • T operator–(T);

• 后置运算符作为二元运算符重载

• 重载为成员函数时候，变量减一，多写一个参数，具体无意义
  
  • T operator++(int)
  • T operator–(int)
• 重载为全局函数的时候，有两个变量
  
  • T operator++(T, int)
  • T operator–(T, int)

#include <iostream>using namespace std;class cdemo{private:    int a;public:    friend ostream &operator<<(ostream &o,cdemo &s);    cdemo(int i):a(i){}    cdemo &operator ++(){//前置，不需要加变量        a++;        return *this;    }    cdemo &operator ++(int){//后置，需要加个变量        cdemo tmp(*this);        a++;        return tmp;    }};ostream &operator<<(ostream &o,cdemo &s){//流输出重载    o<<s.a;    return o;}int main(){    cdemo d(5);    cout<<(d++)<<",";    cout<<d<<",",    cout<<(++d)<<",";    cout<<d<<endl;    cout<<(d--)<<","    cout<<d<<",";    cout<<(--d)<<","    cout<<d<<",";    cout<<d<<endl;    return 0;}