面向对象高级编程

1. 相同class的各对象互为友元

   class complex
   {
      public:
      	complex(double r=0,double i=0) : re(r),im(i) {}
      	int func(const complex& param)
      	{
      		return param.re+param.im;
      	}
      private:
      	double re,im;
   }
   

2. string

   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';
      }
   }
   inline String::~String()
   {
      delete[] m_data;
   }
   

3. 拷贝赋值要先判断是不是自己，然后杀掉自己

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

4. 转换函数：operator double() const { … } //注意const
5. 
6. 一份数据，多个形式或一个形式多份共享时（继承+委托）

   class Subject
   {
   	int m_value;//真正的数据
   	vector<Observer*> m_views;
   public:
   	void attach(Observer* obs)   //注册观察者
   	{
   		m_views.push_back(obs);
   	}
   	void set_val(int value)
   	{
   		m_value=value;
   		notify();
   	}
   	void noitfy()
   	{
   		for(int i=0;i<m_views.size();i++)
   		{
   			m_view[i]->update(this,m_value);
   		}
   	}
   };
   class Observer
   {
   public:
   	virtual void update(Subject* sub,int value)=0;
   }
   

7. composite设计模式
   一个容器既可以放左边的东西，也可以放右边的东西，可以把左边和右边继承一个base，放base
   

   class Component
   {
   	int m_value;
   	vector<Observer*> m_views;
   public:
   	Component(int val) {value=val;}
   	virtual void add(Component*) {}
   };
   class Primitive:public Component
   {
   public:
   	Primitive(int val) : Component(val){}
   }
   class Composite:public Component
   {
   	vector<Component*> c;
   public:
   	Composite(int val) : Component(val){}
   	void add(Component* elem)
   	{
   		c.push_back(elem);
   	}
   }
   

8. 智能指针

   template<class T>
   class shared_ptr
   {
   public:
   	T& operator*() const
   	{
   		return *px;
   	}
   	T* operator->() const
   	{
   		return px;
   	}
   	shared_ptr(T* p):px(p){}
   private:
   	T*  px;
   	long* pn;
   };
   

9. 迭代器

   //list的迭代器
   reference operator*() const
   {
   	return (*node).data;
   }
   pointer operator->() const
   {
   	return &(operator*());
   }
   

10. 成员模板——大量用在构造函数，子类可以传给父类的构造函数

    template<typename _Tp>
    class shared_ptr:public _shared_ptr<_Tp>
    {
    ...
    	template<typename _Tp1>
    	explicit shared_ptr(_Tp1* _p):_shared_ptr<_Tp>(_p){}
    ...
    }
    Base* ptr=new Derived1; //up-cast
    shared_ptr<Base1> sptr(new Derived1);  //模拟up-cast 
    

11. 模板模板参数

     template< typename T,
    			template< typename T> class Container
    			>
    class XCLs
    {
    private:
    		Container< T> c;
    public:
    		...
    }
    tempalte< typename T>
    using Lst=list<T,allocator< T >>;
    XCLs<string,list> mylst1; //X,编译失败，因为list有第二个模板参数
    XCLs<string,Lst>mylst2; //可以通过
    

12. 如果const和非const成员函数同时存在，const对象只能调用非const成员函数，const对象只能调用const成员函数
13. 

以上总结自侯捷老师的C++面向对象高级编程