complex、String类实现

#include <iostream>
#include<string.h>

using namespace std;

class String{
	public:
		String(const char* cstr = 0);
		String(const String& cstr);
		String& operator=(const String& str);
		~String();
		char* get_c_str() const {return my_data;}
	
	private:
		char* my_data;
};

inline String::String(const char* cstr = 0)
{
	if(cstr){
		my_data = new char[strlen(cstr) + 1];
		strcpy(my_data, cstr);
	}
	else{
		my_data = new char[1];
		*my_data = '\0';
	} 
}

inline String::~String()
{
	delete[] my_data;
}

inline String::String(const String& cstr)
{
	my_data = new char[strlen(cstr.my_data) + 1];
	strcpy(my_data, cstr.my_data);
}

inline String& String::operator=(const String& str)
{
	if(&str == this)
		return *this;
	delete[] my_data;
	my_data = new char[strlen(str.my_data) + 1];
	strcpy(my_data, str.my_data);
	return *this;
}

#include <iostream>
using namespace std;

#ifndef __COMPLEX__
#define __COMPLEX__

class complex
{
	
public:
	complex(double r = 0, double i = 0)
		:re(r), im(i){}
	complex& operator += (const complex&);
	double real() const {return re;}
	double imag() const {return im;}
	

private:
	double re,im;
	
	friend complex& __doapl(complex*, const complex&);
};

inline complex& complex::operator += (const complex& r)
{
	return __doapl(this, r);
}

inline complex& __doapl(complex* ths, const complex& r)
{
	ths->re += r.re;
	ths->im += r.im;
	return *ths;
}

inline complex operator + (const complex& x, const complex& y)
{
	return complex(x.real() + y.real(), x.imag() + y.imag());
}

inline ostream& operator << (ostream& os, const complex& x)
{
	return os << '(' << x.real() << ',' << x.imag() << ')';
}
#endif

int main(void)
{
	complex c1(2,3);
	complex c2(3,4);
	complex c3 = c1 + c2;
	cout<<c1<<c2<<endl;
	cout<<c3<<endl;
}