In VC ++, cstring, In, Char, and other data types are converted from: http://blog.csdn.net/heaven13483/article/details/7553176

Cstring, Int, String, char * Conversion
String to cstring
Cstring. Format ("% s", String. c_str ());

Convert Char to cstring
Cstring. Format ("% s", char *);

Char to string
String S (char *);

 

String S; Char * m = "aasf "; S = string (m ); Cout <S <Endl; // output aasf

 

 

String to char *
Char * P = string. c_str ();

 

const char* c;string s="1234";c = s.c_str(); cout<<c<<endl; // Output: 1234Cout <* C <Endl; // output 1Cout <* (C + 1) <Endl; // output 2Cout <C [2] <Endl; // output 3s="abcd";cout<<c<<endl; // Output: ABCD

 

Cstring to string
String S (cstring. getbuffer ());
1, string-> cstring
Cstring. Format ("% s", String. c_str ());
C_str () is indeed better than data.
2, char-> string
String S (char *);
You can only initialize it. It is best to use assign () unless it is initialized ().
3, cstring-> string
String S (cstring. getbuffer ());
Releasebuffer () is required after getbuffer (). Otherwise, no space occupied by the buffer is released.
As mentioned in C ++ standard function library
There are three functions that can convert the content of a string to a character array and a C-string
1. Data (), returns a string array without "\ 0"
2, c_str (), returns a string array with "\ 0"
3, copy ()
---------------------
Conversion between cstring, Int, char *, and char [100 --
Conversion between cstring, Int, char *, and char [100 --
 
Cstring mutual int Conversion
Converts a character to an integer. You can use atoi, _ atoi64, or atol.
To convert a number to a cstring variable, you can use the format function of cstring. For example
Cstring S;
Int I = 64;
S. Format ("% d", I)
The format function is very powerful and worth your research.

Void cstrdlg: onbutton1 ()
{
// Todo: add your control notification handler code here
Cstring
Ss = "1212.12 bytes 〃;
Int temp = atoi (SS );
Cstring AA;
AA. Format ("% d", temp );
Afxmessagebox ("VaR is" + AA );
}

 

The above code, in vs2010, should be

Cstring Ss = _ T ("1212.12 ");
Int temp = _ ttoi (SS );

Cstring AA;
AA. Format (L "% d", temp );
Afxmessagebox (AA );

 

 

Sart. Format ("% s", Buf );
Convert cstring to char *
/// Char * To cstring
Cstring strtest;
Char * charpoint;
Charpoint = "give string a value ";
Strtest = charpoint;
/// Cstring to char *
Charpoint = strtest. getbuffer (strtest. getlength ());
There is no string in Standard C, char * = char [] = string
You can use the cstring. Format ("% s", char *) method to convert char * To cstring. To convert cstring to char *, use the operator (lpcstr) cstring.
Cstring conversion char [100]
Char A [100];
Cstring STR ("aaaaaa ");
Strncpy (A, (lpctstr) STR, sizeof ());
 
(1) Overview
String and cstring are both string template classes. string is a string class defined by the standard template class (STL) and has been incorporated into the C ++ standard;
Cstring (typedef cstringt> cstring) is the most common string class in Visual C ++. It inherits from the csimplestringt class and is mainly used in MFC and ATL programming, the main data types include char (used in ANSI), wchar_t (UNICODE), and tchar (both ANSI and Unicode );
Char * is the most commonly used string pointer in C programming. It generally ends with '\ 0;
(2) Construction
String is convenient and can be constructed from almost all strings, including cstring and char *;
Followed by cstring, which can be constructed from some basic string variables, including char;
Char * has no constructor and can only be assigned a value;
Example:
Char * psz = "joise ";
Cstring CSTR (psz );
String STR (CSTR );
(3) Operator Overloading
A) perator =
String is the most convenient, and almost all strings can be assigned directly, including cstring and char *;
Followed by cstring. You can directly assign values using some basic strings, including char;
Char * can only be assigned values by pointers, which is extremely dangerous. We recommend that you use strcpy or memcpy. In addition, if the initial value is not assigned to char *, we recommend that you set it to null first, to avoid wild pointers and drive you crazy;
Example:
Char * psz = NULL;
Psz = new char [10]; // Of course, the above is directly written as char * psz = new char [10 ];
Memset (psz, 0, 10); // fill 10 in psz with 0.
Strcpy (psz, "joise ");
Cstring CSTR;
CSTR = psz;
String STR;
STR = psz;
STR = CSTR;
Delete [] psz;
B) operator +
String is similar to cstring. It can be added directly to char *, but the + operator cannot be used with each other. That is, string STR = STR + CSTR is invalid and must be converted to char *;
Char * has no + operation. Only two pointers can be connected using strcat;
Example:
Char * psz = "joise ";
Cstring CSTR = psz;
CSTR = CSTR + psz;
String STR = psz;
STR = STR + psz;
Strcat (psz, psz );
Strcat (psz, CSTR); // valid
Strcat (psz, STR); // invalid. Therefore, cstring can be automatically converted to const char *, but string cannot.
C) operator ++ =
String is the most powerful and can be used with almost all string variables + =, including cstring and char *;
Followed by cstring, which can be + = with some basic string variables, including char;
Char * has no + = Operator and can only use strcat to connect two pointers;
D) operator []
The cstring is the best. When a cross-border request is made, an asserted exception is thrown;
The results of the out-of-bounds string and char * subscripts are undefined;
Example:
Char * psz = "joise ";
Cstring CSTR = psz;
Cout <CSTR [8];
String STR = psz;
Cout <STR [8];
Cout <psz [8];
E) perator =, Operator! =, Operator>, operator <, operator> =, perator <=
Cstring and string cannot be compared, but both can be compared with char * and compared with the value rather than the address;
Cout <(psz = CSTR );
Cout <(psz = Str );
Cout <(STR = psz );
Cout <(CSTR = psz); // The code above returns 1
(4) common algorithms
A) Search
Char * string cstring
Find the specified strchr
Strstr
Strrstr
Strspfind find
The first matched value fild_first_of findoneof starts from the end to find reservefind. The specified matching method is find_if.
Note: In find_if, values in the range are substituted into the matching function one by one until true is returned.
B) Comparison
Function char * string cstring to find the specified value (case sensitive) strcmp
Strncmp
Strcoll
_ Strncoll operator <
Operator>
Operator <=
Operator> =
Operator =
Operator! = Collate
Compare searches for the specified value (Case Insensitive) _ stricmp
_ Strnicmp
_ STR illegal advertisement
_ Strn illegal advertisement collatenocase
Comparenocas
Note: If the return value is <0, the previous value is smaller than the subsequent value, and vice versa.
C) replace
Function char * string cstring to find the specified value _ strset
_ Strnset
Replace
Replace_copy
Replace_copy_if
Replace_if replace
D) insert
Function char * string cstring to find the specified value insert

E) added the dynamic added value of char * string cstring strcat push.
Append append
Appendchar
Appendformat
F) intercept
Function char * string cstring get part value substr left
Mid
Right
Truncate
G) Remove
Function char * string cstring remove part of the value remove Blank Value removeblks
Note: This is provided by ATL. Non-C function remove_if trim
Trimleft
Trimrig
H) case-insensitive Conversion
Function: Convert char * string cstring to uppercase/lowercase _ strlwr
_ Strupr makelower
Makeupper
I) conversion from other types
Convert char * string cstring to a number atoi
Atod
Convert atof format to char * c_str
Getbuffer
Getbuffersetlen
J) Format
Function char * string cstring formatting sprintf format
K) Get the length
Char * string cstring
Get strlen length getlength get size getalloclength
L) null judgment
Function char * string cstring determines whether it is null to determine whether = NULL or whether the first character is '\ 0' empty isempty
M) redefinition size
Function char * string cstring redefinition realloc
New resize getbuffersetlength
N) release resources
Function char * string cstring releases free
Delete (Delete []) releasebuffer
Releasebuffersetlength
(5) Security>
Cstring> string> char *;
(6) Flexibility
Cstring> string> char *;
(7) portability
Char * = string> cstring