c/c++面试题(6)运算符重载详解

#include <iostream>
int g = 0;
using namespace std;
int foo(void)
{
    return g;
}

int& bar(void)
{
    return g;
}

void func(int& i)
{
    cout << "func1" << endl;
}
void func(const int& i)
{
    cout << "func2" << endl;
}

int main(void)
{
    int i;  //左值,有名字可以取地址.
    int* p = &i;
    i = 10; //可修改
    //p = &10;这里的10是个右值,上面10赋值给i的时候产生的一个临时变量,是右值.所以10++也是错误的.
    
    // foo() = 10; 这里返回值也是临时变量是右值,是只读的属性,不能修改;++foo();也是错误的.

    bar() = 10; //这里返回的是一个左值引用,所以它是可以赋值的
    cout << g << endl;
    int a = 10,b = 20,c;
    c = a + b;//a + b是右值.
    //a + b = 10;是非法的,因为表达式的值也是用一个临时变量来存储的.是右值.
    //无论是显示的还是隐式的类型转换,都会产生临时变量.
    (a = b) = 10; //赋值表达式返回的是左值.
    ++a = 1000;   //前++表达式返回的是左值.
    //a++ = 2000;  这里是不行的,后++运算符的表达式的值是右值.
    //a++++;这也是不行的,对右值做++是不行的.
    ++++a;//这个是可以的.++a的返回值还是a本身.
    cout << a << endl; //1000
    char ch = 0;
    i = ch; //这里是可以的.
    //int& r = ch;它会先把ch转换成一个临时变量,然后把这个临时;变量赋值给r,而引用是不能引用一个临时变量的.
    //非常引用只能引用一个左值,不能是右值.
    const int& r = ch;  //常左引用又叫万能引用,它可以引用左值和右值.
    func(ch);//这里它会调用参数是常属性的函数,因为它要类型转换,类型转换产生临时变量.
    //所谓类型转换,无论是显示还是隐式的.都不是改变了原来的变量的类型,只能产生一个临时变量.
    return 0;
}

#include <iostream>
using namespace std;
class Complex
{
public:
    Complex(int r = 0,int i = 0):m_r(r),m_i(i){}
    //运算符+-/*表达式的结果是右值,不能是引用.
    /*参数用常引用的好处:
      即避免了拷贝构造的开销,它又能接收常右操作数
      且可以保证右操作数不被修改.
      第三个const是可以支持常属性的左操作数.
      因为非常对象依然可以调用常函数.
      第一const为了追求语义上的一致性,使其返回值是一个
      临时变量.不能被赋值.
    */
    /*从做到右的三个const依次表示:
      1.第一个const:返回常对象,禁止对加号表达式进行赋值.
      2.第二个const:支持常右操作数,并且可以避免其被修改.
      3.第三个const:支持常左操作数.
     */
    const Complex operator+(const Complex& c) const 
    {
        return Complex(m_r + c.m_r,m_i + c.m_i);
    }
    const Complex operator*(const Complex& c) const
    {
        return Complex(m_r*c.m_r,m_i*c.m_i);
    }
    const Complex operator/(const Complex& c) const
    {
        return Complex(m_r/c.m_r,m_i/c.m_i);
    }
    void print(void) const
    {
        cout << m_r << ‘+‘ << m_i << "i" << endl;
    }
    /*用全局函数来实现(友元)
    const Complex operator-(const Complex& c) const
    {
        return Complex(m_r - c.m_r,m_i - c.m_i);
    }
    */
private:
    int m_r;
    int m_i;
    friend const Complex operator-(const Complex&,const Complex&);
};
const Complex operator-(const Complex& left,
        const Complex& right)//这里没有const了,因为
    //const是修饰this指针的,而全局函数是没有this指针的;
{
    return Complex(left.m_r-right.m_r,left.m_i - right.m_i);
}
int main(void)
{
    Complex c1(1,2),c2(3,4);
    Complex c3 = c1 + c2;
    //编译器翻译成Complex c3 = c1.operator+(c2);
    c3.print();
    Complex c4 = c1 + c2 + c3;
    //Complex c4 = c1.operator+(c2).operator+(c3);
    c4.print();
    //(c1 + c2) = c3;如果加号运算符没有第一个const这里编译会通过.
    c4 = c3 - c1;
    //c4 = ::operator-(c3,c1);也可以处理成这样
    c4.print();
    c4 = c1*c2;
    c4.print();
    c4 = c2/c1;
    c4.print();
    return 0;
}

#include <iostream>
using namespace std;
class Complex
{
public:
    Complex(int r = 0,int i = 0):m_r(r),m_i(i){}
    void print(void)const
    {
        cout << m_r << ‘+‘ << m_i << ‘i‘ << endl;
    }
    //这里不能是const函数,因为左操作数要改变的.
    Complex& operator+=(const Complex& c) //这里不能带const
    {
        m_r += c.m_r;
        m_i += c.m_i;
        return *this;
    }
    friend Complex& operator-=(Complex& left,const Complex& right)//友元函数没有this指针,也就没有常函数之说. 
    {
        left.m_r -= right.m_r;
        left.m_i -= right.m_i;
        return left;
    }
    Complex& operator*=(const Complex& c)
    {
        m_r *= c.m_r;
        m_i *= c.m_i;
        return *this;
    }
    Complex& operator/=(const Complex& c)
    {
        m_r /= c.m_r;
        m_i /= c.m_i;
    }
private:
    int m_r;
    int m_i;
};
int main(void)
{
    Complex c1(1,2),c2(3,4),c3(5,6);
    (c1 += c2) = c3;
    //c1.operator+=(c2).operator=(c3);
    c1.print();
    c3 -= c1;
    c3.print();
    //::operator-=(c3,c1);
    c3 *= c1;
    c3.print();
    c3 /= c1;
    c3.print();
    return 0;
}

#include <iostream>
using namespace std;
class Integer
{
public:
    Integer(int i = 0):m_i(i){}
    void print(void) const
    {
        cout << m_i << endl;
    }
    const Integer operator-(void) const
    {
        return Integer(-m_i);
    }
    friend const Integer operator~(const Integer& i)
    {
        return Integer(i.m_i * i.m_i);
    }
    const Integer operator!(void) const
    {
        return m_i?Integer(0):Integer(1);
    }
private:
    int m_i;
};
int main(void)
{
    Integer i(100);
    Integer j = -i;
    //Integer j = i.operator-();
    j.print();
    j = ~i;
    //j = ::operator~(i)求其平方.用~完成一个平方的效果.
    j.print();
    j = !i;   //取反,表示真假之间的转换.
    j.print();
    return 0;
}

#include <iostream>
using namespace std;
class Complex
{
public:
    Complex(int r = 0,int i = 0):m_r(r),m_i(i){}
    friend ostream& operator<<(ostream& os,const Complex& c)
    {
        return os << c.m_r << ‘+‘ << c.m_i << ‘i‘;
    }
    friend istream& operator>>(istream& is,Complex& c)
    {
        return is >> c.m_r >> c.m_i;
    }
private:
    int m_r;
    int m_i;
};
int main(void)
{
    Complex c1(12,23),c2(2,4);
    cout << c1 << ", " << c2 << endl;
    cout << "Please input :" << endl;
    cin >> c1 >> c2;
    cout << c1 << ", " << c2 << endl;
    return 0;
}

#include <iostream>
using namespace std;
class Array
{
public:
    Array(size_t size):m_data(new int[size]),m_size(size){}
    ~Array(void)
    {
        if(m_data != NULL)
            delete[] m_data;
        m_data = NULL;
    }
    int& operator[] (size_t i)
    {
        return *(m_data + i);
    }
    //常版本
    const int& operator[] (size_t i) const
    {
        return const_cast<Array&>(*this)[i];
    }
private:
    int*   m_data;
    size_t m_size;
};
int main(void)
{
    Array a(10);
    a[0] = 13; //a.operator[](0) = 13;
    a[2] = 26;
    a[9] = 58;
    cout << a[0] << ‘ ‘ << a[2] << ‘ ‘ << a[9] << endl; 
    const Array& r = a;
    cout << r[0] << ‘ ‘ << r[2] << ‘ ‘ << endl;
    return 0;
}

#include <iostream>
using namespace std;
class Square
{
public:
    double operator()(double x) const
    {
        return x * x;
    }
    int operator()(int a,int b,int c = 9) const
    {
        return a + b - c;
    }
};
int main(void)
{
    Square square;
    cout << square(13.) << endl;
    //cout << square.operator()(13.) << endl;
    cout << square(10,40,20) << endl;
    cout << square(10,40) << endl;
    return 0;
}