diff --git a/inc/hgl/CodePage.h b/inc/hgl/CodePage.h
index 9634ca7..de2348b 100644
--- a/inc/hgl/CodePage.h
+++ b/inc/hgl/CodePage.h
@@ -85,7 +85,7 @@ namespace hgl
 
     constexpr int CharPageCount=sizeof(CodeSet2CharPage)/sizeof(CodePageAndCharSet);
 
-    inline CharCodePage FindCodePage(const char *char_set)
+    inline CharCodePage FindCodePage(const u8char *char_set)
     {
         for(int i=0;i<CharPageCount;i++)
             if(!charset_cmp(CodePage2CharSet[i].charset,char_set))
@@ -104,17 +104,17 @@ namespace hgl
         CharSet()
         {
             codepage=ccpNone;
-            strcpy(charset,CharSetNameLength,"us-ascii");
+            hgl::strcpy(charset,CharSetNameLength,"us-ascii");
         }
 
         CharSet(CharCodePage ccp,const char *cs)
         {
             codepage=ccp;
-            strcpy(charset,CharSetNameLength,cs);
+            hgl::strcpy(charset,CharSetNameLength,cs);
         }
 
         CharSet(CharCodePage);
-        CharSet(const char *);
+        CharSet(const u8char *);
 
         CharSet(const CodePageAndCharSet &cs)
         {
@@ -129,13 +129,13 @@ namespace hgl
     inline CharSet::CharSet(CharCodePage ccp)
     {
         codepage=ccp;
-        strcpy(charset,CharSetNameLength,FindCharSet(ccp));
+        hgl::strcpy(charset,CharSetNameLength,FindCharSet(ccp));
     }
 
-    inline CharSet::CharSet(const char *cs)
+    inline CharSet::CharSet(const u8char *cs)
     {
         codepage=FindCodePage(cs);
-        strcpy(charset,CharSetNameLength,FindCharSet(codepage));
+        hgl::strcpy(charset,CharSetNameLength,FindCharSet(codepage));
     }
 
     extern CharSet DefaultCharSet();
@@ -152,9 +152,9 @@ namespace hgl
      * @param src_size  字符串长度,-1表示全部
      * @return 转换成功后的字符串字符数
      */
-    int to_utf16(const CharSet &charset,u16char **dst,const char *src,const int src_size=-1);
+    int to_utf16(const CharSet &charset,u16char **dst,const void *src,const int src_size=-1);
 
-    int to_utf8(const CharSet &charset,char **dst,const char *src,const int src_size=-1);
+    int to_utf8(const CharSet &charset,u8char **dst,const void *src,const int src_size=-1);
 
     /**
      * 转换u16char *字符串到指定字符集的字符串
@@ -164,29 +164,29 @@ namespace hgl
      * @param src_size  字符串长度,-1表示全部
      * @return 转换成功后的字符串字符数
      */
-    int utf16_to(const CharSet &charset,char **dst,const u16char *src,const int src_size=-1);
+    int utf16_to(const CharSet &charset,u8char **dst,const u16char *src,const int src_size=-1);
 
-    int utf8_to(const CharSet &charset,char **dst,const char *src,const int src_size=-1);
+    int utf8_to(const CharSet &charset,u8char **dst,const u8char *src,const int src_size=-1);
 
-    int             u16_to_u8(char *,int,const u16char *,const int=-1);                         ///<转换u16char *到utf8格式的char *
-    int             u8_to_u16(u16char *,int,const char *,const int=-1);                         ///<转换utf8格式的char *到u16char *
+    int             u16_to_u8(u8char *,int,const u16char *,const int=-1);                           ///<转换u16char *到utf8格式的u8char *
+    int             u8_to_u16(u16char *,int,const u8char *,const int=-1);                           ///<转换utf8格式的u8char *到u16char *
 
-    char *          u16_to_u8(const u16char *,const int,int &);                                 ///<转换u16char *到utf8格式的char *
-    u16char *       u8_to_u16(const char *,const int,int &);                                    ///<转换utf8格式的char *到u16char *
+    u8char *        u16_to_u8(const u16char *,const int,int &);                                     ///<转换u16char *到utf8格式的u8char *
+    u16char *       u8_to_u16(const u8char *,const int,int &);                                      ///<转换utf8格式的u8char *到u16char *
 
-    inline char *   u16_to_u8(const u16char *str)
+    inline u8char * u16_to_u8(const u16char *str)
     {
         int len;
         return u16_to_u8(str,hgl::strlen<u16char>(str)+1,len);
     }
 
-    inline u16char *u8_to_u16(const char *str)
+    inline u16char *u8_to_u16(const u8char *str)
     {
         int len;
-        return u8_to_u16(str,hgl::strlen<char>(str)+1,len);
+        return u8_to_u16(str,hgl::strlen<u8char>(str)+1,len);
     }
 
-    inline UTF16String to_u16(const char *u8_str,int length)
+    inline UTF16String to_u16(const u8char *u8_str,int length)
     {
         int wlen;
         u16char *ws=u8_to_u16(u8_str,length,wlen);
@@ -199,7 +199,7 @@ namespace hgl
         return to_u16(u8str.c_str(),u8str.Length());
     }
 
-    inline UTF16String to_u16(const char *str)
+    inline UTF16String to_u16(const u8char *str)
     {
         int wlen;
 
@@ -212,7 +212,7 @@ namespace hgl
     {
         int ulen;
 
-        char *us=u16_to_u8(wide_str,length,ulen);
+        u8char *us=u16_to_u8(wide_str,length,ulen);
 
         return UTF8String::newOf(us,ulen);
     }
@@ -223,7 +223,7 @@ namespace hgl
     }
 
 #if HGL_OS == HGL_OS_Windows
-    inline OSString ToOSString(const char *str){return to_u16(str);}
+    inline OSString ToOSString(const u8char *str){return to_u16(str);}
     inline OSString ToOSString(const UTF8String &str){return to_u16(str.c_str(), (int)(str.Length()));}
 
     inline UTF8String ToUTF8String(const os_char *str){return to_u8(str,strlen(str));}
diff --git a/inc/hgl/Endian.h b/inc/hgl/Endian.h
index 181c8f4..e31feea 100644
--- a/inc/hgl/Endian.h
+++ b/inc/hgl/Endian.h
@@ -58,10 +58,10 @@ namespace hgl
             bomEnd
         };
 
-        constexpr uint CharSetNameLength=32;                                                            ///<字符集名称长度
-        using CharSetName=char[CharSetNameLength];                                                      ///<字符集名称类型定义
+        constexpr uint CharSetNameLength=32;                                                        ///<字符集名称长度
+        using CharSetName=char[CharSetNameLength];                                                  ///<字符集名称类型定义
 
-        template<int,char> const CharSetName &GetCurCharSet();                                          ///<取得当前程序编码字符集
+        template<int,char> const CharSetName &GetCurCharSet();                                      ///<取得当前程序编码字符集
 
         constexpr CharSetName utf8_charset="utf8";
         constexpr CharSetName utf16le_charset="utf-16le";
@@ -85,7 +85,7 @@ namespace hgl
         struct BOMFileHeader
         {
             int size;                   ///<字节序文件头长度
-            unsigned char data[4];      ///<字节序数据
+            uint8 data[4];              ///<字节序数据
 
             ByteOrderMask bom;          ///<字节序枚举
             const CharSetName *char_set;///<字符集名称
diff --git a/inc/hgl/filesystem/FileSystem.h b/inc/hgl/filesystem/FileSystem.h
index a0b3417..5d1ce76 100644
--- a/inc/hgl/filesystem/FileSystem.h
+++ b/inc/hgl/filesystem/FileSystem.h
@@ -147,7 +147,7 @@ namespace hgl
         }
 
         inline UTF8String MergeFilename(const UTF8String &pathname,const UTF8String &filename)          ///<组合路径名与文件名
-        {return MergeFilename<char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_U8STR);}
+        {return MergeFilename<u8char>(pathname,filename,HGL_DIRECTORY_SEPARATOR,HGL_DIRECTORY_SEPARATOR_U8STR);}
 
         inline WideString MergeFilename(const WideString &pathname,const WideString &filename)          ///<组合路径名与文件名
         {return MergeFilename<wchar_t>(pathname,filename,L'\\',L"\\");}
diff --git a/inc/hgl/io/DataOutputStream.h b/inc/hgl/io/DataOutputStream.h
index e1e7d29..a61b50d 100644
--- a/inc/hgl/io/DataOutputStream.h
+++ b/inc/hgl/io/DataOutputStream.h
@@ -140,7 +140,7 @@ namespace hgl
             template<typename T> bool WriteUTF16LEChars     (const BaseString<T> &str){return WriteUTF16LEChars (str.c_str(),str.Length());}
             template<typename T> bool WriteUTF16BEChars     (const BaseString<T> &str){return WriteUTF16BEChars (str.c_str(),str.Length());}
 
-            template<typename T> bool WriteUTF8StringWithLength (const char *str,const uint length);
+            template<typename T> bool WriteUTF8StringWithLength (const u8char *str,const uint length);
             template<typename T> bool WriteUTF8StringWithLength (const UTF16String &str);
 
             template<uchar C,typename T> bool WriteUTF16StringWithLength(const u16char *str,const uint len);
@@ -148,8 +148,8 @@ namespace hgl
         public:
 
             //32 bit length
-            bool WriteUTF8String        (const char *str,uint length);                                              ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-            bool WriteUTF8String        (const char *str            );                                              ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteUTF8String        (const u8char *str,uint length);                                            ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+            bool WriteUTF8String        (const u8char *str            );                                            ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
             bool WriteUTF8String        (const UTF8String &str      );                                              ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
             bool WriteUTF8String        (const UTF16String &str     );                                              ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
@@ -166,8 +166,8 @@ namespace hgl
             bool WriteUTF16BEString     (const UTF8String &str      ){return WriteUTF16BEString(to_u16(str));}      ///<按utf16-be格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
             //16 bit length
-            bool WriteUTF8ShortString   (const char *str,uint length);                                              ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-            bool WriteUTF8ShortString   (const char *str            );                                              ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF8ShortString   (const u8char *str,uint length);                                            ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+            bool WriteUTF8ShortString   (const u8char *str            );                                            ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
             bool WriteUTF8ShortString   (const UTF8String &str      );                                              ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
             bool WriteUTF8ShortString   (const UTF16String &str     );                                              ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
@@ -184,8 +184,8 @@ namespace hgl
             bool WriteUTF16BEShortString(const UTF8String &str      ){return WriteUTF16BEShortString(to_u16(str));} ///<按utf16-be格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
             //8 bit length
-            bool WriteUTF8TinyString    (const char *str,uint length);                                              ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-            bool WriteUTF8TinyString    (const char *str            );                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF8TinyString    (const u8char *str,uint length);                                            ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+            bool WriteUTF8TinyString    (const u8char *str            );                                            ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
             bool WriteUTF8TinyString    (const UTF8String &str      );                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
             bool WriteUTF8TinyString    (const UTF16String &str     );                                              ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
diff --git a/inc/hgl/io/TextOutputStream.h b/inc/hgl/io/TextOutputStream.h
index 68e0522..e3f502c 100644
--- a/inc/hgl/io/TextOutputStream.h
+++ b/inc/hgl/io/TextOutputStream.h
@@ -55,7 +55,7 @@ namespace hgl
                 return(out->Write(bom_item->data,bom_item->size)==bom_item->size);
             }
 
-            virtual bool WriteChars(const char *,int64)=0;                                          ///<写入一个字符串
+            virtual bool WriteChars(const u8char *,int64)=0;                                        ///<写入一个字符串
             virtual bool WriteChars(const u16char *,int64)=0;                                       ///<写入一个字符串
 
             template<typename N>
@@ -162,7 +162,7 @@ namespace hgl
 
             EndianTextOutputStream(OutputStream *);
 
-            bool WriteChars(const char *,int64);                                            ///<写入一个字符串
+            bool WriteChars(const u8char *,int64);                                          ///<写入一个字符串
             bool WriteChars(const u16char *,int64);                                         ///<写入一个字符串
         };//template<ByteOrderMask BOM> class EndianTextOutputStream
 
diff --git a/inc/hgl/log/LogInfo.h b/inc/hgl/log/LogInfo.h
index 908e417..fdb6f31 100644
--- a/inc/hgl/log/LogInfo.h
+++ b/inc/hgl/log/LogInfo.h
@@ -30,18 +30,23 @@ namespace hgl
         }
 
         inline  void Log(LogLevel ll,const UTF8String &str)
+        {
+            std::cout<<(char *)str.c_str()<<std::endl;
+        }
+
+        inline  void Log(LogLevel ll,const AnsiString &str)
         {
             std::cout<<str.c_str()<<std::endl;
         }
 
         inline  void DebugLog(LogLevel ll,const UTF16String &str,const char *filename,int line,const char *funcname)
         {
-            Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16(filename)+U16_TEXT("\", ")+UTF16String::valueOf(line)+U16_TEXT(" line,func:\"")+to_u16(funcname)+U16_TEXT("\")"));
+            Log(ll,str+U16_TEXT(">>LogFrom(\"")+to_u16((u8char *)filename)+U16_TEXT("\", ")+UTF16String::valueOf(line)+U16_TEXT(" line,func:\"")+to_u16((u8char *)funcname)+U16_TEXT("\")"));
         }
 
         inline  void DebugLog(LogLevel ll,const UTF8String &str,const char *filename,int line,const char *funcname)
         {
-            Log(ll,str+U8_TEXT(">>LogFrom(\"")+UTF8String(filename)+U8_TEXT("\", ")+UTF8String::valueOf(line)+U8_TEXT(" line,func:\"")+UTF8String(funcname)+U8_TEXT("\")"));
+            Log(ll,str+U8_TEXT(">>LogFrom(\"")+UTF8String((u8char *)filename)+U8_TEXT("\", ")+UTF8String::valueOf(line)+U8_TEXT(" line,func:\"")+UTF8String((u8char *)funcname)+U8_TEXT("\")"));
         }
 
         #define LOG_INFO(str)       {Log(llLog,     str);}
diff --git a/inc/hgl/log/Logger.h b/inc/hgl/log/Logger.h
index 4f58fb8..8c62696 100644
--- a/inc/hgl/log/Logger.h
+++ b/inc/hgl/log/Logger.h
@@ -35,7 +35,7 @@ namespace hgl
             virtual void Close()=0;                                                                 ///<关闭日志
 
             virtual void Write(const u16char *,int)=0;                                              ///<输出一行u16char日志
-            virtual void Write(const char *,int)=0;                                                 ///<输出一行char(utf8)日志
+            virtual void Write(const u8char *,int)=0;                                               ///<输出一行u8char日志
         };//class Logger
     }//namespace logger
 
diff --git a/inc/hgl/platform/os/CharType.h b/inc/hgl/platform/os/CharType.h
index 10751b7..d35345b 100644
--- a/inc/hgl/platform/os/CharType.h
+++ b/inc/hgl/platform/os/CharType.h
@@ -3,7 +3,9 @@
 
 using u32char           =char32_t;
 using u16char           =char16_t;
+using u8char            =char8_t;
 using os_char           =char;
+
 #define to_oschar       to_u8
 #define OS_TEXT(str)    u8##str
 #define U8_TEXT(str)    u8##str
diff --git a/inc/hgl/platform/os/MSWindows.h b/inc/hgl/platform/os/MSWindows.h
index ec51c24..506fc42 100644
--- a/inc/hgl/platform/os/MSWindows.h
+++ b/inc/hgl/platform/os/MSWindows.h
@@ -4,13 +4,16 @@
 #include<malloc.h>
 #include<winsock2.h>        //winsock2必须在Windows.h前面，不然会报错
 #include<windows.h>
+#include<uchar.h>
 
 #undef min
 #undef max
 //--------------------------------------------------------------------------------------------------
 using u32char           =char32_t;
 using u16char           =wchar_t;
+using u8char            =char8_t;
 using os_char           =wchar_t;
+
 #define to_oschar       to_u16
 #define OS_TEXT(str)    L##str
 #define U8_TEXT(str)    u8##str
diff --git a/inc/hgl/thread/Thread.h b/inc/hgl/thread/Thread.h
index 6fb9449..f9a617a 100644
--- a/inc/hgl/thread/Thread.h
+++ b/inc/hgl/thread/Thread.h
@@ -58,7 +58,7 @@ namespace hgl
         virtual bool ProcStartThread()                                                                ///<线程启动运行函数,在Execute前被调用
                 {
 #ifdef _DEBUG
-                    char thread_addr[(sizeof(thread_ptr)<<1)+1];
+                    u8char thread_addr[(sizeof(thread_ptr)<<1)+1];
 
                     DataToUpperHexStr(thread_addr,(uint8 *)&tp,sizeof(thread_ptr));
 
diff --git a/inc/hgl/type/BaseString.h b/inc/hgl/type/BaseString.h
index e9ba098..b64ff1c 100644
--- a/inc/hgl/type/BaseString.h
+++ b/inc/hgl/type/BaseString.h
@@ -1289,12 +1289,12 @@ namespace hgl
 
         return BaseString<T>(value)+str;
     }
-
-    using UTF8String    =BaseString<char>;
+    
     using AnsiString    =BaseString<char>;
+    using UTF8String    =BaseString<u8char>;
     using UTF16String   =BaseString<u16char>;
-    using OSString      =BaseString<os_char>;
     using UTF32String   =BaseString<char32_t>;
+    using OSString      =BaseString<os_char>;
     using WideString    =BaseString<wchar_t>;
 
     template<typename C> bool ToNumber(const BaseString<C> &str,int &value){return str.ToInt(value);}
diff --git a/inc/hgl/type/StdString.h b/inc/hgl/type/StdString.h
index 64bd207..ea4d62f 100644
--- a/inc/hgl/type/StdString.h
+++ b/inc/hgl/type/StdString.h
@@ -7,14 +7,14 @@
 #if HGL_OS == HGL_OS_Windows
 inline hgl::OSString std_to_os(const std::string &str)
 {
-    return hgl::to_u16(str.c_str(),(int)(str.length()));
+    return hgl::to_u16((u8char *)str.c_str(),(int)(str.length()));
 }
 
 inline std::string to_std(const hgl::OSString &str)
 {
     hgl::UTF8String u8_str=hgl::to_u8(str);
 
-    return std::string(u8_str.c_str(),str.Length());
+    return std::string((char *)u8_str.c_str(),str.Length());
 }
 #else
 inline hgl::OSString std_to_os(const std::string &str)
@@ -30,6 +30,5 @@ inline std::string to_std(const hgl::OSString &str)
 
 inline hgl::UTF8String std_to_u8(const std::string &str)
 {
-    return hgl::UTF8String(str.c_str(),int(str.size()));
+    return hgl::UTF8String((u8char *)str.c_str(),int(str.size()));
 }
-
diff --git a/inc/hgl/type/StringList.h b/inc/hgl/type/StringList.h
index a606abd..8a06b69 100644
--- a/inc/hgl/type/StringList.h
+++ b/inc/hgl/type/StringList.h
@@ -639,7 +639,7 @@ namespace hgl
         return(result);
     }//int LoadStringList
 
-    inline int LoadUTF8StringList      (UTF8StringList &   sl,io::DataInputStream *dis){return LoadStringList<char,    bomUTF8     >(sl,dis);}
+    inline int LoadUTF8StringList      (UTF8StringList &   sl,io::DataInputStream *dis){return LoadStringList<u8char,  bomUTF8     >(sl,dis);}
     inline int LoadUTF16LEStringList   (UTF16StringList &  sl,io::DataInputStream *dis){return LoadStringList<u16char, bomUTF16LE  >(sl,dis);}
     inline int LoadUTF16BEStringList   (UTF16StringList &  sl,io::DataInputStream *dis){return LoadStringList<u16char, bomUTF16BE  >(sl,dis);}
 
diff --git a/src/DataType/StringList.cpp b/src/DataType/StringList.cpp
index d65d957..6698565 100644
--- a/src/DataType/StringList.cpp
+++ b/src/DataType/StringList.cpp
@@ -7,16 +7,16 @@ namespace hgl
      */
     int LoadStringListFromText(UTF8StringList &sl,uchar *data,const int size,const CharSet &cs)
     {
-        char *str=nullptr;
+        u8char *str=nullptr;
 
         int line_count;
         int char_count;
 
         if(size>=3&&data[0]==0xEF&&data[1]==0xBB&&data[2]==0xBF)            //utf8
-            line_count=SplitToStringListByEnter<char>(sl,(char *)(data+3),size-3);
+            line_count=SplitToStringListByEnter<u8char>(sl,(u8char *)(data+3),size-3);
         else
         if(cs==UTF8CharSet)
-            line_count=SplitToStringListByEnter<char>(sl,(char *)data,size);
+            line_count=SplitToStringListByEnter<u8char>(sl,(u8char *)data,size);
         else
         {
             if(size>=2)
@@ -69,7 +69,7 @@ namespace hgl
                 char_count=to_utf8(cs,&str,(char *)data,size);
 #endif//
 
-            line_count=SplitToStringListByEnter<char>(sl,str,char_count);
+            line_count=SplitToStringListByEnter<u8char>(sl,str,char_count);
 
             delete[] str;
         }
@@ -128,10 +128,10 @@ namespace hgl
         else
         {
             if(size>=3&&data[0]==0xEF&&data[1]==0xBB&&data[2]==0xBF)        //utf8
-                str=u8_to_u16((char *)(data+3),size-3,char_count);
+                str=u8_to_u16((u8char *)(data+3),size-3,char_count);
             else
             if(cs==UTF8CharSet)
-                str=u8_to_u16((char *)data,size,char_count);
+                str=u8_to_u16((u8char *)data,size,char_count);
             else
             {
 #ifdef __ANDROID__
diff --git a/src/IO/DataInputStream.cpp b/src/IO/DataInputStream.cpp
index 03cfa5a..12cd61b 100644
--- a/src/IO/DataInputStream.cpp
+++ b/src/IO/DataInputStream.cpp
@@ -96,7 +96,7 @@ namespace hgl
 
             const uint count=(max_len>str_len?str_len:max_len);
 
-            char *utf8_str=dis->ReadArrays<char>(count);
+            u8char *utf8_str=dis->ReadArrays<u8char>(count);
 
             if(!utf8_str)
                 return(false);
@@ -131,7 +131,7 @@ namespace hgl
 
             const uint count=(max_len>str_len?str_len:max_len);
 
-            char *utf8_str=dis->ReadArrays<char>(count);
+            u8char *utf8_str=dis->ReadArrays<u8char>(count);
 
             if(!utf8_str)
                 return(false);
diff --git a/src/IO/DataOutputStream.cpp b/src/IO/DataOutputStream.cpp
index 5ed2702..a7ce6e5 100644
--- a/src/IO/DataOutputStream.cpp
+++ b/src/IO/DataOutputStream.cpp
@@ -4,7 +4,7 @@ namespace hgl
 {
     namespace io    // write utf8 chars
     {
-        template<> bool DataOutputStream::WriteUTF8Chars<char>        (const char *str,uint size)
+        template<> bool DataOutputStream::WriteUTF8Chars<u8char>        (const u8char *str,uint size)
         {
             if(!out)return(false);
             if(size==0)return(true);
@@ -27,7 +27,7 @@ namespace hgl
 
     namespace io    //write utf8 string
     {
-        template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const char *str,const uint length)
+        template<typename T> bool DataOutputStream::WriteUTF8StringWithLength(const u8char *str,const uint length)
         {
             if(!out)return(false);
 
@@ -47,7 +47,7 @@ namespace hgl
             if(!out)return(false);
 
             int utf8_count;
-            char *utf8_str=u16_to_u8(str.c_str(),str.Length(),utf8_count);
+            u8char *utf8_str=u16_to_u8(str.c_str(),str.Length(),utf8_count);
 
             const bool result=WriteUTF8StringWithLength<T>(utf8_str,utf8_count);
 
@@ -78,7 +78,7 @@ namespace hgl
 
     namespace io    //write utf16-le chars
     {
-        template<> bool DataOutputStream::WriteUTF16LEChars<char>(const char *str,uint length)
+        template<> bool DataOutputStream::WriteUTF16LEChars<u8char>(const u8char *str,uint length)
         {
             if(length==0)return(true);
             if(!out||!str||!*str)return(false);
@@ -99,7 +99,7 @@ namespace hgl
 
     namespace io    //write utf16-be chars
     {
-        template<> bool DataOutputStream::WriteUTF16BEChars<char>(const char *str,uint length)
+        template<> bool DataOutputStream::WriteUTF16BEChars<u8char>(const u8char *str,uint length)
         {
             if(length==0)return(true);
             if(!out||!str||!*str)return(false);
@@ -136,8 +136,8 @@ namespace hgl
 
     namespace io
     {
-        bool DataOutputStream::WriteUTF8String        (const char *str,uint length){return WriteUTF8StringWithLength<uint32>(str,         length);}                               ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8String        (const char *str            ){return WriteUTF8StringWithLength<uint32>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8String        (const u8char *str,uint length){return WriteUTF8StringWithLength<uint32>(str,         length);}                               ///<按utf16-le格式写入字符串(前置4字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8String        (const u8char *str            ){return WriteUTF8StringWithLength<uint32>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
         bool DataOutputStream::WriteUTF8String        (const UTF8String &str      ){return WriteUTF8StringWithLength<uint32>(str.c_str(), str.Length());}                         ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
         bool DataOutputStream::WriteUTF8String        (const UTF16String &str     ){return WriteUTF8StringWithLength<uint32>(str);}                                               ///<按utf8格式写入字符串(前置4字节字符串长度,再写入字符阵列)
 
@@ -152,8 +152,8 @@ namespace hgl
 
 
 
-        bool DataOutputStream::WriteUTF8ShortString   (const char *str,uint length){return WriteUTF8StringWithLength<uint16>(str,         length);}                               ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8ShortString   (const char *str            ){return WriteUTF8StringWithLength<uint16>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8ShortString   (const u8char *str,uint length){return WriteUTF8StringWithLength<uint16>(str,         length);}                               ///<按utf16-le格式写入字符串(前置2字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8ShortString   (const u8char *str            ){return WriteUTF8StringWithLength<uint16>(str,         hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
         bool DataOutputStream::WriteUTF8ShortString   (const UTF8String &str      ){return WriteUTF8StringWithLength<uint16>(str.c_str(), str.Length());}                         ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
         bool DataOutputStream::WriteUTF8ShortString   (const UTF16String &str     ){return WriteUTF8StringWithLength<uint16>(str);}                                               ///<按utf8格式写入字符串(前置2字节字符串长度,再写入字符阵列)
 
@@ -168,8 +168,8 @@ namespace hgl
 
 
 
-        bool DataOutputStream::WriteUTF8TinyString    (const char *str,uint length){return WriteUTF8StringWithLength<uint8>(str,          length);}                               ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
-        bool DataOutputStream::WriteUTF8TinyString    (const char *str            ){return WriteUTF8StringWithLength<uint8>(str,          hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8TinyString    (const u8char *str,uint length){return WriteUTF8StringWithLength<uint8>(str,          length);}                               ///<按utf16-le格式写入字符串(前置1字节字符串长度,再写入字符阵列)
+        bool DataOutputStream::WriteUTF8TinyString    (const u8char *str            ){return WriteUTF8StringWithLength<uint8>(str,          hgl::strlen(str));}                     ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
         bool DataOutputStream::WriteUTF8TinyString    (const UTF8String &str      ){return WriteUTF8StringWithLength<uint8>(str.c_str(),  str.Length());}                         ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
         bool DataOutputStream::WriteUTF8TinyString    (const UTF16String &str     ){return WriteUTF8StringWithLength<uint8>(str);}                                                ///<按utf8格式写入字符串(前置1字节字符串长度,再写入字符阵列)
 
diff --git a/src/IO/TextOutputStream.cpp b/src/IO/TextOutputStream.cpp
index 65560e5..cca0efe 100644
--- a/src/IO/TextOutputStream.cpp
+++ b/src/IO/TextOutputStream.cpp
@@ -8,13 +8,13 @@ namespace hgl
         template<> EndianTextOutputStream<bomUTF16LE>::EndianTextOutputStream(OutputStream *os):TextOutputStream(bomUTF16LE,new LEDataOutputStream(os)){}
         template<> EndianTextOutputStream<bomUTF16BE>::EndianTextOutputStream(OutputStream *os):TextOutputStream(bomUTF16BE,new BEDataOutputStream(os)){}
 
-        template<> TextOutputStream *CreateTextOutputStream<char>(OutputStream *os){return(new UTF8TextOutputStream(os));}
+        template<> TextOutputStream *CreateTextOutputStream<u8char>(OutputStream *os){return(new UTF8TextOutputStream(os));}
         template<> TextOutputStream *CreateTextOutputStream<wchar_t>(OutputStream *os){return(new UTF16LETextOutputStream(os));}
     }//namespace io
 
     namespace io        //WriteChars函数
     {
-        template<> bool EndianTextOutputStream<bomUTF8>::WriteChars(const char *str,int64 size)
+        template<> bool EndianTextOutputStream<bomUTF8>::WriteChars(const u8char *str,int64 size)
         {
             return out?out->WriteUTF8Chars(str,size):false;
         }
@@ -24,7 +24,7 @@ namespace hgl
             return out?out->WriteUTF8Chars(str,size):false;
         }
 
-        template<> bool EndianTextOutputStream<bomUTF16LE>::WriteChars(const char *str,int64 size)
+        template<> bool EndianTextOutputStream<bomUTF16LE>::WriteChars(const u8char *str,int64 size)
         {
             return out?out->WriteUTF16LEChars(str,size):false;
         }
@@ -34,7 +34,7 @@ namespace hgl
             return out?out->WriteUTF16LEChars(str,size):false;
         }
 
-        template<> bool EndianTextOutputStream<bomUTF16BE>::WriteChars(const char *str,int64 size)
+        template<> bool EndianTextOutputStream<bomUTF16BE>::WriteChars(const u8char *str,int64 size)
         {
             return out?out->WriteUTF16BEChars(str,size):false;
         }
diff --git a/src/Log/LogFile.cpp b/src/Log/LogFile.cpp
index 67f6523..245cd1a 100644
--- a/src/Log/LogFile.cpp
+++ b/src/Log/LogFile.cpp
@@ -86,7 +86,7 @@ namespace hgl
                 }
             }
 
-            void Write(const char *str,int size)
+            void Write(const u8char *str,int size)
             {
                 if(tos&&str&&*str&&size>0)
                 {
diff --git a/src/Log/Loginfo.cpp b/src/Log/Loginfo.cpp
index 35929f3..68b5386 100644
--- a/src/Log/Loginfo.cpp
+++ b/src/Log/Loginfo.cpp
@@ -104,7 +104,7 @@ namespace hgl
             void (*Close)();                                                                            ///<关闭所有日志输出
 
             void (*WriteUTF16)(LogLevel,const u16char *,int);                                           ///<输出一行日志
-            void (*WriteUTF8)(LogLevel,const char *,int);                                               ///<输出一行日志
+            void (*WriteUTF8)(LogLevel,const u8char *,int);                                             ///<输出一行日志
         };//struct LogInterface
 
         static LogInterface LogInterface3=
@@ -115,7 +115,7 @@ namespace hgl
             CloseAllLog,
 
             WriteLog<u16char>,
-            WriteLog<char>
+            WriteLog<u8char>
         };
 
         /**
@@ -180,7 +180,7 @@ namespace hgl
                 li->WriteUTF16(level,str,size==-1?hgl::strlen(str):size);
         }
 
-        void Log(LogLevel level,const char *str,int size)
+        void Log(LogLevel level,const u8char *str,int size)
         {
             if(li)
                 li->WriteUTF8(level,str,size==-1?hgl::strlen(str):size);
diff --git a/src/Other/CodePage.cpp b/src/Other/CodePage.cpp
index b104a24..b8d9426 100644
--- a/src/Other/CodePage.cpp
+++ b/src/Other/CodePage.cpp
@@ -8,7 +8,7 @@ namespace hgl
     CharSet UTF16LECharSet  (ccpUTF16LE,utf16le_charset );
     CharSet UTF16BECharSet  (ccpUTF16BE,utf16be_charset );
 
-    int    u16_to_u8(char *dst,int dst_size,const u16char *src,const int src_size)
+    int    u16_to_u8(u8char *dst,int dst_size,const u16char *src,const int src_size)
     {
         if(src_size<=0||!src||!*src)
         {
@@ -50,7 +50,7 @@ namespace hgl
         return int(tp-(uint8 *)dst);
     }
 
-    int    u8_to_u16(u16char *dst,int dst_size,const char *src,const int src_size)
+    int    u8_to_u16(u16char *dst,int dst_size,const u8char *src,const int src_size)
     {
         if(src_size<=0||!src||!*src)
         {
@@ -116,7 +116,7 @@ namespace hgl
      * @param dst_size 结果字符串字符数
      * @return 转换结果，需自行delete[]
      */
-    char *u16_to_u8(const u16char *src,const int src_size,int &dst_size)
+    u8char *u16_to_u8(const u16char *src,const int src_size,int &dst_size)
     {
         if(src_size<=0||!src||!*src)
         {
@@ -150,7 +150,7 @@ namespace hgl
         if(dst_size<=0)
             return(nullptr);
 
-        char *dst=new char[dst_size+1];
+        u8char *dst=new u8char[dst_size+1];
 
         dst[dst_size]=0;        //为防止内存检测工具报错，所以提前赋0
 
@@ -166,7 +166,7 @@ namespace hgl
      * @param dst_size 结果字符串字符数
      * @return 转换结果，需自行delete[]
      */
-    u16char *u8_to_u16(const char *src,const int src_size,int &dst_size)
+    u16char *u8_to_u16(const u8char *src,const int src_size,int &dst_size)
     {
         if(src_size<=0||!src||!*src)
         {
diff --git a/src/Other/UnicodeBlocks.cpp b/src/Other/UnicodeBlocks.cpp
index 8c0d1bc..f0666c6 100644
--- a/src/Other/UnicodeBlocks.cpp
+++ b/src/Other/UnicodeBlocks.cpp
@@ -372,7 +372,7 @@ namespace hgl
         return UnicodeBlock::Error;
     }
 
-    bool IsInUnicodeBlock(const UnicodeBlock &type,const uint32 ch)
+    bool IsInUnicodeBlock(const UnicodeBlock &type,const u32char ch)
     {
         if(type<UnicodeBlock::basic_latin
          ||type>UnicodeBlock::END_RANGE)
diff --git a/src/PlugIn/ExternalModule.cpp b/src/PlugIn/ExternalModule.cpp
index 549bf27..0f721de 100644
--- a/src/PlugIn/ExternalModule.cpp
+++ b/src/PlugIn/ExternalModule.cpp
@@ -35,13 +35,13 @@ namespace hgl
             void *func=pi_get(fp,name);
 
             if(!func)
-                LOG_ERROR("don't find "+UTF8String(name));
+                LOG_ERROR("don't find "+AnsiString(name));
 
             return(func);
         }
         else
         {
-            LOG_ERROR("Get func <"+UTF8String(name)+"> error: no load module!");
+            LOG_ERROR("Get func <"+AnsiString(name)+"> error: no load module!");
 
             return(nullptr);
         }