c++ 程序设计 week4 运算符重载

运算符重载

这一周的内容主要讲运算符重载， 但是如何设计返回值类型，以及是否需要采用成员函数都是很重要的。

1. 赋值运算符重载

T & operator=(T  &a); 

与copy constructor类类似, 但是存在返回值.

（1） 成员函数：只能定义成成员函数。

（2）返回值：而且返回值类型必须是引用，才能符合我们对等号的直观理解。（a = b） = c 还会将a改变， 所以我们需要返回T&。

（3）类内存在指针时需要注意如果右边赋值和本身相同时，不需要重新赋值; 而且如果原来为空指针,那么也可以直接赋值,  以上两种类型都需要先判断,以防delete时出现错误.

2. 运算符重载位友元函数

T operator+(const T &a, const T &b)

如果我们把函数重载为外部函数, 那么在内部设置为友元函数可以访问成员的私有member.

3. 流输入,输出函数

输出:

ostream & operator<< (ostream &os, const T & a);

(1)返回类型: &ostream, (保证流的一致性)

(2)外部重载函数, 因为我们需要 ostream << , 如果设置为内部函数则无法调用.

输入函数类似.

4. ++ ,--

前置++T: T operator++()

后置T++: T operator++(int)

所以下面用了国外一门课的例子.

例子MyString

#MyString.h

#ifndef __MYSTRING_H__
#define __MYSTRING_H__
#include <iostream>

using namespace std;

class MyString {

    public:

	// default constructor
	MyString();

	// constructor
	MyString(const char* p);

	// destructor
	~MyString();

	// copy constructor 
	MyString(const MyString& s);

	// copy assignment
	MyString& operator=(const MyString& s);

	// returns the length of the string
	int length() const { return len; }
	
	friend int operator==(const MyString& s1,const MyString& s2);
	friend int operator!=(const MyString& s1,const MyString& s2);
	
	friend int operator>(const MyString& s1,const MyString& s2);
	friend int operator<(const MyString& s1,const MyString& s2);

	friend int operator>=(const MyString& s1,const MyString& s2);
	friend int operator<=(const MyString& s1,const MyString& s2);
	MyString& operator+=(const MyString &s);

	// put-to operator
	friend ostream& operator<<(ostream& os, const MyString& s);

	// get-from operator
	friend istream& operator>>(istream& is, MyString& s);

	// operator[]
	char& operator[](int i);

	// operator[] const
	const char& operator[](int i) const;

    private:

	char* data;

	int len;
};

MyString operator+(const MyString& s1, const MyString& s2);
#endif

#MyString.cpp

#include <cstring>
#include <cstdio>

#include "mystring.h"

// default constructor

MyString::MyString() 
{
    data = new char[1];
    data[0] = '\0';   
    len = 0;
}

// constructor

MyString::MyString(const char* p)
{

    if (p) {
	len = strlen(p);
	data = new char[len+1];
	strcpy(data, p);
    } else {
	data = new char[1];
	data[0] = '\0';
	len = 0;
    }
}

// destructor

MyString::~MyString() 
{
    delete[] data;
}

// copy constructor 

MyString::MyString(const MyString& s) 
{
    len = s.len;  
    data = new char[len+1];
    strcpy(data, s.data);
}

// copy assignment

MyString& MyString::operator=(const MyString& rhs)
{
#ifdef BASIC4TRACE
    fprintf(stderr, "BASIC4TRACE: (%p)->op=(const MyString&)\n", this);
#endif

    if (this == rhs) {
	return *this;
    }

    // first, deallocate memory that 'this' used to hold

    delete[] data;

    // now copy from rhs
    
    len = rhs.len;

    data = new char[len+1];
    strcpy(data, rhs.data);

    return *this;
}
//+=operator
MyString& MyString::operator+=(const MyString &s)
{
	len = len + s.len;
	char *temp = new char[len+1];
	strcpy(temp,data);
	strcat(temp,s.data);
	delete[] data;
	data = temp;
	return *this;
}

// operator+

MyString operator+(const MyString& s1, const MyString& s2)
{
#ifdef BASIC4TRACE
    fprintf(stderr, 
	    "BASIC4TRACE: op+(const MyString&, const MyString&)\n");
#endif
    MyString temp = s1;
    temp += s2;
    return temp;
}

// put-to operator

ostream& operator<<(ostream& os, const MyString& s)
{
    os << s.data;
    return os;
}

// get-from operator

istream& operator>>(istream& is, MyString& s)
{
    // this is kinda cheating, but this is just to illustrate how this
    // function can work.
    
    string temp;
    is >> temp;

    delete[] s.data;

    s.len = strlen(temp.c_str());
    s.data = new char[s.len+1];
    strcpy(s.data, temp.c_str());

    return is;
}

// operator[] - in real life this function should be declared inline

char& MyString::operator[](int i) 
{
    return data[i];
}

// operator[] const - in real life this should be inline

const char& MyString::operator[](int i) const
{
    // illustration of casting away constness
    return ((MyString&)*this)[i];
}


int operator==(const MyString& s1,const MyString& s2)
{
	return (strcmp(s1.data,s2.data)==0);
}

int operator!=(const MyString& s1, const MyString& s2)
{
	return (strcmp(s1.data,s2.data)!=0);
}

int operator<(const MyString& s1,const MyString& s2)
{
	return (strcmp(s1.data,s2.data)<0);
}

int operator>(const MyString& s1,const MyString& s2)
{
	return(strcmp(s1.data,s2.data)>0);
}
int operator<=(const MyString& s1,const MyString& s2)
{
	return(strcmp(s1.data,s2.data)<=0);
}
int operator>=(const MyString& s1,const MyString& s2)
{
	return(strcmp(s1.data,s2.data)>=0);
}