C Language---type conversion

Itoa function: Convert an integer to a string
Usage: char *itoa (int value, char *string, int radix);
Explanation: ITOA is an abbreviation for the English Integer to array (converting int integer to a string and storing the value in the array string).
Parameters:
Value: the integer to convert.
Radix: Is the meaning of the cardinality, that is, the value is converted to the number of radix, the range is between 2-36, for example, 10 means 10, 16 means 16 binary.
* String: The string to be saved after the conversion.
return value:
char *: Points to the generated string, with *string.

Note: The function's header file is "Stdlib.h"

#include

#include

int main ()

{

int number = 123456;

Char string[25];

Itoa (number, string, 10);

printf ("integer =%d string =%s\n", number, string);

return 0;

}

Atoi C language Library function name: atoi
Function: Converts a string to an integer number
Function Description: Atoi () scans the parameter nptr string, detects the first number or positive sign when the type conversion is started, and then detects a non-numeric or terminator when the conversion is stopped, returning an integer number.
Prototype: int atoi (const char *nptr);
Required header file: #include
program Example:
1)
#include
#include
int main (void)
{
int n;
Char *str = "12345.67";
n = atoi (str);
printf ("string =%s integer =%d\n", str, n);
return 0;
}
Execution results

string = 12345.67 integer = 12345

String Turn CString
Cstring.format ("%s", String.c_str ());

Char Turn CString
Cstring.format ("%s", char*);

Char to String
string S (char *);

String to char *
Char *p = STRING.C_STR ();

CString Turn string
String s (Cstring.getbuffer ());

1,string-CString
Cstring.format ("%s", String.c_str ());
Using C_str () is really better than data ().
2,char, String
string S (char *);
You can initialize only, preferably in a place that is not initialized or with assign ().
3,cstring, String
String s (Cstring.getbuffer ());
GetBuffer () must be releasebuffer (), otherwise the space occupied by the buffer will not be released.


In the C + + standard function library.
There are three functions to convert the contents of a string to a character array and c-string
1.data (), returns an array of strings without "\"
2,C_STR (), returns an array of strings with "\"
3,copy ()

---------------------------------------------------------------

Conversion between CString and int, char*, char[100]--


Conversion between CString and int, char*, char[100]--



CString Mutual Transfer int

To convert a character to an integer, you can use Atoi, _atoi64, or ATOL.
Instead of converting a number to a CString variable, you can use the CString format function. Such as
CString s;
int i = 64;
S.format ("%d", i)
The Format function is very powerful and deserves your research.

void Cstrdlg::onbutton1 ()
{
Todo:add your control notification handler code here
CString
Ss= "1212.12";
int Temp=atoi (ss);
CString AA;
Aa. Format ("%d", temp);
AfxMessageBox ("var is" + AA);
}

Sart. Format ("%s", buf);

CString Mutual Transfer char*

char * to CString
CString strtest;
char * CHARPOINT;
Charpoint= "Give string a value";
Strtest=charpoint;


CString to char *
Charpoint=strtest. GetBuffer (strtest. GetLength ());

No String,char *==char in standard C []==string

You can use the Cstring.format ("%s", char *) method to turn char * into CString. To turn CString into char *, use the operator (LPCSTR) to CString.


CString conversion char[100]

Char a[100];
CString Str ("aaaaaa");
strncpy (A, (LPCTSTR) str,sizeof (a));

Convert CString type to int
To convert a character to an integer, you can use Atoi, _atoi64, or ATOL.

CString AAA = "16";
int int_chage = Atoi ((LPCSTR) AAA);


Instead of converting a number to a CString variable, you can use the CString format function. Such as
CString s;
int i = 64;
S.format ("%d", i)
The Format function is very powerful and deserves your research.
If you are using a char array, you can also use the sprintf function.

CString ss= "1212.12";
int Temp=atoi (ss);
CString AA;
Aa. Format ("%d", temp);


Numbers--strings in addition to using Cstring::format, there are FORMATV, sprintf and itoa that do not need AFX

#include

int atoi (const char *nptr);
Long Atol (const char *nptr);
Long Long Atoll (const char *nptr);
Long Long Atoq (const char *nptr);

String AA ("AAA"); Char *c=aa.c_str (); Cannot convert from ' const char * ' to ' char * ' const char *C=AA.C_STR ();

STRING.C_STR () can only be converted to a const char *,
To turn to char * write this:

String Mngname;
Char t[200]; memset (t,0,200); strcpy (T,mngname.c_str ());

----------------------------------------------

sprintf
String formatting commands, the main function is to write formatted data into a string. sprintf is a variable parameter function, often problems when used, and as long as the problem is usually can cause the program crashes the memory access error, but fortunately by the misuse of sprintf caused by serious, but very easy to find, is nothing more than a few cases, It is common to look at a few more eyes with the wrong code.

Directory
Introduction to Functions
Parameter description and application examples
Convert characters
Formatting numeric strings
Character/ascii Code Control
Frequently asked questions about using sprintf
Introduction to Functions
function function: Writes formatted data to a string
Header file: stdio.h
function prototypes: int sprintf (char *buffer, const char *format [, argument] ...);
return value: String Length (strlen)
Correlation function: [1]
int sprintf_s (char *buffer,size_t sizeofbuffer,const char *format [, argument] ...);
int _sprintf_s_l (char *buffer,size_t sizeofbuffer,const char *format,locale_t locale [, argument] ...);
int swprintf_s (wchar_t *buffer,size_t sizeofbuffer,const wchar_t *format [, argument] ...);
int _swprintf_s_l (wchar_t *buffer,size_t sizeofbuffer,const wchar_t *format,locale_t locale [, argument] ...);
Template <size_t size>
int sprintf_s (char (&buffer) [Size],const char *format [, argument] ...); C + + only
Template <size_t size>
int swprintf_s (wchar_t (&buffer) [Size],const wchar_t *format [, argument] ...); C + + only
Parameter description and application examples
The specifications for the sprintf format are shown below. The section in [] is optional.
%[specify parameter [identifier] [width] [. precision] Indicator
If you want to output the '% ' itself, please do so '% ' processing.
1. Handle the character orientation. The minus sign is treated from the back forward.
2. Fill in the blanks. 0 words means blank 0, space is the default value, indicating that the space is placed.
3. The total width of the characters. To the minimum width.
4. Accuracy. Refers to the number of floating-point digits after the decimal point.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Convert characters
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Percent percentage mark, not convert.
The%c integer is converted to the corresponding ASCII character.
%d integers are converted to 10 decimal.
%f times the precision number into floating point numbers.
%o The integer is turned into octal.
The%s integer is converted to a string.
%x integers are converted to lowercase 16 rounding.
%x integers are converted to uppercase 16 rounding.
=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
<?
$money = 123.1
$formatted = sprintf (". 2f", $money); At this time the variable $ formatted value is "123.10"
$formatted = sprintf (". 2f", $money); At this time the variable $ formatted value is "00123.10"
$formatted = sprintf ("%-08.2f", $money); At this time the variable $ formatted value is "123.1000"
$formatted = sprintf ("%.2f%%", 0.95 * 100); Format as Percent
?>
￠.2f Explanation:
% start character
0 is the "fill in the blanks" means that if the length is not enough to fill with a.
8 Total length after formatting
2f decimal digit length, 2-bit
￠ the 3rd row value is "00123.10" explained:
Because 2f is (2 bits) + decimal sign (1) + Front 123 (3 bit) = 6 bit, total length is 8 bits, so the front is used in [fill in the blank character]0, that is, 00123.10
￠ the 4th row value is "123.1000" explained:
-Number for the reverse operation, then fill in the blanks 0 added in the last face
　　
The power of sprintf rarely disappoints you when constructing various types of data into strings. Since sprintf is almost the same as printf in usage, it is printed in a different destination, which prints to a string, and the latter is output directly on the command line. This also causes sprintf to be much more useful than printf.
sprintf is a variable parameter function, which is defined as follows:
int sprintf (char *buffer, const char *format [, argument] ...);
In addition to the first two parameter types are fixed, can be followed by any number of parameters. And its essence, obviously, is in the second parameter:
The formatted string.
Both printf and sprintf use a formatted string to specify the format of the string, using some format specifier (the form specifications) that begins with "%" in the format string to occupy a position, providing the corresponding variable in the list of arguments behind it. The final function replaces that specifier with a variable of the corresponding position, producing a string that the caller wants.
Formatting numeric strings
One of the most common applications of sprintf is to print integers into strings, so sprintf can be substituted for most occasions
Itoa
Such as:
The integer 123 is printed into a string stored in S.
sprintf (S, "%d", 123); Generate "123"
You can specify a width, insufficient left fill space:
sprintf (S, "??", 123, 4567); Generated: "123 4567"
Of course, you can also align Left:
sprintf (S, "%-8d", 123, 4567); Generated: "123 4567"
You can also print in 16 binary:
sprintf (S, "%8x", 4567); lowercase 16 Binary, Width 8 positions, right justified
sprintf (S, "%-8x", 4568); Uppercase 16 binary, Width 8 positions, left justified
In this way, an integer 16 binary string is easy to get, but when we are printing 16 binary content, we usually want a kind of equal width format of 0 on the left. It's easy to add a 0 to the front of the number that represents the width.
sprintf (S, "X", 4567); Produce: "000011d7"
The 10-binary printing above with "%d" can also use this way to the left to fill 0.
Note the problem with a symbol extension: For example, if we want to print a 16 binary representation of a short integer-1 of the memory, on the Win32 platform, a shorter type is 2 bytes, so we naturally want to print it with 4 16 digits:
Short si =-1;
sprintf (S, "X", si);
"FFFFFFFF", what's going on? Because SPRITNF is a variable parameter function, in addition to the previous two parameters, the following parameters are not type-safe, the function is not able to just through a "%x" can be learned that the first function call before the argument is pressed into the stack when the end is a 4-byte integer or a 2-byte short integer, so took a unified 4 byte processing mode, resulting in the parameter stack when the symbol expansion, expanded into 32-bit integer-1, when printing 4 position is not enough, the 32-bit integer 1 8-bit 16 is printed out.
If you want to see the true nature of SI, then you should let the compiler do 0 extensions instead of the symbol extension (the binary left side of the extension is 0 instead of the fill sign bit):
sprintf (S, "X", (unsigned short) SI);
You can do it. Or:
unsigned short si =-1;
sprintf (S, "X", si);
sprintf and printf can also print integer strings in 8 binary, using "%o". Note that 8 binary and 16 binary are not hit
Printed negative numbers are unsigned, which is actually the direct 16-or 8-binary representation of the internal code of the variable.
Control floating-point printing format
Floating-point printing and format control is another common function of sprintf, floating-point numbers use the format "%f" control, the default
Leave 6 digits after the decimal point, for example:
sprintf (S, "%f", 3.1415926); Generate "3.141593"
But sometimes we want to control the width and scale of the print, then we should use: "%M/NF" format, where M-table
Shows the width of the print, and n indicates the number of digits after the decimal point. Like what:
sprintf (S, ". 3f", 3.1415626); Generated: "3.142"
sprintf (S, "%-10.3f", 3.1415626); Generated: "3.142"
sprintf (S, "%.3f", 3.1415626); Does not specify the total width, resulting in: "3.142"
Pay attention to a question, you guess.
int i = 100;
sprintf (S, "%.2f", I);
What's going to happen? "100.00"? Is that right? Try it yourself, and try the following:
sprintf (S, "%.2f", (double) i);
The first one is definitely not the right result, as mentioned earlier, the caller does not know that the format controller corresponding to I is a "%f" when the parameter is pressed. When the function is executed, the function itself does not know that the year was pressed into the stack is an integer, so poor to save the integer I of the 4 bytes is without any explanation forcibly as a floating-point format to explain, the whole mess. However, if someone is interested in using manually coding a floating-point number, then you can use this method to verify that the results of your manual orchestration are correct.
Character/ascii Code Control
As we know, char is also a common type of scalable in the C + + language, with short, in addition to the word length,
Int,long These types have no essential difference, but are used by people to represent characters and strings. (Perhaps it was time to
This type is called "byte" and can now be used to define char through a typedef using byte or short as the case may be, so that it is more appropriate to use "%d" or "%x" to print a character, and then to derive its 10-or 16-binary ASCII code In turn, using "%c" to print an integer, you can see the ASCII character it corresponds to. The following section prints the ASCII Code table of all visible characters to the screen (in this case, printf, note that the "#" and "%x" Automatically add the "0X" prefix to the 16 binary number):
for (int i = +; i < 127; i++) {
printf ("[%c]: = 0x% #04X \ n", I, I, I);
}
Connection string
In the sprintf format control string, since it is possible to insert a variety of things and eventually "connect" them, it is natural to be able to connect
strings, which in many cases can be substituted for strcat, but sprintf can concatenate multiple strings at once (naturally
Insert something else between them, in short, very flexible. Like what:
char* who = "I";
char* whom = "CSDN";
sprintf (S, "%s love%s.", who, whom); Produce: "I love CSDN." "
Strcat can only concatenate strings (an array of characters ending in ' ' or ' character buffers, null-terminated-string), but sometimes we have two-bit buffers, and they don't end with '. For example, many of the character arrays that are returned from third-party library functions, the stream of characters that are read from hardware or network transmissions, do not necessarily end with a corresponding ' at the back of each sequence of characters. If the direct connection, whether it is sprintf or strcat will certainly lead to illegal memory operations, and Strncat also at least require the first parameter is a null-terminated-string, then what to do? We naturally recall that the previous introduction of printing integers and floating-point numbers can specify the width, and the string is the same. Like what:
Char a1[] = {' A ', ' B ', ' C ', ' D ', ' E ', ' F ', ' G '};
Char a2[] = {' H ', ' I ', ' J ', ' K ', ' L ', ' M ', ' N '};
If:
sprintf (S, "%s%s", a1, A2); Don ' t do that!
There's going to be a problem. Whether it can be changed to:
sprintf (S, "%7s%7s", a1, A2);
There is no better place to go, the right should be:
sprintf (S, "%.7s%.7s", a1, A2);//generated: "ABCDEFGHIJKLMN"
This can be analogous to the "%m/nf" of the print floating-point number, in "%m.ns", where M is the occupied width (when the length of the string is insufficient to fill a space, beyond the actual width of the print), n represents the maximum number of characters to be taken from the corresponding string. Usually when I print a string, M is not much use, or the number behind the dot is used more. Naturally, you can only take part of the characters before and after:
sprintf (S, "%.6s%.5s", a1, A2);//generated: "ABCDEFHIJKL"
In many cases, we may also want the numbers in these format controls to specify length information to be dynamic, rather than statically specified, because many times the program will have to run until it is clear that a few characters in the character array need to be taken, and this dynamic width/precision setting function is sprintf is also taken into account, sprintf uses "*" to occupy a constant number where a specified width or precision is required, and the actual width or precision can be provided as the other printed variables, and the above example can be turned into:
sprintf (S, "%.*s%.*s", 7, A1, 7, A2);
Or:
sprintf (S, "%.*s%.*s", sizeof (A1), A1, sizeof (A2), a2);
In fact, the previously described print characters, integers, floating-point numbers, and so on can be dynamically specified those constant values, such as:
sprintf (S, "%-*d", 4, ' A '); Generate "65"
sprintf (S, "% #0 *x", 8, 128); Generate "0X000080", "#" to produce 0X
sprintf (S, "%*.*f", 10, 2, 3.1415926); Generate "3.14"
Print address information
Sometimes when debugging a program, we may want to look at the address of some variable or member, and because the address or pointer is just a 32-bit number, you can print them out using the "%u" that prints the unsigned integer:
sprintf (S, "%u", &i);
But usually people prefer to use 16 binary instead of 10 to display an address:
sprintf (S, "X", &i);
However, these are indirect methods, for address printing, SPRINTF provides a dedicated "%p":
sprintf (S, "%p", &i);
I think it's actually equivalent to:
sprintf (S, "%0*x", 2 * sizeof (void *), &i);
Take advantage of the return value of sprintf
Few people notice the return value of the printf/sprintf function, but sometimes it is useful, SPRITNF returns the function call
The number of characters that are ultimately printed to the character buffer. That is, you do not need to call again once the Sprinf call is finished.
Strlen already knows the length of the resulting string. Such as:
int len = sprintf (S, "%d", I);
For a positive integer, Len is equal to the number of 10 decimal digits of the integer i.
The following is a complete example that produces a random number between 10 [0, 100) and prints them into a character array s,
separated by commas.
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main () {
Srand (Time (0));
Char s[64];
int offset = 0;
for (int i = 0; i < i++) {
Offset + = sprintf (s + offset, "%d,", rand ()% 100);
}
S[offset-1] = ' \ n ';//replace the last comma with a newline character.
printf (s);
return 0;
}
Imagine that when you take a record out of the database and then want to connect their fields to a single word in a certain rule
String, you can use this method theoretically, he should be more efficient than the constant strcat, because strcat each call
Need to find the last position, and in the example given above, we use the sprintf return value each time to
A place to write it down directly.
Examples from MSDN:
crt_sprintf.c//compile with:/w3//-uses sprintf to format various//data and place them in the string Nam Ed Buffer.
#include <stdio.h>
int main (void)
{
Char buffer[200], s[] = "Computer", C = ' l ';
int i = +, J;
float fp = 1.7320534f; Format and print various data:
j = sprintf (buffer, "String:%s\n", s); C4996
J + = sprintf (buffer + j, "Character:%c\n", c); C4996
J + = sprintf (buffer + j, "Integer:%d\n", i); C4996
J + = sprintf (buffer + j, "Real:%f\n", FP);//C4996
note:sprintf is deprecated; Consider using sprintf_s instead
printf ("Output:\n%s\ncharacter count =%d\n", buffer, j);
}
Copy
Output:
String:computer
Character:l
Integer:35
real:1.732053
Character Count = 79
Frequently asked questions about using sprintf
sprintf is a variable parameter function, often problematic when used, and as long as the problem is usually a memory visit that can cause the program to crash
Ask the wrong, but fortunately by the misuse of sprintf caused by serious problems, but it is easy to find out, is nothing more than a few cases, through
Often eyes can see the wrong code more than a few eyes.
sprintf_s () is a secure version of sprintf () that avoids the risk of overflow by sprintf () by specifying the length of the buffer. If you use the sprintf function when using VS2008, the compiler warns that using sprintf is risky, sprintf_s is recommended. The prototype for this secure version is:
int sprintf_s (char *buffer,size_t sizeofbuffer,const char *format [, argument] ...);
Buffer overflow
The length of the first parameter is too short to say, give a bigger place. Of course, it could be the argument behind the question
, it is recommended to be careful with the argument, while printing the string, try to specify the maximum number of characters in the form "%.ns".
Forget the first parameter
Low-level can not be any more low-level problems, with printf used too accustomed. I often make it. ：。 （
The change parameter corresponds to the problem
Usually forget to provide a corresponding format for a variable parameter, resulting in the subsequent parameter dislocation, check it. Especially
Are those parameters corresponding to "*" provided? Do not match an integer to a "%s", and the compiler will think you
Bullying her too far (compiler is the mother of obj and EXE, should be a female,:P).
Strftime
SPRNITF also has a good cousin: Strftime, dedicated to formatting the time string, the use of her cousin very much like, also
is a lot of format control, just after all small roomed cautious, she also wants the caller to specify the maximum length of the buffer, possibly for
You can shirk your responsibility in the event of a problem. Here's an example:
time_t t = time (0);
A string that produces a "yyyy-mm-dd hh:mm:ss" format.
Char s[32];
Strftime (S, sizeof (s), "%y-%m-%d%h:%m:%s", LocalTime (&t));
Sprintf in MFC can also find his bosom friend: Cstring::format,strftime in MFC naturally also has her fellow:
Ctime::format, the pair has been sponsored from object-oriented, and the code used to write it is more elegant.

C Language---type conversion