23 运算符重载（二）

++运算符重载

前置++运算符重载
成员函数的方式重载，原型为：
函数类型 & operator++();
友元函数的方式重载，原型为：
friend 函数类型 & operator++(类类型 &);
后置自增和后置自减的重载
成员函数的方式重载，原型为：
函数类型 & operator++(int);
友元函数的方式重载，原型为：
friend函数类型 & operator++(类类型 &,int);

//Integer.h

#ifndef _INTEGER_H_
#define _INTEGER_H_

class Integer
{
public:
    Integer(int n);
    ~Integer();

    Integer& operator++();
    //friend Integer& operator++(Integer& i);

    Integer operator++(int n);
    //friend Integer operator++(Integer& i, int n);

    void Display() const;
private:
    int n_;
};

#endif // _INTEGER_H_

//Integer.cpp
#include "Integer.h"
#include <iostream>
using namespace std;

Integer::Integer(int n) : n_(n)
{
}

Integer::~Integer()
{
}

Integer& Integer::operator ++()
{
    //cout<<"Integer& Integer::operator ++()"<<endl;
    ++n_;
    return *this;
}

//Integer& operator++(Integer& i)
//{
//  //cout<<"Integer& operator++(Integer& i)"<<endl;
//  ++i.n_;
//  return i;
//}

Integer Integer::operator++(int n)
{
    //cout<<"Integer& Integer::operator ++()"<<endl;
    //n_++;
    Integer tmp(n_);
    n_++;//n_本身++
    return tmp;//返回一个临时对象，其没有++
}

//Integer operator++(Integer& i, int n)
//{
//  Integer tmp(i.n_);
//  i.n_++;
//  return tmp;
//}

void Integer::Display() const
{
    cout<<n_<<endl;
}

//main.cpp

#include "Integer.h"
#include <iostream>
using namespace std;


int main(void)
{
    Integer n(100);
    n.Display();

    Integer n2 = ++n;
    n.Display();
    n2.Display();

    Integer n3 = n++;
    n.Display();
    n3.Display();



    return 0;
}

//String.h
#ifndef _STRING_H_
#define _STRING_H_

class String
{
public:
    explicit String(const char* str="");
    String(const String& other);
    String& operator=(const String& other);
    String& operator=(const char* str);

    bool operator!() const;
    ~String(void);

    void Display() const;

private:
    char* AllocAndCpy(const char* str);
    char* str_;
};

#endif // _STRING_H_

//String.cpp
#pragma warning(disable:4996)
#include "String.h"
#include <string.h>
#include <iostream>
using namespace std;

String::String(const char* str)
{
    str_ = AllocAndCpy(str);
}

String::String(const String& other)
{
    str_ = AllocAndCpy(other.str_);
}

String& String::operator=(const String& other)
{
    if (this == &other)
        return *this;

    delete[] str_;
    str_ = AllocAndCpy(other.str_);
    return *this;
}

String& String::operator=(const char* str)
{
    delete[] str_;
    str_ = AllocAndCpy(str);
    return *this;
}

bool String::operator!() const
{
    return strlen(str_) != 0;
}

String::~String()
{
    delete[] str_;
}

char* String::AllocAndCpy(const char* str)
{
    int len = strlen(str) + 1;
    char* newstr = new char[len];
    memset(newstr, 0, len);
    strcpy(newstr, str);

    return newstr;
}

void String::Display() const
{
    cout<<str_<<endl;
}

//main.cpp
#include "String.h"
#include <iostream>
using namespace std;


int main(void)
{
    String s1("abc");
    String s2(s1);

    String s3;
    s3 = s1;//调用=运算符重载 String& operator=(const String& other);
    s3.Display();

    s3 = "xxxx";//调用=运算符重载 String& operator=(const char* str);
    s3.Display();

    return 0;
}