diff --git a/include/struct_pack/struct_pack/reflection.h b/include/struct_pack/struct_pack/reflection.h
index f19e1db76..ebae1a06b 100644
--- a/include/struct_pack/struct_pack/reflection.h
+++ b/include/struct_pack/struct_pack/reflection.h
@@ -16,6 +16,7 @@
 #pragma once
 #include <cstddef>
 #include <cstring>
+#include <limits>
 #include <set>
 #include <string>
 #include <string_view>
@@ -120,13 +121,28 @@ namespace detail {
     container.resize(std::size_t{});
   };
 
+
+  template <typename Type>
+  concept span = container<Type> && requires(Type t) {
+    t=Type{(typename Type::value_type*)nullptr ,std::size_t{} };
+    t.subspan(std::size_t{},std::size_t{});
+  };
+
+
+
+  template <typename Type>
+  concept dynamic_span = span<Type> && std::is_same_v<std::integral_constant<std::size_t,Type::extent>,std::integral_constant<std::size_t,SIZE_MAX>>;
+
+  template <typename Type>
+  concept static_span = span<Type> && !dynamic_span<Type>;
+
+
 #if __cpp_lib_span >= 202002L
 
   template <typename Type>
   concept continuous_container =
-      string<Type> ||(container<Type> && requires(Type container) {
+      string<Type> || (container<Type> && requires(Type container) {
         std::span{container};
-        container.resize(std::size_t{});
       });
 
 #else
diff --git a/include/struct_pack/struct_pack/struct_pack_impl.hpp b/include/struct_pack/struct_pack/struct_pack_impl.hpp
index e89f9f7af..6104d7bf3 100644
--- a/include/struct_pack/struct_pack/struct_pack_impl.hpp
+++ b/include/struct_pack/struct_pack/struct_pack_impl.hpp
@@ -240,6 +240,11 @@ constexpr inline bool is_trivial_tuple = false;
 template <typename... T>
 constexpr inline bool is_trivial_tuple<tuplet::tuple<T...>> = true;
 
+template <typename T>
+[[noreturn]] constexpr T declval() {
+  unreachable();
+}
+
 template <typename U>
 constexpr auto get_types() {
   using T = std::remove_cvref_t<U>;
@@ -247,23 +252,24 @@ constexpr auto get_types() {
                 std::is_same_v<std::string, T> || container<T> || optional<T> ||
                 unique_ptr<T> || variant<T> || expected<T> || array<T> ||
                 c_array<T> || std::is_same_v<std::monostate, T>) {
-    return std::tuple<T>{};
+    return declval<std::tuple<T>>();
   }
   else if constexpr (tuple<T>) {
-    return T{};
+    return declval<T>();
   }
   else if constexpr (is_trivial_tuple<T>) {
-    return T{};
+    return declval<T>();
   }
   else if constexpr (pair<T>) {
-    return std::tuple<typename T::first_type, typename T::second_type>{};
+    return declval<
+        std::tuple<typename T::first_type, typename T::second_type>>();
   }
   else if constexpr (std::is_aggregate_v<T>) {
     // clang-format off
     return visit_members(
-        std::forward<U>(T{}), [&]<typename... Args>(Args &&
-                                                  ...) CONSTEXPR_INLINE_LAMBDA {
-          return std::tuple<std::remove_cvref_t<Args>...>{};
+        declval<T>(), []<typename... Args>(Args &&
+                                                  ...) constexpr {
+          return declval<std::tuple<std::remove_cvref_t<Args>...>>();
         });
     // clang-format on
   }
@@ -567,7 +573,7 @@ consteval type_id get_type_id() {
   else if constexpr (string<T>) {
     return type_id::string_t;
   }
-  else if constexpr (array<T> || c_array<T>) {
+  else if constexpr (array<T> || c_array<T> || static_span<T>) {
     return type_id::array_t;
   }
   else if constexpr (map_container<T>) {
@@ -695,6 +701,26 @@ consteval std::size_t check_circle() {
   }
 }
 
+template <typename T>
+struct get_array_element {
+  using type = typename T::value_type;
+};
+
+template <typename T, std::size_t sz>
+struct get_array_element<T[sz]> {
+  using type = T;
+};
+
+template <typename T>
+std::size_t consteval get_array_size() {
+  if constexpr (array<T> || c_array<T>) {
+    return sizeof(T) / sizeof(typename get_array_element<T>::type);
+  }
+  else {
+    return T::extent;
+  }
+}
+
 // This help function is just to improve unit test coverage. :)
 // The original lambada in `get_type_literal` is a compile-time expression.
 // Currently, the unit test coverage tools like
@@ -750,10 +776,8 @@ consteval decltype(auto) get_type_literal() {
       return ret + body + end;
     }
     else if constexpr (id == type_id::array_t) {
-      constexpr auto sz =
-          sizeof(Arg) /
-          sizeof(decltype(std::declval<
-                          Arg>()[0]));  // std::size(std::declval<Arg>());
+      constexpr auto sz = get_array_size<Arg>();
+      static_assert(sz > 0, "The array's size must greater than zero!");
       return ret +
              get_type_literal<
                  std::remove_cvref_t<decltype(std::declval<Arg>()[0])>, Arg,
@@ -910,7 +934,8 @@ constexpr bool check_if_compatible_element_exist_impl_helper() {
     }
     else if constexpr (id == type_id::array_t) {
       return check_if_compatible_element_exist_impl_helper<
-          version, std::remove_cvref_t<decltype(T{}[0])>, T, ParentArgs...>();
+          version, std::remove_cvref_t<typename get_array_element<T>::type>, T,
+          ParentArgs...>();
     }
     else if constexpr (id == type_id::map_container_t) {
       return check_if_compatible_element_exist_impl_helper<
@@ -978,7 +1003,7 @@ constexpr size_info inline calculate_one_size(const T &item) {
   using type = std::remove_cvref_t<decltype(item)>;
   static_assert(!std::is_pointer_v<type>);
   size_info ret{.total = 0, .size_cnt = 0, .max_size = 0};
-  if constexpr (std::is_same_v<type, std::monostate>) {
+  if constexpr (id == type_id::monostate_t) {
   }
   else if constexpr (std::is_fundamental_v<type> || std::is_enum_v<type>) {
     ret.total = sizeof(type);
@@ -986,7 +1011,7 @@ constexpr size_info inline calculate_one_size(const T &item) {
   else if constexpr (detail::varint_t<type>) {
     ret.total = detail::calculate_varint_size(item);
   }
-  else if constexpr (c_array<type> || array<type>) {
+  else if constexpr (id == type_id::array_t) {
     if constexpr (is_trivial_serializable<type>::value) {
       ret.total = sizeof(type);
     }
@@ -1141,7 +1166,8 @@ constexpr std::size_t calculate_compatible_version_size() {
     }
     else if constexpr (id == type_id::array_t) {
       return calculate_compatible_version_size<
-          std::remove_cvref_t<decltype(T{}[0])>, T, ParentArgs...>();
+          std::remove_cvref_t<typename get_array_element<T>::type>, T,
+          ParentArgs...>();
     }
     else if constexpr (id == type_id::map_container_t) {
       return calculate_compatible_version_size<typename T::key_type, T,
@@ -1217,8 +1243,9 @@ constexpr void get_compatible_version_numbers(auto &buffer, std::size_t &sz) {
       }
     }
     else if constexpr (id == type_id::array_t) {
-      get_compatible_version_numbers<std::remove_cvref_t<decltype(T{}[0])>, T,
-                                     ParentArgs...>(buffer, sz);
+      get_compatible_version_numbers<
+          std::remove_cvref_t<typename get_array_element<T>::type>, T,
+          ParentArgs...>(buffer, sz);
     }
     else if constexpr (id == type_id::map_container_t) {
       get_compatible_version_numbers<typename T::key_type, T, ParentArgs...>(
@@ -1495,7 +1522,7 @@ class packer {
       else if constexpr (detail::varint_t<type>) {
         detail::serialize_varint(writer_, item);
       }
-      else if constexpr (c_array<type> || array<type>) {
+      else if constexpr (id == type_id::array_t) {
         if constexpr (is_trivial_serializable<type>::value) {
           writer_.write((char *)&item, sizeof(type));
         }
@@ -1612,7 +1639,7 @@ class packer {
           }
         }
       }
-      else if constexpr (c_array<type> || array<type>) {
+      else if constexpr (id == type_id::array_t) {
         for (const auto &i : item) {
           serialize_one<size_type, version>(i);
         }
@@ -2215,7 +2242,7 @@ class unpacker {
       else if constexpr (detail::varint_t<type>) {
         code = detail::deserialize_varint<NotSkip>(reader_, item);
       }
-      else if constexpr (array<type> || c_array<type>) {
+      else if constexpr (id == type_id::array_t) {
         if constexpr (is_trivial_serializable<type>::value) {
           if constexpr (NotSkip) {
             if (!reader_.read((char *)&item, sizeof(type))) [[unlikely]] {
@@ -2308,11 +2335,11 @@ class unpacker {
           if constexpr (trivially_copyable_container<type>) {
             size_t mem_sz = size * sizeof(value_type);
             if constexpr (NotSkip) {
-              if constexpr (string_view<type>) {
+              if constexpr (string_view<type> || dynamic_span<type>) {
                 static_assert(
                     view_reader_t<Reader>,
                     "The Reader isn't a view_reader, can't deserialize "
-                    "a string_view");
+                    "a string_view/span");
                 const char *view = reader_.read_view(mem_sz);
                 if (view == nullptr) [[unlikely]] {
                   return struct_pack::errc::no_buffer_space;
@@ -2336,11 +2363,18 @@ class unpacker {
           }
           else {
             if constexpr (NotSkip) {
-              item.resize(size);
-              for (auto &i : item) {
-                code = deserialize_one<size_type, version, NotSkip>(i);
-                if (code != struct_pack::errc{}) [[unlikely]] {
-                  return code;
+              if constexpr (dynamic_span<type>) {
+                static_assert(!dynamic_span<type>,
+                              "It's illegal to deserialize a span<T> which T "
+                              "is a non-trival-serializable type.");
+              }
+              else {
+                item.resize(size);
+                for (auto &i : item) {
+                  code = deserialize_one<size_type, version, NotSkip>(i);
+                  if (code != struct_pack::errc{}) [[unlikely]] {
+                    return code;
+                  }
                 }
               }
             }
@@ -2457,7 +2491,7 @@ class unpacker {
           }
         }
       }
-      else if constexpr (array<type> || c_array<type>) {
+      else if constexpr (id == type_id::array_t) {
         for (auto &i : item) {
           code = deserialize_one<size_type, version, NotSkip>(i);
           if (code != struct_pack::errc{}) [[unlikely]] {
diff --git a/src/struct_pack/tests/test_serialize.cpp b/src/struct_pack/tests/test_serialize.cpp
index f109cadd1..14c4484a3 100644
--- a/src/struct_pack/tests/test_serialize.cpp
+++ b/src/struct_pack/tests/test_serialize.cpp
@@ -549,17 +549,17 @@ TEST_CASE("test get type code") {
 
   SUBCASE("test get_types") {
     using namespace struct_pack::detail;
-    auto t = get_types<person>();
-    static_assert(std::is_same_v<std::tuple<int, std::string>, decltype(t)>);
+    static_assert(std::is_same_v<std::tuple<int, std::string>,
+                                 decltype(get_types<person>())>);
 
-    auto t1 = get_types<std::tuple<int, std::string>>();
-    static_assert(std::is_same_v<std::tuple<int, std::string>, decltype(t1)>);
+    static_assert(
+        std::is_same_v<std::tuple<int, std::string>,
+                       decltype(get_types<std::tuple<int, std::string>>())>);
 
-    auto t2 = get_types<int>();
-    static_assert(std::is_same_v<std::tuple<int>, decltype(t2)>);
+    static_assert(std::is_same_v<std::tuple<int>, decltype(get_types<int>())>);
 
-    auto t3 = get_types<std::vector<int>>();
-    static_assert(std::is_same_v<std::tuple<std::vector<int>>, decltype(t3)>);
+    static_assert(std::is_same_v<std::tuple<std::vector<int>>,
+                                 decltype(get_types<std::vector<int>>())>);
 
     static_assert(std::is_same_v<decltype(get_types<person>()),
                                  std::tuple<int, std::string>>);
@@ -1031,3 +1031,232 @@ TEST_CASE("compatible convert to optional") {
   CHECK(b.value() == "hello world");
   CHECK(a.value() == "hello world");
 }
+
+#if __cpp_lib_span >= 202002L
+
+struct span_test {
+  std::string hello;
+  std::span<int, 4> sp;
+};
+template <>
+constexpr std::size_t struct_pack::members_count<span_test> = 2;
+struct span_test2 {
+  std::string hello;
+  std::array<int, 4> ar;
+};
+
+struct span_test3 {
+  std::string hello;
+  std::span<std::string, 4> sp;
+};
+template <>
+constexpr std::size_t struct_pack::members_count<span_test3> = 2;
+struct span_test4 {
+  std::string hello;
+  std::array<std::string, 4> ar;
+};
+
+struct span_test5 {
+  std::string hello;
+  std::span<person, 4> sp;
+};
+template <>
+constexpr std::size_t struct_pack::members_count<span_test5> = 2;
+struct span_test6 {
+  std::string hello;
+  std::array<person, 4> ar;
+};
+
+TEST_CASE("test static span") {
+  SUBCASE("test static span<int,4>") {
+    {
+      std::array<int, 4> ar = {1, 4, 5, 3};
+      span_test s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      span_test2 s2;
+      auto res = struct_pack::deserialize<span_test2>(buffer);
+      CHECK(res.has_value());
+      CHECK(res.value().hello == s.hello);
+      CHECK(res.value().ar == ar);
+    }
+    {
+      std::array<int, 4> ar = {1, 4, 5, 32}, ar2;
+      span_test s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      span_test s2 = {.sp = ar2};
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(ar == ar2);
+    }
+    {
+      std::array<int, 4> ar2;
+      span_test2 s = {.hello = "Hello", .ar = {1, 4, 5, 3}};
+      auto buffer = struct_pack::serialize(s);
+      span_test s2 = {.sp = ar2};
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(s.ar == ar2);
+    }
+  }
+  SUBCASE("test static span<std::string ,4>") {
+    {
+      std::array<std::string, 4> ar = {"1", "14", "145", "1453"};
+      span_test3 s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      auto res = struct_pack::deserialize<span_test4>(buffer);
+      CHECK(res.has_value());
+      CHECK(res.value().hello == s.hello);
+      CHECK(res.value().ar == ar);
+    }
+    {
+      std::array<std::string, 4> ar = {"1", "14", "145", "1453"}, ar2;
+      span_test3 s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      span_test3 s2 = {.sp = ar2};
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(ar == ar2);
+    }
+    {
+      std::array<std::string, 4> ar2;
+      span_test4 s = {.hello = "Hello", .ar = {"1", "14", "145", "1453"}};
+      auto buffer = struct_pack::serialize(s);
+      span_test3 s2 = {.sp = ar2};
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(s.ar == ar2);
+    }
+  }
+  SUBCASE("test static span<person ,4>") {
+    {
+      std::array<person, 4> ar = {person{.age = 24, .name = "Betty"},
+                                  person{.age = 241, .name = "Betty2"},
+                                  person{.age = 2414, .name = "Betty3"},
+                                  person{.age = 24141, .name = "Betty4"}};
+      span_test5 s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      auto res = struct_pack::deserialize<span_test6>(buffer);
+      CHECK(res.has_value());
+      CHECK(res.value().hello == s.hello);
+      CHECK(res.value().ar == ar);
+    }
+    {
+      std::array<person, 4> ar = {person{.age = 24, .name = "Betty"},
+                                  person{.age = 241, .name = "Betty2"},
+                                  person{.age = 2414, .name = "Betty3"},
+                                  person{.age = 24141, .name = "Betty4"}},
+                            ar2;
+      span_test5 s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      span_test5 s2 = {.sp = ar2};
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(ar == ar2);
+    }
+    {
+      std::array<person, 4> ar2;
+      span_test6 s = {.hello = "Hello",
+                      .ar = {person{.age = 24, .name = "Betty"},
+                             person{.age = 241, .name = "Betty2"},
+                             person{.age = 2414, .name = "Betty3"},
+                             person{.age = 24141, .name = "Betty4"}}};
+      auto buffer = struct_pack::serialize(s);
+      span_test5 s2 = {.sp = ar2};
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(s.ar == ar2);
+    }
+  }
+}
+
+struct dspan_test {
+  std::string hello;
+  std::span<int> sp;
+};
+struct dspan_test2 {
+  std::string hello;
+  std::vector<int> ar;
+};
+struct dspan_test3 {
+  std::string hello;
+  std::span<std::string> sp;
+};
+struct dspan_test4 {
+  std::string hello;
+  std::vector<std::string> ar;
+};
+struct dspan_test5 {
+  std::string hello;
+  std::span<person> sp;
+};
+struct dspan_test6 {
+  std::string hello;
+  std::vector<person> ar;
+};
+
+TEST_CASE("test dynamic span") {
+  SUBCASE("test dynamic span<int>") {
+    {
+      std::vector<int> ar = {1, 4, 5, 3};
+      dspan_test s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      dspan_test2 s2;
+      auto res = struct_pack::deserialize<dspan_test2>(buffer);
+      CHECK(res.has_value());
+      CHECK(res.value().hello == s.hello);
+      CHECK(res.value().ar == ar);
+    }
+    {
+      std::vector<int> ar = {1, 4, 5, 32};
+      dspan_test s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      dspan_test s2;
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(std::equal(ar.begin(), ar.end(), s2.sp.begin()));
+    }
+    {
+      dspan_test2 s = {.hello = "Hello", .ar = {1, 4, 5, 3}};
+      auto buffer = struct_pack::serialize(s);
+      dspan_test s2;
+      auto ec = struct_pack::deserialize_to(s2, buffer);
+      CHECK(ec == struct_pack::errc{});
+      CHECK(s.hello == s2.hello);
+      CHECK(std::equal(s.ar.begin(), s.ar.end(), s2.sp.begin()));
+    }
+  }
+  SUBCASE("test dynamic span<std::string>") {
+    {
+      std::vector<std::string> ar = {"1", "14", "145", "1453"};
+      dspan_test3 s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      auto res = struct_pack::deserialize<dspan_test4>(buffer);
+      CHECK(res.has_value());
+      CHECK(res.value().hello == s.hello);
+      CHECK(res.value().ar == ar);
+    }
+  }
+  SUBCASE("test dynamic span<person>") {
+    {
+      std::vector<person> ar = {person{.age = 24, .name = "Betty"},
+                                person{.age = 241, .name = "Betty2"},
+                                person{.age = 2414, .name = "Betty3"},
+                                person{.age = 24141, .name = "Betty4"}};
+      dspan_test5 s = {.hello = "Hello", .sp = ar};
+      auto buffer = struct_pack::serialize(s);
+      auto res = struct_pack::deserialize<dspan_test6>(buffer);
+      CHECK(res.has_value());
+      CHECK(res.value().hello == s.hello);
+      CHECK(res.value().ar == ar);
+    }
+  }
+}
+
+#endif
\ No newline at end of file