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);
}