diff --git a/cpp11/define.hpp b/cpp11/define.hpp
index 9804aa1d..b29eb600 100644
--- a/cpp11/define.hpp
+++ b/cpp11/define.hpp
@@ -75,7 +75,7 @@ struct define_imp {
 		define_imp<Tuple, N-1>::unpack(o, t);
 		const size_t size = o.via.array.size;
 		if(size <= N-1) { return; }
-		o.via.array.ptr[N-1].convert(&std::get<N-1>(t));
+		o.via.array.ptr[N-1].convert(std::get<N-1>(t));
 	}
 	static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
 		define_imp<Tuple, N-1>::object(o, z, t);
@@ -92,7 +92,7 @@ struct define_imp<Tuple, 1> {
 	static void unpack(msgpack::object const& o, Tuple& t) {
 		const size_t size = o.via.array.size;
 		if(size <= 0) { return; }
-		o.via.array.ptr[0].convert(&std::get<0>(t));
+		o.via.array.ptr[0].convert(std::get<0>(t));
 	}
 	static void object(msgpack::object* o, msgpack::zone* z, Tuple const& t) {
 		o->via.array.ptr[0] = msgpack::object(std::get<0>(t), z);
diff --git a/cpp11/tuple.hpp b/cpp11/tuple.hpp
index 0ef661f5..54724489 100644
--- a/cpp11/tuple.hpp
+++ b/cpp11/tuple.hpp
@@ -141,7 +141,7 @@ struct Converter {
 		object const& 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));
+		o.via.array.ptr[N-1].convert<typename std::remove_reference<decltype(type::get<N-1>(v))>::type>(type::get<N-1>(v));
 	}
 };
 
@@ -150,7 +150,7 @@ struct Converter<Tuple, 1> {
 	static void convert (
 		object const& 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));
 	}
 };
 
diff --git a/src/msgpack/object.hpp b/src/msgpack/object.hpp
index 6042d6c6..b5bf2848 100644
--- a/src/msgpack/object.hpp
+++ b/src/msgpack/object.hpp
@@ -85,9 +85,12 @@ struct object {
 	template <typename T>
 	T as() const;
 
+	template <typename T>
+	void convert(T& v) const;
 	template <typename T>
 	void convert(T* v) const;
 
+
 	object();
 
 	object(msgpack_object o);
@@ -302,17 +305,23 @@ inline object::implicit_type object::convert() const
 	return implicit_type(*this);
 }
 
+template <typename T>
+inline void object::convert(T& v) const
+{
+	*this >> v;
+}
+
 template <typename T>
 inline void object::convert(T* v) const
 {
-	*this >> *v;
+	convert(*v);
 }
 
 template <typename T>
 inline T object::as() const
 {
 	T v;
-	convert(&v);
+	convert(v);
 	return v;
 }
 
diff --git a/src/msgpack/type/define.hpp.erb b/src/msgpack/type/define.hpp.erb
index 905b4496..bf1f4226 100644
--- a/src/msgpack/type/define.hpp.erb
+++ b/src/msgpack/type/define.hpp.erb
@@ -111,7 +111,7 @@ struct define<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
 			msgpack::object *ptr = o.via.array.ptr;
 			switch(size) {
 			default:<%(i).downto(0) {|j|%>
-			case <%=j+1%>: ptr[<%=j%>].convert(&a<%=j%>);<%}%>
+			case <%=j+1%>: ptr[<%=j%>].convert(a<%=j%>);<%}%>
 			}
 		}
 	}
diff --git a/src/msgpack/type/deque.hpp b/src/msgpack/type/deque.hpp
index cf816498..878f5d5b 100644
--- a/src/msgpack/type/deque.hpp
+++ b/src/msgpack/type/deque.hpp
@@ -33,7 +33,7 @@ inline std::deque<T>& operator>> (object o, std::deque<T>& v)
 	object* const pend = o.via.array.ptr + o.via.array.size;
 	typename std::deque<T>::iterator it = v.begin();
 	for(; p < pend; ++p, ++it) {
-		p->convert(&*it);
+		p->convert(*it);
 	}
 	return v;
 }
diff --git a/src/msgpack/type/list.hpp b/src/msgpack/type/list.hpp
index 9367719e..eacad035 100644
--- a/src/msgpack/type/list.hpp
+++ b/src/msgpack/type/list.hpp
@@ -33,7 +33,7 @@ inline std::list<T>& operator>> (object o, std::list<T>& v)
 	object* const pend = o.via.array.ptr + o.via.array.size;
 	typename std::list<T>::iterator it = v.begin();
 	for(; p < pend; ++p, ++it) {
-		p->convert(&*it);
+		p->convert(*it);
 	}
 	return v;
 }
diff --git a/src/msgpack/type/map.hpp b/src/msgpack/type/map.hpp
index 589cff38..84f6237c 100644
--- a/src/msgpack/type/map.hpp
+++ b/src/msgpack/type/map.hpp
@@ -51,8 +51,8 @@ inline type::assoc_vector<K,V>& operator>> (object o, type::assoc_vector<K,V>& v
 	object_kv* const pend = o.via.map.ptr + o.via.map.size;
 	std::pair<K, V>* it(&v.front());
 	for(; p < pend; ++p, ++it) {
-		p->key.convert(&it->first);
-		p->val.convert(&it->second);
+		p->key.convert(it->first);
+		p->val.convert(it->second);
 	}
 	std::sort(v.begin(), v.end(), type::detail::pair_first_less<K,V>());
 	return v;
@@ -101,13 +101,13 @@ inline std::map<K, V> operator>> (object o, std::map<K, V>& v)
 	object_kv* const pend(o.via.map.ptr + o.via.map.size);
 	for(; p != pend; ++p) {
 		K key;
-		p->key.convert(&key);
+		p->key.convert(key);
 		typename std::map<K,V>::iterator it(v.lower_bound(key));
 		if(it != v.end() && !(key < it->first)) {
-			p->val.convert(&it->second);
+			p->val.convert(it->second);
 		} else {
 			V val;
-			p->val.convert(&val);
+			p->val.convert(val);
 			v.insert(it, std::pair<K,V>(key, val));
 		}
 	}
@@ -157,8 +157,8 @@ inline std::multimap<K, V> operator>> (object o, std::multimap<K, V>& v)
 	object_kv* const pend(o.via.map.ptr + o.via.map.size);
 	for(; p != pend; ++p) {
 		std::pair<K, V> value;
-		p->key.convert(&value.first);
-		p->val.convert(&value.second);
+		p->key.convert(value.first);
+		p->val.convert(value.second);
 		v.insert(value);
 	}
 	return v;
diff --git a/src/msgpack/type/nil.hpp b/src/msgpack/type/nil.hpp
index 1b69f3c1..209bd390 100644
--- a/src/msgpack/type/nil.hpp
+++ b/src/msgpack/type/nil.hpp
@@ -55,7 +55,7 @@ template <>
 inline void object::as<void>() const
 {
 	msgpack::type::nil v;
-	convert(&v);
+	convert(v);
 }
 
 
diff --git a/src/msgpack/type/pair.hpp b/src/msgpack/type/pair.hpp
index f8ff85a6..87952365 100644
--- a/src/msgpack/type/pair.hpp
+++ b/src/msgpack/type/pair.hpp
@@ -29,8 +29,8 @@ inline std::pair<T1, T2>& operator>> (object o, std::pair<T1, T2>& v)
 {
 	if(o.type != type::ARRAY) { throw type_error(); }
 	if(o.via.array.size != 2) { throw type_error(); }
-	o.via.array.ptr[0].convert(&v.first);
-	o.via.array.ptr[1].convert(&v.second);
+	o.via.array.ptr[0].convert(v.first);
+	o.via.array.ptr[1].convert(v.second);
 	return v;
 }
 
diff --git a/src/msgpack/type/tr1/unordered_map.hpp b/src/msgpack/type/tr1/unordered_map.hpp
index bb2623ff..23168f4e 100644
--- a/src/msgpack/type/tr1/unordered_map.hpp
+++ b/src/msgpack/type/tr1/unordered_map.hpp
@@ -51,8 +51,8 @@ inline MSGPACK_STD_TR1::unordered_map<K, V> operator>> (object o, MSGPACK_STD_TR
 	object_kv* const pend(o.via.map.ptr + o.via.map.size);
 	for(; p != pend; ++p) {
 		K key;
-		p->key.convert(&key);
-		p->val.convert(&v[key]);
+		p->key.convert(key);
+		p->val.convert(v[key]);
 	}
 	return v;
 }
@@ -100,8 +100,8 @@ inline MSGPACK_STD_TR1::unordered_multimap<K, V> operator>> (object o, MSGPACK_S
 	object_kv* const pend(o.via.map.ptr + o.via.map.size);
 	for(; p != pend; ++p) {
 		std::pair<K, V> value;
-		p->key.convert(&value.first);
-		p->val.convert(&value.second);
+		p->key.convert(value.first);
+		p->val.convert(value.second);
 		v.insert(value);
 	}
 	return v;
diff --git a/src/msgpack/type/tuple.hpp.erb b/src/msgpack/type/tuple.hpp.erb
index cc0f1ea9..bf9cf8e0 100644
--- a/src/msgpack/type/tuple.hpp.erb
+++ b/src/msgpack/type/tuple.hpp.erb
@@ -1,7 +1,7 @@
 //
 // MessagePack for C++ static resolution routine
 //
-// Copyright (C) 2008-2009 FURUHASHI Sadayuki
+// Copyright (C) 2008-2013 FURUHASHI Sadayuki and KONDO Takatoshi
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -92,7 +92,7 @@ private:
 template <>
 struct tuple<> {
 	tuple() {}
-	tuple(object const& o) { o.convert(this); }
+	tuple(object const& o) { o.convert(*this); }
 	typedef tuple<> value_type;
 };
 <%0.upto(GENERATION_LIMIT) {|i|%>
@@ -102,7 +102,7 @@ struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
 	tuple() {}
 	tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
 		a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
-	tuple(object const& o) { o.convert(this); }
+	tuple(object const& o) { o.convert(*this); }
 	template <int N> typename tuple_element<value_type, N>::reference get()
 		{ return tuple_element<value_type, N>(*this).get(); }
 	template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
@@ -111,10 +111,10 @@ struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
 	A<%=j%> a<%=j%>;<%}%>
 };
 
-template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>> 
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
 inline typename type::tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& t)
 { return t.get<N>(); }
-template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>> 
+template <int N, typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
 inline typename type::const_tuple_element<type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::const_reference get(type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> const& t)
 { return t.get<N>(); }
 <%}%>
@@ -147,7 +147,7 @@ type::tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>& operator>> (
 	if(o.type != type::ARRAY) { throw type_error(); }
 	if(o.via.array.size < <%=i+1%>) { throw type_error(); }
 	<%0.upto(i) {|j|%>
-	o.via.array.ptr[<%=j%>].convert<typename type::tuple_type<A<%=j%>>::type>(&v.template get<<%=j%>>());<%}%>
+	o.via.array.ptr[<%=j%>].convert<typename type::tuple_type<A<%=j%>>::type>(v.template get<<%=j%>>());<%}%>
 	return v;
 }
 <%}%>
diff --git a/src/msgpack/type/vector.hpp b/src/msgpack/type/vector.hpp
index 338eb8c0..ce1604ec 100644
--- a/src/msgpack/type/vector.hpp
+++ b/src/msgpack/type/vector.hpp
@@ -34,7 +34,7 @@ inline std::vector<T>& operator>> (object o, std::vector<T>& v)
 		object* const pend = o.via.array.ptr + o.via.array.size;
 		T* it = &v[0];
 		do {
-			p->convert(it);
+			p->convert(*it);
 			++p;
 			++it;
 		} while(p < pend);
diff --git a/test/convert.cc b/test/convert.cc
index f579f33a..e875b749 100644
--- a/test/convert.cc
+++ b/test/convert.cc
@@ -20,7 +20,7 @@ TEST(convert, compatibility_less)
 	msgpack::object obj(src, &z);
 
 	compatibility c;
-	EXPECT_NO_THROW( obj.convert(&c) );
+	EXPECT_NO_THROW( obj.convert(c) );
 
 	EXPECT_EQ("kumofs",  c.str1);
 	EXPECT_EQ("default", c.str2);
@@ -37,7 +37,7 @@ TEST(convert, compatibility_more)
 	msgpack::object obj(src, &z);
 
 	compatibility to;
-	EXPECT_NO_THROW( obj.convert(&to) );
+	EXPECT_NO_THROW( obj.convert(to) );
 
 	EXPECT_EQ("kumofs", to.str1);
 	EXPECT_EQ("mpio",   to.str2);
@@ -69,7 +69,7 @@ TEST(convert, enum_member)
 	msgpack::object obj(src, &z);
 
 	enum_member to;
-	EXPECT_NO_THROW( obj.convert(&to) );
+	EXPECT_NO_THROW( obj.convert(to) );
 
 	EXPECT_EQ(enum_member::B, to.flag);
 }
diff --git a/test/fixint.cc b/test/fixint.cc
index a45edb90..a68d759a 100644
--- a/test/fixint.cc
+++ b/test/fixint.cc
@@ -33,7 +33,7 @@ void check_convert() {
 	msgpack::unpack(msg, sbuf.data(), sbuf.size());
 
 	T v2;
-	msg.get().convert(&v2);
+	msg.get().convert(v2);
 
 	EXPECT_EQ(v1.get(), v2.get());
 
diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp
index 5e23e51c..37904952 100644
--- a/test/msgpack_test.cpp
+++ b/test/msgpack_test.cpp
@@ -41,7 +41,7 @@ const double kEPS = 1e-10;
         msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);    \
       EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                        \
       test_type val2;                                                 \
-      obj.convert(&val2);                                             \
+      obj.convert(val2);                                             \
       EXPECT_EQ(val1, val2);                                          \
     }                                                                 \
 } while(0)
@@ -168,7 +168,7 @@ TEST(MSGPACK, simple_buffer_float)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     float val2;
-    obj.convert(&val2);
+    obj.convert(val2);
 
     if (std::isnan(val1))
       EXPECT_TRUE(std::isnan(val2));
@@ -213,7 +213,7 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     float_type val2;
     obj.convert(&val2);
@@ -258,7 +258,7 @@ TEST(MSGPACK, simple_buffer_double)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     double val2;
-    obj.convert(&val2);
+    obj.convert(val2);
 
     if (std::isnan(val1))
       EXPECT_TRUE(std::isnan(val2));
@@ -280,7 +280,7 @@ TEST(MSGPACK, simple_buffer_true)
     msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   bool val2;
-  obj.convert(&val2);
+  obj.convert(val2);
   EXPECT_EQ(val1, val2);
 }
 
@@ -295,7 +295,7 @@ TEST(MSGPACK, simple_buffer_false)
     msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   bool val2;
-  obj.convert(&val2);
+  obj.convert(val2);
   EXPECT_EQ(val1, val2);
 }
 
@@ -317,7 +317,7 @@ TEST(MSGPACK_STL, simple_buffer_string)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     string val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_EQ(val1, val2);
   }
@@ -337,7 +337,7 @@ TEST(MSGPACK_STL, simple_buffer_vector)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     vector<int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -357,7 +357,7 @@ TEST(MSGPACK_STL, simple_buffer_map)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     map<int, int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -377,7 +377,7 @@ TEST(MSGPACK_STL, simple_buffer_deque)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     deque<int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -397,7 +397,7 @@ TEST(MSGPACK_STL, simple_buffer_list)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     list<int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -417,7 +417,7 @@ TEST(MSGPACK_STL, simple_buffer_set)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     set<int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -435,7 +435,7 @@ TEST(MSGPACK_STL, simple_buffer_pair)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     pair<int, int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.first, val2.first);
     EXPECT_EQ(val1.second, val2.second);
   }
@@ -458,7 +458,7 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     multimap<int, int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
 
     vector<pair<int, int> > v1, v2;
     multimap<int, int>::const_iterator it;
@@ -488,7 +488,7 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     multiset<int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
 
     vector<int> v1, v2;
     multiset<int>::const_iterator it;
@@ -523,7 +523,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_map<int, int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     tr1::unordered_map<int, int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it) {
@@ -550,7 +550,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_multimap<int, int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
 
     vector<pair<int, int> > v1, v2;
     tr1::unordered_multimap<int, int>::const_iterator it;
@@ -584,7 +584,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_set<int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.size(), val2.size());
     tr1::unordered_set<int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it)
@@ -606,7 +606,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_multiset<int> val2;
-    obj.convert(&val2);
+    obj.convert(val2);
 
     vector<int> v1, v2;
     tr1::unordered_multiset<int>::const_iterator it;
@@ -637,7 +637,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     unordered_map<int, int> val2;
     obj.convert(&val2);
@@ -664,7 +664,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     unordered_multimap<int, int> val2;
     obj.convert(&val2);
@@ -698,7 +698,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     unordered_set<int> val2;
     obj.convert(&val2);
@@ -720,7 +720,7 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     unordered_multiset<int> val2;
     obj.convert(&val2);
@@ -765,7 +765,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
     TestClass val2;
     val2.i = -1;
     val2.s = "";
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
   }
@@ -799,7 +799,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
     val2.i = -1;
     val2.s = "";
     val2.v = vector<int>();
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
     EXPECT_FALSE(val2.s.empty());
@@ -820,7 +820,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
     TestClass val2;
     val2.i = -1;
     val2.s = "";
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
     EXPECT_FALSE(val2.s.empty());
@@ -862,7 +862,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
   val2.t1 = TestEnumMemberClass::STATE_INVALID;
   val2.t2 = TestEnumMemberClass::STATE_INVALID;
   val2.t3 = TestEnumMemberClass::STATE_INVALID;
-  obj.convert(&val2);
+  obj.convert(val2);
   EXPECT_EQ(val1.t1, val2.t1);
   EXPECT_EQ(val1.t2, val2.t2);
   EXPECT_EQ(val1.t3, val2.t3);
@@ -899,13 +899,13 @@ public:
   void msgpack_unpack(msgpack::object o)
   {
     msgpack::type::tuple<bool, msgpack::object> tuple;
-    o.convert(&tuple);
+    o.convert(tuple);
 
     is_double = msgpack::type::get<0>(tuple);
     if (is_double)
-      msgpack::type::get<1>(tuple).convert(&value.f);
+      msgpack::type::get<1>(tuple).convert(value.f);
     else
-      msgpack::type::get<1>(tuple).convert(&value.i);
+      msgpack::type::get<1>(tuple).convert(value.i);
   }
 };
 
@@ -922,7 +922,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestUnionMemberClass val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
   }
@@ -937,7 +937,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
       msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestUnionMemberClass val2;
-    obj.convert(&val2);
+    obj.convert(val2);
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_EQ(val1.value.i, 1);
     EXPECT_EQ(val1.value.i, val2.value.i);
@@ -965,7 +965,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
         msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);        \
       EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                          \
       test_type val2;                                                   \
-      obj.convert(&val2);                                               \
+      obj.convert(val2);                                               \
       EXPECT_EQ(val1, val2);                                            \
     }                                                                   \
   } while(0);
@@ -1094,7 +1094,7 @@ TEST(MSGPACK, vrefbuffer_int64)
         EXPECT_TRUE(life != NULL);                                      \
         pac.reset();                                                    \
         vec_type::value_type val;                                       \
-        obj.convert(&val);                                              \
+        obj.convert(val);                                              \
         EXPECT_EQ(*it, val);                                            \
         ++it;                                                           \
         msgpack::zone::destroy(life);                                   \
diff --git a/test/object.cc b/test/object.cc
index 7a6b0a87..8916538c 100644
--- a/test/object.cc
+++ b/test/object.cc
@@ -41,7 +41,7 @@ TEST(object, convert)
 	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 
 	myclass m2;
-	obj.convert(&m2);
+	obj.convert(m2);
 
 	EXPECT_EQ(m1, m2);
 }