diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp
index 4c741a21..7bcca0f3 100644
--- a/include/msgpack/unpack.hpp
+++ b/include/msgpack/unpack.hpp
@@ -873,11 +873,13 @@ private:
     unpacker& operator=(const unpacker&);
 };
 
-
 inline void unpack(unpacked& result,
-        const char* data, size_t len, size_t* offset = nullptr);
+        const char* data, size_t len, size_t& off);
+inline void unpack(unpacked& result,
+        const char* data, size_t len);
+// obsolete
 inline void unpack(unpacked* result,
-        const char* data, size_t len, size_t* offset = nullptr);
+        const char* data, size_t len, size_t* off = nullptr);
 
 // obsolete
 typedef enum {
@@ -888,14 +890,17 @@ typedef enum {
 } unpack_return;
 
 // obsolete
-static unpack_return unpack(const char* data, size_t len, size_t* off,
+static unpack_return unpack(const char* data, size_t len, size_t& off,
+        zone& z, object& result);
+static unpack_return unpack(const char* data, size_t len,
         zone& z, object& result);
 static unpack_return unpack(const char* data, size_t len, size_t* off,
         zone* z, object* result);
 
 
 // obsolete
-static object unpack(const char* data, size_t len, zone& z, size_t* off = nullptr);
+static object unpack(const char* data, size_t len, zone& z, size_t& off);
+static object unpack(const char* data, size_t len, zone& z);
 static object unpack(const char* data, size_t len, zone* z, size_t* off = nullptr);
 
 
@@ -1176,11 +1181,10 @@ inline void unpacker::remove_nonparsed_buffer()
 namespace detail {
 
 inline unpack_return
-unpack_imp(const char* data, size_t len, size_t* off,
+unpack_imp(const char* data, size_t len, size_t& off,
     zone& result_zone, object& result)
 {
-    size_t noff = 0;
-    if(off != nullptr) { noff = *off; }
+    size_t noff = off;
 
     if(len <= noff) {
         // FIXME
@@ -1198,7 +1202,7 @@ unpack_imp(const char* data, size_t len, size_t* off,
         return UNPACK_PARSE_ERROR;
     }
 
-    if(off != nullptr) { *off = noff; }
+    off = noff;
 
     if(e == 0) {
         return UNPACK_CONTINUE;
@@ -1217,13 +1221,13 @@ unpack_imp(const char* data, size_t len, size_t* off,
 
 // reference version
 inline void unpack(unpacked& result,
-    const char* data, size_t len, size_t* offset)
+    const char* data, size_t len, size_t& off)
 {
     object obj;
     msgpack::unique_ptr<zone> z(new zone());
 
     unpack_return ret = detail::unpack_imp(
-            data, len, offset, *z, obj);
+            data, len, off, *z, obj);
 
 
     switch(ret) {
@@ -1245,31 +1249,51 @@ inline void unpack(unpacked& result,
         throw unpack_error("parse error");
     }
 }
+
+inline void unpack(unpacked& result,
+    const char* data, size_t len)
+{
+    std::size_t off = 0;
+    return unpack(result, data, len, off);
+}
+
+// obsolete
 // pointer version
 inline void unpack(unpacked* result,
-    const char* data, size_t len, size_t* offset) {
-    unpack(*result, data, len, offset);
+    const char* data, size_t len, size_t* off) {
+    if (off) unpack(*result, data, len, *off);
+    else unpack(*result, data, len);
 }
 
 
 // obsolete
 // reference version
-inline unpack_return unpack(const char* data, size_t len, size_t* off,
+inline unpack_return unpack(const char* data, size_t len, size_t& off,
         zone& z, object& result)
 {
-    return detail::unpack_imp(data, len, off,
-            z, result);
+    return detail::unpack_imp(data, len, off, z, result);
 }
+
+// obsolete
+inline unpack_return unpack(const char* data, size_t len,
+        zone& z, object& result)
+{
+    std::size_t off = 0;
+    return detail::unpack_imp(data, len, off, z, result);
+}
+
+// obsolete
 // pointer version
 inline unpack_return unpack(const char* data, size_t len, size_t* off,
         zone* z, object* result)
 {
-    return unpack(data, len, off, *z, *result);
+    if (off) return unpack(data, len, *off, *z, *result);
+    else return unpack(data, len, *z, *result);
 }
 
 // obsolete
 // reference version
-inline object unpack(const char* data, size_t len, zone& z, size_t* off)
+inline object unpack(const char* data, size_t len, zone& z, size_t& off)
 {
     object result;
 
@@ -1292,10 +1316,21 @@ inline object unpack(const char* data, size_t len, zone& z, size_t* off)
         throw unpack_error("parse error");
     }
 }
+
+// obsolete
+inline object unpack(const char* data, size_t len, zone& z)
+{
+    std::size_t off = 0;
+    return unpack(data, len, z, off);
+}
+
+
+// obsolete
 // pointer version
 inline object unpack(const char* data, size_t len, zone* z, size_t* off)
 {
-    return unpack(data, len, *z, off);
+    if (off) return unpack(data, len, *z, *off);
+    else return unpack(data, len, *z);
 }
 
 }  // namespace msgpack
diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp
index c3479e63..08027497 100644
--- a/test/msgpack_test.cpp
+++ b/test/msgpack_test.cpp
@@ -38,7 +38,7 @@ const double kEPS = 1e-10;
       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(), z, obj);            \
       EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                        \
       test_type val2;                                                 \
       obj.convert(&val2);                                             \
@@ -165,7 +165,7 @@ TEST(MSGPACK, simple_buffer_float)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     float val2;
     obj.convert(&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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     float_type val2;
     obj.convert(&val2);
@@ -255,7 +255,7 @@ TEST(MSGPACK, simple_buffer_double)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     double val2;
     obj.convert(&val2);
@@ -277,7 +277,7 @@ TEST(MSGPACK, simple_buffer_true)
   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(), z, obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   bool val2;
   obj.convert(&val2);
@@ -292,7 +292,7 @@ TEST(MSGPACK, simple_buffer_false)
   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(), z, obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   bool val2;
   obj.convert(&val2);
@@ -314,7 +314,7 @@ TEST(MSGPACK_STL, simple_buffer_string)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     string val2;
     obj.convert(&val2);
@@ -334,7 +334,7 @@ TEST(MSGPACK_STL, simple_buffer_vector)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     vector<int> val2;
     obj.convert(&val2);
@@ -354,7 +354,7 @@ TEST(MSGPACK_STL, simple_buffer_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     map<int, int> val2;
     obj.convert(&val2);
@@ -374,7 +374,7 @@ TEST(MSGPACK_STL, simple_buffer_deque)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     deque<int> val2;
     obj.convert(&val2);
@@ -394,7 +394,7 @@ TEST(MSGPACK_STL, simple_buffer_list)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     list<int> val2;
     obj.convert(&val2);
@@ -414,7 +414,7 @@ TEST(MSGPACK_STL, simple_buffer_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     set<int> val2;
     obj.convert(&val2);
@@ -432,7 +432,7 @@ TEST(MSGPACK_STL, simple_buffer_pair)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     pair<int, int> val2;
     obj.convert(&val2);
@@ -455,7 +455,7 @@ TEST(MSGPACK_STL, simple_buffer_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     multimap<int, int> val2;
     obj.convert(&val2);
@@ -485,7 +485,7 @@ TEST(MSGPACK_STL, simple_buffer_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     multiset<int> val2;
     obj.convert(&val2);
@@ -520,7 +520,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_map<int, int> val2;
     obj.convert(&val2);
@@ -547,7 +547,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_multimap<int, int> val2;
     obj.convert(&val2);
@@ -581,7 +581,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_set<int> val2;
     obj.convert(&val2);
@@ -603,7 +603,7 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_multiset<int> val2;
     obj.convert(&val2);
@@ -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(), 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(), 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(), 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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     unordered_multiset<int> val2;
     obj.convert(&val2);
@@ -751,7 +751,7 @@ TEST(MSGPACK_CPP11, simple_tuple)
   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(), z, obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   std::tuple<bool, std::string, double> val2;
   obj.convert(&val2);
@@ -780,7 +780,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestClass val2;
     val2.i = -1;
@@ -813,7 +813,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestClass2 val2;
     val2.i = -1;
@@ -835,7 +835,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestClass val2;
     val2.i = -1;
@@ -876,7 +876,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
   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(), z, obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   TestEnumMemberClass val2;
   val2.t1 = TestEnumMemberClass::STATE_INVALID;
@@ -919,7 +919,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member)
   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(), z, obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   TestEnumClassMemberClass val2;
   val2.t1 = TestEnumClassMemberClass::TestEnumClassType::STATE_INVALID;
@@ -984,7 +984,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestUnionMemberClass val2;
     obj.convert(&val2);
@@ -999,7 +999,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     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(), z, obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestUnionMemberClass val2;
     obj.convert(&val2);
@@ -1027,7 +1027,7 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
       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(), z, obj);              \
       EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                          \
       test_type val2;                                                   \
       obj.convert(&val2);                                               \
diff --git a/test/object.cc b/test/object.cc
index 627ca1a1..8742179f 100644
--- a/test/object.cc
+++ b/test/object.cc
@@ -37,7 +37,7 @@ TEST(object, convert)
     msgpack::object obj;
 
     msgpack::unpack_return ret =
-        msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+        msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
     EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 
     myclass m2;
@@ -58,7 +58,7 @@ TEST(object, as)
     msgpack::object obj;
 
     msgpack::unpack_return ret =
-        msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+        msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
     EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 
     EXPECT_EQ(m1, obj.as<myclass>());
@@ -131,4 +131,3 @@ TEST(object, construct_primitive)
     EXPECT_EQ(msgpack::type::BOOLEAN, obj_bool.type);
     EXPECT_EQ(true, obj_bool.via.boolean);
 }
-
diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc
index 3805a4a6..7f2afd45 100644
--- a/test/pack_unpack.cc
+++ b/test/pack_unpack.cc
@@ -50,7 +50,7 @@ TEST(pack, myclass)
 }
 
 
-TEST(unpack, myclass)
+TEST(unpack, myclass_no_offset)
 {
     msgpack::sbuffer sbuf;
     myclass m1(1, "phraser");
@@ -59,8 +59,9 @@ TEST(unpack, myclass)
     msgpack::zone z;
     msgpack::object obj;
 
+    // obsolete
     msgpack::unpack_return ret =
-        msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+        msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
 
     EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 
@@ -69,6 +70,125 @@ TEST(unpack, myclass)
     EXPECT_EQ(m1.str, m2.str);
 }
 
+TEST(unpack, myclass_offset)
+{
+    msgpack::sbuffer sbuf;
+    myclass m1(1, "phraser");
+    msgpack::pack(sbuf, m1);
+
+    msgpack::zone z;
+    msgpack::object obj;
+    std::size_t off = 0;
+    // obsolete
+    msgpack::unpack_return ret =
+        msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
+
+    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+
+    myclass m2 = obj.as<myclass>();
+    EXPECT_EQ(m1.num, m2.num);
+    EXPECT_EQ(m1.str, m2.str);
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack, myclass_offset_pointer)
+{
+    msgpack::sbuffer sbuf;
+    myclass m1(1, "phraser");
+    msgpack::pack(sbuf, m1);
+
+    msgpack::zone z;
+    msgpack::object obj;
+    std::size_t off = 0;
+    // obsolete
+    msgpack::unpack_return ret =
+        msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj);
+
+    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+
+    myclass m2 = obj.as<myclass>();
+    EXPECT_EQ(m1.num, m2.num);
+    EXPECT_EQ(m1.str, m2.str);
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack, myclass_offset_null_pointer)
+{
+    msgpack::sbuffer sbuf;
+    myclass m1(1, "phraser");
+    msgpack::pack(sbuf, m1);
+
+    msgpack::zone z;
+    msgpack::object obj;
+    // obsolete
+    msgpack::unpack_return ret =
+        msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj);
+
+    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+
+    myclass m2 = obj.as<myclass>();
+    EXPECT_EQ(m1.num, m2.num);
+    EXPECT_EQ(m1.str, m2.str);
+}
+
+TEST(unpack, int_no_offset)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    msgpack::unpacked msg;
+
+    msgpack::unpack(msg, sbuf.data(), sbuf.size());
+    EXPECT_EQ(1, msg.get().as<int>());
+}
+
+TEST(unpack, int_offset)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    msgpack::unpacked msg;
+
+    std::size_t off = 0;
+
+    msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
+    EXPECT_EQ(1, msg.get().as<int>());
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack, int_pointer)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    msgpack::unpacked msg;
+
+    std::size_t off = 0;
+
+    // obsolete
+    msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &off);
+    EXPECT_EQ(1, msg.get().as<int>());
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack, int_null_pointer)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    msgpack::unpacked msg;
+
+    // obsolete
+    msgpack::unpack(&msg, sbuf.data(), sbuf.size(), nullptr);
+    EXPECT_EQ(1, msg.get().as<int>());
+}
+
+TEST(unpack, int_default_null_pointer)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+    msgpack::unpacked msg;
+
+    // obsolete
+    msgpack::unpack(&msg, sbuf.data(), sbuf.size());
+    EXPECT_EQ(1, msg.get().as<int>());
+}
 
 TEST(unpack, sequence)
 {
@@ -77,18 +197,90 @@ TEST(unpack, sequence)
     msgpack::pack(sbuf, 2);
     msgpack::pack(sbuf, 3);
 
-    size_t offset = 0;
+    std::size_t off = 0;
 
     msgpack::unpacked msg;
 
-    msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
+    msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
     EXPECT_EQ(1, msg.get().as<int>());
 
-    msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
+    msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
     EXPECT_EQ(2, msg.get().as<int>());
 
-    msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
+    msgpack::unpack(msg, sbuf.data(), sbuf.size(), off);
     EXPECT_EQ(3, msg.get().as<int>());
+
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack_return, int_no_offset)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret;
+
+    // obsolete
+    ret = msgpack::unpack(sbuf.data(), sbuf.size(), z, obj);
+    EXPECT_TRUE(ret >= 0);
+    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+    EXPECT_EQ(1, obj.as<int>());
+}
+
+TEST(unpack_return, int_offset)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    std::size_t off = 0;
+
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret;
+
+    // obsolete
+    ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
+    EXPECT_TRUE(ret >= 0);
+    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+    EXPECT_EQ(1, obj.as<int>());
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack_return, int_pointer)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    std::size_t off = 0;
+
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret;
+
+    // obsolete
+    ret = msgpack::unpack(sbuf.data(), sbuf.size(), &off, &z, &obj);
+    EXPECT_TRUE(ret >= 0);
+    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+    EXPECT_EQ(1, obj.as<int>());
+    EXPECT_EQ(off, sbuf.size());
+}
+
+TEST(unpack_return, int_null_pointer)
+{
+    msgpack::sbuffer sbuf;
+    msgpack::pack(sbuf, 1);
+
+    msgpack::zone z;
+    msgpack::object obj;
+    msgpack::unpack_return ret;
+
+    // obsolete
+    ret = msgpack::unpack(sbuf.data(), sbuf.size(), nullptr, &z, &obj);
+    EXPECT_TRUE(ret >= 0);
+    EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
+    EXPECT_EQ(1, obj.as<int>());
 }
 
 
@@ -99,25 +291,27 @@ TEST(unpack, sequence_compat)
     msgpack::pack(sbuf, 2);
     msgpack::pack(sbuf, 3);
 
-    size_t offset = 0;
+    std::size_t off = 0;
 
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret;
 
-    ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj);
+    // obsolete
+    ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
     EXPECT_TRUE(ret >= 0);
     EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
     EXPECT_EQ(1, obj.as<int>());
 
-    ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj);
+    // obsolete
+    ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
     EXPECT_TRUE(ret >= 0);
     EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
     EXPECT_EQ(2, obj.as<int>());
 
-    ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj);
+    // obsolete
+    ret = msgpack::unpack(sbuf.data(), sbuf.size(), off, z, obj);
     EXPECT_TRUE(ret >= 0);
     EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
     EXPECT_EQ(3, obj.as<int>());
 }
-