Question: C里面的'\b'退格符是不是不能显示啊我用"\\b"想显示无法显示

你要显示\b这个字符需要写成：\\b

活人永远不会被尿憋死的！ Linux下参考NCURSES库。

#include <conio.h> #include <windows.h> int main() {     char s[]="I hate\b\b\b\blove you!";     int i;      i=0;     while (1) {         if (s[i]==0) break;         cprintf("%c_",s[i]);         Sleep(500);         cprintf("\b \b");         i++;     }     cprintf(" ");     return 0; }

电脑内存或文件内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

引用 5 楼 baidu_29912505 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] #include <conio.h> int main() {  cprintf("I hate\b\b\b\blove you!\r\n");  return 0; }也是答非所问 难道大神都没了吗？[/quote] 呵呵

printf("\\b"); ？  你希望显示出来的是什么样的呢？数字？字符？光标？还是啥？

\b  改成  \\b     在输出的时候系统会吧 \b 看成一个字符   把 \\   与 b  看做一个字符   前面输出 \  后面输出b

Windows '\'用来转义符  想输出“\b” :"\\b"

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.)

引用 3 楼 zhao4zhong1 的回复:#include <conio.h> int main() {  cprintf("I hate\b\b\b\blove you!\r\n");  return 0; }也是答非所问 难道大神都没了吗？

引用 2 楼 GKatHere 的回复: 	cout << "abc\bd"; // 小c不见了 我说的是如何把你这个退格键用\b显示出来 你的这个谁不会？？

cout << "abc\bd"; // 小c不见了

确实没法显示


Question: 结构体对象作函数参数问题

引用 3 楼 zhangxiangDavaid 的回复:引用是C++中的概念，你得用C++编译器编译试试。 非常感谢

引用是C++中的概念，你得用C++编译器编译试试。

引用 1 楼 zhangxiangDavaid 的回复:void increase_SqListlength(SqList &L)这是引用，要使用指针，才可以传地址。 谢谢，如果是传递引用的话，这个代码有啥错啊


Question: 对这个字符串求长度是多少

\001 不是 \0 01

这涉及到转义字符的一些用法，其中转义字符 ‘\’ 带数字的话共有三种情况。 1）直接带一个数字0 ，那么形如“abs\0mn” 中间的‘\0’部分会被解释成字符串结束符。 2）带一个8进制数（表示法：\ddd），这就是楼主遇到的情况，事实上那个001 被看成了8进制数1. 3）带一个16进制数（表示法：\xdd），十六进制数前需要带标识x 。  转义字符带除 0，双引号外的可打印字符的话可以直接表示该字符本身，那就是"abc\001\///n" 中的‘ \/ ’ 只表示'/' . 综上所述，只有8个字符（除结束符外） 。

int main() {  	char str1[] = "abc\001\///n"; 	printf("%d\n", strlen(str1)); 	for (int i = 0; i < strlen(str1); i++){ 		printf("[%c] ", str1[i]); 	}  	getchar(); 	 }

宽字符算长度算的是宽字符的个数，自然是一样的。

C++ String Literals A string literal consists of zero or more characters from the source character set surrounded by double quotation marks ("). A string literal represents a sequence of characters that, taken together, form a null-terminated string.  Syntax  string-literal :  "s-char-sequenceopt" L"s-char-sequenceopt"  s-char-sequence :  s-char s-char-sequence s-char  s-char :  any member of the source character set except the double quotation mark ("), backslash (\), or newline character escape-sequence  C++ strings have these types:   Array of char[n], where n is the length of the string (in characters) plus 1 for the terminating '\0' that marks the end of the string   Array of wchar_t, for wide-character strings  The result of modifying a string constant is undefined. For example:  char *szStr = "1234"; szStr[2] = 'A';      // Results undefined  Microsoft Specific   In some cases, identical string literals can be “pooled” to save space in the executable file. In string-literal pooling, the compiler causes all references to a particular string literal to point to the same location in memory, instead of having each reference point to a separate instance of the string literal. The/Gf compiler option enables string pooling.  END Microsoft Specific  When specifying string literals, adjacent strings are concatenated. Therefore, this declaration:  char szStr[] = "12" "34";  is identical to this declaration:  char szStr[] = "1234";  This concatenation of adjacent strings makes it easy to specify long strings across multiple lines:  cout << "Four score and seven years "         "ago, our forefathers brought forth "         "upon this continent a new nation.";  In the preceding example, the entire string Four score and seven years ago, our forefathers brought forth upon this continent a new nation. is spliced together. This string can also be specified using line splicing as follows:  cout << "Four score and seven years \ ago, our forefathers brought forth \ upon this continent a new nation.";  After all adjacent strings in the constant have been concatenated, the NULL character, '\0', is appended to provide an end-of-string marker for C string-handling functions.  When the first string contains an escape character, string concatenation can yield surprising results. Consider the following two declarations:  char szStr1[] = "\01" "23"; char szStr2[] = "\0123";  Although it is natural to assume that szStr1 and szStr2 contain the same values, the values they actually contain are shown in Figure 1.1.  Figure 1.1   Escapes and String Concatenation    Microsoft Specific   The maximum length of a string literal is approximately 2,048 bytes. This limit applies to strings of type char[] and wchar_t[]. If a string literal consists of parts enclosed in double quotation marks, the preprocessor concatenates the parts into a single string, and for each line concatenated, it adds an extra byte to the total number of bytes.   For example, suppose a string consists of 40 lines with 50 characters per line (2,000 characters), and one line with 7 characters, and each line is surrounded by double quotation marks. This adds up to 2,007 bytes plus one byte for the terminating null character, for a total of 2,008 bytes. On concatenation, an extra character is added to the total number of bytes for each of the first 40 lines. This makes a total of 2,048 bytes. (The extra characters are not actually written to the string.) Note, however, that if line continuations (\) are used instead of double quotation marks, the preprocessor does not add an extra character for each line.  END Microsoft Specific  Determine the size of string objects by counting the number of characters and adding 1 for the terminating '\0' or 2 for type wchar_t.  Because the double quotation mark (") encloses strings, use the escape sequence (\") to represent enclosed double quotation marks. The single 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 string, you must type two backslashes (\\). (SeePhases of Translation in the Preprocessor Reference for more information about line continuation.)  To specify a string of type wide-character (wchar_t[]), precede the opening double quotation mark with the character L. For example:  wchar_t wszStr[] = L"1a1g";  All normal escape codes listed in Character Constants are valid in string constants. For example:  cout << "First line\nSecond line"; cout << "Error! Take corrective action\a";  Because the escape code terminates at the first character that is not a hexadecimal digit, specification of string constants with embedded hexadecimal escape codes can cause unexpected results. The following example is intended to create a string literal containing ASCII 5, followed by the characters five:  \x05five"  The actual result is a hexadecimal 5F, which is the ASCII code for an underscore, followed by the characters ive. The following example produces the desired results:   "\005five"     // Use octal constant. "\x05" "five"  // Use string splicing.

\001 不是结束字符 如果是 \000 结果就是3

C风格字符串是以0结尾的, 所以是8

'a' 'b' 'c' '\001' '\' '/' '/' 'n'

呵呵, 这个个有意思了, 为什么宽字节也是三位, 就让人迷惑了  char str1[] = "abc\1\///n";  //  中间不断 char str1[] = "abc\01\///n";  //  中间不断 char str1[] = "abc\001\///n";  //  中间不断 char str1[] = "abc\0001\///n";  //  中间断开  WCHAR str1[] = L"abc\1\///n";  //  中间不断 WCHAR str1[] = Labc\01\///n";  //  中间不断 WCHAR str1[] = L"abc\001\///n";  //  中间不断 WCHAR str1[] = L"abc\0001\///n";  //  中间断开

他其实判断到的是\001，而不是\0然后再字符01  如果想表示\0后面是字符01可以写成"abc\00001\///n"


Question: linux 下的open的用法请教

错了，unmask屏蔽是022，即000 010 010，那么它的权限码就是取反得到 111 101 101，对应八进制是755。 这个时候做&操作：  111 101 101 &100 000 001 -----------------------  100 000 001得到八进制权限码401，与你系统运行的结果一致。


Question: [leetcode]的题目“Best Time to Buy and Sell Stock”

引用 1 楼 user-1 的回复:tmp = (int*)malloc(pricesSize *sizeof(*tmp)); 呀，太脑残了，真想抽自己。多谢


Question: 【新人求助】关于main函数的疑惑

返回值是给操作系统中的一个叫加载程序看的。

谁调用谁看了

引用 7 楼 wplink 的回复:[quote=引用 5楼mewiteor 的回复:]在shell中：./你的程序&&echo 运行成功||echo 运行失败 并且: windows下cmd中的%errorlevel% linux下shell中的$? 都是上次程序的返回值能否说详细点？ 我看的视频也是这段话 由于初学自学 我看不懂 所以才过来提问的 烦请指教 不甚感激[/quote]  这个表达式的意思是，  nRet && echo true || echo false  nRet 是0，则 echo true  否则echo false。  nRet---是程序执行的返回值。   命令可以连接在一起的。  ./test.exe && echo true || echo false;  ./test.exe会有返回值。

引用 5楼mewiteor 的回复:在shell中：./你的程序&&echo 运行成功||echo 运行失败 并且: windows下cmd中的%errorlevel% linux下shell中的$? 都是上次程序的返回值能否说详细点？ 我看的视频也是这段话 由于初学自学 我看不懂 所以才过来提问的 烦请指教 不甚感激

可以根据其返回值来判断进程是否正常运行

这个返回值可以通过 GetExitCodeProcess 来获取 获取后你可以根据其返回值来判断进程是否正常运行  如果在编译器中 F5 运行, 则在"输出"栏会直接显示该返回值

给你自己看的, 一般在 main 函数中会调用一系列初始化函数 理想情况下所有函数调用正常, 没有错误发生则 main 可以返回一个你自己定义的无错误的值 如果有错误发生, 那么你可以根据其返回值判断是那一步出错  这些返回值是由你自己定义的, 一般没什么特殊情况下开发工具默认生成的代码都会返回0 因为它不知道你需要什么样的返回值, 如果你自己定义了返回值, 改过来就是了  #define MAINRTN_NOERROR 1 #define MAINRTN_FUNC1ERR 2 #define MAINRTN_FUNC2ERR 3 #define MAINRTN_FUNC3ERR 4  int main {     if (xxx != xxx) return MAINRTN_FUNC1ERR;     if (xxxx != xxxx) return MAINRTN_FUNC2ERR;     if (xxxxx!= xxxxx) return MAINRTN_FUNC3ERR;      // 没有错误发生     return MAINRTN_NOERROR }

受教了，原来main函数都有这么多的学问

当其他文件要调用这条main()时依靠返回判断文件是否是正常运行。


Question: linux 的read(0,,)问题

引用 1 楼 zhangxiangDavaid 的回复:可能是没在当前目录下查找   hello  there  必须是程序？

查找可执行程序

可能是没在当前目录下查找


Question: 求助，编写一个函数，将两个字符串链接起来。

楼主的逻辑写错了，两层循环应该是并列的而不是嵌套  for(int i=0;i<strlen(a);i++){         sum[i]=a[i];         for(int j=1;j<=strlen(b);j++){             sum[i+j]=b[j-1];         }     } -->  for(int i=0;i<strlen(a);i++){         sum[i]=a[i]; }     for(int j=1;j<=strlen(b);j++){         sum[i+j]=b[j-1]; }

注：我是小白，可能代码有些啰唆了 #include<stdio.h> #include<string.h> void main() { 	void lj(char a[20],char b[20]); 	int i=0,j=0; 	char str1[20],str2[20];     gets(str1);     gets(str2); 	lj(str1,str2); } void lj(char a[20],char b[20]) { 	char c[40]; 	int i,s,j,z=0; 	i=strlen(a); 	j=strlen(b); 	for(s=0;s<=i;s++) 	{ 		c[s]=a[s]; 	} 	for(s=i;s<=i+j;s++) 	{ 	 c[s]=b[z]; 	 z++; 	} 	puts(c); }

char *mystrcat(char a[], char b[]) {     char *ret = a;     if (a != NULL && b != NULL) {         while (*a != 0) {             a++;         }         while (*b != 0) {             *a++ = *b++;         }         *a = 0;     }     return ret; }

不用str函数:       char* a = "asd";     char* b = "edf";          int lenNew = 0;     char* tmp = a;     while (*tmp != '\0') {         lenNew++;         tmp++;     }     tmp = b;     while (*tmp != '\0') {         lenNew++;         tmp++;     }          char* newStr = malloc((lenNew+1)*sizeof(char));     memset(newStr, 0, (lenNew+1)*sizeof(char));          int newIndex = 0;     tmp = a;     while (*tmp != '\0') {         newStr[newIndex] = *tmp;         tmp++;         newIndex++;     }     tmp = b;     while (*tmp != '\0') {         newStr[newIndex] = *tmp;         tmp++;         newIndex++;     }

char* a = "asd";     char* b = "edf";               int lena = strlen(a);     int lenb = strlen(b);     int lenAll = lena + lenb;          char* all = malloc((lenAll+1)*sizeof(char));     memset(all, 0, (lenAll+1)*sizeof(char));          sprintf(all, "%s%s", a,b);          printf(all);

内外循环是什么意思？

二层循环？有问题 简单点的逻辑： 首先确定a的长度 > 连接后的新长度  1. 目的字符串，a,strlen(a),得到a的长度 2. 使用下标寻址，来一个循环，a的尾部逐个加上b的字符 3. 返回地址  4. main函数中，最好使用strcpy(a,返回地址），不用用=号，

char sum[200];没有初始化，---》char sum[200] = {‘/0’} 或者拼接完后加一个字符串结束sum[strlen(a)+strlen(b)] = '\0';

引用 3 楼 zhangxiangDavaid 的回复:修改如下：  #include<string.h> char *link(char a[], char b[]) { 	int n1, n2; 	n1 = strlen(a), n2 = strlen(b); 	char *res = malloc(n1 + n2 + 1); 	strncpy(res, a, n1); 	strncpy(res + n1, b, n2); 	res[n1 + n2] = 0; 	return res; } int main() { 	char str1[100], str2[100]; 	char *res; 	printf("please input two sentence:\n"); 	scanf("%s%s", str1, str2); 	res = link(str1, str2); 	printf("%s\n", res); 	free(res); 	return 0; } //please input two sentence: //zhangxiang David //zhangxiangDavid  +++这种方法是可以行的~当然也可以直接使用strcat的库函数

字符串以0结尾, 所以sum应该在最后放个0, 这里二重循环是什么意思,不太明白?

sum没有字符串结束符号 link函数内for循环有问题，如果参数a长度为1，程序是正常，如果a长度>1那么显示内容并不是两个字符串的拼接

用strcat不好吗？

为什么会出现乱码？


Question: 关于getchar、putchar

引用 5 楼 Real_Bird 的回复:[quote=引用 2 楼 user-2 的回复:] #include<stdio.h> int main() { 	int i; 	for(i=0;i<256;++i) 		printf("%3d:%c\n",i,i); 	return 0; } 整型转换为字符型是问号？[/quote]asc码1是“SOH(start of headline) 标题开始”，在控制台上，对于无法输出的字符，统一使用问号显示。

引用 4 楼 Real_Bird 的回复:[quote=引用 3 楼 Real_Bird 的回复:] [quote=引用 1 楼 Falleyes 的回复:] 错误的，当你使用不加括号的，c的值会是0或者1，但是putchar是根据asc码输出字符啊。输出的应该是asc码0和1对应的字符。 你要是输出0或者1，应该putchar(c+'0')或者使用printf("%d",c);  为什么这两个输出的都是两个1呢  是回车的原因吗[/quote] 还有c+‘0’是把c加上0的asc码吗  这么用是什么意思[/quote]是的，这种是输出数字对应字符的方法。

引用 3 楼 Real_Bird 的回复:[quote=引用 1 楼 Falleyes 的回复:] 错误的，当你使用不加括号的，c的值会是0或者1，但是putchar是根据asc码输出字符啊。输出的应该是asc码0和1对应的字符。 你要是输出0或者1，应该putchar(c+'0')或者使用printf("%d",c);  为什么这两个输出的都是两个1呢  是回车的原因吗[/quote]是的，回车也是字符，只要不是EOF就会输出1

引用 5 楼 Real_Bird 的回复:[quote=引用 2 楼 user-2 的回复:] #include<stdio.h> int main() { 	int i; 	for(i=0;i<256;++i) 		printf("%3d:%c\n",i,i); 	return 0; } 整型转换为字符型是问号？[/quote]你主要看一下putchar(1)是什么结果。

引用 2 楼 user-2 的回复:#include<stdio.h> int main() { 	int i; 	for(i=0;i<256;++i) 		printf("%3d:%c\n",i,i); 	return 0; } 整型转换为字符型是问号？

引用 3 楼 Real_Bird 的回复:[quote=引用 1 楼 Falleyes 的回复:] 错误的，当你使用不加括号的，c的值会是0或者1，但是putchar是根据asc码输出字符啊。输出的应该是asc码0和1对应的字符。 你要是输出0或者1，应该putchar(c+'0')或者使用printf("%d",c);  为什么这两个输出的都是两个1呢  是回车的原因吗[/quote] 还有c+‘0’是把c加上0的asc码吗  这么用是什么意思

引用 1 楼 Falleyes 的回复:错误的，当你使用不加括号的，c的值会是0或者1，但是putchar是根据asc码输出字符啊。输出的应该是asc码0和1对应的字符。 你要是输出0或者1，应该putchar(c+'0')或者使用printf("%d",c);  为什么这两个输出的都是两个1呢  是回车的原因吗


Question: linux下的系统调用和api有到底有什么区别？

引用 4 楼 caddor9100 的回复:[quote=引用 3 楼 user-1 的回复:] 有些早期几乎每个编译器都实现了的库函数，没有进入标准库。  你如果使用过man手册，你肯定有印象：  man 1---系统命令 man 2---内核（包括系统调用） man 3---c库  那么api 在man number?   按照man的用法一分，似乎api 在man 2里了。 [/quote]标准库中 stdio.h 中输入输出函数，基本就是对一部分系统调用（API）的封装。 很多编译器的 io.h 中，部分库函数，基本就是 一部分其他系统调用（API）的封装，这部分好像不属于标准库。 man 命令，是UNIX linux 的帮助系统，内核（包括系统调用）基本上对应与API 之所以，API（系统调用），和库函数，关系这么复杂，是因为，标准化，没有吸收所有 unix 库函数（即早期编译器库函数） 而每个编译器，又都增加了自己扩展函数

结论： UNIX，linux  有一部分库函数，是系统调用，或者系统调用的某种简单封装 一部分是，其他标准库函数， 一部分是编译器扩展库函数 。  windows  SDK,DDK，API 都是独立于编译器的 系统库函数，相当于UNIX，linux的某些系统调用。 而，标准库，封装了一部分 API（系统调用），以及一些常用函数。 通常编译器，另外在库中额外提供一些，同样比较常用的，没有进入标准库的扩展库函数。  widows，DOS 操作系统，和编译器是分家的，微软对二者是分别卖钱的。 UNIX，linux则至少提供一个缺省的，和操作系统一起发行的C编译器，供用户使用。 这是二者一个区别。

引用 3 楼 user-1 的回复:有些早期几乎每个编译器都实现了的库函数，没有进入标准库。  你如果使用过man手册，你肯定有印象：  man 1---系统命令 man 2---内核（包括系统调用） man 3---c库  那么api 在man number?   按照man的用法一分，似乎api 在man 2里了。

有些早期几乎每个编译器都实现了的库函数，没有进入标准库。

UNIX是和C共生的，linux 是Unix的某种变体 早期的C库，基本就是unix 系统调用，和一些常用函数库（数学库，字符串库等等）。  后来C因为可移植性好，广泛流传，DOS 上就有四大编译器。 由于，广泛流传，所以后来为了统一和可移植性，就制定了标准。 某些库函数，被标准化了，成了标准库的一部分，另一些没有。 标准化的这一部分，就可以用于任何执行标准的编译器，包括DOS和Windows 上的. 没标准化的部分，只能是unix,linux 专用，其他操作系统上的编译器，也有可能部分自己专用库，或者该操作系统专用库 而操作系统，年最核心功能部分的库函数，unix,linux 就是系统调用（听说是X86 上是 int 80中断啥的）。 DOS是 int21中断，Windows 是API,SDK,DDK等。  有些系统调用，和API 被封装到标准库了，有些没有。


Question: 新人求助   如何搭建C语言环境

http://www.microsoft.com/visualstudio/chs/downloads#d-2010-express 点开Visual C++ 2010 Express下面的语言选‘简体中文’，再点立即安装

下载http://sourceforge.net/projects/codeblocks/files/Binaries/13.12/Windows/codeblocks-13.12mingw-setup-TDM-GCC-481.exe，直接安装就好了。

学个 C 语言而已，为什么要去安装 VS 这么庞然大物？可试试以下软件： Pelles C for Windows 8.00 英文版（仅支持 C 语言，内置编译器和 Windows 头文件、对话框设计器）： http://www.smorgasbordet.com/pellesc/800/setup.exe http://www.smorgasbordet.com/pellesc/800/setup64.exe C-Free 官方下载页面（中文，仅开发环境，需要自己下载独立编译器配置，根据编译器的不同可支持 C/C++）： http://programarts.com/cfree_ch/download.htm 上面的软件都是十几 MB 左右的大小，对于新手而言，安装动辄几百兆数 GB 的 VS 意义不大。 Code::Blocks Windows 版（支持 C/C++，英文界面，分为仅 IDE 版本和集成 GCC 版本，均可再配置其他编译器）： 仅 Code::Blocks IDE，需自行配置编译器： http://sourceforge.net/projects/codeblocks/files/Binaries/13.12/Windows/codeblocks-13.12-setup.exe/download Code::Blocks IDE + TDM GCC 编译环境： http://sourceforge.net/projects/codeblocks/files/Binaries/13.12/Windows/codeblocks-13.12mingw-setup-TDM-GCC-481.exe/download 大小均不超过 100MB。

新手的话，windows下用集成开发环境吧，codeblocks或者楼上说的vc（个人不推荐vc）。这两个开发环境比较小，能满足你的现在的需要。vs比较大，但是也可以试一试。 如果是linux下的话，下载gcc编译器（有的会随系统附带），用记事本写代码，终端调用编译器编译。

VC就行 当然，VS也可以  其他也有一些，比如eclipse


Question: linux c编程问题

#include <stdio.h>  int main() {     int ap = 0755 ;     char out[] ="rwx-" ;     int i = 0 ;      char str[10];     for(i = 0 ; i <= 8 ; ++i )     {         str[i] = ap & (1<<(8-i)) ? out[i%3] : out[3];     }     str[9] = 0 ;       printf("%s\n", str);       return 0 ; }

比如:  ls -l libmysqlclient_r.so.15.0.0 -rw-r--r-- 1 me cnshlogin 0 Jun  5 13:43 libmysqlclient_r.so.15.0.0 对于libmysqlclient_r.so.15.0.0 这个文件来说,他的权限是-rw-r--r-- 第一组:-rw 表示:对象属主拥有读和写的权限 第二组:-r- 表示:对象属组成员拥有读的权限 第三组:r-- 表示:其他用户拥有读的权限 读(x)数值表示就是:4  写(w)数值表示就是:2 执行(下)数值表示就是: 1 每一个对象(属主,组内用户,其他用户),都有rwx三种权限中的不同权限,比如上面的对应数值就是 rw = 4+2 r = 4 r =4 因此该文件的权限值就是0644.就是这个意思

校验输入的问题可能是程序员终其一生都无法满足的追求！ #include <stdio.h> #include <string.h> int main() {     int ap;     char str[10];     char ins[6],c;      while (1) {         printf("Input 0ooo:");         fflush(stdout);         rewind(stdin);         fgets(ins,6,stdin);         if (strlen(ins)==5 && 2==sscanf(ins,"0%3o%c",&ap,&c) && '\n'==c) break;     }     str[0] = ap & 0400 ? 'r' : '-';     str[1] = ap & 0200 ? 'w' : '-';     str[2] = ap & 0100 ? 'x' : '-';     str[3] = ap & 0040 ? 'r' : '-';     str[4] = ap & 0020 ? 'w' : '-';     str[5] = ap & 0010 ? 'x' : '-';     str[6] = ap & 0004 ? 'r' : '-';     str[7] = ap & 0002 ? 'w' : '-';     str[8] = ap & 0001 ? 'x' : '-';     str[9] = 0;     printf("%s", str);      return 0; } //Input 0ooo:1 //Input 0ooo:01a //Input 0ooo:0888 //Input 0ooo:755 //Input 0ooo:0755 //rwxr-xr-x

#include <stdio.h> #include <fcntl.h>  //定义宏变量，用于输出字符 #define READ 'r' #define WRITE 'w' #define EXEC 'x' #define NONE '-'  int main() {     //用户权限码和字符串索引     int ap = 0755, index = 0;     //输出字符串     char str[10];      //用户权限值和相应的标准权限码做与操作，如果为真则说明该权限存在     str[index++] = (ap & S_IRUSR ? READ : NONE);     str[index++] = (ap & S_IWUSR ? WRITE : NONE);     str[index++] = (ap & S_IXUSR ? EXEC : NONE);     str[index++] = (ap & S_IRGRP ? READ : NONE);     str[index++] = (ap & S_IWGRP ? WRITE : NONE);     str[index++] = (ap & S_IXGRP ? EXEC : NONE);     str[index++] = (ap & S_IROTH ? READ : NONE);     str[index++] = (ap & S_IWOTH ? WRITE : NONE);     str[index++] = (ap & S_IXOTH ? EXEC : NONE);     str[index] = '\0';      //输出字符串     printf("%s", str);  //rwxr-xr-x }

引用 1 楼 wtx_sonery 的回复:作业题？我记得权限是3位，你写个4位是啥意思开头的0表示8进制

作业题？我记得权限是3位，你写个4位是啥意思


Question: 求各位看看哪里错了，还有函数tolower和toupper是可以直接调用吗？

引用 3 楼 fly_dragon_fly 的回复:可以直接用的,不过就直接大小写转化没什么必要用 while(scanf("%d",&n)!=EOF&&n){         for(int i=0; i<n; i++){             scanf("%c",&a[i]);             if(isalpha(a[i])) a[i]^=0x20;             putchar(a[i]);         }     }      这个代码不能移植到其它编码的平台上。

简单的事情为什么要做成这么复杂？  #include <ctype.h> #include <stdio.h>  int main(void) {     int  c;      while ((c = getchar()) != EOF) {         if (islower(c)) {             c = toupper(c);         } else if (isupper(c)){             c = tolower(c);         }         putchar(c);     }      return 0; }

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。

添加头文件：#include <ctype.h>


Question: char **字符串数组，这个数组很大会影响速度吗？

指针是一个内存单元的地址，其大小跟操作系统处理机位数有关，即32位机占4个字节， 64位机占8个字节 如果普通变量之间相互赋值，相当于变量内容之间的拷贝，如果变量比较大，它们之间传递的数据量就大，执行就慢。  而指针赋值，由于传递的是地址，在操作系统一定的情况下， 其大小都是一定的，而且一般是4个字节或8个字节，其数据传递量小，所以效率高。不过二者共享一个内存空间，实现数据共享  就好比你有一栋房子， 我觉得你那房子不错，也想体验一下。 普通变量赋值就相当于：我按照你的房子结构，自己也造一个。 指针变量赋值就相当于：你把地址和钥匙给我，我也搬进去住，共同享有里面的资源

有一点明白了，可能是我说的不太清楚。唉

没关系吧，传递的是一个地址值；即使你定义了一个大的数组，但是传递的也是大数组的地址值。所以，传参是没问题的吧。

我是来看楼主挨砖家的板砖的

初学者不要纠结速度  等你技术有成了在去找优化方式吧

无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！

贴上你的代码来看看

也就多mov一次的操作而已 ... 对速度影响比较大的是 cache ，内存对齐 ，和并行性 c程序员最主要改善效率的途径是算法 ... 前面所说的东西全扔给编译器处理了 ...

如果是传入指针的指针, 那么就是说这个指针是需要你去更改 那么这个指针所代表的大小由你自己来决定, 你想它大就大, 小就小 int InitializeChar(char **pPointer) {     int length = 1024 * 1024 * 512; // 512mb     char *pData = new char[length];     *pPointer = pData;     // 或者可以直接写成 *pPointer = new char[length];     return length; }  int main() {     char *pchData = NULL;     int length = InitializeChar(&pchData);      if (length != 0) delete[] pchData;      return 0; }

很大看多大2G,4G以内吧。。吃内存 传的是地址，速度很快的。

问这种问题的话，我建议先把C/C++教程看一下毕竟好


Question: 帮忙看看我的冒泡排序哪里出了问题？

把子函数的if和while循环换成两个for循环试试

//m_sort(a, low, high-1);   m_sort(a, low+1, high);


Question: 这段为什么输出是4

引用 2 楼 user-1 的回复:刚才搞错，是把b[i]是否等于4的值赋给a  如果相等，a是1，否则是0   懂了，，，谢谢。。。

刚才搞错，是把b[i]是否等于4的值赋给a  如果相等，a是1，否则是0

把b[i]的值赋给a 判断a与4是否相等来决定要不要循环 无论是否循环，i都会再自加上1


Question: Linux，gcc编译，字符串替换，用strcat出错，后面的字符莫名其妙地多了几个字符

对不符合规范的代码，C++标准只说行为未定义，具体会产生什么样的行为和编译器，和环境这些都有关系，没有出错也属于正常。就好比使用已经释放的内存样，它的内容是不可预知的，也可能刚好就是你需要的内容。

5楼，为什么有的Linux系统可以，但是有的Linux系统又不行呢

难题，求大神回答。。。。

1楼，我的代码，短的换长的可以，长的换短的不行，而且在有的Linux下可以，有几台Linux下又不行

仅供参考：#include <stdio.h> #include <string.h> char s[256]; char *p; int r,n,i; int main() {     while (1) {         printf("请输入一行文字(空行结束),\"%%20\"将替换为\" \",\"你懂得\"将替换为\"XXXXXX\":\n");         fgets(s,256,stdin);         if ('\n'==s[0]) break;         p=s;         while (1) {             p=strstr(p,"%20");             if (p) {                 memmove(p+1,p+3,strlen(p)-3+1);                 p[0]=' ';             } else break;         }         p=s;         while (1) {             p=strstr(p,"你懂得");             if (p) {                 memmove(p+6,p+6,strlen(p)-6+1);                 for (i=0;i<6;i++) p[i]='X';             } else break;         }         printf("%s",s);     }     return 0; } //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //abcdefg%20helloworld%20something.pdf //abcdefg helloworld something.pdf //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //这是测试文字你懂得，在这个你懂的地方，就得做你懂得的事 //这是测试文字XXXXX，在这个你懂的地方，就得做XXXXX的事 //请输入一行文字(空行结束),"%20"将替换为" ","你懂得"将替换为"XXXXXX": //

strcat 要求源地址和目标地址不能有重叠

一般这问题可能是没设置 \0

短的子串替换为长的字符串，你应该先把被替换字符串以后的字符串整体向后移动，不应该直接用'\0'截断字符串。你这样等于已经把原来的字符串不应该修改的字符替换为'\0'，然后进行复制又会把一部分字符串覆盖了。。。 正确的做法，应该是将被替换字符串以后的部分，整体向后移动strlen(new_str)-strlen(old_str)字节。然后，将新字符串覆盖旧子串，strcat不用在这里。或者就是你注释代码的做法，先把后面部分放到新分配的空间里，然后再拼接回来，这样的效率就低了。


Question: 互斥锁，怎么加锁和解锁？

引用 2 楼 user-1 的回复:3）锁有没有初始化 ok,thanks

3）锁有没有初始化

互斥锁是任何一个获得，另一个就得不到 如果加了互斥锁，不能互斥 1）看是否同一把锁，两把不同的锁，达不到互斥目的 2）有没有其他地方也在加锁


Question: 关于指针的问题

引用 1 楼 user-1 的回复:free 内存不会自动 将指针 设置为NULL 建议 free（str）后面加上 str = NULL; free 只是将内存标志为释放，但指针还指向那块内存,再对那块内存进行操作，可能会出保错，但不是一定会报错（内存未被其他程序使用时可能不会出错）那么对于在栈中的局部变量呢？栈中的局部变量释放后是否还有访问到的可能性？

引用 2 楼 qq_28839381 的回复:[quote=引用 1 楼 user-1 的回复:] free 内存不会自动 将指针 设置为NULL 建议 free（str）后面加上 str = NULL; free 只是将内存标志为释放，但指针还指向那块内存,再对那块内存进行操作，可能会出保错，但不是一定会报错（内存未被其他程序使用时可能不会出错）那么对于在栈中的局部变量呢？栈中的局部变量释放后是否还有访问到的可能性？[/quote]  有啊，指针可以指向，但是那块内存不是自己申请的，对自己一点意义也没有，或是错误的


Question: C语言内存问题

free(token);错误          token并没有使用malloc分配内存给它 strtok 错误            strtok会对原先字符串造成破坏

貌似不需要free(token);

看上去怪怪的

strtok, 这是linux中的吗, 真是怪, 竟然第二次不用源串???????????????????????一点都不符合普通vc语言习惯

试试这个 #include<io.h> #include<stdio.h> #include<conio.h> #include<malloc.h> #include<stdlib.h> #include<string.h>  void localSearch(); void allMusicList(struct Music *local); void playMusicList(struct Music *play, struct Music *local);//导入播放列表   int  count = 0;//本地歌曲数目 int temp = 0;   struct Music { 	int order; 	char *name; 	char *singer; };//歌曲信息   int main() {  	localSearch();//计算 本地音乐数量 	struct Music *allSong = (struct Music*) malloc(sizeof(struct Music) * count);//建立全部歌曲列表 	memset(allSong, NULL, sizeof(struct Music) * count);  	if (NULL == allSong) 	{ 		printf("内存分配失败"); 		return -1; 	}  	allMusicList(allSong);//导入全部歌曲列表  	free(allSong);//释放全部歌曲内存  	system("pause");  	return 0; }   void localSearch() { 	long Handle; 	struct _finddata_t FileInfo; 	if ((Handle = _findfirst("D:\\CloudMusic\\*.MP3", &FileInfo)) == -1L)//存放歌曲的路径 	{ 		printf("本地没有歌曲可以播放\n"); 	} 	else 	{ 		printf("localSearch()---%s\n", FileInfo.name);  		count = 1; 		while (_findnext(Handle, &FileInfo) == 0) 		{ 			printf("localSearch()---%s\n", FileInfo.name); 			count++; 		} 		_findclose(Handle); 		printf("localSearch()---共找到%d首音乐\n", count); 	} }   void allMusicList(struct Music *local) { 	long Handle; 	char *buf = NULL; 	struct _finddata_t FileInfo; 	Handle = _findfirst("D:\\CloudMusic\\*.MP3", &FileInfo); 	int address = 0; 	char str[100];  	char *token;  	token = strtok_s(FileInfo.name, "-", &buf);  	local[address].singer = (char *)malloc(strlen(token) + 1); 	strcpy_s(local[address].singer, strlen(token) + 1, token); 	while (token != NULL) 	{ 		token = strtok_s(NULL, "-", &buf); 		if (token != NULL) 		{ 			local[address].name = (char *)malloc(strlen(token) + 1); 			strcpy_s(local[address].name, strlen(token) + 1, token); 		} 	} 	local[address].order = address + 1; 	printf("allMusicList()---%d. %s  \t%s\n", local[address].order, local[address].name, local[address].singer); 	address++;  	//分割第一首歌的歌手与歌名并加序号   	while (_findnext(Handle, &FileInfo) == 0) 	{ 		token = strtok_s(FileInfo.name, "-", &buf);  		local[address].singer = (char *)malloc(strlen(token) + 1); 		strcpy_s(local[address].singer, strlen(token) + 1, token); 		while (token != NULL) 		{ 			token = strtok_s(NULL, "-", &buf); 			if (token != NULL) 			{ 				local[address].name = (char *)malloc(strlen(token) + 1); 				strcpy_s(local[address].name, strlen(token) + 1, token); 			} 		} 		local[address].order = address + 1; 		printf("allMusicList()---%d. %s  \t%s\n", local[address].order, local[address].name, local[address].singer);//输出结果与下面输出不一致 		address++; 	} 	for (int i = 0; i < count; i++) 	{ 		printf("allMusicList()---%d. %s  \t%s\n", local[i].order, local[i].name, local[i].singer);//输出结果与上面不一致 	}   	_findclose(Handle); 	//分割全部歌曲的歌手与歌名并加序号  }

仅供参考：#include <stdio.h> #include <string.h> char string[80]; char seps1[3]; char seps2[3]; char *token; char *zzstrtok (     char *string,     const char *control1,//连续出现时视为中间夹空token     const char *control2 //连续出现时视为中间无空token     ) {     unsigned char *str;     const unsigned char *ctrl1 = (const unsigned char *)control1;     const unsigned char *ctrl2 = (const unsigned char *)control2;     unsigned char map1[32],map2[32];     static char *nextoken;     static char flag=0;     unsigned char c;     int L;      memset(map1,0,32);     memset(map2,0,32);     do {         map1[*ctrl1 >> 3] |= (1 << (*ctrl1 & 7));     } while (*ctrl1++);     do {         map2[*ctrl2 >> 3] |= (1 << (*ctrl2 & 7));     } while (*ctrl2++);      if (string) {         if (control2[0]) {             L=strlen(string);             while (1) {                 c=string[L-1];                 if (map2[c >> 3] & (1 << (c & 7))) {                     L--;                     string[L]=0;                 } else break;             }         }         if (control1[0]) {             L=strlen(string);             c=string[L-1];             if (map1[c >> 3] & (1 << (c & 7))) {                 string[L]=control1[0];                 string[L+1]=0;             }         }         str=(unsigned char *)string;     }     else str=(unsigned char *)nextoken;      string=(char *)str;     while (1) {         if (0==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 string++;                 str++;             } else {                 flag=1;                 str++;             }         } else if (1==flag) {             if (!*str) break;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=0;                 break;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 *str=0;                 str++;                 flag=2;                 break;             } else str++;         } else {//2==flag             if (!*str) return NULL;             if (map1[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;                 flag=0;             } else if (map2[*str >> 3] & (1 << (*str & 7))) {                 str++;                 string=(char *)str;             } else {                 string=(char *)str;                 str++;                 flag=1;             }         }     }     nextoken=(char *)str;      if (string==(char *)str) return NULL;     else             return string; } void main() {    strcpy(string,"A \tstring\t\tof ,,tokens\n\nand some  more tokens, ");    strcpy(seps1,",\n");strcpy(seps2," \t");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234| LIYI|China | 010 |201110260000|OK");    strcpy(seps1,"|");strcpy(seps2," ");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234|LIYI||010|201110260000|OK");    strcpy(seps1,"");strcpy(seps2,"|");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"1234|LIYI||010|201110260000|OK");    strcpy(seps1,"|");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",a");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,"a,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",a,,b");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,a,,b,,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,");    strcpy(seps1,",");strcpy(seps2,"");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    }     strcpy(string,",,,");    strcpy(seps1,",");strcpy(seps2," ");    printf("\n[%s]\nTokens:\n",string);    token=zzstrtok(string,seps1,seps2);    while (token!=NULL) {       printf(" <%s>",token);       token=zzstrtok(NULL,seps1,seps2);    } } // //[A      string          of ,,tokens // //and some  more tokens,] //Tokens: // <A>, <string>, <of>, <>, <tokens>, <>, <and>, <some>, <more>, <tokens>, <>, //[1234| LIYI|China | 010 |201110260000|OK] //Tokens: // <1234>, <LIYI>, <China>, <010>, <201110260000>, <OK>, //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234>, <LIYI>, <010>, <201110260000>, <OK>, //[1234|LIYI||010|201110260000|OK] //Tokens: // <1234>, <LIYI>, <>, <010>, <201110260000>, <OK>, //[a] //Tokens: // <a>, //[a,b] //Tokens: // <a>, <b>, //[a,,b] //Tokens: // <a>, <>, <b>, //[,a] //Tokens: // <>, <a>, //[a,] //Tokens: // <a>, <>, //[,a,,b] //Tokens: // <>, <a>, <>, <b>, //[,,a,,b,,] //Tokens: // <>, <>, <a>, <>, <b>, <>, <>, //[,] //Tokens: // <>, <>, //[,,] //Tokens: // <>, <>, <>, //[,,,] //Tokens: // <>, <>, <>, <>,


Question: 在数组中覆盖前一个元素和删除该元素一样吗？

引用 7 楼 Devinvow的回复:[quote=引用 4楼自在飞花6541 的回复:]像list这种的直接删除就可以了，这样你以后遍历的话不会有影响，如果你边遍历边删除的话你得注意一下位置若是顺序存储，直接覆盖掉，算不算删除？ 如arr[i] = arr[i-1]，不缓存和删除的元素。[/quote] 这算删除，但是如果你这是指针的话那你得保证你指针指向的区域不要被无法调用

理论上可以，操作上复杂，而且由于线性表中数据如果过多，复制数据会消耗大量的系统资源和时间，没有修改指针指向的位置方便省时而已

其实电脑开机后物理内存的每个字节都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。

引用 4楼自在飞花6541 的回复:像list这种的直接删除就可以了，这样你以后遍历的话不会有影响，如果你边遍历边删除的话你得注意一下位置若是顺序存储，直接覆盖掉，算不算删除？ 如arr[i] = arr[i-1]，不缓存和删除的元素。

引用 3楼cbNotes 的回复:你说的太笼统了，线性表分顺序存储和链式存储，不知道你具体什么意思！顺序存储。假如有个arr[10]，我想删除arr[4]，让arr[5]及以后得数据往前覆盖，这样算的上是删除吗？

本质上并没有区别，都是都是对地址区间里寄存器值的更改，只是一个是从相邻的地址里修改出来的值，另一个是重新赋值。

你说的太笼统了，线性表分顺序存储和链式存储，不知道你具体什么意思！

线性表删除的是里面的元素，找到要删除元素的指针free掉就行

线性表的删除是删除了该位置的地址还是什么？是不是删除的元素的生命周期归main函数释放？


Question: 字符串数组初始化 &&  L"String is not null terminated"

机器在重装，没有精力细看了，应当是a[100]的问题，这个没有初始化就直接strcat_s。 因为没有初始化，所以没有NULL结尾，所以会出这个提示。

你传入的p未初始，这样写就可以了：   #include "stdafx.h"  #include"string.h" #define   M   3 #define   N   20  void fun(char a[M][N], char*p) { *p = 0; int i = 0; for (i = 0; i < M; i++) strcat_s(p,100,a[i]); }   void main() { 	char  w[M][N] = { "AAAA\0", "BBBBBBB\0", "CC\0" }, a[100]; 	int i; 	printf("The string:\n"); 	for (i = 0; i<M; i++) 		puts(w[i]); 	printf("\n"); 	fun(w, a); 	printf("The A string:\n"); 	printf("%s", a); printf("\n\n"); }


Question: 问题是求某一天在该年中第几天，输入1996/5/20这种中间有/的数据，下面我写的程序如果只输入数据可以运行出来，但是加上在数中加上/就不行了，求解。。。。。。

当然不行，你既然指定了参数为%d，那自然就默认你输入的是int型的数据。1996是int，5是int，1991/是什么鬼？只能是char*咯  个人建议你要麽就直接把输入的字符按照%s处理。

引用 4 楼 wanggaofengwz的回复:scanf("%d/%d/%d",&year,&month,&day) 可以这样用吗，应该把输入作为一个字符串去处理，写一个函数来处理那个字符串 能举个例子吗？不会写那个字符串处理函数，初学acm各种不会︶︿︶

仅供参考：#include <stdio.h> #include <string.h> #include <time.h> struct tm st; time_t tt; char timstr[40]; char tmpbuf[128]; char c; int t; int AP() {     if ('P'==c || 'p'==c) {st.tm_hour+=12;return 1;}     if ('A'==c || 'a'==c)                 return 1;                                           return 0; } int dtparse() {     if (7==sscanf(timstr,"%d/%d/%4d %d:%d:%d %c",&st.tm_mday,&st.tm_mon ,&st.tm_year,&st.tm_hour,&st.tm_min,&st.tm_sec,&c)) if (AP()) goto STEP2;     if (6==sscanf(timstr,"%d/%d/%4d %d:%d%c"    ,&st.tm_mday,&st.tm_mon ,&st.tm_year,&st.tm_hour,&st.tm_min           ,&c)) if (AP()) goto STEP1;     if (6==sscanf(timstr,"%4d/%d/%d %d:%d %c"   ,&st.tm_year,&st.tm_mon ,&st.tm_mday,&st.tm_hour,&st.tm_min           ,&c)) if (AP()) goto STEP1;     if (5==sscanf(timstr,"%d.%d.%4d %d:%d"      ,&st.tm_mon ,&st.tm_mday,&st.tm_year,&st.tm_hour,&st.tm_min              ))           goto STEP1;     if (6==sscanf(timstr,"%4d-%d-%d %d:%d:%d"   ,&st.tm_year,&st.tm_mon ,&st.tm_mday,&st.tm_hour,&st.tm_min,&st.tm_sec   ))           goto STEP2; STEP1:     st.tm_sec=0; STEP2:     st.tm_year-=1900;     if (st.tm_mon>12) {t=st.tm_mon;st.tm_mon=st.tm_mday;st.tm_mday=t;}     st.tm_mon-=1;     tt=mktime(&st);     if (-1!=tt) {         strftime(tmpbuf,128,"%Y-%m-%d %H:%M:%S",localtime(&tt));         return 1;     } else {         printf("[%s] is Invalid time string!\n",timstr);         return 0;     } } int main() {     strcpy(timstr,"10.01.2012 15:43"        );if (dtparse()) printf("[%s] is [%s]\n",timstr,tmpbuf);     strcpy(timstr,"8/11/2006 11:10AM"       );if (dtparse()) printf("[%s] is [%s]\n",timstr,tmpbuf);     strcpy(timstr,"2006/10/31 04:50 PM"     );if (dtparse()) printf("[%s] is [%s]\n",timstr,tmpbuf);     strcpy(timstr,"1/6/2010 5:20:12 PM"     );if (dtparse()) printf("[%s] is [%s]\n",timstr,tmpbuf);     strcpy(timstr,"13/12/2012 11:16:17 a.m.");if (dtparse()) printf("[%s] is [%s]\n",timstr,tmpbuf);     strcpy(timstr,"2013-06-08 09:56:59"     );if (dtparse()) printf("[%s] is [%s]\n",timstr,tmpbuf);     return 0; } //[10.01.2012 15:43] is [2012-10-01 15:43:00] //[8/11/2006 11:10AM] is [2006-11-08 11:10:00] //[2006/10/31 04:50 PM] is [2006-10-31 16:50:00] //[1/6/2010 5:20:12 PM] is [2010-06-01 17:20:12] //[13/12/2012 11:16:17 a.m.] is [2012-12-13 11:16:17] //[2013-06-08 09:56:59] is [2013-06-08 09:56:59] //

求解求解～～

另外如果scanf("%d/%d/%d",&year,&month,&day)变成这种形式的话就不能运行了


Question: 有大神做过电竞13年F题吗？有问题要问


Question: 数据结构栈的应用---表达式求解

如果c 或者 GetTop(OPTR)的返回值不等于‘#’就可以进入while循环，也就是说当c 并且GetTop(OPTR)返回值都是'#'则跳出（不进入）循环


Question: 关于空字符串比较问题

引用 楼主 xianzhutou 的回复:#include <stdio.h> #include <memory.h> #include <stdlib.h> #include <string.h>   int main() { 	char *output = (char*)malloc(10); 	char *tmp = (char*)malloc(10); 	output = ""; 	*tmp = '\0'; 	if ( output == tmp ) 	{ 		printf("equal\n"); 	} 	return 0; }  output 是空字符串， tmp也是没有字符的空字符串，为什么两者不相等呢？  c 标准库有 strcmp 函数可以用  #include <string.h>   int strcmp( const char *str1, const char *str2 );  记得 The c programming language 中有段代码 //根据 s 按照字典顺序 小于 等于 或大于 t 的结果 分别返回 负整数 0 或 整数 int mystrcmp(char *s ,char *t) {     for( ; *s == *t; s++,t++ )       if( *s == '\0')          return 0; return *s - *t; }

一楼的打比方挺形象~~ 楼主比较的是两个指针，是两个不同的地址值，指向不同的内存，肯定是不相等的……

#include <stdlib.h> #include <string.h> int main() {     char *output = (char*)malloc(10);     char *tmp = (char*)malloc(10);     output = "";     *tmp = '\0'; 	printf("%p %p",output,tmp);     return 0; }  output 和tmp是指针变量 存的是地址， output指向空字符串的首地址，而tmp指向malloc指向的地址 不会相等

这比较的是地址值，不是字符串

引用 楼主 xianzhutou 的回复:#include <stdio.h> #include <memory.h> #include <stdlib.h> #include <string.h>   int main() { 	char *output = (char*)malloc(10); 	char *tmp = (char*)malloc(10); 	output = ""; 	*tmp = '\0'; 	if ( output == tmp ) 	{ 		printf("equal\n"); 	} 	return 0; }  output 是空字符串， tmp也是没有字符的空字符串，为什么两者不相等呢？ 字符串内容比较还得用strcmp 两个地址进行比较没有意义

代码三个问题： 1. 分配无意义的内存 2. 内存未被释放 3. 进行指针比较

字符串不是这样比较的哦，memcmp或者strcmp、strncmp；if ( output == tmp )这样比较的是指针变量里的地址值。由于指向的内容不一样，所以地址值也不相等。

if ( output == tmp ) 这表示的是 地址与地址 是否相等吧？ 肯定是不不等的。。

用strcmp可以比较！

字符串可以用“==”比较吗？

是啊，这是为什么呢？  有俩抽屉，都没有装东西，都是空的，那么，这俩抽屉是一样的吗？


Question: 使用c写一个三维图形

搜网络教程“学OpenGL编3D游戏”。

自己去下directx的sdk去，里面有example，directx的api c和c++都可以用，只是有些区别，具体可以在vs里按f1查看相关帮助文档。


Question: C fputc（）返回值-1

为了减少可能的低级错误，建议分开两行写：  fp = fopen(filename,"w"); if (NULL == fp) {     /* ... */ }

if(fp=fopen(filename,"w")==NULL){ ===>     if((fp=fopen(filename,"w"))==NULL){


Question: fread读文件的问题

使用前先把数组清空

为何不用fstream

你要显示的是e的内容，e是DWORDLONG    类型的，可以表示的数字很大 还有显示的数字是20位（十进制）并不表示   数据长度是20位


Question: 请修改补充以下代码完成能搜索打印出盘内所有txt文件的程序

引用 2 楼 bjym1987 的回复:赵老师来个dos命令，一切搞定，哪要这么复杂@赵4老师 system("dir /b /a-d c:\\*.* >d:\\allfiles.txt"); //读文件d:\\allfiles.txt的内容即C:\\下所有文件的名字 system("dir /b /a-d /s c:\\*.* >d:\\allfilesinsub.txt"); //读文件d:\\allfilesinsub.txt的内容即C:\\下所有文件的名字包含子目录 system("dir /b /ad  c:\\*.* >d:\\alldirs.txt"); //读文件d:\\alldirs.txt的内容即C:\\下所有子目录的名字 请记住，能用shell命令获取文件、文件夹信息或者操作文件、文件夹最好用shell命令获取或者操作，而不要用各种API获取或者操作，因为当遇到非法文件夹名或非法文件名或非法文件长度、非法文件日期、压缩文件、链接文件、稀疏文件……等各种意料之外的情况时，API会处理的不全面或陷入死循环，而shell命令不会。

赵老师来个dos命令，一切搞定，哪要这么复杂@赵4老师

#include<windows.h>   #include<iostream>   #include<string>   using namespace std;  //可同时处理目录和文件:path可以是路径，也可以是文件名，或者文件通配符   void _find(string path) { 	//保存目录名 	string prefix = path.substr(0, path.find_last_of('\\') + 1); 	//输出要查找的目录的名字 	cout << "[目录]  " << prefix  << endl;  	WIN32_FIND_DATA FindFileData; 	HANDLE hFind = ::FindFirstFile(path.c_str(), &FindFileData); 	if (INVALID_HANDLE_VALUE == hFind) 	{ 		cout << "文件通配符错误" << endl; 		return; 	} 	while (TRUE) 	{ 		//目录   		if ( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) 		{ 			//不是当前目录，也不是父目录（.是当前目录 ..是上级目录） 			if (FindFileData.cFileName[0] != '.') 			{ 				//查找下一级目录   				_find(prefix + FindFileData.cFileName + "\\" + "*.*"); 			} 		} 		else 		{ 			cout << "+文件+\t" << FindFileData.cFileName << endl; 		} 		if(!FindNextFile(hFind, &FindFileData)) 			break; 	} 	FindClose(hFind); }  int main() { 	_find("E:\\*.*");	//E盘下所有文件   	string path;   	cout<<"请输入路径和文件通配符：例如：（E:\\*.* 或者 abc\\*.* ）"<<flush;   	cin>>path;   	_find(path); 	system("pause"); 	return 0; }


Question: 关于指针数组的问题

引用 5 楼 sdghchj 的回复:[quote=引用 3 楼 u011330815 的回复:] [quote=引用 2 楼 sdghchj 的回复:] 我相信没人会这样写代码的，首先你要搞清楚传值和传引用或指针的区别，然后再搞清一级指针和二级指针甚至三级以上的指针，搞清数组名和指针间的异同。一句话真说不清楚。  char *OutName[10] = {0};  GetName(OutName);  for(int i=0;i<10;i++)      //输出数组  函数调用： GetName(char **&Outname)  {  for(int i=0;i<10;i++)      Outname[i] = "asd";  } 问题已经解决了，主要是在调用函数的时候，指针指向临时变量了···[/quote] 指向的是常量，什么临时变量！[/quote] 因为我把指针数组传到函数中，函数结束后，指针指向的就是空地址了

这样就ok了：  GetName(char *Outname[]) { 	for (int i = 0; i < 10; i++) 		Outname[i] = "asd"; } int main(void) { 	char *OutName[10]; 	GetName(OutName); 	for (int i = 0; i < 10; i++) 		printf("%s\n", OutName[i]); 	return 0; }

理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 （Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）

引用 3 楼 u011330815 的回复:[quote=引用 2 楼 sdghchj 的回复:] 我相信没人会这样写代码的，首先你要搞清楚传值和传引用或指针的区别，然后再搞清一级指针和二级指针甚至三级以上的指针，搞清数组名和指针间的异同。一句话真说不清楚。  char *OutName[10] = {0};  GetName(OutName);  for(int i=0;i<10;i++)      //输出数组  函数调用： GetName(char **&Outname)  {  for(int i=0;i<10;i++)      Outname[i] = "asd";  } 问题已经解决了，主要是在调用函数的时候，指针指向临时变量了···[/quote] 指向的是常量，什么临时变量！

#include <iostream>  void GetName( char  const * outname[] ); int main( ) {         char const *OutName[10] = { NULL };         GetName(OutName);         for(int i=0; i<10; i++)             std::cout<< OutName[i]<< std::endl;         return 0; }  void GetName( char const * Outname[] ) {         for(int i=0;i<10;i++)             Outname[i] =  "asd"; }   以上可以使用g++直接编译运行。楼主找到了问题的地方，原来的那个赋值语句 char *OutName[10] = "0"  是一个本质性的错误。从类型匹配的角度都能够嗅出一点不好的味道。因为左端本质是一个二阶指针，右端的本质是指向内存常数段的一个一届指针。 且不管楼主怎样让编译器做出各种转型，我们看看你把这个指针传给GetName以后会发生生么事。  for 循环里面的第一次赋值，做了一次解析引用，然后把另外一个指针赋给了原来值为 ‘0’ ‘\0'的地方。之后的赋值（如果能执行的话）其实是在污染内存，因为那些地址程序根本没有申请。  为什么 const char *OutName[10]= { NULL }; 能工作 ？ 这是数组初始化的时候发现左边需要10个 const char *的指针，而右端只有一个元素，于是编译器使用 0 转型以后补满了其他9个值。注意，这是C有关数组初始化的已定义行为，什么时候都可以安全利用。

没看出调用和传参有什么问题。就是那个指针数组的初始化不对吧；char *OutName[10] = {NULL};

引用 2 楼 sdghchj 的回复:我相信没人会这样写代码的，首先你要搞清楚传值和传引用或指针的区别，然后再搞清一级指针和二级指针甚至三级以上的指针，搞清数组名和指针间的异同。一句话真说不清楚。  char *OutName[10] = {0};  GetName(OutName);  for(int i=0;i<10;i++)      //输出数组  函数调用： GetName(char **&Outname)  {  for(int i=0;i<10;i++)      Outname[i] = "asd";  } 问题已经解决了，主要是在调用函数的时候，指针指向临时变量了···

我在GetName(char *Outname[])函数里面输出数组的结果是对的，然后调用函数结束后，输出数组就是乱码。这是为什么？


Question: 请问为什么要定义数组szline为char型而不是int型？求解～～～

引用 3 楼 tr1cks的回复:因为scanf（）读进来的是一个字符串，所以用char类型的数组 可是感觉scanf读进一串数字也行(･ิϖ･ิ)っ

因为scanf（）读进来的是一个字符串，所以用char类型的数组

仅供参考：#include <stdio.h> #include <string.h> #define MAXLEN 1000 char a1[MAXLEN]; char a2[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; void main(void) {     scanf("%d",&n);     for (j=0;j<n;j++) {         scanf("%s%s",a1,a2);          L=strlen(a1);         for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';          L=strlen(a2);         for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';          for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];          for (i=0;i<MAXLEN;i++) {             if (v3[i]>=10) {                 v3[i+1]+=v3[i]/10;                 v3[i]=v3[i]%10;             }         }          printf("Case %d:\n", j+1);         printf("%s + %s = ", a1, a2);          z=0;         for (i=MAXLEN-1;i>=0;i--) {             if (z==0) {                 if (v3[i]!=0) {                     printf("%d",v3[i]);                     z=1;                 }             } else {                 printf("%d",v3[i]);             }         }         if (z==0) printf("0");          printf("\n");     } } //Sample Input //3 //0 0 //1 2 //112233445566778899 998877665544332211 // //Sample Output //Case 1: //0 + 0 = 0 //Case 2: //1 + 2 = 3 //Case 3: //112233445566778899 + 998877665544332211 = 1111111111111111110

好像是模拟加法吧, char可以到127, 这里最多才用到10, 有必要int吗


Question: glib io channel的讨论

个人建议，不要用Windows的知识来猜测Linux的行为。  另外建议看看libevent。

引用 3 楼 user-1 的回复:帮顶下先，不明觉厉。  文章不一正确，没有找到原文的出处。  文章中提到的windows的概念，是凭借自己一些基础和理解得出的。  猜测linux也是如此。

up 起来。up起来

http://blog.csdn.net/halsonhe/article/details/5955752   这是文章的连接


Question: 指针 输入3个字符串之后比较其大小 用指针

引用 3楼赵4老师 的回复:#include <stdio.h> #include <string.h> void get(char *p[]) {     for (int i = 0; i < 3; i++)         scanf_s("%s",p[i],10); } void exchange(char *p[]) {     char *temp;     for (int i = 0; i < 2; i++)         for (int j = i + 1; j < 3; j++) {             if ((strcmp(p[i], p[j]))>0) {                 temp = p[i];                 p[i] = p[j];                 p[j] = temp;             }         } } void put(char *p[]) {     for (int i = 0; i < 3; i++) {         printf("%s",p[i]);         printf("\n");     } } int main() {     char a[10];     char b[10];     char c[10];     char *p[3]={a,b,c};      get(p);     printf("\n");     exchange(p);     put(p);      return 0; } 实在感谢 小白一名 太感谢了

十分感谢！小白一名 谢谢帮助

#include<stdio.h> #include<string.h>  void get(char *p[]); void exchange(char *p[]); void put(char *p[]);  void get(char *p[]) { 	int i; 	for (i = 0; i < 3; i++) 		scanf_s("%s", *(p+i), 10);    //这个地方类型不对，你在编译的时候应该能够看到有警告 } void exchange(char *p[]) { 	char *temp; 	int i, j; 	for (i = 0; i < 2; i++) 		for (j = i + 1; j < 3; j++) 		{ 			if ((strcmp(p[i], p[j]))>0) 			{ 				temp = p[i]; 				p[i] = p[j]; 				p[j] = temp; 			} 		} } void put(char *p[]) { 	int i; 	for (i = 0; i < 3; i++) 	{ 		printf("%s",* (p + i)); 		printf("\n"); 	} } int main() { 	//很少在这申明函数了 	char a[10], b[10], c[10]; 	char *p[3] = { a, b, c }; 	get(p); 	printf("\n"); 	exchange(p); 	put(p); 	 	return 0; }

刚才 我改成  int main() { void get(char *p[]); void exchange(char *p[]); void put(char *p[]); char a[10]; char b[10]; char c[10]; char *p[3]={a,b,c}; get(p); printf("\n"); exchange(p); put(p); } 依然程序停止工作 在跑的时候 可以输入 执行完get()后就死了......

你操作的字符串的内存空间在哪里申请的？？？ 你输入的字符串存到哪里了，你申请空间了么


Question: c语言中(0|1|2|3|4    &   (0x00000001 <

//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+

&比|高了2级, 是要考这个吧

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！

引用 3 楼 king191923157 的回复:i=0       1 i=1       5 i=2       3 i>=3     0  我运行了一下，我错了 程序先执行的   iTemp = ( 4    &   (0x00000001 <<i)  ) 然后执行的(0|1|2|3| iTemp)  所以除了i=2时i Temp  ＝  4    结果是   7          (0|1|2|3| 4) ＝》7 其他情况都是        (0|1|2|3| 0)  ＝》 3

i=0       1 i=1       5 i=2       3 i>=3     0

= =没看见括号，哎。。。 应该是这样 0|1|2|3|4 = 0xF，如果i=0，那就是0xF & 0 = 0；如果i=1，那就是0xF&1 = 0x0001；如果i=2，那就是0xF & 2 = 0x0010，也就是2.。。其他的自己推了。

X &   0x00000001 这个就只保留了低1位，最后结果就是0或者1，再左移I位，自己算了咯


Question: EEPROM字节写入 的两个问题。

引用 1 楼 Kusk 的回复:1. 因为传进这个变量的值本身，也是指针的值转型过来的unsigned int，所以使用的时候，可以转回去，这个依赖于这个前提； 2. 语句的意思是，FLASH_IAPSR_bit.EOP等于1时循环，也就是不等于1时才跳出。这个需要看上下文语义了。  最后那句话是等待写入IO完成的意思

楼主这是学嵌入式吧，请原谅我说话直，我建议从基础学起，最后那个是等待写入完成，都==0了还等毛线 至于第二个，是吧一个address传进去的是int，要直接转换成指针，强行访问这个地址 EEROM的底层支持系统的编写和ring 3的不一样，建议楼主从头学起，楼主这看的是RTOS访问EEROM的驱动程序吧？或者单片机的芯片程序，建议楼主从头看起

void EEPROM_Byte_Write(unsigned int address,unsigned char data)函数写EEPROM，其地址一般是在芯片设计时定义，每个地址是一个直接指定的数据，所以使用unsigned int address比较方便，在函数内要让编译器知道那是一个地址，因此需要使用强制转换


Question: C语言 txt文件元素追加

我是采用“a”将一个文件追加到另一个文件中的，结果是这个样子。采用fprintf的话事先需要定义结构体吧，不这样的话有没有其他的办法直接追加成下面的形式。

将形如 for fprintf data %d\n for fprintf delay %d\n 改为形如 for  fprintf data %d delay %d\n ？

只跟你fprintf的顺序有关，跟“a"不”a"无关。


Question: 关于printf()在循环中重复打印两次的问题

//请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];

引用 7 楼 u012990532 的回复:[quote=引用 2 楼 JiangWenjie2014 的回复:] 你有发现，你输入的时候，先按一下Y键，在按一下回车键结束输入。那么scanf第一次得到的是'y'，第二次得到的是'\n'。 引用 1 楼 user-7 的回复:看看是不是  缓冲区刷新的问题 试试fflush(stdin) 引用 3 楼 zxh707wk 的回复:scanf不接收回车。。。 引用 4 楼 weixin_29796265 的回复:可能是缓冲区东西读多了。。。。   是的，这个要考虑到缓冲区，对于这个例子中，只要把那个在缓冲区保留enter 键用getchar（）读走就可以了，但是我在scanf后加fflush(stdin)后执行printf的内容还是会打印两次。谢谢大家，scanf稍不注意不理解有好多陷进[/quote]  你在scanf加fflush(stdin)当然会打印两次了，因为scanf已经把回车字符读进去了，再清空缓存就没意义了，在scanf之前加就好了

引用 2 楼 JiangWenjie2014 的回复:你有发现，你输入的时候，先按一下Y键，在按一下回车键结束输入。那么scanf第一次得到的是'y'，第二次得到的是'\n'。 引用 1 楼 user-7 的回复:看看是不是  缓冲区刷新的问题 试试fflush(stdin) 引用 3 楼 zxh707wk 的回复:scanf不接收回车。。。 引用 4 楼 weixin_29796265 的回复:可能是缓冲区东西读多了。。。。   是的，这个要考虑到缓冲区，对于这个例子中，只要把那个在缓冲区保留enter 键用getchar（）读走就可以了，但是我在scanf后加fflush(stdin)后执行printf的内容还是会打印两次。谢谢大家，scanf稍不注意不理解有好多陷进

因为有回车符，回车符的ASCII值为10，所以满足循环。建议在scanf("%c", &c)；后面加上一句getchar();这样试试应该就没有两次循环了。

如二楼所说，scanf会接收回车键字符，将while循环体中的前面加上 fflush(stdin) ;    \\清空缓冲区 if(ch == 10)       \\忽略回车字符 continue;

可能是缓冲区东西读多了。。。。

scanf不接收回车。。。

看看是不是  缓冲区刷新的问题 试试fflush(stdin)


Question: hdoj2020绝对值排序 运行结果正确为什么oj一直通不过？

关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”

每一行最后是不是多了一个空格

引用 2 楼 king191923157 的回复:原来帮别人做过华为的题，那个变态的系统要猜输入输出的格式 ，提示不能多，连空格也不能多， 猜了好多次输入输入形式才通过 一般在线做题网站都是这样的吧

引用 2 楼 king191923157 的回复:原来帮别人做过华为的题，那个变态的系统要猜输入输出的格式 ，提示不能多，连空格也不能多， 猜了好多次输入输入形式才通过  与逻辑和运算结果没有关系（因为第一次就是对的），纯粹就是输入和输出与他给的例子一样，提示，空格，换行，一摸一样才行

for (int i = 0; i < n; ++i) {     if (0 == i)         printf ("%d", a[i]);     else         printf (" %d", a[i]); } printf ("\n");


Question: 字符串右移，调用strcpy时产生中断，利用库自带的strcpy一样的现象

#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！

char *s = "hello";  Strcpy(pStr, tmp);  pStr 指向的是 字符串  常量"hello";，不能对其进行修改操作 main函数改成下面试试  int main() { char s[100]; memset(s,0,100); strcpy(s,"hello");     LoopMove(s, 2); }


Question: 关于c语言的printf函数的使用问题

浮点型和整形在计算机内部的存储格式是不一样的，printf中使用%d，函数并不会将其它类型的数据安全转换成整形来输出，而是取其前4个字节（假设整形占4个字节），强制采用整形的格式输出，所以结果会不对。可将 printf("%d\t %f\n", fahr, celsius)改成 printf("%d\t %f\n", （int）fahr, celsius)就没问题了 关于浮点型二进制存储结构，请参考：http://www.cnblogs.com/fromchaos/archive/2010/12/07/1898698.html

printf("%d\t %f\n", fahr, celsius);    中  ％d   必须和后面的类型相匹配，不匹配会使最后生成的字符串出错（越界操作）


Question: 使用动态链表完成一个简单的商品库存信息管理系统。不知道哪里错了

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: scanf("%d",&n)与while(scanf("%d",&n)!=EOF)用的时候有什么不同

英语也是一门计算机语言的说。  Return Value  Both scanf and wscanf return the number of fields successfully converted and assigned; the return value does not include fields that were read but not assigned. A return value of 0 indicates that no fields were assigned. The return value is EOF for an error or if the end-of-file character or the end-of-string character is encountered in the first attempt to read a character.

scanf只有输入 CTRL  +Z  （CTRL  +D） 这种表示文件结束的 数据时候，才会返回 EOF 其他时候，返回成功输入的数据个数  当只有一个数据要输入的时候，成功 返回1 ，失败返回0，文件结束 返回  EOF。 这里的数据个数， 是指格式串指定的，输入数据个数，  和调用参数个数，关系不大。  while (scanf("%d", &n) != EOF) 表示程序 以 CTRL  +Z  （CTRL  +D）结束这个循环输入。 CTRL  +Z ：DOS，Windows  CTRL  +D：Unix，linux 等系统

引用 5 楼 fly_dragon_fly 的回复:scanf成功返回读入参数的个数,失败返回EOF 赞同~ while (scanf("%d", &n) != EOF)只有在输入即scanf返回错误时才能退出循环。scanf的返回值是输入的数据的个数，这个scanf若返回成功则会返回1；

scanf成功返回读入参数的个数,失败返回EOF

一个是单个输入，一个是循环多个输入，后一个通过EOF来判断是否已全部读完

引用 2 楼 赵4老师的回复:scanf, wscanf Read formatted data from the standard input stream.  int scanf( const char *format [,argument]... );  int wscanf( const wchar_t *format [,argument]... );  Routine Required Header Compatibility  scanf <stdio.h> ANSI, Win 95, Win NT  wscanf <stdio.h> or <wchar.h> ANSI, Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  Both scanf and wscanf return the number of fields successfully converted and assigned; the return value does not include fields that were read but not assigned. A return value of 0 indicates that no fields were assigned. The return value is EOF for an error or if the end-of-file character or the end-of-string character is encountered in the first attempt to read a character.  Parameters  format  Format control string  argument  Optional arguments  Remarks  The scanf function reads data from the standard input stream stdin and writes the data into the location given by argument. Each argument must be a pointer to a variable of a type that corresponds to a type specifier in format. If copying takes place between strings that overlap, the behavior is undefined.  wscanf is a wide-character version of scanf; the format argument to wscanf is a wide-character string. wscanf and scanf behave identically otherwise.   Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tscanf scanf scanf wscanf    For more information, see Format Specification Fields — scanf functions and wscanf Functions.   Example   /* SCANF.C: This program uses the scanf and wscanf functions   * to read formatted input.   */  #include <stdio.h>  void main( void ) {    int   i, result;    float fp;    char  c, s[81];    wchar_t wc, ws[81];     printf( "\n\nEnter an int, a float, two chars and two strings\n");     result = scanf( "%d %f %c %C %s %S", &i, &fp, &c, &wc, s, ws );    printf( "\nThe number of fields input is %d\n", result );    printf( "The contents are: %d %f %c %C %s %S\n", i, fp, c, wc, s, ws);     wprintf( L"\n\nEnter an int, a float, two chars and two strings\n");     result = wscanf( L"%d %f %hc %lc %S %ls", &i, &fp, &c, &wc, s, ws );    wprintf( L"\nThe number of fields input is %d\n", result );    wprintf( L"The contents are: %d %f %C %c %hs %s\n", i, fp, c, wc, s, ws); }   Output  Enter an int, a float, two chars and two strings 71 98.6 h z Byte characters  The number of fields input is 6 The contents are: 71 98.599998 h z Byte characters  Enter an int, a float, two chars and two strings 36 92.3 y n Wide characters  The number of fields input is 6 The contents are: 456 92.300003 y n Wide characters   Floating-Point Support Routines, Stream I/O Routines, Locale Routines  See Also   fscanf, printf, sprintf, sscanf 神(๑•ั็ω•็ั๑)看不懂……

一个一次，一个循环的吧


Question: linux下fwrite向移动硬盘写大数据，为什么速度还不到3M/S

每次写的块更大点，不行了就用映射写啊。

无profiler不要谈效率！！尤其在这个云计算、虚拟机、模拟器、CUDA、多核 、多级cache、指令流水线、多种存储介质、……满天飞的时代！

原来移动硬盘是NTFS格式的，格式化成FAT32之后，写速度就跟上了。问题算是解决了，可是为什么在LINUX下NTFS比FAT32还慢

引用 3 楼 user-3 的回复:我搬了你的代码, 往2.0接口的u盘里写数据, 速度有5.0mb以上 看问题是不是出在 receive_queue 这个函数里 我没有写这行代码 int receive_queue(ec_queue_t queue, ec_u32 timeout, ec_u8 *buf) { 	queue_s *q = (queue_s *)queue; 	ec_u8 *p; 	ec_os_wait_sem(&q->sem, EC_WAIT); 	if (buf) 	{ 		memcpy(buf, q->element_buf + (q->read_pos % q->element_count) * q->element_size, q->element_size); 		q->read_pos++; 		return 1; 	} 	return EC_OK; } 应该不是receive queue的问题，信号量那里等待可以忽略不计，前端数据传输速率有6MB/S，我也做过测试，就是不在这个函数做任何相关的写操作，结果就很快了

在文件大小相同的前提下：  读刚读过的文件比头次读没读过的文件快  读转速快的硬盘上的文件比读转速慢的硬盘上的文件快  读没有磁盘碎片的文件比读有磁盘碎片的文件快  读文件不处理比边读边处理快  单线程从头到尾一次读文件比多线程分别读文件各部分快（非固态硬盘上）  读固态硬盘上的文件比读普通硬盘上的文件快  写类似。

具体的每次写是fwrite(data_buffer+13,4063,1,fp);


Question: 求助，vs2010怎么对C代码创建单元测试

单元测试是鸡肋。 详细的日志记录才靠谱。


Question: 我用gcc打开vc6.0编的这个程序怎么输出错误？

引用 6 楼 Edwed_LI 的回复:我改了==了的，还是错的输出的是无限的数字  完全不懂你想干嘛。

我改了==了的，还是错的输出的是无限的数字

if(a=b)

什么样的错误？

结尾少个｝ if（a=b）应该能编译通过

刚学编程最容易犯的错，==和=，；和; 等等

引用 2 楼 iyomumx 的回复:if(a=b) +1


Question: 关于结构体指针段错误的问题

strcpy字符串复制。。。。p没有内存空间，复制不进去。。

p本来没有存储空间 a->p = "heo";  是将p指向  字符串常量 “heo”的内存空间，是正确的  strcpy(a->p, "hello"); 是将“hello”  赋值到p指向的内存空间，应为没有，所以出错  你可以改为 int iLen = sizeof("hello");  a->p = new char[iLen]; memset(a->p,0,iLen) ; strcpy(a->p, "hello"); printf("%s\n", a->p); if(a->p != NULL) { delete [] a->p; a->p = NULL; } return;

你用动态内存分配函数定义了一个node指针a，但是没有赋予初值，所以a指针是没有指向任何实际的内存空间。如果用strcpy(a->p, "hello")，表示将hello字符串复制至P所指向的内存空间，由于P并没有赋予初值，所以报错。

在strcpy前加一句 a->p=(char*)malloc(sizeof(char*));

p没分配内存。肯定错误。 a->p = "hello"; 是让p指向hello的内存地址。并不是p自己内存块。

lz的过程好像是构造函数的工作

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。

可以给p     malloc一下试试


Question: 关于for循环的用法

楼上正解，读入了多余内容进入输入缓冲区

#include <stdio.h> #include <ctype.h> int main(void) {     char answer = 0;      for(;;) 	{ 	printf("\n是否继续？（y/n）");fflush(stdout);     rewind(stdin); 	scanf("%c",&answer); 	if(tolower(answer) == 'n') 		break; 	else 		printf("\n你输入的是字母Y！");     }  	return 0; }

缓存 输入流的问题

沙发是正解，除了你输出的y之外还读了一个0x0A，也就是LF/NL符号。

输入的应该是y\r\n

引用 7 楼 u010012811 的回复:我看懂了，就是多读了符号进入缓冲区，然后就循环了两遍！赵老师的解决办法很正确。。。

前段时间也遇到这个问题，学习了~~

这段程序的运作机制是怎样的呢？


Question: 这道c prime plus上的练习为什么我这样做不行而且答案根本不是题目所说的那样

ch在for循环一直没改变啊，你i无论怎么加，ch一开始就是字母那你的for循环中，ch一直都是字母。死循环

我改了int依然没什么变化 还是不行啊

引用 5 楼 sholber 的回复:getchar的返回类型是int，不是char，否则有可能得不到EOF。别的我没看。 顶

都没说到点子上啊 感觉 有没有人能说出我为什么错了

Linux：Ctrl+D Windows：Enter、Ctrl+Z、Enter

int main(void) { 	char  ch; 	int i, sum = 0, count = 0; 	float avg; 	ch = getchar(); 	while (ch != EOF) 	{ 		if ((!ispunct(ch)) && ch != '\n') 			sum++;  		ch = getchar(); 		if (ch == '\n' && (!ispunct(ch))) 			count++; 	} 	avg = ((float)sum) / count; 	printf("%f", avg); 	return 0; }

for语句怎么能够退出?


Question: 一个关于参数类型的问题求教一下高手

谢谢大家，我想只有这样解释。

char类型本身表示的数在0-127之间，是可以直接赋值给int类型的

char类型的实参会自动转换为其对应的asc码


Question: scanf读取字符的问题

修改如下：  int main(void) { 	int i, j; 	i = 0; 	int arr[100]; 	while (i != 100 && 1 == scanf("%d", arr + i)) i++; 	for (j = 0; j < i; j++) 		printf("%d ", arr[j]); 	return 0; } //1 2 3^z //1 2 3

引用 6 楼 Falleyes 的回复:因为你输入的是"1 2 3\n"，当你首先getchar()的时候，'1'这个字符就已经被读走了。到了scanf读取，缓冲区中只有" 2 3\n“，注意第一个是空格。scanf会"跳过"空格读取数字，把2读走了。缓冲区中剩余的是" 3\n”，你getchar()把空格读走，scanf把3读走，再getchar读取最后的'\n‘，就结束啦。 我是反过来的，先读取数字，然后读取一个字符当执行while(getchar()!='\n')这条语句时，我还没有输入1 2 3 \n呢，我有点搞不懂scanf了，我的理解是我从键盘输入1 2 3 \n后，arr[0]获取到1，然后getchar获取到2，然后a[1]获取到3.。。。

引用 2 楼 user-7 的回复:getchar()会读取一个字符的，你定义的整型数组为固定长度，所以该程序不合适存放任意个整型数+1

while(scanf(“%d”,arr+i) == 1) {     i++;     if (getchar == '\n')         break; } 手机打的。

不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) {  if (条件1) break;  //...  if (条件2) continue;  //...  if (条件3) return;  //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) {  a=fgetc(f);  //...  b=fgetc(f);//可能此时已经feof了！  //... } 而这样写就没有问题： while (1) {  a=fgetc(f);  if (feof(f)) break;  //...  b=fgetc(f);  if (feof(f)) break;  //... } 类似的例子还可以举很多。

getchar()也是从终端获取数据的。你是不是把这个给忘了呢？

仅供参考：#include <stdio.h> int main() {     int a,b,n,v,r,k;     char buf[80];     char *p;      k=0;     r=EOF;     while (1) {         if (EOF==r) {             fgets(buf,80,stdin);             p=buf;         }         while (1) {             r=sscanf(p,"%d%n",&v,&n);             if (1==r) {k++;break;}             if (EOF==r) break;             p++;         }         if (EOF==r) continue;         p+=n;         if (1==k) a=v;         if (2==k) {             b=v;             break;         }     }     printf("%d,%d\n",a,b);     return 0; }

引用 3 楼 Falleyes 的回复:#include <stdio.h>  //不考虑非法输入 int main(){     int i=0,j;     int arr[100];      do{         scanf("%d",arr+i);         ++i;     }while(getchar()!='\n');      for(j=0;j<i;++j)         printf("%d ",*(arr+j)); } 任意长度的，需要动态分配空间那你的getchar()为什么没有影响?

while循环本来就getchar一次，你还要scanf，那相当于读一个字符再读一个整型


Question: 关于scanf中*的用法

请判断scanf函数的返回值。

int		a, b; scanf("%2d%*2d%2d", &a, &b);

%d%*d%d可以把中间的数字忽略


Question: 关于c语言的

自己搜printf的用法

输出只是会在有诸如%d的地方替换为对应的数据，其他原样输出

原样输出呗，没什么特别

加号：+，会原样打印，没什么特别


Question: 求助关于长整型数据转换整型数据的问题

把 int 换成 short 就能看到效果了。早期的 DOS short 和 int 范围一样大。

short是双字节，long是4字节，而int跟系统有关。 早期的16位系统时，int是跟short一样是双字节；而在32位系统里int跟long是一样的4字节，即在现在主流的32位系统里，int和long没区别。

int型一般是4个字节存储，你的书上用的int型是两字节的。系统关系，你明白过大的数据转换会出现高位截断就好。 按照你的系统整型大小，应该这样尝试：#include<stdio.h> int main(){     long a=0xff00f00fff00f00f;     int b;     char c;     b=a;     c=b;     printf("b=%x,c=%x",b,c);  //ff00f00f }

因为你用的系统是容纳这么大数值的


Question: R/G/B三个值递增递减变化

void main() { 	int* a = new int[3];// 分别表示 R, G, B 	int i = 0;  	a[0] = 255; 	a[1] = 1; 	a[2] = 1;  	// 1 	for (i = 0; i < 255; i++) 	{ 		a[0]--; 		a[1]++; 	} 	printf("R: %d G: %d B:%d\n", a[0], a[1], a[2]);  	// 2 	for (i = 0; i < 255; i++) 	{ 		a[1]--; 		a[2]++; 	} 	printf("R: %d G: %d B:%d\n", a[0], a[1], a[2]);  	//3 	for (i = 0; i < 255; i++) 	{ 		a[0]++; 		a[2]--; 	} 	printf("R: %d G: %d B:%d\n", a[0], a[1], a[2]);  	delete[]a; }

你这个程序RGB值不是同时变化的吧？？？？？ for(R=255;R>=1;R--)         printf("%d ",R);     printf("\n");     printf("G值得变化\n");     for(G=1;G<=255;G++)         printf("%d ",G);     printf("\n");     printf("B的值为%d\n",B); 比如这里是R的值变为1，G的值才往上加，加到255，接着才输出B的值不变？？？？？？我要同时变化的怎么写，请教。。。

我好好研究研究。。。先谢谢大哥了！

/* R/G/B三个值：首先R从255递减到1，G从1递增到255，B保持不变；                            再R保持不变，G从255递减到1，B从1递增到255；                            最后R从1递增到255，G保持不变，B从255递减到1； 我要输出得到这三组的值，程序怎么写。。。急求! */  #include <stdio.h> int main(void) { 	int R=1; 	int G=1; 	int B = 1; 	printf("R值得变化\n"); 	for(R=255;R>=1;R--) 		printf("%d ",R); 	printf("\n"); 	printf("G值得变化\n"); 	for(G=1;G<=255;G++) 		printf("%d ",G); 	printf("\n"); 	printf("B的值为%d\n",B);  	printf("G值得变化\n"); 	for(G=255;G>=1;G--) 		printf("%d ",G); 	printf("\n"); 	printf("B值得变化\n"); 	for(B=1;B<=255;B++) 		printf("%d ",B); 	printf("\n"); 	printf("R的值为%d\n",R+1); 	printf("R值得变化\n"); 	for(R=1;R<=255;R++) 		printf("%d ",R); 	printf("\n"); 	printf("B值得变化\n"); 	for(B=255;B>=1;B--) 		printf("%d ",B); 	printf("\n"); 	printf("G的值为%d\n",G+1); }


Question: 初学c语言，为什么没有输出数组数据

引用 4 楼 zhao4zhong1 的回复:代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。谢谢

数组的长度应该不能是动态的，真想实现这个的话可以考虑用malloc比如 int main() { 	int n,i; 	int *p1; 	scanf("%d",&n); 	int *p=(int *)malloc(n*sizeof(int)); 	//p1=p; 	for(i=0;i<n;i++) 	{         scanf("%d",p++); 	} 	p--; 	for(i=0;i<n;i++) 		printf("%d ",*p--);//逆序输出 	//printf("%d ",*p1++);正序输出  return 0; }

引用 1 楼 zhao4zhong1 的回复:#include <stdio.h> #include <locale.h> int main(int argc, char const *argv[]) {     int number=0,i;      setlocale(LC_ALL,"chs");     printf("输入的数据个数：");fflush(stdout);     scanf("%d",&number);     if (number<=0) return 1;     int *a=new int[number];     for (i=0;i<number;i++) {         scanf("%d",&a[i]);     }     printf("不能再输入数据\n");     for(i=number-1;i>=0;i--) {         printf("%d ",a[i]);     }     delete[] a;     return 0; } //输入的数据个数：3 //1 2 3 //不能再输入数据 //3 2 1 为什么可以一直输入不是有number<i条件限制吗？？？

for(int i=number-1;i<=0;i--) {


Question: （附翻译）Have Fun with Numbers (20)的问题

应该是用数组存放吧，20位数ll也放不下

引用 12 楼 zhao4zhong1 的回复:仅供参考：#include <stdio.h> #include <string.h> #define MAXLEN 1000 char a1[MAXLEN]; char a2[MAXLEN]; static int v1[MAXLEN]; static int v2[MAXLEN]; static int v3[MAXLEN]; int i,j,n,L,z; void main(void) {     scanf("%d",&n);     for (j=0;j<n;j++) {         scanf("%s%s",a1,a2);          L=strlen(a1);         for (i=0;i<L;i++) v1[i]=a1[L-1-i]-'0';          L=strlen(a2);         for (i=0;i<L;i++) v2[i]=a2[L-1-i]-'0';          for (i=0;i<MAXLEN;i++) v3[i]=v1[i]+v2[i];          for (i=0;i<MAXLEN;i++) {             if (v3[i]>=10) {                 v3[i+1]+=v3[i]/10;                 v3[i]=v3[i]%10;             }         }          printf("Case %d:\n", j+1);         printf("%s + %s = ", a1, a2);          z=0;         for (i=MAXLEN-1;i>=0;i--) {             if (z==0) {                 if (v3[i]!=0) {                     printf("%d",v3[i]);                     z=1;                 }             } else {                 printf("%d",v3[i]);             }         }         if (z==0) printf("0");          printf("\n");     } } //Sample Input //3 //0 0 //1 2 //112233445566778899 998877665544332211 // //Sample Output //Case 1: //0 + 0 = 0 //Case 2: //1 + 2 = 3 //Case 3: //112233445566778899 + 998877665544332211 = 1111111111111111110 非常感谢

引用 9 楼 user-3 的回复:不知道是不是你画蛇添足了, 题目说了输入一个正整数, 不存在负数和0的情况.哦。。原来如此

楼主的OutPut后面应加一句printf("\n");吧。 参考4楼。

内存malloc出来, 用完记得free.

不知道是不是你画蛇添足了, 题目说了输入一个正整数, 不存在负数和0的情况.

引用 5 楼 user-3 的回复: scanf("%lld",&x); 改了%lld输入以后，还考虑了负数和0的问题，之后的结果只有部分通过，不知为何： #include<stdio.h> #include<stdlib.h> int *DevideNumber(long long int );   void OutPut(int,int,int *,int);//输出结果函数，参数：Correct:Yes/NO static int cnt=0;									//Plus_Minus:正/负					 													//int*:分解结果的地址 int main(){											//cnt:位数 	long long  int x,b[20]; 	int i,NotMatch=0,Mark,Plus_Minus,Correct; 	scanf("%lld",&x); 	 	if(x>0){ 		Plus_Minus=1; 	}else if(x==0){ 		Corret=1; 		Plus_Minus=0; 	}else if(x<0){ 		x=-x; 		Plus_Minus=-1; 	} 	 	int *a=DevideNumber(x); 	while(cnt){ 		b[cnt-1]=*a++; 		cnt--; 	} 	x=2*x; 	int* save=a=DevideNumber(x); 	while(1){ 		for(i=0,Mark=0;i<cnt;i++){ 			if(*a==b[i]){	 				b[i]=-1;  				Mark=1;  				NotMatch++; 				a++; 				break; 			} 		} 		if(NotMatch==cnt&&Mark==1||x==0){ 			Correct=1; 			printf("Yes\n"); 			OutPut(Correct,Plus_Minus,a,cnt); 			break; 		}else if(Mark==0){ 			Correct=0; 			printf("No\n"); 			OutPut(Correct,Plus_Minus,save,cnt); 			break; 		} 	} 	 	return 0; } int *DevideNumber(long long int x){ 	int i; 	int* a=(int *)malloc(20*sizeof(int)); 	for(i=0;x!=0;i++){ 		a[i]=x%10; 		x=x/10; 		cnt++; 	} 	return a; }  void OutPut(int Correct,int Plus_Minus,int *p,int cnt){ 	if(Plus_Minus==-1) 		printf("-"); 	else if(Plus_Minus==0) 		printf("0"); 	if(Correct==1){ 		while(cnt--) 			printf("%d",*(p---1)); 	}else if(Correct==0){ 		while(cnt--) 			printf("%d",*(p+cnt)); 	}		 }

引用 5 楼 user-3 的回复: scanf("%lld",&x); 非常感谢！我一直在想为什么每次用%d输入都会溢出

引用 5 楼 user-3 的回复: scanf("%lld",&x);    printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

scanf("%lld",&x);

引用 1 楼 zhao4zhong1 的回复:printf("NO"); 改为 printf("NO\n"); ？不过您的回答倒是提醒了我，可能是输出方面没有仔细读要求。我忽视了Yes的大小写问题，还有No以后仍要求输出数字。非常感谢您的启发！

关于自己是否适合编程的很简单的测试： 在报纸或杂志上随便找一段约1000字的文章，在Word中输入一遍。输完后再参考下面答案：  A里面有10处以上文字或标点错误 B里面没有文字或标点错误并敢为此跟人打赌 C里面没有文字或标点错误并且字体和排版完全与原稿一致 D打印在半透明的纸上和原稿重叠在一起检查一模一样，且自我感觉很有成就感  A不适合编程（理由：打字准确度偏低、粗心大意） B初级程序员（理由：打字准确度很高、认真细致、自信、理解全角半角概念） C高级程序员（理由：在B的基础上理解字体和排版也是电脑打印的重要因素、但相比D还不够偏执、精益求精、结果可验证） D软件项目经理（理由：能针对项目给出令人信服的细致到极点的需求说明和典型测试用例。用户几乎挑不出毛病。专业！）  如果想从A变成B的话，到我的资源http://download.csdn.net/detail/zhao4zhong1/4084259里面下载“适合程序员的键盘练习”

引用 1 楼 zhao4zhong1 的回复:printf("NO"); 改为 printf("NO\n"); ？检测还是没通过，应该不是这样的小问题。所有的检测点都没过，一定是原理哪里错了

printf("NO"); 改为 printf("NO\n"); ？


Question: 一个处理XML的通讯函数，不明白什么意思，请高手解惑

#define  XML_HAS_A   (0X00000001 <<XML_ELEMENT_A   )这个是什么意思？？？   mask=XML_ELEMENT_A   |XML_ELEMENT_C   |XML_ELEMENT_E   |XML_ELEMENT_F     为什么 这样赋值？？   mask    &   (0x00000001 <<i)  实现什么？？？


Question: 这个怎么修改？

引用 2 楼 hexiujun_ 的回复:你的插入函数insert有问题，里面的node换成l，后面的也是一样吧怎么改？改成l？ l没定义的啊

引用 1 楼 user-2 的回复:c++的话，你把函数都放到struct里面  就行了求大神赐教，怎么放？

你的插入函数insert有问题，里面的node换成l，后面的也是一样吧

c++的话，你把函数都放到struct里面  就行了


Question: 求教，在线等！！！！挺急的！！！用C从一个TXT中提取需求数据写入另一个txt文件中

引用 1 楼 zhao4zhong1 的回复:仅供参考：//NAME: essaie bla bla //DIMENSION: 8 //DATA //1  14  15 //2  11  10 //3  6   4 //4  7   13 //5  9   21 //6  19  3 //7  1   5 //8  8   8 //EOF // // 文本文件中可能还含有其他内容，但是需要用到的内容即以上  //比如data.txt: //NAME: essaie bla bla //其它内容 //DIMENSION: 8 //其它内容 //DATA //其它内容 //1  14  15 //其它内容 //2  11  10 //其它内容 //3  6   4 //其它内容 //4  7   13 //其它内容 //5  9   21 //其它内容 //6  19  3 //其它内容 //7  1   5 //其它内容 //8  8   8 //其它内容 //EOF  // 目标是要获取NAME后字串，DIMENSION后数值，以及DATA以下的数值 // 其中NAME就是随便个字句，DIMENSION是城市数量，DATA以下是城市编号，X坐标，Y坐标 // 所有的这些将赋值给一个事先定义好的结构 #include <stdio.h> #include <string.h> #define MAXCPL   80   //每行最大字符数 #define MAXCITY  100  //每组数据中DATA最多项数，DIMENSION的最大值 #define MAXNAMEL 32   //NAME最大长度 struct S {     char NAME[MAXNAMEL+1];     int  DIMENSION;     struct D {         int NO;         int X;         int Y;     } DATA[MAXCITY]; } s; FILE *f; int st,n,i; char ln[MAXCPL]; int main() {     f=fopen("data.txt","r");     if (NULL==f) {         printf("Can not open file data.txt!\n");         return 1;     }     st=0;     n=0;     while (1) {         if (NULL==fgets(ln,MAXCPL,f)) break;         if (st==0) {             if (1==sscanf(ln,"NAME: %32[^\n]",s.NAME)) st=1;         } else if (st==1) {             if (1==sscanf(ln,"DIMENSION: %d",&s.DIMENSION)) st=2;         } else if (st==2) {             if (0==strcmp(ln,"DATA\n")) st=3;         } else if (st==3) {             if (3==sscanf(ln,"%d%d%d",&s.DATA[n].NO,&s.DATA[n].X,&s.DATA[n].Y)) {                 n++;                 if (n>=MAXCITY || n>=s.DIMENSION) break;             }         }     }     fclose(f);     printf("s.NAME=[%s]\n",s.NAME);     printf("s.DIMENSION=%d\n",s.DIMENSION);     for (i=0;i<n;i++) {         printf("s.DATA[%d].NO,X,Y=%d,%d,%d\n",i,s.DATA[i].NO,s.DATA[i].X,s.DATA[i].Y);     }     return 0; } //s.NAME=[essaie bla bla] //s.DIMENSION=8 //s.DATA[0].NO,X,Y=1,14,15 //s.DATA[1].NO,X,Y=2,11,10 //s.DATA[2].NO,X,Y=3,6,4 //s.DATA[3].NO,X,Y=4,7,13 //s.DATA[4].NO,X,Y=5,9,21 //s.DATA[5].NO,X,Y=6,19,3 //s.DATA[6].NO,X,Y=7,1,5 //s.DATA[7].NO,X,Y=8,8,8   可不可以详细解释下 我的水平很渣的

记录的地方写错了 后面四个是第二块芯片的。。。。


Question: c语言小问题，求解答

b没用。len没定义

len没定义是一眼就能看见的，如果你要问sizeof(a)为什么等于4的话，那你可以去看看sizeof（）的用法。这里面它相当于是sizeof(int)的意思。因为int类型占四个字节，所以就等于4

是关于sizeof的问题还是程序有问题，你应该说清楚的

int len = 0;

什么问题? len没有定义 改为 int len

len未定义

问题是不知道问题，所以如何帮你解决问题~

len未定义


Question: c语言中通过加速度求位移怎么实现

撞击时的速度可以通过各种设备检测, 如果加速度是已知的话, 就知道下滑时间t. 初始速度是0. 得到位移s

真的基本都忘记了，楼上的公式，应该是对的

这个问题初中物理有讲  a=(V-V0)/t s=V0t +1/2 a t^2  代码仅仅是现实生活的某种反应而已 会写字的人不一定会写小说 会写代码的人不一定能解决**问题

引用 3 楼 link0007 的回复:[quote=引用 1 楼 link0007 的回复:] t*a = v t*v = l -> t^2 * a = l 时间 * 加速度 = 速度 时间 * 速度 = 位移 故 时间的平方 * 加速度 = 位移[/quote] 时间 * 速度 = 位移  只对于匀速直线运动管用，有加速度了，这个公式就失效了。高一物理

引用 1 楼 link0007 的回复:t*a = v t*v = l -> t^2 * a = l 时间 * 加速度 = 速度 时间 * 速度 = 位移 故 时间的平方 * 加速度 = 位移

可以用C语言表述一下吗？你这个回答不容易被人看得明白！

t*a = v t*v = l -> t^2 * a = l


Question: 请教宏使用的问题

在你需要区分版的地方使用 #include PLATFORM   然后再你的目录下定义 hisi 和 ali 文件。 在这两个文件中定义 不同平台的宏。

编译器的命令行参数设定

引用 10 楼 Saleayas 的回复:#if defined ( PLATFORM_HISI ) // include HISI 代码。 #elif defined ( PLATFORM_ALI ) // include ALI 代码。 #endif  我的错，前面的例子举的太随意了。。。 实际是这样，编译项目代码前会先执行配置，宏是同一个，但是不同的平台，宏的值有差异： 编译前配置hisi #define  PLATFORM  “hisi” 编译前配置ali #define  PLATFORM  “ali”  是这样的，所以我代码里只能比较字符串。配置我还不能改。。。

请教一下，怎样使用字符串去表示不同的编译平台。

引用 1 楼 ant2012 的回复:预编译阶段进行的运算是很有限的 #define COMPARE(str) if(#str == "string")return true; 这是可以的，不过还是得在运行时进行的字符口串比较。楼主为何一定得在预编译中比较呢？ 没辙啊 项目代码有平台差异，还是字符串标识的。还只能在之前的代码基础上修改，有段平台无关的代码不想编译。。。 哎，再想辙了

引用 8 楼 Saleayas 的回复:请教一下，怎样使用字符串去表示不同的编译平台。 不是这个意思，比如说： #define PLATFORM_HISI "hisi" #define PLATFORM_ALI "ali" 这是现有的代码，原本是用在函数里的。在这个基础上，我想在预处理阶段做划分而已。

理解和讨论之前请先学会如何观察！  VC编译选项加/EP /P，重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898

宏只是单纯的展开

是可以比较的，lz没有写宏的名称，所以编译不过，还有宏名和宏体之间要用空格分开

在预编译的时候，就算你使用字符串，这些字符串也是固定的。 那么为什么不使用一个标识来定义这些需要使用字符串的地方呢？ 只有在运行期，字符串才是真正的字符串。

一般这样会把被比较的"字符串"也换做宏: #define AAAA 4512 #define BBBB 4511 #define CCCC 4512  #if (AAAA == BBBB) .... #elif (AAAA == CCCC) .... #endif


Question: 如何编程读取.prnx文件内容

文件I/O咯，指定目录的话，遍历目录下文件名，再比较文件后缀。 不知道这个文件是二进制还是文本，需要有个格式化的标准才能解析内容吧。


Question: 求助 Windows程序设计 free时报错 VS2013

你的代码都编不过吧


Question: C语言题目,新手求解答

int eat_banana(int n) { 	if (1 == n)  		return 1; 	else 	 		return (eat_banana(n - 1)+1) * 2; } int main(void) { 	int n = 10; 	 	fprintf(stdout, "before ten days is %d\n", eat_banana(n)); 	return 0; }  用递归或者迭代都可以的~并且相互之间可以转换；

void decode(char *str){     char *a=str,*b=str;     while(*b){         *a++ =*b++;         if(!*b) break;         *a++ =*b++;         if(!*b) break;         if(isalpha(*b)) *a++ =*b++;         else if(isdigit(*b)) b++;         else assert(false);     }     *a='\0'; } int bal(){     int v =1;     for(int i=10;i;i--)         v =(v+1)*2;     return v; }

1. 指针偏移, 正则判断 2. 递归

1T if(A[3*n]>='A'&&A[3*n]<='Z'||A[3*n]>='a'&&A[3*n]<='z') 保留；  2T 1 4=2*2+1 (4+1)*2=10 ............... 接下来自己推


Question: 指针问题

引用 9 楼 cc_mugiwala 的回复:这种问题，也拿来问，还不如多看看书 都是从新手过来的，何必打击别人！

引用 4 楼 zhao4zhong1 的回复:定义和使用时*的意思不一样。 ++

这种问题，也拿来问，还不如多看看书

4楼的说法还是很好的

楼上的回答有两种： 1，答非所问； 2，荒谬的回答。  朕的回答： printf函数的格式串中有%s时，要求对应的参数是一个指针，p是一个指针。

定义和使用时*的意思不一样。

printf函数中约定与%s对应的应该为地址，并且是指向char型的连续的空间的首地址，要求那一片连续空间中还要有一个‘\0’

支持1楼2楼

%s输出的是p指向的地址开始字符串；怎么会是*p，再说*p也是一个字符即'a'；

字符串数组和整型数组是不太一样的，输出时p代表的是整个字符串，整个字符串是指从首地址到'\0'字符，这是C++规定  如果用*p则只是第一个char字符，这与其他类型指针是一样的  如果想看p的地址，需要写成&p

*p指的是第一个元素a,而p是整个字符串的首地址，(建议用const 修饰指针指向的字符串常量！:const char *p)