diff --git a/cpp11/define.hpp b/cpp11/define.hpp
index 9754af27..526a4aea 100644
--- a/cpp11/define.hpp
+++ b/cpp11/define.hpp
@@ -74,7 +74,7 @@ struct define_imp {
 	static void unpack(msgpack::object o, Tuple& t) {
 		define_imp<Tuple, N-1>::unpack(o, t);
 		const size_t size = o.via.array.size;
-		if(size <= N-1) { return; } 
+		if(size <= N-1) { return; }
 		o.via.array.ptr[N-1].convert(&std::get<N-1>(t));
 	}
 	static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
@@ -91,7 +91,7 @@ struct define_imp<Tuple, 1> {
 	}
 	static void unpack(msgpack::object o, Tuple& t) {
 		const size_t size = o.via.array.size;
-		if(size <= 0) { return; } 
+		if(size <= 0) { return; }
 		o.via.array.ptr[0].convert(&std::get<0>(t));
 	}
 	static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
@@ -109,24 +109,24 @@ struct define {
 	void msgpack_pack(Packer& pk) const
 	{
 		pk.pack_array(sizeof...(Args));
-		
+
 		define_imp<tuple<Args&...>, sizeof...(Args)>::pack(pk, a);
 	}
 	void msgpack_unpack(msgpack::object o)
 	{
 		if(o.type != type::ARRAY) { throw type_error(); }
-		
+
 		define_imp<tuple<Args&...>, sizeof...(Args)>::unpack(o, a);
 	}
 	void msgpack_object(msgpack::object* o, msgpack::zone* z) const
 	{
 		o->type = type::ARRAY;
-		o->via.array.ptr = (object*)z->malloc(sizeof(object)*sizeof...(Args));
+		o->via.array.ptr = static_cast<object*>(z->malloc(sizeof(object)*sizeof...(Args)));
 		o->via.array.size = sizeof...(Args);
-		
+
 		define_imp<tuple<Args&...>, sizeof...(Args)>::object(o, z, a);
 	}
-	
+
 	tuple<Args&...> a;
 };
 
diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp
index a29ad257..1a92e208 100644
--- a/cpp11/tuple.hpp
+++ b/cpp11/tuple.hpp
@@ -26,91 +26,91 @@ namespace msgpack {
 // --- Pack ( from tuple to packer stream ---
 template <typename Stream, typename Tuple, std::size_t N>
 struct Packer {
-    static void pack(
+	static void pack(
 		packer<Stream>& o,
 		const Tuple& v) {
-        Packer<Stream, Tuple, N-1>::pack(o, v);
-        o.pack(type::get<N-1>(v));
-    }
+		Packer<Stream, Tuple, N-1>::pack(o, v);
+		o.pack(type::get<N-1>(v));
+	}
 };
 
 template <typename Stream, typename Tuple>
 struct Packer<Stream, Tuple, 1> {
-    static void pack (
+	static void pack (
 		packer<Stream>& o,
 		const Tuple& v) {
-        o.pack(type::get<0>(v));
-    }
+		o.pack(type::get<0>(v));
+	}
 };
 
 template <typename Stream, typename... Args>
 const packer<Stream>& operator<< (
-    packer<Stream>& o,
-    const type::tuple<Args...>& v) {
+	packer<Stream>& o,
+	const type::tuple<Args...>& v) {
 	o.pack_array(sizeof...(Args));
-    Packer<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
-    return o;
+	Packer<Stream, decltype(v), sizeof...(Args)>::pack(o, v);
+	return o;
 }
 
 // --- Convert from tuple to object ---
 
 template <typename Tuple, std::size_t N>
 struct Converter {
-    static void convert(
-        object o,
+	static void convert(
+		object o,
 		Tuple& v) {
-        Converter<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(&type::get<N-1>(v));
-    }
+		Converter<Tuple, N-1>::convert(o, v);
+		o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(&type::get<N-1>(v));
+	}
 };
 
 template <typename Tuple>
 struct Converter<Tuple, 1> {
-    static void convert (
-        object o,
+	static void convert (
+		object o,
 		Tuple& v) {
-        o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(&type::get<0>(v));
-    }
+		o.via.array.ptr[0].convert<typename std::remove_reference<decltype(type::get<0>(v))>::type>(&type::get<0>(v));
+	}
 };
 
 template <typename... Args>
 type::tuple<Args...>& operator>> (
-    object o,
-    type::tuple<Args...>& v) {
+	object o,
+	type::tuple<Args...>& v) {
 	if(o.type != type::ARRAY) { throw type_error(); }
 	if(o.via.array.size < sizeof...(Args)) { throw type_error(); }
-    Converter<decltype(v), sizeof...(Args)>::convert(o, v);
-    return v;
+	Converter<decltype(v), sizeof...(Args)>::convert(o, v);
+	return v;
 }
 
 // --- Convert from tuple to object with zone ---
 template <typename Tuple, std::size_t N>
 struct TupleToObjectWithZone {
-    static void convert(
+	static void convert(
 		object::with_zone& o,
 		const Tuple& v) {
-        TupleToObjectWithZone<Tuple, N-1>::convert(o, v);
-        o.via.array.ptr[N-1] = object(type::get<N-1>(v), o.zone);
-    }
+		TupleToObjectWithZone<Tuple, N-1>::convert(o, v);
+		o.via.array.ptr[N-1] = object(type::get<N-1>(v), o.zone);
+	}
 };
 
 template <typename Tuple>
 struct TupleToObjectWithZone<Tuple, 1> {
-    static void convert (
+	static void convert (
 		object::with_zone& o,
 		const Tuple& v) {
-        o.via.array.ptr[0] = object(type::get<0>(v), o.zone);
-    }
+		o.via.array.ptr[0] = object(type::get<0>(v), o.zone);
+	}
 };
 
 template <typename... Args>
 inline void operator<< (
 		object::with_zone& o,
-        type::tuple<Args...>& v) {
+		type::tuple<Args...>& v) {
 	o.type = type::ARRAY;
-	o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*sizeof...(Args));
+	o.via.array.ptr = static_cast<object*>(o.zone->malloc(sizeof(object)*sizeof...(Args)));
 	o.via.array.size = sizeof...(Args);
-    TupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
+	TupleToObjectWithZone<decltype(v), sizeof...(Args)>::convert(o, v);
 }
 
 } // msgpack
diff --git a/cpp11/zone.hpp b/cpp11/zone.hpp
index 3f223ced..17a4e0dd 100644
--- a/cpp11/zone.hpp
+++ b/cpp11/zone.hpp
@@ -59,15 +59,15 @@ private:
 		void push(void (*func)(void* data), void* data)
 		{
 			finalizer* fin = tail_;
-			
+
 			if(fin == end_) {
 				push_expand(func, data);
 				return;
 			}
-			
+
 			fin->func_ = func;
 			fin->data_ = data;
-			
+
 			++tail_;
 		}
 		void push_expand(void (*func)(void*), void* data) {
@@ -80,7 +80,7 @@ private:
 				nnext = nused * 2;
 			}
 			finalizer* tmp =
-				(finalizer*)::realloc(array_, sizeof(finalizer) * nnext);
+				static_cast<finalizer*>(::realloc(array_, sizeof(finalizer) * nnext));
 			if(!tmp) {
 				throw std::bad_alloc();
 			}
@@ -101,14 +101,14 @@ private:
 	struct chunk_list {
 		chunk_list(size_t chunk_size)
 		{
-			chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size);
+			chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
 			if(!c) {
 				throw std::bad_alloc();
 			}
-			
+
 			head_ = c;
 			free_ = chunk_size;
-			ptr_  = ((char*)c) + sizeof(chunk);
+			ptr_  = reinterpret_cast<char*>(c) + sizeof(chunk);
 			c->next_ = nullptr;
 		}
 		~chunk_list()
@@ -138,7 +138,7 @@ private:
 			}
 			head_->next_ = nullptr;
 			free_ = chunk_size;
-			ptr_  = ((char*)head_) + sizeof(chunk);
+			ptr_  = reinterpret_cast<char*>(head_) + sizeof(chunk);
 		}
 		size_t free_;
 		char* ptr_;
@@ -147,7 +147,7 @@ private:
 	size_t chunk_size_;
 	chunk_list chunk_list_;
 	finalizer_array finalizer_array_;
-	
+
 public:
 	zone(size_t chunk_size = MSGPACK_ZONE_CHUNK_SIZE);
 
@@ -166,7 +166,7 @@ public:
 
 	void swap(zone& o);
 
-	
+
 	template <typename T, typename... Args>
 	T* allocate(Args... args);
 
@@ -181,7 +181,7 @@ private:
 
 inline zone* zone::create(size_t chunk_size)
 {
-	zone* z = (zone*)::malloc(sizeof(zone) + chunk_size);
+	zone* z = static_cast<zone*>(::malloc(sizeof(zone) + chunk_size));
 	if (!z) {
 		return nullptr;
 	}
@@ -234,9 +234,9 @@ inline void* zone::malloc_expand(size_t size)
 		sz *= 2;
 	}
 
-	chunk* c = (chunk*)::malloc(sizeof(chunk) + sz);
+	chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
 
-	char* ptr = ((char*)c) + sizeof(chunk);
+	char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
 
 	c->next_  = cl->head_;
 	cl->head_ = c;
diff --git a/src/msgpack/sbuffer.hpp b/src/msgpack/sbuffer.hpp
index aa197038..3371bcb1 100644
--- a/src/msgpack/sbuffer.hpp
+++ b/src/msgpack/sbuffer.hpp
@@ -98,7 +98,7 @@ private:
 			throw std::bad_alloc();
 		}
 	
-		data_ = (char*)tmp;
+		data_ = static_cast<char*>(tmp);
 		alloc_ = nsize;
 	}
 
diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb
index 331bbce4..8aead021 100644
--- a/src/msgpack/type/define.hpp.erb
+++ b/src/msgpack/type/define.hpp.erb
@@ -118,7 +118,7 @@ struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
 	void msgpack_object(msgpack::object* o, msgpack::zone* z) const
 	{
 		o->type = type::ARRAY;
-		o->via.array.ptr = (object*)z->malloc(sizeof(object)*<%=i+1%>);
+		o->via.array.ptr = static_cast<object*>(z->malloc(sizeof(object)*<%=i+1%>));
 		o->via.array.size = <%=i+1%>;
 		<%0.upto(i) {|j|%>
 		o->via.array.ptr[<%=j%>] = object(a<%=j%>, z);<%}%>
diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp
index dcce1dc7..cf816498 100644
--- a/src/msgpack/type/deque.hpp
+++ b/src/msgpack/type/deque.hpp
@@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::deque<T>& v)
 		o.via.array.ptr = NULL;
 		o.via.array.size = 0;
 	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
diff --git a/src/msgpack/type/int.hpp b/src/msgpack/type/int.hpp
index b1af29fe..5286f010 100644
--- a/src/msgpack/type/int.hpp
+++ b/src/msgpack/type/int.hpp
@@ -44,7 +44,7 @@ namespace detail {
 			throw type_error();
 		}
 	};
-	
+
 	template <typename T>
 	struct convert_integer_sign<T, false> {
 		static inline T convert(object o) {
diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp
index 0c246f6a..9367719e 100644
--- a/src/msgpack/type/list.hpp
+++ b/src/msgpack/type/list.hpp
@@ -57,7 +57,7 @@ inline void operator<< (object::with_zone& o, const std::list<T>& v)
 		o.via.array.ptr = NULL;
 		o.via.array.size = 0;
 	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp
index b58f5f58..589cff38 100644
--- a/src/msgpack/type/map.hpp
+++ b/src/msgpack/type/map.hpp
@@ -78,7 +78,7 @@ inline void operator<< (object::with_zone& o, const type::assoc_vector<K,V>& v)
 		o.via.map.ptr  = NULL;
 		o.via.map.size = 0;
 	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
 		object_kv* const pend = p + v.size();
 		o.via.map.ptr  = p;
 		o.via.map.size = v.size();
@@ -134,7 +134,7 @@ inline void operator<< (object::with_zone& o, const std::map<K,V>& v)
 		o.via.map.ptr  = NULL;
 		o.via.map.size = 0;
 	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
 		object_kv* const pend = p + v.size();
 		o.via.map.ptr  = p;
 		o.via.map.size = v.size();
@@ -184,7 +184,7 @@ inline void operator<< (object::with_zone& o, const std::multimap<K,V>& v)
 		o.via.map.ptr  = NULL;
 		o.via.map.size = 0;
 	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
 		object_kv* const pend = p + v.size();
 		o.via.map.ptr  = p;
 		o.via.map.size = v.size();
diff --git a/src/msgpack/type/pair.hpp b/src/msgpack/type/pair.hpp
index 7ed57388..f8ff85a6 100644
--- a/src/msgpack/type/pair.hpp
+++ b/src/msgpack/type/pair.hpp
@@ -47,7 +47,7 @@ template <typename T1, typename T2>
 inline void operator<< (object::with_zone& o, const std::pair<T1, T2>& v)
 {
 	o.type = type::ARRAY;
-	object* p = (object*)o.zone->malloc(sizeof(object)*2);
+	object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*2));
 	o.via.array.ptr = p;
 	o.via.array.size = 2;
 	p[0] = object(v.first, o.zone);
diff --git a/src/msgpack/type/set.hpp b/src/msgpack/type/set.hpp
index 5aa9f2ae..065e69a6 100644
--- a/src/msgpack/type/set.hpp
+++ b/src/msgpack/type/set.hpp
@@ -56,7 +56,7 @@ inline void operator<< (object::with_zone& o, const std::set<T>& v)
 		o.via.array.ptr = NULL;
 		o.via.array.size = 0;
 	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
@@ -102,7 +102,7 @@ inline void operator<< (object::with_zone& o, const std::multiset<T>& v)
 		o.via.array.ptr = NULL;
 		o.via.array.size = 0;
 	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
diff --git a/src/msgpack/type/string.hpp b/src/msgpack/type/string.hpp
index 870517d2..e7839472 100644
--- a/src/msgpack/type/string.hpp
+++ b/src/msgpack/type/string.hpp
@@ -42,7 +42,7 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const std::string& v)
 inline void operator<< (object::with_zone& o, const std::string& v)
 {
 	o.type = type::RAW;
-	char* ptr = (char*)o.zone->malloc(v.size());
+	char* ptr = static_cast<char*>(o.zone->malloc(v.size()));
 	o.via.raw.ptr = ptr;
 	o.via.raw.size = (uint32_t)v.size();
 	memcpy(ptr, v.data(), v.size());
diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp
index 88c61a87..bb2623ff 100644
--- a/src/msgpack/type/tr1/unordered_map.hpp
+++ b/src/msgpack/type/tr1/unordered_map.hpp
@@ -77,7 +77,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
 		o.via.map.ptr  = NULL;
 		o.via.map.size = 0;
 	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
 		object_kv* const pend = p + v.size();
 		o.via.map.ptr  = p;
 		o.via.map.size = v.size();
@@ -127,7 +127,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
 		o.via.map.ptr  = NULL;
 		o.via.map.size = 0;
 	} else {
-		object_kv* p = (object_kv*)o.zone->malloc(sizeof(object_kv)*v.size());
+		object_kv* p = static_cast<object_kv*>(o.zone->malloc(sizeof(object_kv)*v.size()));
 		object_kv* const pend = p + v.size();
 		o.via.map.ptr  = p;
 		o.via.map.size = v.size();
diff --git a/src/msgpack/type/tr1/unordered_set.hpp b/src/msgpack/type/tr1/unordered_set.hpp
index 33c35929..63f37045 100644
--- a/src/msgpack/type/tr1/unordered_set.hpp
+++ b/src/msgpack/type/tr1/unordered_set.hpp
@@ -74,7 +74,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_s
 		o.via.array.ptr = NULL;
 		o.via.array.size = 0;
 	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
@@ -120,7 +120,7 @@ inline void operator<< (object::with_zone& o, const MSGPACK_STD_TR1::unordered_m
 		o.via.array.ptr = NULL;
 		o.via.array.size = 0;
 	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb
index f4a691ca..4f73eb20 100644
--- a/src/msgpack/type/tuple.hpp.erb
+++ b/src/msgpack/type/tuple.hpp.erb
@@ -184,7 +184,7 @@ inline void operator<< (
 		object::with_zone& o,
 		const type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& v) {
 	o.type = type::ARRAY;
-	o.via.array.ptr = (object*)o.zone->malloc(sizeof(object)*<%=i+1%>);
+	o.via.array.ptr = static_cast<object*>(o.zone->malloc(sizeof(object)*<%=i+1%>));
 	o.via.array.size = <%=i+1%>;
 	<%0.upto(i) {|j|%>
 	o.via.array.ptr[<%=j%>] = object(v.template get<<%=j%>>(), o.zone);<%}%>
diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp
index ae2da47f..338eb8c0 100644
--- a/src/msgpack/type/vector.hpp
+++ b/src/msgpack/type/vector.hpp
@@ -61,7 +61,7 @@ inline void operator<< (object::with_zone& o, const std::vector<T>& v)
 		o.via.array.ptr = NULL;
 		o.via.array.size = 0;
 	} else {
-		object* p = (object*)o.zone->malloc(sizeof(object)*v.size());
+		object* p = static_cast<object*>(o.zone->malloc(sizeof(object)*v.size()));
 		object* const pend = p + v.size();
 		o.via.array.ptr = p;
 		o.via.array.size = v.size();
diff --git a/src/msgpack/vrefbuffer.hpp b/src/msgpack/vrefbuffer.hpp
index 8d22cfea..a2f4db58 100644
--- a/src/msgpack/vrefbuffer.hpp
+++ b/src/msgpack/vrefbuffer.hpp
@@ -56,23 +56,23 @@ private:
 	};
 public:
 	vrefbuffer(size_t ref_size = MSGPACK_VREFBUFFER_REF_SIZE,
-			size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE)
+			   size_t chunk_size = MSGPACK_VREFBUFFER_CHUNK_SIZE)
 		:ref_size_(ref_size), chunk_size_(chunk_size)
 	{
 		size_t nfirst = (sizeof(iovec) < 72/2) ?
 			72 / sizeof(iovec) : 8;
 
-		iovec* array = (iovec*)::malloc(
-			sizeof(iovec) * nfirst);
+		iovec* array = static_cast<iovec*>(::malloc(
+			sizeof(iovec) * nfirst));
 		if(!array) {
 			throw std::bad_alloc();
 		}
-		
+
 		tail_  = array;
 		end_   = array + nfirst;
 		array_ = array;
 
-		chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size);
+		chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
 		if(!c) {
 			::free(array);
 			throw std::bad_alloc();
@@ -80,10 +80,10 @@ public:
 		inner_buffer* const ib = &inner_buffer_;
 
 		ib->free = chunk_size;
-		ib->ptr	 = ((char*)c) + sizeof(chunk);
+		ib->ptr	 = reinterpret_cast<char*>(c) + sizeof(chunk);
 		ib->head = c;
 		c->next = nullptr;
-		
+
 	}
 
 	~vrefbuffer()
@@ -117,17 +117,17 @@ public:
 			const size_t nused = tail_ - array_;
 			const size_t nnext = nused * 2;
 
-			iovec* nvec = (iovec*)::realloc(
-				array_, sizeof(iovec)*nnext);
+			iovec* nvec = static_cast<iovec*>(::realloc(
+				array_, sizeof(iovec)*nnext));
 			if(!nvec) {
 				throw std::bad_alloc();
 			}
-			
+
 			array_ = nvec;
 			end_   = nvec + nnext;
 			tail_  = nvec + nused;
 		}
-		
+
 		tail_->iov_base = (char*)buf;
 		tail_->iov_len	= len;
 		++tail_;
@@ -143,24 +143,26 @@ public:
 				sz = len;
 			}
 
-			chunk* c = (chunk*)::malloc(sizeof(chunk) + sz);
+			chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
 			if(!c) {
 				throw std::bad_alloc();
 			}
-			
+
 			c->next = ib->head;
 			ib->head = c;
 			ib->free = sz;
-			ib->ptr	 = ((char*)c) + sizeof(chunk);
+			ib->ptr	 = reinterpret_cast<char*>(c) + sizeof(chunk);
 		}
 
 		char* m = ib->ptr;
 		::memcpy(m, buf, len);
 		ib->free -= len;
 		ib->ptr	 += len;
-		
+
 		if(tail_ != array_ && m ==
-			(const char*)((tail_ - 1)->iov_base) + (tail_ - 1)->iov_len) {
+			static_cast<const char*>(
+				const_cast<const void *>((tail_ - 1)->iov_base)
+			) + (tail_ - 1)->iov_len) {
 			(tail_ - 1)->iov_len += len;
 			return;
 		} else {
@@ -182,7 +184,7 @@ public:
 	{
 		size_t sz = chunk_size_;
 
-		chunk* empty = (chunk*)::malloc(sizeof(chunk) + sz);
+		chunk* empty = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
 		if(!empty) {
 			throw std::bad_alloc();
 		}
@@ -198,8 +200,8 @@ public:
 				nnext *= 2;
 			}
 
-			iovec* nvec = (iovec*)::realloc(
-				to->array_, sizeof(iovec)*nnext);
+			iovec* nvec = static_cast<iovec*>(::realloc(
+				to->array_, sizeof(iovec)*nnext));
 			if(!nvec) {
 				::free(empty);
 				throw std::bad_alloc();
@@ -211,7 +213,7 @@ public:
 		}
 
 		::memcpy(to->tail_, array_, sizeof(iovec)*nused);
-			
+
 		to->tail_ += nused;
 		tail_ = array_;
 
@@ -225,18 +227,18 @@ public:
 		}
 		last->next = toib->head;
 		toib->head = ib->head;
-			
+
 		if(toib->free < ib->free) {
 			toib->free = ib->free;
 			toib->ptr  = ib->ptr;
 		}
-			
+
 		ib->head = empty;
 		ib->free = sz;
-		ib->ptr	 = ((char*)empty) + sizeof(chunk);
-			
+		ib->ptr	 = reinterpret_cast<char*>(empty) + sizeof(chunk);
+
 	}
-		
+
 	void clear()
 	{
 		chunk* c = inner_buffer_.head->next;
@@ -251,7 +253,7 @@ public:
 		c = ib->head;
 		c->next = nullptr;
 		ib->free = chunk_size_;
-		ib->ptr	 = ((char*)c) + sizeof(chunk);
+		ib->ptr	 = reinterpret_cast<char*>(c) + sizeof(chunk);
 
 		tail_ = array_;
 	}
diff --git a/src/msgpack/zbuffer.hpp b/src/msgpack/zbuffer.hpp
index 1afe8025..10c0077e 100644
--- a/src/msgpack/zbuffer.hpp
+++ b/src/msgpack/zbuffer.hpp
@@ -57,7 +57,7 @@ public:
 public:
 	void write(const char* buf, size_t len)
 	{
-		stream_.next_in = (Bytef*)buf;
+		stream_.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(buf));
 		stream_.avail_in = len;
 
 		do {
@@ -115,8 +115,8 @@ public:
 
 	void reset_buffer()
 	{
-		stream_.avail_out += (char*)stream_.next_out - data_;
-		stream_.next_out = (Bytef*)data_;
+		stream_.avail_out += reinterpret_cast<char*>(stream_.next_out) - data_;
+		stream_.next_out = reinterpret_cast<Bytef*>(data_);
 	}
 
 	char* release_buffer()
@@ -131,17 +131,17 @@ public:
 private:
 	bool expand()
 	{
-		size_t used = (char*)stream_.next_out - data_;
+		size_t used = reinterpret_cast<char*>(stream_.next_out) - data_;
 		size_t csize = used + stream_.avail_out;
 		size_t nsize = (csize == 0) ? init_size_ : csize * 2;
 
-		char* tmp = (char*)::realloc(data_, nsize);
+		char* tmp = static_cast<char*>(::realloc(data_, nsize));
 		if(tmp == NULL) {
 			return false;
 		}
 
 		data_ = tmp;
-		stream_.next_out  = (Bytef*)(tmp + used);
+		stream_.next_out  = reinterpret_cast<Bytef*>(tmp + used);
 		stream_.avail_out = nsize - used;
 
 		return true;
diff --git a/src/msgpack/zone.hpp.erb b/src/msgpack/zone.hpp.erb
index d8b5820a..11e0fd18 100644
--- a/src/msgpack/zone.hpp.erb
+++ b/src/msgpack/zone.hpp.erb
@@ -80,7 +80,7 @@ class zone {
                 nnext = nused * 2;
             }
             finalizer* tmp =
-                (finalizer*)::realloc(array_, sizeof(finalizer) * nnext);
+                static_cast<finalizer*>(::realloc(array_, sizeof(finalizer) * nnext));
             if(!tmp) {
                 throw std::bad_alloc();
             }
@@ -101,14 +101,14 @@ class zone {
     struct chunk_list {
         chunk_list(size_t chunk_size)
         {
-            chunk* c = (chunk*)::malloc(sizeof(chunk) + chunk_size);
+            chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + chunk_size));
             if(!c) {
                 throw std::bad_alloc();
             }
             
             head_ = c;
             free_ = chunk_size;
-            ptr_  = ((char*)c) + sizeof(chunk);
+            ptr_  = reinterpret_cast<char*>(c) + sizeof(chunk);
             c->next_ = nullptr;
         }
         ~chunk_list()
@@ -138,7 +138,7 @@ class zone {
             }
             head_->next_ = nullptr;
             free_ = chunk_size;
-            ptr_  = ((char*)head_) + sizeof(chunk);
+            ptr_  = reinterpret_cast<char*>(head_) + sizeof(chunk);
         }
         size_t free_;
         char* ptr_;
@@ -183,7 +183,7 @@ private:
 
 inline zone* zone::create(size_t chunk_size)
 {
-    zone* z = (zone*)::malloc(sizeof(zone) + chunk_size);
+    zone* z = static_cast<zone*>(::malloc(sizeof(zone) + chunk_size));
     if (!z) {
         return nullptr;
     }
@@ -236,9 +236,9 @@ inline void* zone::malloc_expand(size_t size)
         sz *= 2;
     }
 
-    chunk* c = (chunk*)::malloc(sizeof(chunk) + sz);
+    chunk* c = static_cast<chunk*>(::malloc(sizeof(chunk) + sz));
 
-    char* ptr = ((char*)c) + sizeof(chunk);
+    char* ptr = reinterpret_cast<char*>(c) + sizeof(chunk);
 
     c->next_  = cl->head_;
     cl->head_ = c;