FAQ VC++ et MFCConsultez toutes les FAQ

typedef OLECHAR FAR* BSTR;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void BSTRtoASC (BSTR str, char * &strRet) 
{ 
    if ( str != NULL ) 
    { 
        unsigned long length = WideCharToMultiByte (CP_ACP, 0, str, SysStringLen(str), 
                                            NULL, 0, NULL, NULL); 
        strRet = new char[length]; 
        length = WideCharToMultiByte (CP_ACP, 0, str, SysStringLen(str),  
                           reinterpret_cast <char *>(strRet), length, NULL, NULL); 
        strRet[length] = '\0'; 
    } 
} 
  
void ASCtoBSTR (char * str, BSTR * strRet) 
{ 
    if ( str != NULL ) 
    { 
        unsigned long length = strlen(str); 
        int ResultLength = MultiByteToWideChar (CP_ACP,MB_PRECOMPOSED, 
                           reinterpret_cast <char *>(str),length,NULL,0); 
        *strRet = SysAllocStringLen( NULL, ResultLength); 
        MultiByteToWideChar (CP_ACP,MB_PRECOMPOSED, 
                           reinterpret_cast <char *>(str),length,*strRet,ResultLength); 
    } 
}

1
2
CString strResult("un test de chaîne"); 
return strResult.AllocSysString();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
   char  *stopstring; 
   double x; 
   long   l; 
   int    base; 
   unsigned long ul; 
  
   CString string="3.1415926This stopped it"; 
  
   x = strtod( string, &stopstring ); 
   TRACE( "string = %s\n",(const char *)string ); 
   TRACE("   strtod = %f\n", x ); 
   TRACE("   Stopped scan at: %s\n\n", stopstring ); 
  
   string = "-10110134932This stopped it"; 
   l = strtol( string, &stopstring, 10 ); 
   TRACE( "string = %s",(const char *)string ); 
   TRACE("   strtol = %ld", l ); 
   TRACE("   Stopped scan at: %s", stopstring ); 
  
   string = "10110134932"; 
   TRACE( "string = %s\n",(const char *)string ); 
   /* Convert string using base 2, 4, and 8: */ 
   for( base = 2; base <= 8; base *= 2 ) 
   { 
      /* Convert the string: */ 
      ul = strtoul( string, &stopstring, base ); 
      TRACE( "   strtol = %ld (base %d)\n", ul, base ); 
      TRACE( "   Stopped scan at: %s\n", stopstring ); 
   }

1
2
3
4
5
6
7
8
9
10
11
12
13
string = 3.1415926This stopped it 
   strtod = 3.141593 
   Stopped scan at: This stopped it 
 
string = -10110134932This stopped it   strtol = -2147483647   
   Stopped scan at: This stopped itstring = 10110134932 
 
   strtol = 45 (base 2) 
   Stopped scan at: 34932 
   strtol = 4423 (base 4) 
   Stopped scan at: 4932 
   strtol = 2134108 (base 8) 
   Stopped scan at: 932

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <sstream> 
template<typename T> 
bool ConvertCString( const CString & Str, T & Dest ) 
{ 
    // créer un flux à partir de la chaîne donnée 
    std::istringstream iss( static_cast<const char *>( Str) ); 
    // tenter la conversion vers Dest 
    return iss >> Dest != 0; 
} 
CString str="25"; 
int nInt; 
ConvertCString( str, nInt ); 
//ou 
ConvertCString( "25", nInt );// fonctionne aussi ...

1
2
CString str("Bonjour"); 
std::string s((LPCTSTR)str);

1
2
   std::string s("Bonjour"); 
   CString str(s.c_str());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//*************************************************************************** 
// Change la base d'une valeur sous forme de chaîne. 
//*************************************************************************** 
CString COutils::ChangeBase(CString Value, int BaseFrom, int BaseTo) 
{ 
    CString ValBaseChanged; 
  
    if (!( BaseFrom <2 || BaseFrom >36 || BaseTo <2 || BaseTo >36) ) 
    { 
        char *StopScan= NULL; 
        char StrBaseOut[250]; 
        intValIn= 0; 
        //Merci nico-pyright(c)  
        ValIn = strtol(Value.GetBuffer(0), &StopScan, BaseFrom); 
        _itoa(ValIn, StrBaseOut, BaseTo); 
  
        ValBaseChanged = CString(StrBaseOut, strlen(StrBaseOut)); 
    } else { 
        ValBaseChanged = "Invalid Base Number"; 
    } 
    return ValBaseChanged; 
}

1
2
3
4
5
char *StopScan= NULL; 
  
intValIn= 0; 
//Merci nico-pyright(c) 
ValIn = strtol(Value.GetBuffer(0), &StopScan, BaseFrom);

1
2
3
4
CString StrHexa; 
int Val = 125; 
  
StrHexa.Format("%X",Val);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
void CString::AllocBuffer(int nLen) 
// always allocate one extra character for '\0' termination 
// assumes [optimistically] that data length will equal allocation length 
{ 
    ASSERT(nLen >= 0); 
    ASSERT(nLen <= INT_MAX-1);    // max size (enough room for 1 extra) 
  
    if (nLen == 0) 
        Init(); 
    else 
    { 
        CStringData* pData; 
#ifndef _DEBUG 
        if (nLen <= 64) 
        { 
            pData = (CStringData*)_afxAlloc64.Alloc(); 
            pData->nAllocLength = 64; 
        } 
        else if (nLen <= 128) 
        { 
            pData = (CStringData*)_afxAlloc128.Alloc(); 
            pData->nAllocLength = 128; 
        } 
        else if (nLen <= 256) 
        { 
            pData = (CStringData*)_afxAlloc256.Alloc(); 
            pData->nAllocLength = 256; 
        } 
        else if (nLen <= 512) 
        { 
            pData = (CStringData*)_afxAlloc512.Alloc(); 
            pData->nAllocLength = 512; 
        } 
        else 
#endif 
        { 
            pData = (CStringData*) new BYTE[sizeof(CStringData) + (nLen+1)*sizeof(TCHAR)]; 
            pData->nAllocLength = nLen; 
        } 
        pData->nRefs = 1; 
        pData->data()[nLen] = '\0'; 
        pData->nDataLength = nLen; 
        m_pchData = pData->data(); 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
CString str = "aaa,bbb,ccc,,123"; 
CString strTemp = str; 
char *pWord = strtok(strTemp.GetBuffer(0), ","); 
while (pWord != NULL) { 
    // Work 
    // .................. 
  
    afxDump << "\nWord:" << "\"" << pWord << "\"";  
    // Get Next Token 
    pWord = strtok( NULL, "," ); 
} 
strTemp.ReleaseBuffer();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
CString CStringTok(const char *szToken, const char *szDelimit, bool &rbEndParse) 
{ 
    CString strOrg, str; 
    static const char *pszOrg = NULL; 
  
    ASSERT(szDelimit != NULL); 
  
    if(szToken) { 
        pszOrg = szToken; 
        rbEndParse = false; 
    } 
    if(!pszOrg) { 
        rbEndParse = true; 
        return ""; 
    } 
  
    strOrg = pszOrg; 
    int nPos = strOrg.Find(szDelimit); 
    if(nPos != -1) { 
        str = strOrg.Left(nPos); 
        pszOrg += (nPos + strlen(szDelimit)); 
    } else { 
        str = strOrg; 
        pszOrg = NULL;       
    } 
    return str; 
}

1
2
3
4
5
6
7
8
9
10
11
CString strOrg = "aaa,bbb,,ccc"; 
  
bool bEndParse; 
CString strWord = CStringTok(strOrg, ",", bEndParse); 
while (!bEndParse) { 
    // Work 
    // .................. 
    afxDump << "\nWord:" << "\"" << strWord << "\"";  
    // Get Next Token 
    strWord = CStringTok(NULL, ",", bEndParse); 
}

BSTR chaine = SysAllocString(L"Exemple de chaine");

BSTR chaine2 = SysAllocStringLen(chaine, SysStringLen(chaine));

1
2
3
char t1[] = "Exemple"; 
BSTR test1; 
ASCtoBSTR(t1, &test1);

1
2
3
4
BSTR chaine1 = SysAllocString(L"Exemple "); 
BSTR chaine2 = SysAllocString(L"de chaine"); 
BSTR chaine3; 
VarBstrCat(chaine1, chaine2, &chaine3);

SysFreeString(chaineBstr);

1
2
3
4
5
6
7
8
9
CString str; 
str.Format(_T("Float arrondi 2 décimales: %.2f\n"), 12345.12345); 
str.Format(_T("Float longueur 10 dont 2 décimales: %10.2f\n"), 12345.12345); 
str.Format(_T("entier cadré a gauche : %.6d\n"), 35); 
str.Format(_T("entier cadré avec zéro : %06d\n"), 35); 
CString str2=_T("essai") ; 
str.Format(_T("chaine :%s: \n"), static_cast<const char *>(str2)); 
char c='1'; 
str.Format(_T("char %c", c) ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
{ 
        CStringW wstr = L"Chaine UNICODE"; 
        CStringA str(wstr);  // convertit en ANSI 
        LPCSTR lpcstr = str; 
        AfxMessageBox(lpcstr); 
    } 
    { 
        CComBSTR bstr = L"Chaine UNICODE"; 
        CStringA str(bstr); // convertit en ANSI 
        LPCSTR lpcstr = str; 
        AfxMessageBox(lpcstr); 
    } 
    { 
        CStringA str = "Chiane ANSI"; 
        CStringW wstr(str); // convertit en UNICODE 
        LPCWSTR lpcwstr = wstr; 
    } 
    { 
        CStringA str = "Chaine ANSI"; 
        CComBSTR bstr(str); // convertit en UNICODE 
        BSTR b = bstr; 
    } 
    { 
        GUID guid; 
        ::CoCreateGuid(&guid);  // j'obtient un GUID 
        CComBSTR bstrGuid(guid); // je convertit en UNICODE 
        CStringA strGuid(bstrGuid);  // Je convertit en ANSI 
        AfxMessageBox(strGuid);     // et j'affiche 
        AfxMessageBox(CStringA(CComBSTR(guid))); // ou bien... 
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <string> 
#include <iostream> 
#include <sstream> 
  
template<typename T,typename S> 
bool FromString( const S & Str, T & Dest ) 
{ 
#ifdef _UNICODE 
    std::wistringstream iss( Str ); 
#else 
    std::istringstream iss( Str ); 
#endif 
    // tenter la conversion vers Dest 
    return iss >> Dest != 0; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int nInt ; 
FromString(_T("10"), nInt ); // conversion en int. 
  
double dDouble; 
FromString( _T("3.14107"), dDouble ); // conversion en double 
  
CString str=_T("1200"); 
#ifdef _UNICODE 
    std::wstring strstl; 
#else 
    std::string strstl; 
#endif 
  
strstl=_T("1200"); 
int n=0; 
FromString(str.GetString(),n); 
n=0; 
FromString(strstl,n);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <sstream>  
#include <string>  
#include <iostream>  
  
template<typename T> 
bool FromCtrl( const CWnd & Ctrl, T & Dest ) 
{ 
    CString Str; 
    Ctrl.GetWindowText(Str); 
#ifdef _UNICODE 
    std::wistringstream iss( static_cast<LPCTSTR>( Str) ); 
#else 
	std::istringstream iss( static_cast<LPCTSTR>( Str) ); 
#endif 
    // tenter la conversion vers Dest 
    return iss >> Dest != 0; 
}

1
2
3
4
5
6
7
double d; 
FromCtrl(*GetDlgItem(IDC_EDITNOM),d); 
if(d==10.0) 
{ 
    // traitement 
} 
// etc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <sstream> 
#include <string> 
#include <iomanip> 
#include <iostream> 
  
class FormatNum 
{ 
public : 
    FormatNum(){} 
    template <typename T> 
    FormatNum(const T&t) 
    { 
        operator <<(t); 
    } 
    template <typename T> 
    FormatNum & operator << (const T& t) 
    {         
        m_ss << t; 
        return *this; 
    } 
  
public : 
#ifdef _UNICODE 
    std::wstringstream m_ss; 
#else 
    std::stringstream m_ss; 
#endif 
}; 
  
template<typename T> 
void ToCtrl(CWnd & Ctrl,const T & Src,FormatNum &rFormat=FormatNum()) 
{ 
    rFormat << Src; 
  
#ifdef _UNICODE 
    std::wstring s=rFormat.m_ss.str(); 
#else 
    std::string s=rFormat.m_ss.str(); 
#endif 
    Ctrl.SetWindowText(s.c_str()); 
}

1
2
3
4
5
// met 10.345 dans le contrôle. 
ToCtrl(*GetDlgItem(IDC_EDITNUM),10.345); 
// met 10.35 dans le contrôle. 
ToCtrl(*GetDlgItem(IDC_EDITNUM),10.345, 
            FormatNum()<<std::setprecision(4));

1
2
3
// donne 0000010.35 
ToCtrl(*GetDlgItem(IDC_EDITNUM),10.345, 
       FormatNum()<<std::setprecision(4)<<std::setfill(_TCHAR('0'))<<std::setw(10));

1
2
3
// donne 0000000020 
ToCtrl(*GetDlgItem(IDC_EDITNUM),32, 
    FormatNum()<<std::setprecision(4)<<std::setfill(_TCHAR('0'))<<std::setw(10)<<setbase(16));

1
2
3
4
5
6
7
8
// donne: Conversion Hexa: 0x0000000020 
ToCtrl(*GetDlgItem(IDC_EDITNUM), 
32, 
FormatNum()<<_T("Conversion Hexa: 0x") <<std::setprecision(4)<<std::setfill(_TCHAR('0'))<<std::setw(10)<<setbase(16)); 
//ou 
ToCtrl(*GetDlgItem(IDC_EDITNUM), 
32, 
FormatNum(_T("Conversion Hexa: 0x"))<<std::setprecision(4)<<std::setfill(_TCHAR('0'))<<std::setw(10)<<setbase(16));

1
2
3
4
FormatNum format; 
format <<_T("Conversion Hexa: 0x") <<std::setprecision(4)<<std::setfill(_TCHAR('0'))<<std::setw(10)<<setbase(16); 
  
ToCtrl(*GetDlgItem(IDC_EDITNUM),32,format); // donne: Conversion Hexa: 0x0000000020[FONT=monospace]

1
2
3
4
5
6
7
8
9
10
11
template<typename T,typename S> 
void ToString(S & rstr,const T & Src,FormatNum &rFormat=FormatNum()) 
{     
    rFormat << Src; 
#ifdef _UNICODE 
    std::wstring s=rFormat.m_ss.str(); 
#else 
    std::string s=rFormat.m_ss.str(); 
#endif 
    rstr=s.c_str(); 
}

1
2
3
4
5
6
7
8
CString str; 
ToString(str,1200); 
#ifdef _UNICODE 
    std::wstring strstl; 
#else 
    std::string strstl; 
#endif 
ToString(strstl,1200);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//------------------------------------------------------------------------- 
CStringA  UTF8EncodeString(const CStringA str) 
{ 
   CStringW input(str); 
   CStringA output; 
   for(int i=0; i < input.GetLength(); i++) 
   { 
      // 0xxxxxxx 
      if(input[i] < 0x80) 
      { 
        output+=input[i];          
      }        
      // C0          80     
      // 110xxxxx 10xxxxxx       
      else if((input[i] > 0x7F) && (input[i] < 0x800)) 
      { 
         output+=static_cast<unsigned char>(0xC0 | (input[i] >> 6)); 
         output+=static_cast<unsigned char>(0x80 | (input[i] & 0x3F));                       
      } 
      // E0       80       80 
      // 1110xxxx 10xxxxxx 10xxxxxx 
      else if(input[i] < 0x8000) 
      { 
        output+=static_cast<unsigned char>(0xE0 | (input[i] >> 12));          
        output+=static_cast<unsigned char>(0x80 | (input[i] >> 6 & 0x3F));          
        output+=static_cast<unsigned char>(0x80 | (input[i] & 0x3F)); 
      } 
      else 
      {  // F0      80       80       80 
         //11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 
        output+=static_cast<unsigned char>(0xF0 | (input[i] >> 12)>>6); 
        output+=static_cast<unsigned char>(0x80 | (input[i] >> 12 & 0x3F)); 
        output+=static_cast<unsigned char>(0x80 | (input[i] >> 6 & 0x1F)); 
        output+=static_cast<unsigned char>(0x80 | (input[i] & 0x3F)); 
      } 
   } 
   return output; 
}

1
2
3
4
5
6
7
8
CStringA input,output; 
input = "é"; 
output = UTF8EncodeString(input); 
TRACE("\n output é:%s", static_cast<const char *>(output)); 
  
input = "€"; 
output = UTF8EncodeString(input); 
TRACE("\n output €:%s",static_cast<const char *>(output));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
CStringA UTF8DecodeString(const CStringA input) 
{    
   CStringW output; 
   for(int i=0; i < input.GetLength();i++) 
   {   
      // F0      80       80       80 
      //11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 
      if((input[i] & 0xFE) == 0xFE) 
      { 
           output+= static_cast<wchar_t>(((input[i] & 7 )<< 18) | ((input[i+1] & 0x3F) << 12) | ((input[i+2] & 0x3F) << 6) | (input[i+3] & 0x3F)); 
           i += 3; 
      } 
      else 
      // E0       80       80 
      // 1110xxxx 10xxxxxx 10xxxxxx 
      if((input[i] & 0xE0) == 0xE0) 
      { 
         output+= static_cast<wchar_t>(((input[i] & 0x0F) << 12) | ((input[i+1] & 0x3F) << 6) | (input[i+2] & 0x3F)); 
         i += 2; 
      } 
      // C0       80 
      // 110xxxxx 10xxxxxx 
      else if((input[i] & 0xC0) == 0xC0) 
      { 
         output+= static_cast<wchar_t>(((input[i] & 0x1F) << 6) | (input[i+1] & 0x3F)); 
         i ++; 
      } 
      // 0xxxxxxx 
      else if(input[i] < 0x80)   output+=input[i];            
   } 
   return CStringA(output); 
}

1
2
3
4
5
6
7
8
9
10
11
12
CStringA input,output; 
input = "é"; 
output = UTF8EncodeString(input); 
TRACE("\n output é:%s",static_cast<const char *>(output)); 
output = UTF8DecodeString(output); 
TRACE("\n output é:%s",static_cast<const char *>(output)); 
  
input = "€"; 
output = UTF8EncodeString(input); 
TRACE("\n output €:%s",static_cast<const char *>(output)); 
output = UTF8DecodeString(output); 
TRACE("\n output é:%s",static_cast<const char *>(output));

1
2
3
4
5
6
7
8
// réglage du projet en UNICODE 
CString strWide = _T("chaine de caractères"); 
CStringA strA(strWide); 
  
CString strWideDup(strA); // l'inverse 
VERIFY(strWideDup == strWide); 
  
char *sz = strA.GetBuffer(0);

1
2
3
4
5
6
// réglage du projet en UNICODE 
CString strWide = _T("chaine de caractères"); 
char *sz = new char [strWide.GetLength()+1] ; 
WideCharToMultiByte(CP_ACP, 0, strWide, -1, sz, strWide.GetLength()+1, NULL, NULL ); 
//...... 
delete[] sz;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// réglage du projet en UNICODE 
CString strWide = _T("chaine de caractères"); 
char *sz = new char [strWide.GetLength()+1] ; 
WideCharToMultiByte( CP_ACP, 0, strWide, -1, sz, strWide.GetLength()+1, NULL, NULL ); 
  
int nSize = strlen(sz) + 1; 
TCHAR *wsz = new TCHAR[nSize]; 
MultiByteToWideChar(CP_ACP, 0, sz,nSize, wsz,nSize); 
CString strWideDup = wsz; 
  
VERIFY(strWideDup == strWide); 
//...... 
delete[] wsz; 
delete[] sz;