include <string>
std::string

include <atlstr.h>
CString

E>>Ну а если строки это главная или одна из главных структур данных в твоей сложной программе, то, скорее всего, прийдётся написать свою строку

CString str;
UINT len = MAX_USER_NAME_LENGTH;
GetUserName( str.GetBuffer( len ), &len );
str.Release( len );

vector<char> buffer;
UINT len = MAX_USER_NAME_LENGTH;
buffer.set_size( len + 1 );
GetUserName( &buffer[0], &len );
buffer.set_size( len );
buffer.push_back( 0 );
string str = &buffer[0]; // типа лишнее копирование :(

S>_putenv("myvar=" + var); //здесь происходит преобразование типа в std::string результирующей строки — а она уже в const char * автоматом преобразовываться не умеет.

_putenv( ("myvar=" + var ).c_str() );

static const class to_c_str_t {
public:
    to_c_str_t() {}
    to_c_str_t( const string& src ) : text( src ) {}
    
    operator const char*() const { return text.c_str(); }
    operator const string() const { return text; }
    
    to_c_str_t& operator += ( const to_c_str_t& toAdd ) { text += toAdd; return *this; }
    to_c_str_t& operator += ( const string& toAdd ) { text += toAdd; return *this; }
    to_c_str_t& operator += ( const char* toAdd ) { text += toAdd; return *this; }

private:
    string text;
} to_c_str;

inline to_c_str_t operator( to_c_str_t left, const to_c_str_t& right ) { return left += right; }
inline to_c_str_t operator( to_c_str_t left, const string& right ) { return left += right; }
inline to_c_str_t operator( to_c_str_t left, const char* right ) { return left += right; }
inline to_c_str_t operator( const string& left, const to_c_str_t& right ) 
    { return to_c_str_t( left ) + right; }
inline to_c_str_t operator( const char* left, const to_c_str_t& right ) 
    { return to_c_str_t( left ) + right; }

_putenv(to_c_str + "myvar=" + var);

_putenv("myvar=" + var + to_c_str);

CString str;
str += stsstr( str, str );

CString str = "idfhkdsfjv";
const char* text = str;
str += text + str.Length() / 2;

CString str;
if( str ) {
    std::cout << "Ленин всегда с тобой, Ленин всегда живой...\n"; 
}

S>include <string>
S>std::string

S>include <atlstr.h>
S>CString

s = s1 - s2 + s3;
//     ↑ ой, должен был быть «+»

// а на самом деле это эквивалентно:

s = CString(LPCTSTR(ptrdiff_t(LPCTSTR(s1) - LPCTSTR(s2)) + LPCTSTR(s3)));

RO>s = s1 - s2 + s3;
RO>//     ↑ ой, должен был быть «+»

RO>// а на самом деле это эквивалентно:

RO>s = CString(LPCTSTR(ptrdiff_t(LPCTSTR(s1) - LPCTSTR(s2)) + LPCTSTR(s3)));
RO>

std::string str;
delete &str;

BOOL CReg::GetArray(CString strValueName, void * pArr, size_t sizeArr)
{
    if(pArr && sizeArr && strValueName.GetLength())
    {
        CString strSK;
        GetSubKeyString(strSK);

        //
        // it is essential to call Sleep(0) here
        // because there is seems to be a bug in MSVC,
        // and without Sleep(0) call 
        // functions GetSubKeyString && GetArray
        // will not work properly
        //

        Sleep(0);
        
        return GetArray(CReg::HKCU,
            (LPCTSTR)strSK,
            (LPCTSTR) strValueName,
            pArr,
            sizeArr);
    }
    return FALSE;
}

BOOL CReg::GetSubKeyString(CString& str)
{
    CString s;
    str = _T("Software\\");
    str += CMfcieApp::_strRegKey;
    str += _T("\\");
    s.LoadString(AFX_IDS_APP_TITLE);
    str += s;
    str += _T("\\");
    str += this->_strSubSectionName;
    return TRUE;
}

vector<char> buffer;
E>UINT len = MAX_USER_NAME_LENGTH;
E>buffer.set_size( len + 1 );
E>GetUserName( &buffer[0], &len );
E>buffer.set_size( len );
E>buffer.push_back( 0 );
E>string str = &buffer[0]; // типа лишнее копирование :(

const UINT len = MAX_USER_NAME_LENGTH;
TCHAR sz[len + 1];
STL_STR str; // STL_STR это либо std::string либо std::wstring
if(GetUserName(sz, &len)) str = sz;

vector<char> buffer;
E>UINT len = MAX_USER_NAME_LENGTH;
E>buffer.set_size( len + 1 );
E>GetUserName( &buffer[0], &len );
E>buffer.set_size( len );
E>buffer.push_back( 0 );
E>string str = &buffer[0]; // типа лишнее копирование :(

The GetUserName function retrieves the user name of the current thread. This is the name of the user currently logged onto the system.
[]
If the function succeeds, the return value is a nonzero value, and the variable pointed to by nSize contains the number of TCHARs copied to the buffer specified by lpBuffer, including the terminating null character.

If the function fails, the return value is zero. To get extended error information, call GetLastError.

А>>Сейчас и без слипа заработало. Почему — не знаю Возможно, железо глючило тогда.

typedef map<int, string, less<int> > INT2STRING;
INT2STRING theMap;
INT2STRING::iterator theIterator;

theMap.insert(INT2STRING::value_type(0,"Zero"));
theMap.insert(INT2STRING::value_type(1,"One"));
theMap.insert(INT2STRING::value_type(2,"Two"));
theMap.insert(INT2STRING::value_type(3,"Three"));

CString str;
E>UINT len = MAX_USER_NAME_LENGTH;
E>GetUserName( str.GetBuffer( len ), &len );
E>str.Release( len );

vector<char> buffer;
E>UINT len = MAX_USER_NAME_LENGTH;
E>buffer.set_size( len + 1 );
E>GetUserName( &buffer[0], &len );
E>buffer.set_size( len );
E>buffer.push_back( 0 );
E>string str = &buffer[0]; // типа лишнее копирование :(

UINT len = MAX_USER_NAME_LENGTH;
std::string buf(len + 1, 0);
GetUserName(&buf[0], &len);

E>ИМХО отсутствие чего-то вроде GetBuffer/ReleaseBuffer -- косяк std::string. Опреация редкая. но нужная. Хрен ли её делать каким-то неявными нестандартными мульками --

      // Element access:
      /**
       *  @brief  Subscript access to the data contained in the %string.
       *  @param  n  The index of the character to access.
       *  @return  Read-only (constant) reference to the character.
       *
       *  This operator allows for easy, array-style, data access.
       *  Note that data access with this operator is unchecked and
       *  out_of_range lookups are not defined. (For checked lookups
       *  see at().)
       */
      const_reference
      operator[] (size_type __pos) const
      {
        _GLIBCXX_DEBUG_ASSERT(__pos <= size());
        return _M_data()[__pos];
      }

      /**
       *  @brief  Subscript access to the data contained in the %string.
       *  @param  n  The index of the character to access.
       *  @return  Read/write reference to the character.
       *
       *  This operator allows for easy, array-style, data access.
       *  Note that data access with this operator is unchecked and
       *  out_of_range lookups are not defined. (For checked lookups
       *  see at().)  Unshares the string.
       */
      reference
      operator[](size_type __pos)
      {
        _GLIBCXX_DEBUG_ASSERT(__pos < size());
        _M_leak();
        return _M_data()[__pos];
      }

CString ConvertToCodePage( const wchar_t* text, UINT CodePage, DWORD flags = 0 );