BSTR、LPSTR、LPWSTR、CString、VAvariant_t、CComBSTR、...

Visual C++.NET涉及到ATL/ATL Server、MFC和託管C++等多種編程方式，不只功能強大並且應用普遍。在編程中，咱們經常會遇到ANSI、Unicode以及BSTR不一樣編碼類 型的字符串轉換操做。本文先介紹基本字符串類型，而後說明相關的類，如CComBSTR、_bstr_t、CStringT等，最後討論它們的轉換方法， 其中還包括使用最新ATL7.0的轉換類和宏，如CA2CT、CA2TEX等。

1、BSTR、LPSTR和LPWSTR

在Visual C++.NET的全部編程方式中，咱們經常要用到這樣的一些基本字符串類型，如BSTR、LPSTR和LPWSTR等。之因此出現相似上述的這些數據類 型，是由於不一樣編程語言之間的數據交換以及對ANSI、Unicode和多字節字符集(MBCS)的支持。

那麼什麼是BSTR、LPSTR以及LPWSTR呢？

BSTR(Basic STRing，Basic字符串)是一個OLECHAR*類型的Unicode字符串。它被描述成一個與自動化相兼容的類型。因爲操做系統提供相應的 API函數(如SysAllocString)來管理它以及一些默認的調度代碼，所以BSTR實際上就是一個COM字符串，但它卻在自動化技術之外的多種 場合下獲得普遍使用。圖1描述了BSTR的結構，其中DWORD值是字符串中實際所佔用的字節數，且它的值是字符串中Unicode字符的兩倍。

LPSTR和LPWSTR是Win32和VC++所使用的一種字符串數據類型。LPSTR被定義成是一個指向以NULL(‘/0’)結尾的8位 ANSI 字符數組指針，而LPWSTR是一個指向以NULL結尾的16位雙字節字符數組指針。在VC++中，還有相似的字符串類型，如LPTSTR、 LPCTSTR等，它們的含義如圖2所示。

例如，LPCTSTR是指「long pointer to a constant generic string」，表示「一個指向通常字符串常量的長指針類型」，與C/C++的const char*相映射，而LPTSTR映射爲 char*。

通常地，還有下列類型定義：

#ifdef UNICODE
typedef LPWSTR LPTSTR;
typedef LPCWSTR LPCTSTR;
#else
typedef LPSTR LPTSTR;
typedef LPCSTR LPCTSTR;
#endif

2、CString、CStringA 和 CStringW

Visual C++.NET中將CStringT做爲ATL和MFC的共享的「通常」字符串類，它有CString、CStringA和CStringW三種形式，分 別操做不一樣字符類型的字符串。這些字符類型是TCHAR、char和wchar_t。TCHAR在Unicode平臺中等同於WCHAR(16位 Unicode字符)，在ANSI中等價於char。wchar_t一般定義爲unsigned short。因爲CString在MFC應用程序中常常用到，這裏再也不重複。

3、VARIANT、COleVariant 和_variant_t

在OLE、ActiveX和COM中，VARIANT數據類型提供了一種很是有效的機制，因爲它既包含了數據自己，也包含了數據的類型，於是它能夠實現各類不一樣的自動化數據的傳輸。下面讓咱們來看看OAIDL.H文件中VARIANT定義的一個簡化版：

struct tagVARIANT {
VARTYPE vt;
union {
short iVal; // VT_I2.
long lVal; // VT_I4.
float fltVal; // VT_R4.
double dblVal; // VT_R8.
DATE date; // VT_DATE.
BSTR bstrVal; // VT_BSTR.
…
short * piVal; // VT_BYREF|VT_I2.
long * plVal; // VT_BYREF|VT_I4.
float * pfltVal; // VT_BYREF|VT_R4.
double * pdblVal; // VT_BYREF|VT_R8.
DATE * pdate; // VT_BYREF|VT_DATE.
BSTR * pbstrVal; // VT_BYREF|VT_BSTR.
};
};

顯然，VARIANT類型是一個C結構，它包含了一個類型成員vt、一些保留字節以及一個大的union類型。例如，若是vt爲VT_I2，那麼咱們能夠從iVal中讀出VARIANT的值。一樣，當給一個VARIANT變量賦值時，也要先指明其類型。例如：

VARIANT va;
:: VariantInit(&va); // 初始化
int a = 2002;
va.vt = VT_I4; // 指明long數據類型
va.lVal = a; // 賦值

爲了方便處理VARIANT類型的變量，Windows還提供了這樣一些很是有用的函數：

VariantInit —— 將變量初始化爲VT_EMPTY；

VariantClear —— 消除並初始化VARIANT；

VariantChangeType —— 改變VARIANT的類型；

VariantCopy —— 釋放與目標VARIANT相連的內存並複製源VARIANT。

COleVariant類是對VARIANT結構的封裝。它的構造函數具備極爲強大大的功能，當對象構造時首先調用VariantInit進行初始 化， 而後根據參數中的標準類型調用相應的構造函數，並使用VariantCopy進行轉換賦值操做，當VARIANT對象不在有效範圍時，它的析構函數就會被 自動調用，因爲析構函數調用了VariantClear，於是相應的內存就會被自動清除。除此以外，COleVariant的賦值操做符在與 VARIANT類型轉換中爲咱們提供極大的方便。例以下面的代碼：

COleVariant v1(」This is a test」); // 直接構造
COleVariant v2 = 「This is a test」;
// 結果是VT_BSTR類型，值爲」This is a test」
COleVariant v3((long)2002);
COleVariant v4 = (long)2002;
// 結果是VT_I4類型，值爲2002

_variant_t是一個用於COM的VARIANT類，它的功能與COleVariant類似。不過在Visual C++.NET的MFC應用程序中使用時須要在代碼文件前面添加下列兩句：

#include 「comutil.h」

#pragma comment( lib, 「comsupp.lib」 )

4、CComBSTR和_bstr_t

CComBSTR是對BSTR數據類型封裝的一個ATL類，它的操做比較方便。例如：

CComBSTR bstr1;
bstr1 = 「Bye」; // 直接賦值
OLECHAR* str = OLESTR(」ta ta」); // 長度爲5的寬字符
CComBSTR bstr2(wcslen(str)); // 定義長度爲5
wcscpy(bstr2.m_str, str); // 將寬字符串複製到BSTR中
CComBSTR bstr3(5, OLESTR(」Hello World」));
CComBSTR bstr4(5, 「Hello World」);
CComBSTR bstr5(OLESTR(」Hey there」));
CComBSTR bstr6(」Hey there」);
CComBSTR bstr7(bstr6);
// 構造時複製，內容爲」Hey there」

_bstr_t是是C++對BSTR的封裝，它的構造和析構函數分別調用SysAllocString和SysFreeString函數，其餘操做是借用BSTR API函數。與_variant_t類似，使用時也要添加comutil.h和comsupp.lib。

5、BSTR、char*和CString轉換

(1) char*轉換成CString

若將char*轉換成CString，除了直接賦值外，還可以使用CString::Format進行。例如：

char chArray[] = 「This is a test」;
char * p = 「This is a test」;

或

LPSTR p = 「This is a test」;

或在已定義Unicode應的用程序中

TCHAR * p = _T(」This is a test」);

或

LPTSTR p = _T(」This is a test」);
CString theString = chArray;
theString.Format(_T(」%s」), chArray);
theString = p;

(2) CString轉換成char*

若將CString類轉換成char*(LPSTR)類型，經常使用下列三種方法：

方法一，使用強制轉換。例如：

CString theString( 「This is a test」 );
LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;

方法二，使用strcpy。例如：

CString theString( 「This is a test」 );
LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
_tcscpy(lpsz, theString);

須要說明的是，strcpy(或可移值Unicode/MBCS的_tcscpy)的第二個參數是 const wchar_t* (Unicode)或const char* (ANSI)，系統編譯器將會自動對其進行轉換。

方法三，使用CString::GetBuffer。例如：

CString s(_T(」This is a test 「));
LPTSTR p = s.GetBuffer();
// 在這裏添加使用p的代碼
if(p != NULL) *p = _T(’/0′);
s.ReleaseBuffer();
// 使用完後及時釋放，以便能使用其它的CString成員函數

(3) BSTR轉換成char*

方法一，使用ConvertBSTRToString。例如：

#include
#pragma comment(lib, 「comsupp.lib」)
int _tmain(int argc, _TCHAR* argv[]){
BSTR bstrText = ::SysAllocString(L」Test」);
char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);
SysFreeString(bstrText); // 用完釋放
delete[] lpszText2;
return 0;
}

方法二，使用_bstr_t的賦值運算符重載。例如：

_bstr_t b = bstrText;
char* lpszText2 = b;

(4) char*轉換成BSTR

方法一，使用SysAllocString等API函數。例如：

BSTR bstrText = ::SysAllocString(L」Test」);
BSTR bstrText = ::SysAllocStringLen(L」Test」,4);
BSTR bstrText = ::SysAllocStringByteLen(」Test」,4);

方法二，使用COleVariant或_variant_t。例如：

//COleVariant strVar(」This is a test」);
_variant_t strVar(」This is a test」);
BSTR bstrText = strVar.bstrVal;

方法三，使用_bstr_t，這是一種最簡單的方法。例如：

BSTR bstrText = _bstr_t(」This is a test」);

方法四，使用CComBSTR。例如：

BSTR bstrText = CComBSTR(」This is a test」);

或

CComBSTR bstr(」This is a test」);
BSTR bstrText = bstr.m_str;

方法五，使用ConvertStringToBSTR。例如：

char* lpszText = 「Test」;
BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);

(5) CString轉換成BSTR

一般是經過使用CStringT::AllocSysString來實現。例如：

CString str(」This is a test」);
BSTR bstrText = str.AllocSysString();
…
SysFreeString(bstrText); // 用完釋放

(6) BSTR轉換成CString

通常可按下列方法進行：

BSTR bstrText = ::SysAllocString(L」Test」);
CStringA str;
str.Empty();
str = bstrText;

或

CStringA str(bstrText);

(7) ANSI、Unicode和寬字符之間的轉換

方法一，使用MultiByteToWideChar將ANSI字符轉換成Unicode字符，使用WideCharToMultiByte將Unicode字符轉換成ANSI字符。

方法二，使用「_T」將ANSI轉換成「通常」類型字符串，使用「L」將ANSI轉換成Unicode，而在託管C++環境中還可以使用S將ANSI字符串轉換成String*對象。例如：

TCHAR tstr[] = _T(」this is a test」);
wchar_t wszStr[] = L」This is a test」;
String* str = S」This is a test」;

方法三，使用ATL 7.0的轉換宏和類。ATL7.0在原有3.0基礎上完善和增長了許多字符串轉換宏以及提供相應的類，它具備如圖3所示的統一形式：

其中，第一個C表示「類」，以便於ATL 3.0宏相區別，第二個C表示常量，2表示「to」，EX表示要開闢必定大小的緩衝。SourceType和DestinationType能夠是A、 T、W和OLE，其含義分別是ANSI、Unicode、「通常」類型和OLE字符串。例如，CA2CT就是將ANSI轉換成通常類型的字符串常量。下面 是一些示例代碼：

LPTSTR tstr= CA2TEX<16>(」this is a test」);
LPCTSTR tcstr= CA2CT(」this is a test」);
wchar_t wszStr[] = L」This is a test」;
char* chstr = CW2A(wszStr);

6、結語

幾乎全部的程序都要用到字符串，而Visual C++.NET因爲功能強大、應用普遍，於是字符串之間的轉換更爲頻繁。本文幾乎涉及到目前的全部轉換方法。固然對於.NET框架來講，還可以使用Convert和Text類進行不一樣數據類型以及字符編碼之間的相互轉換。

CString ,BSTR ,LPCTSTR之間關係和區別

CString是一個動態TCHAR數組，BSTR是一種專有格式的字符串（須要用系統提供的函數來操縱，LPCTSTR只是一個常量的TCHAR指針。

CString 是一個徹底獨立的類，動態的TCHAR數組，封裝了 + 等操做符和字符串操做方法。
typedef OLECHAR FAR* BSTR;
typedef const char * LPCTSTR;

vc++中各類字符串的表示法

首先char* 是指向ANSI字符數組的指針，其中每一個字符佔據8位（有效數據是除掉最高位的其餘7位），這裏保持了與傳統的C,C++的兼容。

LP的含義是長指針(long pointer)。LPSTR是一個指向以‘/0’結尾的ANSI字符數組的指針，與char*能夠互換使用，在win32中較多地使用LPSTR。
而LPCSTR中增長的‘C’的含義是「CONSTANT」（常量），代表這種數據類型的實例不能被使用它的API函數改變，除此以外，它與LPSTR是等同的。
1.LP表示長指針,在win16下有長指針(LP)和短指針(P)的區別,而在win32下是沒有區別的,都是32位.因此這裏的LP和P是等價的.
2.C表示const
3.T是什麼東西呢,咱們知道TCHAR在採用Unicode方式編譯時是wchar_t,在普通時編譯成char.

爲了知足程序代碼國際化的須要，業界推出了Unicode標準，它提供了一種簡單和一致的表達字符串的方法，全部字符中的字節都是16位的值，其數 量也能夠知足差很少世界上全部書面語言字符的編碼需求，開發程序時使用Unicode（類型爲wchar_t)是一種被鼓勵的作法。

LPWSTR與LPCWSTR由此產生，它們的含義相似於LPSTR與LPCSTR，只是字符數據是16位的wchar_t而不是char。

而後爲了實現兩種編碼的通用，提出了TCHAR的定義：
若是定義_UNICODE，聲明以下：
typedef wchar_t TCHAR;
若是沒有定義_UNICODE，則聲明以下：
typedef char TCHAR;

LPTSTR和LPCTSTR中的含義就是每一個字符是這樣的TCHAR。

CString類中的字符就是被聲明爲TCHAR類型的，它提供了一個封裝好的類供用戶方便地使用。

LPCTSTR:
#ifdef _UNICODE
typedef const wchar_t * LPCTSTR;
#else
typedef const char * LPCTSTR;
#endif

VC經常使用數據類型使用轉換詳解

先定義一些常見類型變量藉以說明
int i = 100;
long l = 2001;
float f=300.2;
double d=12345.119;
char username[]=」女俠程佩君」;
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2;

1、其它數據類型轉換爲字符串

短整型(int)
itoa(i,temp,10);     //將i轉換爲字符串放入temp中,最後一個數字表示十進制
itoa(i,temp,2);      //按二進制方式轉換
長整型(long)
ltoa(l,temp,10);
2、從其它包含字符串的變量中獲取指向該字符串的指針

CString變量
str = 「2008北京奧運」;
buf = (LPSTR)(LPCTSTR)str;
BSTR類型的_variant_t變量
v1 = (_bstr_t)」程序員」;
buf = _com_util::ConvertBSTRToString((_bstr_t)v1);

3、字符串轉換爲其它數據類型
strcpy(temp,」123″);

短整型(int)
i = atoi(temp);
長整型(long)
l = atol(temp);
浮點(double)
d = atof(temp);

4、其它數據類型轉換到CString

使用CString的成員函數Format來轉換,例如:

整數(int)
str.Format(」%d」,i);
浮點數(float)
str.Format(」%f」,i);
字符串指針(char *)等已經被CString構造函數支持的數據類型能夠直接賦值
str = username;

5、BSTR、_bstr_t與CComBSTR

CComBSTR、_bstr_t是對BSTR的封裝,BSTR是指向字符串的32位指針。
char *轉換到BSTR能夠這樣: BSTR b=_com_util::ConvertStringToBSTR(」數據」);     //使用前須要加上頭文件comutil.h
反之可使用char *p=_com_util::ConvertBSTRToString(b);
6、VARIANT 、_variant_t 與 COleVariant

VARIANT的結構能夠參考頭文件VC98/Include/OAIDL.H中關於結構體tagVARIANT的定義。
對於VARIANT變量的賦值：首先給vt成員賦值，指明數據類型，再對聯合結構中相同數據類型的變量賦值，舉個例子：
VARIANT va;
int a=2001;
va.vt=VT_I4;    //指明整型數據
va.lVal=a;      //賦值

對於不立刻賦值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);進行初始化,其本質是將vt設置爲VT_EMPTY,下表咱們列舉vt與經常使用數據的對應關係:

unsigned char bVal; VT_UI1
short iVal; VT_I2
long lVal; VT_I4
float fltVal; VT_R4
double dblVal; VT_R8
VARIANT_BOOL boolVal; VT_BOOL
SCODE scode; VT_ERROR
CY cyVal; VT_CY
DATE date; VT_DATE
BSTR bstrVal; VT_BSTR
IUnknown FAR* punkVal; VT_UNKNOWN
IDispatch FAR* pdispVal; VT_DISPATCH
SAFEARRAY FAR* parray; VT_ARRAY|*
unsigned char FAR* pbVal; VT_BYREF|VT_UI1
short FAR* piVal; VT_BYREF|VT_I2
long FAR* plVal; VT_BYREF|VT_I4
float FAR* pfltVal; VT_BYREF|VT_R4
double FAR* pdblVal; VT_BYREF|VT_R8
VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL
SCODE FAR* pscode; VT_BYREF|VT_ERROR
CY FAR* pcyVal; VT_BYREF|VT_CY
DATE FAR* pdate; VT_BYREF|VT_DATE
BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR
IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN
IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH
SAFEARRAY FAR* FAR* pparray; VT_ARRAY|*
VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT
void FAR* byref; VT_BYREF

_variant_t是VARIANT的封裝類，其賦值可使用強制類型轉換，其構造函數會自動處理這些數據類型。
例如：
long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;

COleVariant的使用與_variant_t的方法基本同樣，請參考以下例子：
COleVariant v3 = 「字符串」, v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;

7、其它

對消息的處理中咱們常常須要將WPARAM或LPARAM等32位數據(DWORD)分解成兩個16位數據(WORD),例如：
LPARAM lParam;
WORD loValue = LOWORD(lParam);     //取低16位
WORD hiValue = HIWORD(lParam);     //取高16位
對於16位的數據(WORD)咱們能夠用一樣的方法分解成高低兩個8位數據(BYTE),例如:
WORD wValue;
BYTE loValue = LOBYTE(wValue);     //取低8位
BYTE hiValue = HIBYTE(wValue);     //取高8位

如何將CString類型的變量賦給char*類型的變量
一、GetBuffer函數：
使用CString::GetBuffer函數。
char *p;
CString str=」hello」;
p=str.GetBuffer(str.GetLength());
str.ReleaseBuffer();

將CString轉換成char * 時
CString str(」aaaaaaa」);
strcpy(str.GetBuffer(10),」aa」);
str.ReleaseBuffer();
當咱們須要字符數組時調用GetBuffer(int n),其中n爲咱們須要的字符數組的長度.使用完成後必定要立刻調用ReleaseBuffer();
還有很重要的一點就是,在能使用const char *的地方,就不要使用char *

二、memcpy：
CString mCS=_T(」cxl」);
char mch[20];
memcpy(mch,mCS,20);

三、用LPCTSTR強制轉換： 儘可能不使用
char *ch;
CString str;
ch=(LPSTR)(LPCTSTR)str;

CString str = 「good」;
char *tmp;
sprintf(tmp,」%s」,(LPTSTR)(LPCTSTR)str);

四、
CString Msg;
Msg=Msg+」abc」;
LPTSTR lpsz;
lpsz = new TCHAR[Msg.GetLength()+1];
_tcscpy(lpsz, Msg);
char * psz;
strcpy(psz,lpsz);
CString類向const char *轉換
char a[100];
CString str(」aaaaaa」);
strncpy(a,(LPCTSTR)str,sizeof(a));
或者以下:
strncpy(a,str,sizeof(a));
以上兩種用法都是正確地. 由於strncpy的第二個參數類型爲const char *.因此編譯器會自動將CString類轉換成const char *.

CString轉LPCTSTR (const char *)
CString cStr;
const char *lpctStr=(LPCTSTR)cStr;

LPCTSTR轉CString
LPCTSTR lpctStr;
CString cStr=lpctStr;

將char*類型的變量賦給CString型的變量
能夠直接賦值，如：
CString myString = 「This is a test」;
也能夠利用構造函數，如：
CString s1(」Tom」);

將CString類型的變量賦給char []類型(字符串)的變量
一、sprintf()函數
CString str = 「good」;
char tmp[200] ;
sprintf(tmp, 「%s」,(LPCSTR)str);
(LPCSTR)str這種強制轉換至關於(LPTSTR)(LPCTSTR)str
CString類的變量須要轉換爲(char*)的時,使用(LPTSTR)(LPCTSTR)str

然而，LPCTSTR是const char *,也就是說，獲得的字符串是不可寫的！將其強制轉換成LPTSTR去掉const，是極爲危險的！
一不留神就會完蛋！要獲得char *,應該用GetBuffer()或GetBufferSetLength()，用完後再調用ReleaseBuffer()。

二、strcpy()函數
CString str;
char c[256];
strcpy(c, str);

char mychar[1024];
CString source=」Hello」;
strcpy((char*)&mychar,(LPCTSTR)source);
關於CString的使用
一、指定 CString 形參
對於大多數須要字符串參數的函數，最好將函數原型中的形參指定爲一個指向字符 (LPCTSTR) 而非 CString 的 const 指針。
當將形參指定爲指向字符的 const 指針時，可將指針傳遞到 TCHAR 數組（如字符串 ["hi there"]）或傳遞到 CString 對象。
CString 對象將自動轉換成 LPCTSTR。任何可以使用 LPCTSTR 的地方也可以使用 CString 對象。

二、若是某個形參將不會被修改，則也將該參數指定爲常數字符串引用（即 const CString&）。若是函數要修改該字符串，
則刪除 const 修飾符。若是須要默認爲空值，則將其初始化爲空字符串 [""]，以下所示：
void AddCustomer( const CString& name, const CString& address, const CString& comment = 「」 );

三、對於大多數函數結果，按值返回 CString 對象便可。
串的基本運算
對於串的基本運算，不少高級語言均提供了相應的運算符或標準的庫函數來實現。
爲敘述方便，先定義幾個相關的變量：
char s1[20]=」dir/bin/appl」,s2[20]=」file.asm」,s3[30],*p;
int result;
下面以C語言中串運算介紹串的基本運算
一、求串長
int strlen(char *s);         //求串s的長度
【例】printf(」%d」,strlen(s1));    //輸出s1的串長12

二、串複製
char *strcpy(char *to,*from)；//將from串複製到to串中，並返回to開始處指針
【例】strcpy(s3,s1); //s3=」dir/bin/appl」,s1串不變
三、聯接
char *strcat(char *to,char *from);//將from串複製到to串的末尾，
//並返回to串開始處的指針
【例】strcat(s3,」/」);    //s3=」dir/bin/appl/」
strcat(s3,s2);     //s3=」dir/bin/appl/file.asm」

四、串比較
int strcmp(char *s1,char *s2);//比較s1和s2的大小，
//當s1<s二、s1>s2和s1=s2時，分別返回小於0、大於0和等於0的值
【例】result=strcmp(」baker」,」Baker」);    //result>0
result=strcmp(」12″,」12″);        //result=0
result=strcmp(」Joe」,」joseph」)   //result<0

五、字符定位
char *strchr(char *s,char c);//找c在字符串s中第一次出現的位置，
//若找到，則返回該位置，不然返回NULL
【例】p=strchr(s2,’.');      //p指向」file」以後的位置
if(p) strcpy(p,」.cpp」);     //s2=」file.cpp」

注意：
①上述操做是最基本的，其中後 4個操做還有變種形式：strncpy，strncath和strnchr。
②其它的串操做見C的<string.h>。在不一樣的高級語言中，對串運算的種類及符號都不盡相同
③其他的串操做通常可由這些基本操做組合而成

【例】求子串的操做可以下實現： void substr(char *sub,char *s,int pos,int len){ //s和sub是字符數組，用sub返回串s的第pos個字符起長度爲len的子串 //其中0<=pos<=strlen(s)-1,且數組sub至少可容納len+1個字符。 if (pos<0||pos>strlen(s)-1||len<0) Error(」parameter error!」); strncpy(sub,&s[pos],len);      //從s[pos]起復制至多len個字符到sub