user-0 提问: 转义字符的问题 请解答 谢谢

回复:
user: user-1
content: C++ Character Constants Character constants are one or more members of the “source character set,” the character set in which a program is written, surrounded by single quotation marks ('). They are used to represent characters in the “execution character set,” the character set on the machine where the program executes.  Microsoft Specific   For Microsoft C++, the source and execution character sets are both ASCII.  END Microsoft Specific  There are three kinds of character constants:   Normal character constants   Multicharacter constants   Wide-character constants  Note   Use wide-character constants in place of multicharacter constants to ensure portability.  Character constants are specified as one or more characters enclosed in single quotation marks. For example:  char ch = 'x';          // Specify normal character constant. int mbch = 'ab';        // Specify system-dependent                         //  multicharacter constant. wchar_t wcch = L'ab';   // Specify wide-character constant.  Note that mbch is of type int. If it were declared as type char, the second byte would not be retained. A multicharacter constant has four meaningful characters; specifying more than four generates an error message.  Syntax  character-constant :  'c-char-sequence' L'c-char-sequence'  c-char-sequence :  c-char c-char-sequence c-char  c-char :  any member of the source character set except the single quotation mark ('), backslash (\), or newline character escape-sequence  escape-sequence :  simple-escape-sequence octal-escape-sequence hexadecimal-escape-sequence  simple-escape-sequence : one of  \' \" \? \\ \a \b \f \n \r \t \v  octal-escape-sequence :  \octal-digit \octal-digit octal-digit \octal-digit octal-digit octal-digit  hexadecimal-escape-sequence :  \xhexadecimal-digit hexadecimal-escape-sequence hexadecimal-digit  Microsoft C++ supports normal, multicharacter, and wide-character constants. Use wide-character constants to specify members of the extended execution character set (for example, to support an international application). Normal character constants have type char, multicharacter constants have type int, and wide-character constants have type wchar_t. (The type wchar_t is defined in the standard include files STDDEF.H, STDLIB.H, and STRING.H. The wide-character functions, however, are prototyped only in STDLIB.H.)  The only difference in specification between normal and wide-character constants is that wide-character constants are preceded by the letter L. For example:  char schar = 'x';               // Normal character constant wchar_t wchar = L'\x81\x19';    // Wide-character constant  Table 1.2 shows reserved or nongraphic characters that are system dependent or not allowed within character constants. These characters should be represented with escape sequences.  Table 1.2   C++ Reserved or Nongraphic Characters  Character ASCII  Representation ASCII  Value Escape Sequence  Newline NL (LF) 10 or 0x0a \n  Horizontal tab HT 9 \t  Vertical tab VT 11 or 0x0b \v  Backspace BS 8 \b  Carriage return CR 13 or 0x0d \r  Formfeed FF 12 or 0x0c \f  Alert BEL 7 \a  Backslash \ 92 or 0x5c \\  Question mark ? 63 or 0x3f \?  Single quotation mark ' 39 or 0x27 \'  Double quotation mark " 34 or 0x22 \"  Octal number ooo — \ooo  Hexadecimal number hhh — \xhhh  Null character NUL 0 \0    If the character following the backslash does not specify a legal escape sequence, the result is implementation defined. In Microsoft C++, the character following the backslash is taken literally, as though the escape were not present, and a level 1 warning (“unrecognized character escape sequence”) is issued.  Octal escape sequences, specified in the form \ooo, consist of a backslash and one, two, or three octal characters. Hexadecimal escape sequences, specified in the form \xhhh, consist of the characters \x followed by a sequence of hexadecimal digits. Unlike octal escape constants, there is no limit on the number of hexadecimal digits in an escape sequence.  Octal escape sequences are terminated by the first character that is not an octal digit, or when three characters are seen. For example:  wchar_t och = L'\076a';  // Sequence terminates at a char    ch = '\233';     // Sequence terminates after 3 characters  Similarly, hexadecimal escape sequences terminate at the first character that is not a hexadecimal digit. Because hexadecimal digits include the letters a through f (and A through F), make sure the escape sequence terminates at the intended digit.  Because the single quotation mark (') encloses character constants, use the escape sequence \' to represent enclosed single quotation marks. The double quotation mark (") can be represented without an escape sequence. The backslash character (\) is a line-continuation character when placed at the end of a line. If you want a backslash character to appear within a character constant, you must type two backslashes in a row (\\). (SeePhases of Translation in the Preprocessor Reference for more information about line continuation.)

user: user-2
content: 引用 11 楼 pozimxb 的回复:[quote=引用 10 楼 zjq9931 的回复:] [quote=引用 9 楼 pozimxb 的回复:] [quote=引用 8 楼 zjq9931 的回复:] [quote=引用 7 楼 pozimxb 的回复:] [quote=引用 6 楼 zjq9931 的回复:] [quote=引用 5 楼 zjq9931 的回复:] [quote=引用 4 楼 pozimxb 的回复:] [quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。[/quote] 这里的回车，指的是，回到一行的开始，\r代表回车，意思是，会到当前行的开始，并不换行。 \n代表，换行（相当于，另起一行）[/quote]  哦 谢谢 耐心回答我  我主要是想知道这个\t 为什么把as d 给覆盖没了  你上面说是\r的作用 可是先去掉后面的\tj  这样输出printf(" as d\t fg\rh); 结果是as d还在  这就是不是\r的作用啊    如果\t是输出tab 那应该第一行是h 然后as d往后挪8格才对..   还是说\t就是往后覆盖8个空格的内容呢[/quote] \r指的是，光标回到行的开始，光表回到行的开始的过程中不会删除字符，只有回到开始后再输出才会替换（不是插入和编辑器中的不一样）字符。  #include<stdio.h>  int main() { 	printf("123456789\r000");//这个的输出结果 	printf("\t123456789\r000");//这个的输出结果 	return 0; }   [/quote]  我知道\r是回到行首不删除字符的  我一直问的是\t 啊 为什么printf(" as d\t fg\rh\tj\n");后面多了\tj  最后的输出结果就是h       jfg 而printf(" as d\t fg\rh); 结果是has d        fg  asd是怎么没的[/quote] 结果都很正常啊。。。没有什么奇怪的，不知道你觉得哪里奇怪？ 如果你觉得奇怪，可以把\r换成\n，这样就可以，上下两行对比，然后把第二行的换到，第一行去，就好了。[/quote]  我没说\r奇怪的啊  是\t   把asd都覆盖消失了.. 然后在f前面加了一个j 我理解\t的意思是输出tab 就是8个空格  那结果应该是asd往后挪8位  而不是消失了...    在\tj 执行前的结果是has d        fg      而\tj执行后就是h       jfg   我不是觉得那\r有问题  是\tj  去输出一个j  为啥把前面的asd弄没了.... 是说\t就是 覆盖后面8位变成空格吗 [/quote] 是的\r移动到行首，然后再输出的字符会替换掉原来的字符。

user: user-0
content: 引用 10 楼 zjq9931 的回复:[quote=引用 9 楼 pozimxb 的回复:] [quote=引用 8 楼 zjq9931 的回复:] [quote=引用 7 楼 pozimxb 的回复:] [quote=引用 6 楼 zjq9931 的回复:] [quote=引用 5 楼 zjq9931 的回复:] [quote=引用 4 楼 pozimxb 的回复:] [quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。[/quote] 这里的回车，指的是，回到一行的开始，\r代表回车，意思是，会到当前行的开始，并不换行。 \n代表，换行（相当于，另起一行）[/quote]  哦 谢谢 耐心回答我  我主要是想知道这个\t 为什么把as d 给覆盖没了  你上面说是\r的作用 可是先去掉后面的\tj  这样输出printf(" as d\t fg\rh); 结果是as d还在  这就是不是\r的作用啊    如果\t是输出tab 那应该第一行是h 然后as d往后挪8格才对..   还是说\t就是往后覆盖8个空格的内容呢[/quote] \r指的是，光标回到行的开始，光表回到行的开始的过程中不会删除字符，只有回到开始后再输出才会替换（不是插入和编辑器中的不一样）字符。  #include<stdio.h>  int main() { 	printf("123456789\r000");//这个的输出结果 	printf("\t123456789\r000");//这个的输出结果 	return 0; }   [/quote]  我知道\r是回到行首不删除字符的  我一直问的是\t 啊 为什么printf(" as d\t fg\rh\tj\n");后面多了\tj  最后的输出结果就是h       jfg 而printf(" as d\t fg\rh); 结果是has d        fg  asd是怎么没的[/quote] 结果都很正常啊。。。没有什么奇怪的，不知道你觉得哪里奇怪？ 如果你觉得奇怪，可以把\r换成\n，这样就可以，上下两行对比，然后把第二行的换到，第一行去，就好了。[/quote]  我没说\r奇怪的啊  是\t   把asd都覆盖消失了.. 然后在f前面加了一个j 我理解\t的意思是输出tab 就是8个空格  那结果应该是asd往后挪8位  而不是消失了...    在\tj 执行前的结果是has d        fg      而\tj执行后就是h       jfg   我不是觉得那\r有问题  是\tj  去输出一个j  为啥把前面的asd弄没了.... 是说\t就是 覆盖后面8位变成空格吗

user: user-2
content: 引用 9 楼 pozimxb 的回复:[quote=引用 8 楼 zjq9931 的回复:] [quote=引用 7 楼 pozimxb 的回复:] [quote=引用 6 楼 zjq9931 的回复:] [quote=引用 5 楼 zjq9931 的回复:] [quote=引用 4 楼 pozimxb 的回复:] [quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。[/quote] 这里的回车，指的是，回到一行的开始，\r代表回车，意思是，会到当前行的开始，并不换行。 \n代表，换行（相当于，另起一行）[/quote]  哦 谢谢 耐心回答我  我主要是想知道这个\t 为什么把as d 给覆盖没了  你上面说是\r的作用 可是先去掉后面的\tj  这样输出printf(" as d\t fg\rh); 结果是as d还在  这就是不是\r的作用啊    如果\t是输出tab 那应该第一行是h 然后as d往后挪8格才对..   还是说\t就是往后覆盖8个空格的内容呢[/quote] \r指的是，光标回到行的开始，光表回到行的开始的过程中不会删除字符，只有回到开始后再输出才会替换（不是插入和编辑器中的不一样）字符。  #include<stdio.h>  int main() { 	printf("123456789\r000");//这个的输出结果 	printf("\t123456789\r000");//这个的输出结果 	return 0; }   [/quote]  我知道\r是回到行首不删除字符的  我一直问的是\t 啊 为什么printf(" as d\t fg\rh\tj\n");后面多了\tj  最后的输出结果就是h       jfg 而printf(" as d\t fg\rh); 结果是has d        fg  asd是怎么没的[/quote] 结果都很正常啊。。。没有什么奇怪的，不知道你觉得哪里奇怪？ 如果你觉得奇怪，可以把\r换成\n，这样就可以，上下两行对比，然后把第二行的换到，第一行去，就好了。

user: user-0
content: 引用 8 楼 zjq9931 的回复:[quote=引用 7 楼 pozimxb 的回复:] [quote=引用 6 楼 zjq9931 的回复:] [quote=引用 5 楼 zjq9931 的回复:] [quote=引用 4 楼 pozimxb 的回复:] [quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。[/quote] 这里的回车，指的是，回到一行的开始，\r代表回车，意思是，会到当前行的开始，并不换行。 \n代表，换行（相当于，另起一行）[/quote]  哦 谢谢 耐心回答我  我主要是想知道这个\t 为什么把as d 给覆盖没了  你上面说是\r的作用 可是先去掉后面的\tj  这样输出printf(" as d\t fg\rh); 结果是as d还在  这就是不是\r的作用啊    如果\t是输出tab 那应该第一行是h 然后as d往后挪8格才对..   还是说\t就是往后覆盖8个空格的内容呢[/quote] \r指的是，光标回到行的开始，光表回到行的开始的过程中不会删除字符，只有回到开始后再输出才会替换（不是插入和编辑器中的不一样）字符。  #include<stdio.h>  int main() { 	printf("123456789\r000");//这个的输出结果 	printf("\t123456789\r000");//这个的输出结果 	return 0; }   [/quote]  我知道\r是回到行首不删除字符的  我一直问的是\t 啊 为什么printf(" as d\t fg\rh\tj\n");后面多了\tj  最后的输出结果就是h       jfg 而printf(" as d\t fg\rh); 结果是has d        fg  asd是怎么没的

user: user-2
content: 引用 7 楼 pozimxb 的回复:[quote=引用 6 楼 zjq9931 的回复:] [quote=引用 5 楼 zjq9931 的回复:] [quote=引用 4 楼 pozimxb 的回复:] [quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。[/quote] 这里的回车，指的是，回到一行的开始，\r代表回车，意思是，会到当前行的开始，并不换行。 \n代表，换行（相当于，另起一行）[/quote]  哦 谢谢 耐心回答我  我主要是想知道这个\t 为什么把as d 给覆盖没了  你上面说是\r的作用 可是先去掉后面的\tj  这样输出printf(" as d\t fg\rh); 结果是as d还在  这就是不是\r的作用啊    如果\t是输出tab 那应该第一行是h 然后as d往后挪8格才对..   还是说\t就是往后覆盖8个空格的内容呢[/quote] \r指的是，光标回到行的开始，光表回到行的开始的过程中不会删除字符，只有回到开始后再输出才会替换（不是插入和编辑器中的不一样）字符。  #include<stdio.h>  int main() { 	printf("123456789\r000");//这个的输出结果 	printf("\t123456789\r000");//这个的输出结果 	return 0; }

user: user-0
content: 引用 6 楼 zjq9931 的回复:[quote=引用 5 楼 zjq9931 的回复:] [quote=引用 4 楼 pozimxb 的回复:] [quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。[/quote] 这里的回车，指的是，回到一行的开始，\r代表回车，意思是，会到当前行的开始，并不换行。 \n代表，换行（相当于，另起一行）[/quote]  哦 谢谢 耐心回答我  我主要是想知道这个\t 为什么把as d 给覆盖没了  你上面说是\r的作用 可是先去掉后面的\tj  这样输出printf(" as d\t fg\rh); 结果是as d还在  这就是不是\r的作用啊    如果\t是输出tab 那应该第一行是h 然后as d往后挪8格才对..   还是说\t就是往后覆盖8个空格的内容呢

user: user-2
content: 引用 5 楼 zjq9931 的回复:[quote=引用 4 楼 pozimxb 的回复:] [quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。[/quote] 这里的回车，指的是，回到一行的开始，\r代表回车，意思是，会到当前行的开始，并不换行。 \n代表，换行（相当于，另起一行）

user: user-2
content: 引用 4 楼 pozimxb 的回复:[quote=引用 3 楼 zjq9931 的回复:] 因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么[/quote] 结果是对的啊，相当于输出" as d\t fg"，然后会到这一行的开始，再输出h。

user: user-0
content: 引用 3 楼 zjq9931 的回复:因为“\r”是回车键，回到这一行的开始，但并不换行。  但是我修改成这样printf(" as d\t fg\rh); 结果是has d        fg      这时fg是在第十行 光标在第二行a  然后输出\t   asd就都会没了吗？  反正我输出的结果就是空的 不知道为什么

user: user-2
content: 因为“\r”是回车键，回到这一行的开始，但并不换行。

user: user-0
content: 引用 1 楼 user-3 的回复:先输出： as d\t fg 可是马上遇到 \r，这个是回车不换行 h\tj，将覆盖掉上面的输出，考虑 \t 占 8 个字符位置 如果考虑将它们分两行输出，就是下面这样：  然而，它们输出到一行，就成了： h       jfg 不过，其中的两个 \t 所占的字符数不一样，有点蹊跷  谢谢哦    那两个\t所占的字符数不一样  第一个\t后有个空格fg  第二个\t直接跟着j

user: user-3
content: 先输出： as d\t fg 可是马上遇到 \r，这个是回车不换行 h\tj，将覆盖掉上面的输出，考虑 \t 占 8 个字符位置 如果考虑将它们分两行输出，就是下面这样：  然而，它们输出到一行，就成了： h       jfg 不过，其中的两个 \t 所占的字符数不一样，有点蹊跷