diff --git a/cpp/msgpack/object.hpp b/cpp/msgpack/object.hpp
index 3b42a8e3..0125d0a5 100644
--- a/cpp/msgpack/object.hpp
+++ b/cpp/msgpack/object.hpp
@@ -87,15 +87,15 @@ struct object {
 	template <typename T>
 	void convert(T* v) const;
 
-	operator msgpack_object();
-	object(msgpack_object obj);
-
 	object();
-	object(bool v);
-	object(uint64_t v);
-	object(int64_t v);
-	object(double v);
-	object(const char* ptr, size_t size);
+
+	template <typename T>
+	object(const T& v);
+
+	template <typename T>
+	object& operator=(const T& v);
+
+	operator msgpack_object();
 
 private:
 	struct implicit_type;
@@ -115,9 +115,11 @@ bool operator!=(const object x, const object y);
 std::ostream& operator<< (std::ostream& s, const object o);
 
 
+// serialize operator
 template <typename Stream, typename T>
 packer<Stream>& operator<< (packer<Stream>& o, const T& v);
 
+// convert operator
 template <typename T>
 T& operator>> (object o, T& v);
 
@@ -190,61 +192,6 @@ inline bool operator!=(const object x, const object y)
 { return !(x == y); }
 
 
-inline object::object()
-{
-	type = type::NIL;
-}
-
-inline object::object(bool v)
-{
-	type = type::BOOLEAN;
-	via.boolean = v;
-}
-
-inline object::object(uint64_t v)
-{
-	type = type::POSITIVE_INTEGER;
-	via.u64 = v;
-}
-
-inline object::object(int64_t v)
-{
-	if(v >= 0) {
-		type = type::POSITIVE_INTEGER;
-		via.u64 = v;
-	} else {
-		type = type::NEGATIVE_INTEGER;
-		via.i64 = v;
-	}
-}
-
-inline object::object(double v)
-{
-	type = type::DOUBLE;
-	via.dec = v;
-}
-
-inline object::object(const char* ptr, size_t size)
-{
-	type = type::RAW;
-	via.raw.size = size;
-	via.raw.ptr = ptr;
-}
-
-inline object::object(msgpack_object obj)
-{
-	// FIXME beter way?
-	::memcpy(this, &obj, sizeof(obj));
-}
-
-inline object::operator msgpack_object()
-{
-	// FIXME beter way?
-	msgpack_object obj;
-	::memcpy(&obj, this, sizeof(obj));
-	return obj;
-}
-
 inline object::implicit_type object::convert() const
 {
 	return implicit_type(*this);
@@ -265,6 +212,40 @@ inline T object::as() const
 }
 
 
+inline object::object()
+{
+	type = type::NIL;
+}
+
+template <typename T>
+inline object::object(const T& v)
+{
+	*this << v;
+}
+
+template <typename T>
+inline object& object::operator=(const T& v)
+{
+	*this << v;
+	return *this;
+}
+
+
+inline object::operator msgpack_object()
+{
+	// FIXME beter way?
+	msgpack_object obj;
+	::memcpy(&obj, this, sizeof(obj));
+	return obj;
+}
+
+inline void operator<< (object& o, msgpack_object v)
+{
+	// FIXME beter way?
+	::memcpy(&o, &v, sizeof(v));
+}
+
+
 // obsolete
 template <typename T>
 inline void convert(T& v, object o)
diff --git a/cpp/msgpack/type/bool.hpp b/cpp/msgpack/type/bool.hpp
index b945d856..9d634352 100644
--- a/cpp/msgpack/type/bool.hpp
+++ b/cpp/msgpack/type/bool.hpp
@@ -39,6 +39,12 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const bool& v)
 	return o;
 }
 
+inline void operator<< (object& o, bool v)
+{
+	o.type = type::BOOLEAN;
+	o.via.boolean = v;
+}
+
 
 }  // namespace msgpack
 
diff --git a/cpp/msgpack/type/float.hpp b/cpp/msgpack/type/float.hpp
index 390e340f..28131d12 100644
--- a/cpp/msgpack/type/float.hpp
+++ b/cpp/msgpack/type/float.hpp
@@ -57,6 +57,19 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const double& v)
 }
 
 
+inline void operator<< (object& o, float v)
+{
+	o.type = type::DOUBLE;
+	o.via.dec = v;
+}
+
+inline void operator<< (object& o, double v)
+{
+	o.type = type::DOUBLE;
+	o.via.dec = v;
+}
+
+
 }  // namespace msgpack
 
 #endif /* msgpack/type/float.hpp */
diff --git a/cpp/msgpack/type/int.hpp b/cpp/msgpack/type/int.hpp
index 03500f76..2dab78b6 100644
--- a/cpp/msgpack/type/int.hpp
+++ b/cpp/msgpack/type/int.hpp
@@ -56,7 +56,7 @@ namespace detail {
 			throw type_error();
 		}
 	};
-	
+
 	template <typename T>
 	static inline T convert_integer(object o)
 	{
@@ -141,6 +141,38 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const unsigned long long&
 	{ o.pack_unsigned_long_long(v); return o; }
 
 
+inline void operator<< (object& o, signed char v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed short v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed int v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed long v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, signed long long v)
+	{ v < 0 ? o.type = type::NEGATIVE_INTEGER, o.via.i64 = v : o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+
+inline void operator<< (object& o, unsigned char v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned short v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned int v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned long v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+inline void operator<< (object& o, unsigned long long v)
+	{ o.type = type::POSITIVE_INTEGER, o.via.u64 = v; }
+
+
 }  // namespace msgpack
 
 #endif /* msgpack/type/int.hpp */
diff --git a/cpp/msgpack/type/nil.hpp b/cpp/msgpack/type/nil.hpp
index 93e66ff8..ed583840 100644
--- a/cpp/msgpack/type/nil.hpp
+++ b/cpp/msgpack/type/nil.hpp
@@ -42,6 +42,11 @@ inline packer<Stream>& operator<< (packer<Stream>& o, const type::nil& v)
 	return o;
 }
 
+inline void operator<< (object& o, type::nil v)
+{
+	o.type = type::NIL;
+}
+
 
 }  // namespace msgpack