diff --git a/include/HStructConvByte.h b/include/HStructConvByte.h
index e125ac8..7d75529 100644
--- a/include/HStructConvByte.h
+++ b/include/HStructConvByte.h
@@ -33,6 +33,14 @@
  *     HSTRUCT_GET_TYPE() = HSTRUCT_GET_DATA(uint8_t);
  *     HSTRUCT_END();
  * }
+ * // 使用已有的来序列化和反序列化
+ * HSTRUCT_CONV_DEFINE(uint16_t)
+ * {
+ *     HSTRUCT_FROM_BEGIN(uint16_t);
+ *     // 这里只是示例, 使用 HSTRUCT_USE_CONV_FUNC 调用外部序列化, 数据偏移会自动调整
+ *     HSTRUCT_USE_CONV_FUNC(uint8_t, sizeof(uint8_t), HSTRUCT_GET_TYPE());
+ *     HSTRUCT_END();
+ * }
  */
 
 #include <stdint.h>
@@ -57,10 +65,47 @@
  */
 #define HSTRUCT_FROM_BYTE(type, var, data, len) _HStructFrom_##type((void *)&var, data, len)
 
+/**
+ * @brief 在序列化函数中使用已有的序列化类型的宏
+ * @param type 序列化类型
+ * @param typeLen 序列化类型长度
+ * @param var 变量
+ */
+#define HSTRUCT_USE_CONV_FUNC(type, typeLen, var)                                         \
+    do                                                                                    \
+    {                                                                                     \
+        int useLen = HSTRUCT_CONV_BYTE(type, var, _convData, _len - (_useLen - typeLen)); \
+        if (useLen <= 0)                                                                  \
+        {                                                                                 \
+            LogD("conv is empty, len[%d], useLen[%d][%d]", _len, _useLen, useLen);        \
+            return _useLen;                                                               \
+        }                                                                                 \
+        _useLen += useLen;                                                                \
+        HSTRUCT_UPDATE(0);                                                                \
+    } while (0)
+
+/**
+ * @brief 在反序列化函数中使用已有的反序列化类型的宏
+ * @param type 反序列化类型
+ * @param typeLen 反序列化类型长度
+ * @param var 变量
+ */
+#define HSTRUCT_USE_FROM_FUNC(type, typeLen, var)                                         \
+    do                                                                                    \
+    {                                                                                     \
+        int useLen = HSTRUCT_FROM_BYTE(type, var, _convData, _len - (_useLen - typeLen)); \
+        if (useLen <= 0)                                                                  \
+        {                                                                                 \
+            LogD("from is empty, len[%d], useLen[%d][%d]", _len, _useLen, useLen);        \
+            return _useLen;                                                               \
+        }                                                                                 \
+        _useLen += useLen;                                                                \
+        HSTRUCT_UPDATE(0);                                                                \
+    } while (0)
 
 // 定义或生命该类型的转换函数
-#define HSTRUCT_CONV_DEFINE(type)               int _HStructConv_##type(const void *_var, char *_data, int _len)
-#define HSTRUCT_FROM_DEFINE(type)               int _HStructFrom_##type(void *_var, const char *_data, int _len)
+#define HSTRUCT_CONV_DEFINE(type) int _HStructConv_##type(const void *_var, char *_data, int _len)
+#define HSTRUCT_FROM_DEFINE(type) int _HStructFrom_##type(void *_var, const char *_data, int _len)
 
 // 给已有的类型取别名
 #define HSTRUCT_CONV_ALIAS(type, aliasType) \
@@ -87,11 +132,11 @@
 #define HSTRUCT_END() return _useLen
 
 // 函数的检查数据是否足够
-#define HSTRUCT_CHECK_LEN(len)                                     \
-    if (HSTRUCT_GET_LEN() < len + _useLen)                         \
-    {                                                              \
+#define HSTRUCT_CHECK_LEN(len)                                                                            \
+    if (HSTRUCT_GET_LEN() < len + _useLen)                                                                \
+    {                                                                                                     \
         LogD("data len[%d], use[%d]", __FILE_NAME__, __FUNCTION__, __LINE__, HSTRUCT_GET_LEN(), _useLen); \
-        return _useLen;                                            \
+        return _useLen;                                                                                   \
     }
 
 // 更新长度数据
@@ -100,19 +145,6 @@
     HSTRUCT_CHECK_LEN(nextLen)     \
     _useLen += nextLen
 
-/**
- * @brief 在序列化函数中使用已有的序列化类型的宏
- */
-#define HSTRUCT_USE_CONV_FUNC(type, typeLen, var) \
-    HSTRUCT_UPDATE(typeLen);                      \
-    HSTRUCT_CONV_BYTE(type, var, _convData, _len - (_useLen - typeLen))
-
-/**
- * @brief 在反序列化函数中使用已有的反序列化类型的宏
- */
-#define HSTRUCT_USE_FROM_FUNC(type, typeLen, var) \
-    HSTRUCT_UPDATE(typeLen);                      \
-    HSTRUCT_FROM_BYTE(type, var, _convData, _len - (_useLen - typeLen))
 
 ///< 预设转换函数
 HSTRUCT_CONV_DEFINE(uint8_t);
@@ -125,23 +157,27 @@ HSTRUCT_FROM_DEFINE(uint32_t);
 
 ///< 预设别名转换
 HSTRUCT_CONV_ALIAS(char, uint8_t);
+HSTRUCT_CONV_ALIAS(short, uint16_t);
+HSTRUCT_CONV_ALIAS(int, uint32_t);
+
+HSTRUCT_FROM_ALIAS(char, uint8_t);
+HSTRUCT_FROM_ALIAS(short, uint16_t);
+HSTRUCT_FROM_ALIAS(int, uint32_t);
+
+#ifdef _HSTRUCT_USE_ALIAS
 HSTRUCT_CONV_ALIAS(u8, uint8_t);
 HSTRUCT_CONV_ALIAS(s8, uint8_t);
-HSTRUCT_CONV_ALIAS(short, uint16_t);
 HSTRUCT_CONV_ALIAS(u16, uint16_t);
 HSTRUCT_CONV_ALIAS(s16, uint16_t);
-HSTRUCT_CONV_ALIAS(int, uint32_t);
 HSTRUCT_CONV_ALIAS(u32, uint32_t);
 HSTRUCT_CONV_ALIAS(s32, uint32_t);
 
-HSTRUCT_FROM_ALIAS(char, uint8_t);
 HSTRUCT_FROM_ALIAS(u8, uint8_t);
 HSTRUCT_FROM_ALIAS(s8, uint8_t);
-HSTRUCT_FROM_ALIAS(short, uint16_t);
 HSTRUCT_FROM_ALIAS(u16, uint16_t);
 HSTRUCT_FROM_ALIAS(s16, uint16_t);
-HSTRUCT_FROM_ALIAS(int, uint32_t);
 HSTRUCT_FROM_ALIAS(u32, uint32_t);
 HSTRUCT_FROM_ALIAS(s32, uint32_t);
+#endif
 
 #endif // __HSTRUCT_CONV_BYTE_H__