diff --git a/TinySTL/COWPtr.h b/TinySTL/COWPtr.h
index fd23cfc..9b22626 100644
--- a/TinySTL/COWPtr.h
+++ b/TinySTL/COWPtr.h
@@ -4,10 +4,33 @@
 #include "Memory.h"
 
 namespace TinySTL{
+	template<class T>
+	class cow_ptr;
+	namespace Detail{
+		template <class T>
+		class proxy{
+		public:
+			explicit proxy(cow_ptr<T> *const cp) :cp_(cp){}
+			proxy(const proxy<T>&) = default;
+			proxy& operator = (const proxy<T>&) = default;
+
+			const T& operator *()const;
+			T& operator *();
+			const T *operator ->()const;
+			T *operator ->();
+			cow_ptr<T>& operator = (const T& val);
+			operator T()const;
+		private:
+			cow_ptr<T> *cp_;
+		};
+	}
 	template<class T>
 	class cow_ptr{
 	public:
 		typedef T element_type;
+	private:
+		template<class _T>
+		using proxy = Detail::proxy < _T > ;
 	public:
 		explicit cow_ptr(T *p = nullptr);
 		template<class D>
@@ -15,13 +38,12 @@ namespace TinySTL{
 
 		cow_ptr(const cow_ptr& cp);
 		cow_ptr& operator = (const cow_ptr& cp);
-
-		const element_type& operator *()const;
-		const element_type *operator ->()const;
-		//注意 这两个函数可能会改变指针指向的对象的内容，需要cow机制
-		//element_type& operator *();
-		//element_type *operator ->();
-
+		
+		const proxy<element_type> operator *()const;
+		proxy<element_type> operator *();
+		const proxy<element_type> operator ->()const;
+		proxy<element_type> operator ->();
+		
 		element_type *get();
 		const element_type *get()const;
 
@@ -41,6 +63,9 @@ namespace TinySTL{
 		friend bool operator != (const cow_ptr<T>& cp, nullptr_t p);
 		template<class T>
 		friend bool operator != (nullptr_t p, const cow_ptr<T>& cp);
+
+		template<class _T>
+		friend class Detail::proxy;
 	};
 }
 
diff --git a/TinySTL/Detail/COWPtr.impl.h b/TinySTL/Detail/COWPtr.impl.h
index 0010a1a..fad4eb1 100644
--- a/TinySTL/Detail/COWPtr.impl.h
+++ b/TinySTL/Detail/COWPtr.impl.h
@@ -2,6 +2,35 @@
 #define _COWPTR_IMPL_H_
 
 namespace TinySTL{
+	namespace Detail{
+		template<class T>
+		const T& proxy<T>::operator *()const{ 
+			return *(cp_->ptr_); 
+		}
+		template<class T>
+		T& proxy<T>::operator *(){
+			auto t = *(cp_->ptr_);
+			cp_->ptr_ = make_shared<T>(t);
+			return *(cp_->ptr_);
+		}
+		template<class T>
+		const T *proxy<T>::operator ->()const{
+			return cp_->ptr_.operator->(); 
+		}
+		template<class T>
+		T *proxy<T>::operator ->(){
+			auto t = *(cp_->ptr_);
+			cp_->ptr_ = make_shared<T>(t);
+			return cp_->ptr_.operator->();
+		}
+		template<class T>
+		cow_ptr<T>& proxy<T>::operator = (const T& val){
+			cp_->ptr_ = make_shared<T>(val);
+			return *cp_;
+		}
+		template<class T>
+		proxy<T>::operator T()const{ return *(cp_->ptr_); }
+	}
 	template<class T>
 	cow_ptr<T>::cow_ptr(T *p = nullptr) :ptr_(p){}
 	template<class T>
@@ -20,19 +49,6 @@ namespace TinySTL{
 		return *this;
 	}
 	template<class T>
-	const typename cow_ptr<T>::element_type& cow_ptr<T>::operator *()const{
-		return *ptr_;
-	}
-	template<class T>
-	const typename cow_ptr<T>::element_type *cow_ptr<T>::operator ->()const{
-		return ptr_.operator->();
-	}
-	//注意 这两个函数可能会改变指针指向的对象的内容，需要cow机制
-	//template<class T>
-	//typename cow_ptr<T>::element_type& cow_ptr<T>::operator *();
-	//template<class T>
-	//typename cow_ptr<T>::element_type *cow_ptr<T>::operator ->();
-	template<class T>
 	typename cow_ptr<T>::element_type *cow_ptr<T>::get(){
 		return ptr_.get();
 	}
@@ -44,6 +60,22 @@ namespace TinySTL{
 	cow_ptr<T>::operator bool()const{
 		return ptr_ != nullptr;
 	}
+	template<class T>
+	const typename cow_ptr<T>::proxy<T> cow_ptr<T>::operator *()const{
+		return proxy<T>(const_cast<cow_ptr *const>(this)); 
+	}
+	template<class T>
+	typename cow_ptr<T>::proxy<T> cow_ptr<T>::operator *(){ 
+		return proxy<T>(this); 
+	}
+	template<class T>
+	const typename cow_ptr<T>::proxy<T> cow_ptr<T>::operator ->()const{ 
+		return proxy<T>(const_cast<cow_ptr *const>(this)); 
+	}
+	template<class T>
+	typename cow_ptr<T>::proxy<T> cow_ptr<T>::operator ->(){ 
+		return proxy<T>(this); 
+	}
 
 	template<class T1, class T2>
 	bool operator == (const cow_ptr<T1>& cp1, const cow_ptr<T2>& cp2){