C++ 学习1

#ifndef __COMPLEX__
#define __COMPLEX__

class complex
{
public:
	complex(double r = 0, double i = 0)//构造函数必须和类同名complex，
		//（）里是默认值
		:re(r), im(i) //初值列，有则设置初值，
	{ }
	complex& operator += (const complex&);//设置的函数能进行 +=。
	//每个成员函数都隐藏一个参数：complex& operator += (this,const complex&);
	//this谁调用，那个谁就是this
	double real() { return re; }//这个函数只是取出值，不改变所以加const
	double imag() { return im; }
private:
	double re, im;

	friend complex& _doapl(complex*,  //想直接取private参数，声明友元函数。
		const complex&);

};

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

complex::operator += (const complex& r) //(传引用，右边加到左面，右面不动加const）
{
	return _doapl(this, r);//
}


operator + (const complex& x, const complex& y)
{
	return comlex(
		real(x)+real(y),
		imag(x)+image(y)
	);//在类的后面加括号，就可以直接创建临时对象。然后把创建的东西返回。
}
//操作符重载
operator << (ostream& os, const complex& x)//非成员函数不加类。

//
complex ca(9, 8);
cout << ca;
#endif

 

 

class String
{
public:
	String(const char* cstr + 0);
	String(const String& str);//拷贝构造
	String& operator=(const String& str);//拷贝赋值，返回引用
	~String();
	char*get_c_str() { return m_data; }

private:
	char* m_data;
};
//构造函数
inline
String::String(const char* cstr = 0)
{
	if (cstr) {
		m_data = new char[strlen(cstr) + 1];
		strcpy(m_data, cstr);
	}
	else {
		m_data = new char[1];
		*m_data = '\0';
	}
}
//析构函数
String::~String()
{
	delete[] m_data;
}
//拷贝构造函数
inline
String::String(const String& str)
{
	m_data = new char[strlen(str.m_data) + 1];
	strcpy(m_data, str.m_data);
}
//拷贝赋值函数
inline
String&String::operator=(const String& str)//&表示引用
{
	if (this == &str)//检测来源端和目的端是否相同。&表示取地址
		return *this;//自我赋值

	delete[] m_data;
	m_data = new char[strlen(str.m_data) + 1];
	strcpy(m_data, str.m_data);
	return *this;//取目的端值
}

 

 

//静态数据和静态函数
//静态函数没有thispointer

class Account {
public:
	static double m_rate;//静态数据，要在class外设置定义
	static void set_rate(const double& x) { m_rate = x; }//静态函数只能处理静态数据
};

double Account::m_rate = 8.0;//定义，初值给不给都行

int main() {
	Account::set_rate(5.0);//调用static函数的方式一，通过classname调用
	Account a;
	a.set_rate(7.0);//方式二通过object调用。
}

 

//复合
//复合下的构造和析构
//构造由内而外，析构由外而内。
Container::Container() : Component() { ... };
Container::~Container(...) : {...~Component() ... };
//template <class T,class Sequence = deque<T>> //作用和下面的一样。
template <class T>
class queue {//我有一个另外一种东西叫复合
	,,,
protected:
	//Sequence c: //底层容器，queue拥有c
	deque<T> c;//queue想用deque的功能
public:
	//一下完全利用c的操作函数完成
	bool empty() const { return c.empty; }
	size_type size() const { return c.size(); }
	reference front() { return c.front(); }
	reference back() { return c.back(); }
	//
	void push(const value_type& x) { c.push_back(x); }
	//把c.pop_front();改头换面变成了queue的pop()
	void pop() { c.pop_front(); }
};

//委托
class StringRep;
class String
{
public:
	String();
	String(const char* s);
	String(const String& s);
	String &operator=(const String& s);
	~String();
	...

private:
	StringRep* rep;//指针指向StringRep，
};
//
#include "String.hpp"
namespace {
	class StringRep {
		friend class String;
		StringRep(const char* s);
		~StringRep();
		int count;
		char* rep;
	};
}

String::String(){.....}
......


//继承：子类有父类的成分

struct _List_node_base
{
	_List_node_base* _M_next;
	_List_node_base* _M_prev;
};

trmplate<typename _Tp> //模板
struct _List_node
	:public _List_node_base//继承_List_node_base
{
	_Tp _M_data;
};

//虚函数;希望派生类子类重新定义
//纯虚函数；一定要重新定义
class Shape {
public:
	virtual void draw() const = 0;//纯虚函数
	virtual void error(const std::string& msg);//虚函数
	int objectID() const;//非虚函数
	.....
};

class Rectangle:public Shape{..};
class Ellipse:public Shape {..};