Question: 求教一个问题

推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } }

teacher是指针类型，sizeof(teacher) 大小只是4，而不是你分配的内存空间的大小

乱码问题请用二进制查看器一个个字节看吧


Question: 两个数组拼接的一点问题

引用 1 楼 user-3 的回复:unsigned char buf[16]; memcpy(buf ,buf1 ,8); memcpy(buf+8,buf2,8); 这不是字符串，不要用strcat  多谢指导，这个方法可行！多谢！

引用 2 楼 paschen 的回复:那就使用memcpy并指定拷贝的长度  http://en.cppreference.com/w/c/string/byte/memcpy  多谢指导！这个方法非常可行!

unsigned char buf1[8] = { 0x01, 0x04, 0x00, 0x10, 0x00, 0x0C, 0xF1, 0xCA }; 	unsigned char buf2[8] = { 0x02, 0x04, 0x00, 0x10, 0x00, 0x0C, 0xF1, 0xF9 }; 	unsigned char buf[16] {0}; 	memcpy_s(buf, 16, buf1, 8); 	memcpy_s(buf+8, 16, buf2, 8);


Question: 问个简单的C语言问题

引用 2 楼 qq_36496856 的回复:[quote=引用 1 楼 user-1的回复:]这句话的意思是，二元操作符左右两个操作数的计算顺序是不确定的， 比如(++a) * a; 可能先算左边，则结果为(a+1) * (a +1)，如果先算右边，则结果是(a+1) * a.  exception指的是逻辑与&&，逻辑或|| 运算符 一楼之前讲的对，谢谢了。然而例子确实错的,++的优先级要比+高很多，所以编译器肯定会先算++，就是说会是两个a+1[/quote] 你多试几个编译器

引用 1 楼 user-1的回复:这句话的意思是，二元操作符左右两个操作数的计算顺序是不确定的， 比如(++a) * a; 可能先算左边，则结果为(a+1) * (a +1)，如果先算右边，则结果是(a+1) * a.  exception指的是逻辑与&&，逻辑或|| 运算符 一楼之前讲的对，谢谢了。然而例子确实错的,++的优先级要比+高很多，所以编译器肯定会先算++，就是说会是两个a+1

引用 4 楼 qq_36496856 的回复:可以看到无论++a在哪边，结果都是一样的。（第二个例子中用b） 嗯，我的例子确实错了，只有在一个表达式中对一个变量改变超过或等于两次才可能是未定义行为

#include<stdio.h>  int main(){    int a = 1, b = 1;     printf( "%d\n",  ++a  * a); 	printf( "%d\n", b *  ++ b );  	return 0; }不知道为什么在手机上图片上传不了，就上传代码把

可以看到无论++a在哪边，结果都是一样的。（第二个例子中用b）


Question: 新人求解：一个简单程序的问题

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

建议VS，界面相对来说比较美观，用着很舒服，只是比较大。。

引用 3 楼 Maokaitou 的回复://float  weighht; float  weight;拼写错误 +1

初期的话用dev就可以了，操作界面很简洁，很舒服，而且基本可以满足需求，vs的话编译器比dev要好一点，功能也更强大一点，但对电脑资源占用比较多，后期的话再考虑也是可以的。

float  weighht;  改成  float  weight;  如果在WINDOS下，可以用VS2010，不过不支持C99标准

scanf使用也是有限制的

Visual Studio Community

新手推荐dev c++(大神可以忽略)，vc++6.0标准是c89的，可能会造成一些不必要的麻烦，当然vs应该是个更好的选择(编译器比较大，如果只是练习，不是很推荐，里面有很多功能你可能完全用不到)

//float  weighht; float  weight;拼写错误

最好用VS，不要用VC6，VC6太老了 VS各版本下载地址：http://blog.csdn.net/cometnet/article/details/19551125 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

float weight; 写错了


Question: [理论探讨] 你对C做过扩展吗？

引用 6 楼 u010165006 的回复:与其扩展C，不如把C++（高配）当C用（或者加上类）。  尝试过。所以才考虑回来扩展C。

与其扩展C，不如把C++（高配）当C用（或者加上类）。

引用 3 楼 user-2 的回复:扩展的功能包括：  https://msdn.microsoft.com/zh-cn/library/34h23df8(v=vs.110).aspx  项目规模和复杂度提高时，希望在模块独立性、代码简洁性之间有个平衡的东西。

引用 1 楼 u010165006 的回复:目标是什么，接近C++（带类的C）+ STL？  大概是这个方向。还没到STL。

各大编译器都会在语法上进行一些扩展，如VS可以通过/Za来决定是否禁用微软的语言扩展功能：  https://msdn.microsoft.com/query/dev11.query?appId=Dev11IDEF1&l=ZH-CN&k=k(VC.Project.VCCLCompilerTool.DisableLanguageExtensions)&rd=true

目标是什么，接近C++（带类的C）+ STL？


Question: 关于多项式合并函数的一些问题，就是在polyadd函数里感觉有问题，最后显示不出来

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

那就在polyadd中下断点，然后单步跟踪程序运行，观察程序变化情况分析原因

在显示的时候每次都把a链中的东西删除一次，直到删除完


Question: 这是大小端的问题吗

你可以参考一下这里   http://bbs.csdn.net/topics/380256750

郁闷， P和q的地址变了； 大小端指的是不同CPU的设备环境，最起码是两台CPU才能是大小端问题；

不是大端小端  是你算法有问题  123  与  321  你在返回的时候都指向2这个字符   所以相减是0

这里的问题主要是你程序写的不对。 int my_strcmp(char *p, char *q) {    while(*p++ == *q++)    /*判断以后会自增，这个时候p,q都指向第二个字符了*/     {      printf("-------\n");     if(*q == '\0')       {          return 0;       }     }    printf("%d-----\n", *p - *q);        /*由于是指向了第二个字符，所以如果你输入的第二个字符是一样的，那么这里的值就是0了，这也是为什么你后面会显示相等的原因*/   return (*p - *q); }  希采纳！~！~！~！


Question: 小白求助，关于在不同编译器中使用数组的一个简单问题，求大神解答，谢谢

C99标准支持可变长数组，不过VC不支持C99标准，所以不能用

引用 2 楼 qq_36409192 的回复:vc++6.0是c89。。建议楼主用c99标准的编译器。。这样可以避免很多小问题。。  谢谢

引用 1 楼 user-2 的回复:C99标准支持可变长数组，不过VC不支持C99标准，所以不能用  谢谢


Question: #define LEN 10  scanf("%LENs",a) 想达到这样scanf怎么破？

%s输入的是一串不能确定长度的字符串，当遇到空格。回车。tab键的时候，它会自动停止输入。所以你这里才会无效。方便点，你还是用scanf_s吧！

printf 的话可以写成：printf("%.*s",LEN, a);  scanf不能确定长度

引用 8 楼 u010165006 的回复:#define STRLEN(X) #X 为什么x前面要用#号呢？为什么最后展开成 "10"会带引号？ 直接scanf("%" #LEN "s",a); 为什么不可以？ 还有三句#define的顺序有关系吗？ 这个#是宏的一个特殊用法 不清楚 百度 C语言宏 # https://www.baidu.com/s?ie=UTF-8&wd=C%E8%AF%AD%E8%A8%80%E5%AE%8F+%23 #LEN什么都不是  #得用在宏里面才有特殊效果 顺序无关

引用 6 楼 user-3 的回复:[quote=引用 5 楼 u010165006 的回复:] [quote=引用 4 楼 user-3 的回复:] #define LEN 10   #define STRLEN(X) #X #define _LEN(X) STRLEN(X) 	char a[LEN+1]; 	scanf("%" _LEN(LEN) "s",a); 	puts(a);   确实可以，不过为什么要这么定义呢？ 直接#define _LEN(X) #x 为什么不行？或者直接写一句scanf？[/quote] 直接#define _LEN(X) #x  那么 _LEN(LEN) 展开是 "LEN" #define STRLEN(X) #X #define _LEN(X) STRLEN(X) 展开_LEN(LEN) 就变成 STRLEN(10) 最后是 "10"[/quote]  #define STRLEN(X) #X 为什么x前面要用#号呢？为什么最后展开成 "10"会带引号？ 直接scanf("%" #LEN "s",a); 为什么不可以？ 还有三句#define的顺序有关系吗？

引用 5 楼 u010165006 的回复:[quote=引用 4 楼 user-3 的回复:] #define LEN 10   #define STRLEN(X) #X #define _LEN(X) STRLEN(X) 	char a[LEN+1]; 	scanf("%" _LEN(LEN) "s",a); 	puts(a);   确实可以，不过为什么要这么定义呢？ 直接#define _LEN(X) #x 为什么不行？或者直接写一句scanf？[/quote] 直接一句 scanf("%LENs",a);  字符串内部的字符就只是字符而已 不是宏 不会进行展开 你这样写是 "%L" 而格式控制符里面 并没有%L的解析

引用 5 楼 u010165006 的回复:[quote=引用 4 楼 user-3 的回复:] #define LEN 10   #define STRLEN(X) #X #define _LEN(X) STRLEN(X) 	char a[LEN+1]; 	scanf("%" _LEN(LEN) "s",a); 	puts(a);   确实可以，不过为什么要这么定义呢？ 直接#define _LEN(X) #x 为什么不行？或者直接写一句scanf？[/quote] 直接#define _LEN(X) #x  那么 _LEN(LEN) 展开是 "LEN" #define STRLEN(X) #X #define _LEN(X) STRLEN(X) 展开_LEN(LEN) 就变成 STRLEN(10) 最后是 "10"

引用 4 楼 user-3 的回复:#define LEN 10   #define STRLEN(X) #X #define _LEN(X) STRLEN(X) 	char a[LEN+1]; 	scanf("%" _LEN(LEN) "s",a); 	puts(a);   确实可以，不过为什么要这么定义呢？ 直接#define _LEN(X) #x 为什么不行？或者直接写一句scanf？

char a[LEN+1];


Question: 数据结构定长顺序存储表示串的定位（index）操作

if( i=0)  改成  if( i==0)  if(S[i]=T[j]){  改成  if(S[i]==T[j]){   Index函数与StrAssign函数不是所有情况都会有返回值

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

我改了一下（改了三个地方，不一定正确），你试试 int Index(SString S, SString T, int pos) {     int j=1;     int i=pos;      while(i<=S[0] && j<=T[0]){         if(S[i] == T[j]){             i++;             j++;         }else{             i = ++pos;             j=1;         }     }      if(j>T[0])         return pos;      else          return 0; }


Question: 望大神告诉扑克牌问题的思路

小时候玩过这个，倒背如流。

已采纳，谢谢啦

完整的版本在这里，可以输入N的大小，用C的动态分配数组： http://blog.163.com/tab_98/blog/static/11924097201692314754324/

引用 1 楼 u010165006 的回复:小时候玩过这个，倒背如流。  不过忘了是13张还是52张。  // Poker.cpp : Defines the entry point for the console application. //  #include "stdafx.h" #include <iostream> using namespace std;  struct Node { 	int no; 	int value; 	bool hasValue; };  int _tmain(int argc, _TCHAR* argv[]) { 	Node poker[53];  	for(int i=1;i<=52;i++) 	{ 		poker[i].no=i; 		poker[i].hasValue=false; 	}  	for(int i=0,value=1,count=0;count<52;) 	{ 		for(int j=0;j<2;j++) 		{ 			do 			{ 				i++;   				if(i>52) 					i=1; 			}while(poker[i].hasValue); 		} 		poker[i].value=value++; 		poker[i].hasValue=true; 		count++; 	}  	for(int i=1;i<=52;i++) 		cout<<poker[i].value<<"  "; 	cout<<endl;  	return 0; }    运行结果： 46  1  27  2  40  3  28  4  51  5  29  6  41  7  30  8  47  9  31  10  42  11  32  12  50  13  33  14  43  15  34  16  48  17  35  18  44  19  36  20  52  21  37  22  45  23  38  24  49  25  39  26


Question: 求助，用c语言写的数据结构作业

谢谢楼上和楼上上，换了个思路最后还是写出来了

if(op->next=NULL)  改成  if(op->next==NULL)


Question: C语言指针问题

引用 3 楼 cqs20141005225115 的回复:[quote=引用 2 楼 paschen 的回复:] *(p2 + i), 本来就等于 p2[i]，含义是一样的  你的p是指向数组的指针，解引后得到的是数组，数组会退化为指针（你例子中为int*指针），即*(p2 + i)输出退化为int*指针，而p2 + i 为数组的地址，这两个的值是相等的，但指针的类型是不同的  谢谢大神，终于理解了，不过我还有个问题，ruguo 我没给p2赋值，p2会是0，就是上面所有输出结果减1，代码是放在main里面的，地址为什么会自动初始化为0呢[/quote]  全局变量或静态变量会初始化为0，局部变量是之前栈上的随机值

*(p+i),p[i]和p+i都是指向二维数组每行的首列地址，区别在于，*(p+i)和p[i]指向的是那一行第一个元素的地址，p+i指向的是那一行那一列的首地址。但他们的值都是一样的。

引用 6 楼 cqs20141005225115 的回复:[quote=引用 5 楼 fefe82 的回复:] [quote=引用 3 楼 cqs20141005225115 的回复:] [quote=引用 2 楼 paschen 的回复:] *(p2 + i), 本来就等于 p2[i]，含义是一样的  你的p是指向数组的指针，解引后得到的是数组，数组会退化为指针（你例子中为int*指针），即*(p2 + i)输出退化为int*指针，而p2 + i 为数组的地址，这两个的值是相等的，但指针的类型是不同的  谢谢大神，终于理解了，不过我还有个问题，ruguo 我没给p2赋值，p2会是0，就是上面所有输出结果减1，代码是放在main里面的，地址为什么会自动初始化为0呢[/quote]  全局变量初始化为0 局部变量是随机值。[/quote]   但是它并没有是随机值，每次运行都自动赋值0，怎么回事呢[/quote]  0也是合理的随机值啊 ....

引用 5 楼 fefe82 的回复:[quote=引用 3 楼 cqs20141005225115 的回复:] [quote=引用 2 楼 paschen 的回复:] *(p2 + i), 本来就等于 p2[i]，含义是一样的  你的p是指向数组的指针，解引后得到的是数组，数组会退化为指针（你例子中为int*指针），即*(p2 + i)输出退化为int*指针，而p2 + i 为数组的地址，这两个的值是相等的，但指针的类型是不同的  谢谢大神，终于理解了，不过我还有个问题，ruguo 我没给p2赋值，p2会是0，就是上面所有输出结果减1，代码是放在main里面的，地址为什么会自动初始化为0呢[/quote]  全局变量初始化为0 局部变量是随机值。[/quote]   但是它并没有是随机值，每次运行都自动赋值0，怎么回事呢

引用 3 楼 cqs20141005225115 的回复:[quote=引用 2 楼 paschen 的回复:] *(p2 + i), 本来就等于 p2[i]，含义是一样的  你的p是指向数组的指针，解引后得到的是数组，数组会退化为指针（你例子中为int*指针），即*(p2 + i)输出退化为int*指针，而p2 + i 为数组的地址，这两个的值是相等的，但指针的类型是不同的  谢谢大神，终于理解了，不过我还有个问题，ruguo 我没给p2赋值，p2会是0，就是上面所有输出结果减1，代码是放在main里面的，地址为什么会自动初始化为0呢[/quote]  全局变量初始化为0 局部变量是随机值。

引用 1 楼 qq407311984 的回复:p2指向的数组第二个地址，你怎么加i只是让指针后移相同位  谢谢

引用 2 楼 paschen 的回复:*(p2 + i), 本来就等于 p2[i]，含义是一样的  你的p是指向数组的指针，解引后得到的是数组，数组会退化为指针（你例子中为int*指针），即*(p2 + i)输出退化为int*指针，而p2 + i 为数组的地址，这两个的值是相等的，但指针的类型是不同的  谢谢大神，终于理解了，不过我还有个问题，ruguo 我没给p2赋值，p2会是0，就是上面所有输出结果减1，代码是放在main里面的，地址为什么会自动初始化为0呢

p2指向的数组第二个地址，你怎么加i只是让指针后移相同位


Question: Xcode环境，报错如下


Question: C语言char类型的二维数组问题

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

引用 2 楼 paschen的回复:宏定义不需要用分号结尾，否则替换时会将分号换入导致错误 sorry,粗心了，程序猿需要胆大心细……

理解和讨论之前请先学会如何观察！  VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898

#define max_rows    20; #define max_colunms 20;  换成更好 const int  max_rows = 20; const int max_colunms = 20;

宏定义那里有问题，是不需要加分号的。

宏定义、宏定义、宏定义 去分号、去分号、去分号

多了分号 http://blog.csdn.net/sinat_30415255/article/details/50596355

20后的两个分号，多了

#define max_rows    20 #define max_colunms 20

宏定义不需要用分号结尾，否则替换时会将分号换入导致错误

理论上来说是可以的。。可能是编译器的问题。。而且你这里主函数是int形，所以得有返回值。


Question: 结构体中的指针变量申请空间问题

我想提问，如果我想把name声明为指针，我该如何解决这个问题；还有就是这两种做法的区别在哪里，我声明为指针的做法错误在哪里。   小白解答一下， 当你声明为数组时，char name[20];这句话以为着你在内存中已经为name这个指针划分了20个char的内存空间； 如果你想要用char * name;那么你可以在结构定义中再写一个int max_size；当你初始化的时候记得还要为name申请max_size大小的内存，这个需要你手动malloc，stack->name=(char*)malloc(sizeof(char)*stack->maxsize));//stack是这个结构的指针，这样你就可以实现动态申请内存大小了，不会浪费

引用 6 楼 u011028771 的回复:[quote=引用 3 楼 paschen 的回复:] char *name[20];  改成 char *name; 粘程序粘错了，我声明的是char *name;但是出现了如题的问题[/quote]  如果是指针，对象复制、赋值需要深拷贝，默认的是浅拷贝，也就是只是复制指针的值，并没重新申请一片内存，而如果是数组的话，会复制整个数组

如果定义的是char*name，那么添加新节点时需要新开辟一段空间，比如malloc（20*sizeof(char))，而不只是简单的开辟结构体空间，然后直接把传进来的结构体付给他那么简单，那样的话，你结构体里的name指针只是指向了一个临时参数里的空间，函数结束就无效了，所以出现了错误。 如果你定义的是字符数组char name[20]那就没有什么问题了

楼上解释正确。简单说就是， 每个节点的name都指向最初malloc的那段空间。

哥们，出现你上面那个结果是因为深拷贝的问题导致得     1.你对student.name在main()中申请了一片空间，注意只是一片空间，当你第一次赋值之后，你传入了函数（进行的是值传递，也就是说只是传了student.name指针的副本，没有在单独开辟空间出来），此时你直接赋值给另一个结构体（由于你结构体没有等号操作符重载，因此采用默认的，只进行值得赋值，因此就只是student.name的指针本身的值付给它，并没有开辟另外的空间，暂记这个指针ptr，指向A空间）。当你第二次传递进来的时候一样的传递ptr指针，而同样进行值赋值没创建空间。因此你第一次与第二次传递的都是ptr指针，指向的空间都是A，当你第二次重新赋值了A空间后，那么第一次同样也是指向了这个空间，那么就是第一次、第二次指向同样空间 ，里面的值当然以第二次为准，所以打印结果相同      2.基本数据类型这不一样，没有深拷贝，直接赋值即可，显示结果就不同了      3.你将char* 换成char数组当然就可以了，因为char数组初始化结构体时就会申请出空间，那么两次就是不同的空间了，就可以保存不同的值了      嘿嘿！不好意，第一次在这上面回答问题，说的不清楚，还望谅解

引用 3 楼 paschen 的回复:char *name[20];  改成 char *name; 粘程序粘错了，我声明的是char *name;但是出现了如题的问题

引用 1 楼 eastfriendwu 的回复:你声明的是指针数组了，改成char* name即可。 我粘程序是粘错了，我声明的是char *name;但是出现了提问中的问题

创建链表的 (*L)->next = (*L); (*L)->prior = (*L); return OK;  就是几句废话 等于空不行吗？ (*L)->next =NULL; (*L)->prior =NULL; 这个是链表的头结点，空的循环链表，头结点不应该是自己指向自己吗？  char *name[20];  改成 char *name; 我贴程序是粘错了，我声明的是char *name;但是出现了我提问时的错误！

char *name[20];  改成 char *name;

创建链表的 (*L)->next = (*L); (*L)->prior = (*L); return OK;  就是几句废话 等于空不行吗？ (*L)->next =NULL; (*L)->prior =NULL;  自己等于自己，又要二次分配Name 你丫就不当心重复分配

你声明的是指针数组了，改成char* name即可。


Question: 我想设计一条简单的C语言程序，用于识别输入的两位数所对应的身份

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

谢谢楼上两位大神，可是无错误运行以后无法输出任何有效信息，就是填数字空格以后程序就显示结束了……

检查你是否使用了中文下的符号  switch那一行最前面是不是有个点

右括号用了全角的了


Question: 关于用fread读函数的问题

sizeof指针的大小只是4  你需要写入与读取指针指向的数据  而不是指针本身


Question: 数组指针之间的运算问题

理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  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对应的汇编并单步执行观察相应内存和寄存器变化。）  想要从本质上理解C指针，必须学习汇编以及C和汇编的对应关系。 从汇编的角度理解和学习C语言的指针，原本看似复杂的东西就会变得非常简单！ 指针即地址。“地址又是啥？”“只能从汇编语言和计算机组成原理的角度去解释了。” 但我又不得不承认：  有那么些人喜欢或者适合用“先具体再抽象”的方法学习和理解复杂事物；  而另一些人喜欢或者适合用“先抽象再具体”的方法学习和理解复杂事物。 而我本人属前者。  不要企图依赖输出指针相关表达式...的值【比如printf("%p\n",...);或者cout<<...】来理解指针的本质， 而要依赖调试时的反汇编窗口中的C/C++代码【比如void *p=(void *)(...);】及其对应汇编指令以及内存窗口中的内存地址和内存值来理解指针的本质。  这辈子不看内存地址和内存值；只画链表、指针示意图，画堆栈示意图，画各种示意图，甚至自己没画过而只看过书上的图……能从本质上理解指针、理解函数参数传递吗？本人深表怀疑！ 这辈子不种麦不收麦不将麦粒拿去磨面；只吃馒头、吃面条、吃面包、……甚至从没看过别人怎么蒸馒头，压面条，烤面包，……能从本质上理解面粉、理解面食吗？本人深表怀疑！！  提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！  不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  有人说一套做一套，你相信他说的还是相信他做的？ 其实严格来说这个世界上古往今来所有人都是说一套做一套，不是吗？  不要写连自己也预测不了结果的代码！  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  十字链表交换任意两个节点C源代码（C指针应用终极挑战）http://download.csdn.net/detail/zhao4zhong1/5532495

*p-*q是可以计算的，因为他们都表示指针所指向的地址里的内容。望采纳！

引用 7 楼 fefe82的回复:p-q 不可以。p q 类型不同直接是编译错误。类型相同的时候是一个未定义行为。 但是类型相同时，这东西编译期运行期都不好检查，一般编译器都不管。多数编译器都能有一个结果。 未定义行为，编译器没有义务进行任何编译期或运行期检查，但是程序可能得到任何结果。  =================================== *p - *q ： 首先澄清一个概念，指向数组的指针与指向数组元素的指针是完全不同的两个概念。  p q 如果是指向两个数组的指针，那么 *p 与 *q 就都是数组。他们在参与运算时，会转化为指向各自第一个元素的指针。如果数组类型不同，无法相减；类型相同，同上是未定义行为。  如果 p q 分别为指向两个数组元素的指针，那么 *p  *q 就分别是两个数组的某一个元素。能否相减要看数组是啥类型的。 都是整型数组时一般没有问题（注意有符号整型溢出同样是未定义行为） 都是指针数组时，一般要是同类型指针才能运算，只有两个指针指向同一个数组的元素时结果才是有定义的。 ....... 怎么区分指向数组的指针和指向数组元素的指针呢！

例如： int a[10]={0};  int *p =a; a表示该数组的首个元素的地址；&a表示该数组的地址。 数组a的元素个数=sizeof（a）/sizeof(a[0])。 sizeof（a）计算数组a占的字节数，sizeof(a[0])计算每个元素占的字节数。

如果你一个数组类型定义为char一个数组定义为int就不能计算，必须类型一致

引用 3 楼 paschen的回复:1、可以进行p-q的运算，两个指针相减返回的是指向类型元素的个数  2、*p - *q能不能运算取决于*p与*q这种类型能不能进行相减运算 能具体解释下第一个吗？

p-q我在书上看到的是只能在同一数组中才合法啊！！！

假设有2个数组a[]和b[]， 并且指针p=a;q=b; 那么p是数组a的起始地址，相当于p=&a[0]，q是数组b的起始地址，相当于q=&b[0] *p-*q是可以计算的，相当于a[0]-b[0] PS：理论上p-q也是可以算的，结果是它们地址的差


Question: 错误：expected ‘)’ before ‘Book’

是自己理解错了，以为makefile的子函数不需要添加头文件，在每个子函数的开头添加头文件就好了

偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。

就是在第一行就报错了 void add(BOOK Book),这是第一行的代码

我用的makefile管理的代码，功能子目录里的函数开头不需要include包含头文件的

引用 2 楼 Echo_Ana 的回复:就是在第一行就报错了 void add(BOOK Book),这是第一行的代码  第一行？前面没个 #include ?

没有代码帮不了你。 首先你要include上面定义的结构体吧？

看看编译器报错的行号，是不是周围代码缺少了一些字符? 上面的结构体定义没有问题。


Question: c语言怎么将字符数组转换成整型

字符数组a[i]="\u5e74\u5934" —————————————— 不明白楼主说的a[i]指什么？

我是这样弄得：如果有一个char c = ‘0’那么其ascll码 = 48   即int a = c；那么c = 48；写一个函数使a = c - 48；即可转换


Question: 一个关于c语言的字符串问题，大一生，求解答

用我这个吧。简单 #include "stdafx.h" int main() { 	char str[1000]="|Hallo World!|"; 	char buf[1000]; 	int n=strlen(str); 	int j=0; 	for(int i=0;i<n;i++) 	{ 		if(str[i]!='|') 		{ 			buf[j]=str[i]; 			j++; 		} 	} 	buf[j]='\0'; 	printf("%s\n",buf); }

char s[]=" |Hallo World!|"; char str[100]; sscanf(s,"|%99[^|]|",str);

没有环境，先这样写了

引用 1 楼 user-6的回复:那自己来提取也很简单：   void main() { 	int i; 	char* p; 	char str[1000] = "|Hallo World!|"; 	p = str; 	while (*p++!='|'); 	for (i = strlen(p); p[i] !='|';--i); 	p[i] = '\0';  	//此时p指向的字符串即为你要的  	printf("%s", p); }  人家大一新生，你这代码6

char str[10000] //10000是随便设的，首先你的10000设的太大了

使用getchar()函数来一个字符一个字符地读取就可以了。读入的字符，保存到数组中。 示例代码如下： #include <conio.h> #define INPUT_MAX_COUNT	1000 int  main(){ 	char szInputChars[INPUT_MAX_COUNT]; 	char ch; 	int nInputCount = 0; 	while(1){ 		ch = getchar(); 		if (ch == '\n') 		{ 			break;//按了回车按就退出输入 		} 		else if (ch == '|') 		{ 			//根据实际，处理这个符号 		} 		else 		{ 			//保存输入的字符 			szInputChars[nInputCount++] = ch; 			if (nInputCount >= INPUT_MAX_COUNT) 			{ 				szInputChars[nInputCount - 1] = 0; 				break; 			} 		} 	} 	if (nInputCount < INPUT_MAX_COUNT) 	{ 		szInputChars[nInputCount] = 0; 	} 	printf("输入的字符串是：\n%s",szInputChars); 	getch(); 	return 0; }


Question: c语言中 关于字符数组和字符串的区别

引用 3 楼 lxq0228 的回复:字符串： char a="abc";等价于char a[]={'a','b','c','\0'};当然后者也是字符数组，字符串的读取遇到零会自动停止读取，“abc”是常量字符串，里面的内容不能更改，而后者可以。多看看书，所有的学习，基础很重要！自勉！  写错了吧  char a ="abc" 应该是 char *a="abc" 吧

c里边的所谓的字符串就是一连串的字符，也可以理解为数组里边保存的一连串的字符（char）类型的数据，当然作为合法的字符串是需要有结束符'\0'的。也可以有这样的形式，定义一个字符指针，比如const char*p="hello"这样的形式表示字符指针p指向这个常量字符串“hello”的首字符的位置，而这个常量字符串是隐含结束符'\0'的。当你定义一个char数组准备保存字符串的时候，需要为结束符预留一个空间，比如char a[10]，这个数组最多只能保存9个有效字符，如果你写入超过9个有效字符，要么程序会出错（越界访问），要么就是无法正确显示这个字符串（因为在合法界限内，没有结束符）

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

C没有字符串这种类型，只要字符数组最后是以\0结尾的，就算是C的字符串  char a[10]={'x','a','a','b'}  后面的字符将全会用0填充，所以是以\0结尾的  同理char a[5]={'a','b'}也是


Question: 初学，for的问题

去掉分号，for后面的

for(i=1 ; i<=n ; i=i+1 );   后面多了分号，有分号会让for循环成为一个空循环

for(i=1 ; i<=n ; i=i+1 ); 改为 for(i=1 ; i<=n ; i=i+1 ) 去掉最后那个分号

给你个范例来看看，你对比下

for语句的那一行，多了个";"


Question: 求助

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

scanf("d%",&score);  改成  scanf("%d",&score);

引用 2 楼 ANARTH的回复:建议把result=(score>=90?'A':(score<60?'C':'B'));分开写成两句试试。 呃，score应该是%c，你写成%d了

scanf("d%",&score); 是%d，你写错了


Question: 二维数组的问题

在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];

scanf %c 会将每次输入完的换行符 \n接收到数组中 用getchar接收了\n   int main() { 	char m[5][5];  	for(int i=0;i<5;i++) 	{ 		for(int j=0;j<5;j++) 		{ 			scanf("%c",&m[i][j]); 		} 		getchar(); 	}  	for(int i=0;i<5;i++) 	{ 		for(int j=0;j<5;j++) 			printf("%c",m[i][j]); 		printf("\n"); 	} 	return 0; }

问题解决了，是scanf（”%c"，&x）；这句。 一直印象里的都是scanf会跳过空白字符，但%c时，则会吸收换行符。  我的解决办法是在j==4时用getchar();吸收换行符，结果对的。

引用 1 楼 oYinGui1 的回复:字符串以'\0'结尾，你要输入5个字符，应该定义的字符数组大小是6，要把'\0'算上。  我觉得字符串是'\0'结尾 没错，但我定义的是字符数组吧，这个应该没有影响的。


Question: 求助哪里错了 ---biff过滤器

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

引用 2 楼 paschen的回复:for (n=0;ch!='\n';n++)  改成：  for (n=0;ch[n]!='\n';n++)    case 'A':ch[i]="4";break;  改成  case 'A':ch[i]='4';break;  是单引号，其他case后面的也一样换成单引号 谢谢 我一定是傻了-_-#

第一个for循环 ch是指针, 和字符进行比较了.


Question: 一运行就出现问题停止运行 求解

%s改成 %d  或者  2+3+1 改成 "2+3+1"

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

直接 printf("Beware the Idea Of March2+3+1");不就可以了，干嘛自找麻烦

%s  后面应该跟一个变量的 变量呢？

可能没关闭上一个空间站

%s 的意思是指从一个指定地址开始 到\0结束的字符串。 而你给地址是 1+2+3 这个地址(0000000006)在操作系统可能是一个非法地址 或者是内核的地址。不是用户空间地址。


Question: 如何消除警[Warning] initialization from incompatible pointer type

struct data *pdate=&today;  改成  struct date *pdate=&today;   #include<stdio.h>  struct date{ 	int month; 	int day; 	int year;  };  int main(int argc,char const *argv[]){ 	struct date today = { 		07,31,2014 	}; 	struct date day; 	struct date *pdate=&today; 	day=today; 	day.year=2015;  	printf("Today's date is %i-%i-%i.\n",today.year,today.month,today.day); 	printf("this month is %i-%i-%i.\n",day.year,day.month,day.day); 	printf("address of today is %p\n",pdate);  	return 0; }

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

说明一下，首先，date已经定义为结构体，后面使用date定义变量时，没有必要在前面添加struct。 其次，不知道是打错了还是源代码就是这样，第16行，date打成了data，要注意避免。  修改后代码如下：  #include<stdio.h>  struct date{ 	int month; 	int day; 	int year;  };  int main(int argc, char const *argv[]){ 	date today; 	today = date{ 		07, 31, 2014 	}; 	date day; 	date *pdate = &today; 	day = today; 	day.year = 2015;  	printf("Today's date is %i-%i-%i.\n", today.year, today.month, today.day); 	printf("this month is %i-%i-%i.\n", day.year, day.month, day.day); 	printf("address of today is %p\n", pdate);  	return 0; }


Question: 单链表长度如何表示

单链表的长度可以添加在定义链表的结构中： typedef struct cList{     node *ptrBack;     node *ptrNext;     int lLength;    //链表长度 } CLIST;

顺序表和单链表有什么区别？ 没有！

struct node { 	int value; 	char *name; 	struct node *next; }; struct node *mdzz=NULL; void add(int value,char *name) { 	struct node *temNode=malloc(sizeof(struct node)); 	temNode->name=strdup(name); 	temNode->value=value; 	temNode->next=mdzz; 	mdzz=temNode; } void printTotal(struct node *current) { 	int i=0; 	while(current!=NULL) { 		i++; 		current=current->next; 	} 	printf("%d:",i); } int main(){       // 用add加然后printTotal 会print长度  改void成int然后返回I也就是返回长度 )

将链表长度记录在外头，不是记录在Node节点里面。 比如  struct ListHeader {       Struct Node *head; 链表头       size_t numNode; 记录节点数目 };

头文件


Question: 运行错误

printf("你喜欢的颜色是%s\n",&colorName);  改成  printf("你喜欢的颜色是%s\n",colorName);  %s 需要char*类型指针，colorName本身已经是指针了

#include<stdio.h>    #include <string.h> enum COLOR {RED,YELLOW,GREEN };    int main(int argc,char const *argv[]) {      int color=-1;      char colorName[10]={0};            	 printf("输入你喜欢的颜色代码：");      	 scanf("%d",&color);      	 switch(color) 	{          	 	case RED:strcpy(colorName,"red");break;          		case YELLOW:strcpy(colorName,"yellow");break;          		case GREEN:strcpy(colorName,"green");break;          		default :strcpy(colorName,"unknow");break;      	}      	printf("你喜欢的颜色是%s\n",colorName);            	return 0;  }

clang的提示非常清晰

printf("你喜欢的颜色是%s\n",&colorName); 不需要取地址


Question: 这个警告怎么解决

char *colorName=NULL;  改成  const char *colorName=NULL;

楼上解释的很清楚了。。

这句warning是针对你case中 colorName=“red”形式而提示的，目的在于提示不建议将char*指向常字符串。 因为常字符串为了优化通常村存在符号表中，也就意味着不能修改。 你使用非const的char*指向它，很有可能在后面进行修改，从而引发错误。  解决办法可使用strcpy进行拷贝

switch里面   case123吧


Question: 关于文件与链表

那么我要实现打印所有数据 直接从文件中打印到显示器 还是转入到链表在打印呢 查询的时候是否也是这样子呢

访问内存的速度远远高于访问硬盘的速度


Question: 输入字符串，并且按照字符个数多到少的输出字符，字符个数相同的按asill顺序，从小到大输出

先去重，然后排序，很基础的东西

完成

构造一个结构体，调用qsort即可

引用 1 楼 user-3 的回复:你可以定义一个类 包含char a;存放字符  int b; 存放数量   定义一个该类的对象数组  用字符串操作函数 将整个字符串 先整理一下 放入对象数组里。 再按照某种规则排列对象数组并输出 规则为：1先按照b的大小排序 2  如果b相同，则按照a的顺序排序 思路是这么个思路，具体的自己实现吧、 哦 C语言啊 那就把上文所有的类用结构体去代替


Question: 输出一串字符找出最大的单词，出现烫烫烫，是代码哪里错了吗？

} while (ch[i] != '\0');  改成  } while (ch[i-1] != '\0');    #include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996) int main(void) { 	char ch[100]; 	int  i, j, len, maxlen, p; 	i = len = maxlen = 0; 	printf("\n输入一串字符:"); 	gets(ch); 	do 	{ 		j = i; 		for (len = 0; ch[i] != ' '&&ch[i] != '\0'; i++) 		{ 			len++; 		} 		if (len > maxlen) 		{ 			maxlen = len; 			p = j; 		} 		i++; 	} while (ch[i-1] != '\0'); 	printf("\n"); 	if (len == 0) 		printf("\n没有输入单词！"); 	else 	{ 		for (i = p; i < p + maxlen; i++) 			printf("%c", ch[i]); 		printf("\n"); 	} 	system("pause"); 	return 0; }


Question: 明天参加c语言自学考试，有两个题不懂，麻烦大侠解答一下，谢谢。

引用 1 楼 user-6 的回复:19.初始化x为整形，前半部分强制转换成float型，2/5=0.4，后半部分x是整型，3/5=0，相加就是0.4。 7.&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为非零时，整个运算结果才为1，否则，只要有一方为0，则结果为0。这里5&5=1，3&&4=1，相减等于0.还有这么解释的。。。

我要结贴了，大家都会得分的！

谢谢大家的回答，谢谢赵4老师！有帮助！我彻底看懂了！

引用 4 楼 Saleayas 的回复:运算符的优先级的问题。  5 & 5 - 3 && 4 等同于 (5 & (5 - 3)) && 4 = (5 & 2) && 4 = 0 && 4 = 0  5 & 5 是等于 5 的。 && 和 & 的算法是不一致的。   谢谢回复，对我有很大的帮助。        2转2进制等于10         5转2进制等于101        按位与，就是：                                101                                                                   010     ===========                                                                                000           ==========       =0。                        0&&4=0。

仅供参考：//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 | //+------------------+-----------------------------------------+---------------+

引用 1 楼 user-6 的回复:19.初始化x为整形，前半部分强制转换成float型，2/5=0.4，后半部分x是整型，3/5=0，相加就是0.4。 7.&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为非零时，整个运算结果才为1，否则，只要有一方为0，则结果为0。这里5&5=1，3&&4=1，相减等于0. 谢谢1楼user-6的回复。但是5&5不是等于5吗？取自于位运算——       5转二进制——101。                     101                                                                101                                                     =         101

第二题考算操作符的优先级。 相等于(5&（5-3))&&4

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！

引用 1 楼 user-6 的回复:19.初始化x为整形，前半部分强制转换成float型，2/5=0.4，后半部分x是整型，3/5=0，相加就是0.4。 7.&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为非零时，整个运算结果才为1，否则，只要有一方为0，则结果为0。这里5&5=1，3&&4=1，相减等于0. +1


Question: 求助：超时处理如何编程

socket通信 可以设置接收超时 有些可以创建线程后用WaitForSingleObject设置超时


Question: 这是咋回事？

引用 1 楼 ipqtjmqj 的回复:你在linux上是utf-8编码吧， 汉字在utf-8中一般是３个字节的， 第１次p++后少了１个字节，导致后面的都解释错误。 １４与１６行单个字节当然无法打印了。  你把汉字去掉，全部换成英文字母，就都可以打印出来了\ +1

引用 3 楼 u014325402 的回复:[quote=引用 1 楼 ipqtjmqj的回复:]你在linux上是utf-8编码吧， 汉字在utf-8中一般是３个字节的， 第１次p++后少了１个字节，导致后面的都解释错误。 １４与１６行单个字节当然无法打印了。  你把汉字去掉，全部换成英文字母，就都可以打印出来了 嗯嗯，我用的的是UTF-8,我还不明白，p++后，第一个汉子打印错误，那后面的为什么不能打印正确呢？[/quote] 遇0而止。

引用 1 楼 ipqtjmqj的回复:你在linux上是utf-8编码吧， 汉字在utf-8中一般是３个字节的， 第１次p++后少了１个字节，导致后面的都解释错误。 １４与１６行单个字节当然无法打印了。  你把汉字去掉，全部换成英文字母，就都可以打印出来了 嗯嗯，我用的的是UTF-8,我还不明白，p++后，第一个汉子打印错误，那后面的为什么不能打印正确呢？


Question: vs无法成功调试以下代码，但是gcc可以，如何使vs成功调试？

VS2015装上 Clang with Microsoft CodeGen  用clang 编译即可调试。

VC 不支持C99标准


Question: 如何将普通的形式转化为json字符串形式

作为一个C程序员，对  scanf,sscanf,fscanf  printf,sprintf,fprintf 这类函数的用法，还是要做到“拳不离手，曲不离口”的。


Question: 请教下，为什么数组中i[3] == 3[i];

c语言就是这样规定的 a[b] = *(a+b)

引用 7 楼 qiaojiuyuan 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价   如上你所说的A[B] *(A+B) *(B+A) B[A] //以上四行等价 那*(A+B)中的b我知道是偏移量，那是多少啊？也是一个Int值吗[/quote] 其中有一个是指针，另外一个是数值。如： char *p = NULL; char *p1_1 = p + 1; int  *p1_2 = p + 1; char *p2_1 = 1 + p; int  *p2_2 = 1 + p; 如上，你肯定明白 int 指针的那两行编译不过去的，除非强转。而且，运算结果其实也是和数值相加的那个指针类型是一样的，所以根本不存在歧义。

引用 7 楼 qiaojiuyuan 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价   如上你所说的A[B] *(A+B) *(B+A) B[A] //以上四行等价 那*(A+B)中的b我知道是偏移量，那是多少啊？也是一个Int值吗[/quote]  偏移量是指针指针的类型的大小

引用 2 楼 zhao4zhong1 的回复:A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价   如上你所说的A[B] *(A+B) *(B+A) B[A] //以上四行等价 那*(A+B)中的b我知道是偏移量，那是多少啊？也是一个Int值吗

引用 3 楼 paschen 的回复:看我的这个帖子你就知道了：http://blog.csdn.net/paschen/article/details/47315449 恩 看了挺不错 谢谢

引用 4 楼 user-5 的回复:请问在哪里学的，有教材吗？ 在《嗨翻C语言》里看到的

请问在哪里学的，有教材吗？


Question: KMP算法

百度搜相关博文。


Question: C语言写入文件时指针和数组有什么区别？

char *str; 只是一个指针，你没有为指针分配内存就去写（gets(str);）  当然出错了

楼主，估计是个新手，内存分配没有搞懂， 建议初学的时候，理解c语言的内存 指针是个地址， 所以你引用的时候， 要分配内存空间， 才可以*str !

你要注意的是指针的使用。 char *str 这是没有分配空间的指针，自然就会报错了。  两种解决办法： 1.用数组，提前分配空间 2.调用动态分配空间的函数malloc或者自己封装一个函数，给指针分配空间就好了


Question: 运行到输入值得时候c语言程序运行时提示出现了一个问题，导致程序停止工作

int number; 	LinkList p1,p2,r1=La,r2=Lb; 	printf("请输入第一组要输入元素的个数"); 	scanf("%d",&number); 	for(int i=0;i<number;i++){ 		scanf("%d",&p1->data); 		p1->next=NULL; 		r1->next=p1; 		r1=p1;  这里的p1没有初始化就使用了

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

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。

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

scanf("%d",&p1->data); 之前需要判断 p1->data 是否为空， 如果为空 应该添加新节点

内存越界了，自己慢慢找吧


Question: C语言反函数表示方法

百度搜相关关键字。

这个问题很麻烦，如果你是想编一个程序自己用的话，直接去网上找现成的就可以了。

再来看看有人没

求指点哇，实在是爪机


Question: C语言不定积分的计算

#include "math.h" double romb(double a, double b, double eps , double (*f) ()) {     int m, n, i, k;     double y[10], h, ep, p, x, s, q;     h = b - a;     y[0] = h*((*f)(a) + (*f)(b)) / 2.0;     m = 1; n = 1; ep = eps + 1.0;     while ((ep>=eps)&&(m<=9))     {         p = 0.0;         for(i=0;i<=n-1;i++)         {             x = a + (i + 0.5)*h;             p = p + (*f)(x);         }         p = (y[0] + h*p) / 2.0;         s = 1.0;         for(k=1;k<=m;k++)         {             s = 4.0*s;             q = (s*p - y[k - 1]) / (s - 1.0);             y[k - 1] = p;             p = q;         }         ep = fabs(q - y[m - 1]);         m = m + 1; y[m - 1] = q; n = n + m; h = h / 2.0;     }     return(q); }

如何双重积分

引用 6 楼 paschen 的回复:[quote=引用 4 楼 云中睡觉的龙的回复:][quote=引用 3 楼 paschen 的回复:] 计算机通常使用数值积分来计算，可参看《数值分析》 我专门去图书馆借了本数值计算  可是只有定积分的 没看到不定积分怎么求  小白求指点[/quote] 可以考虑用MATLAB来写程序，直接有现成的可以用  也可以用C调用Matlab计算[/quote] 小白完全不懂  我查查库函数  希望有！！！！！！！！！！！！！

引用 4 楼 云中睡觉的龙的回复:[quote=引用 3 楼 paschen 的回复:] 计算机通常使用数值积分来计算，可参看《数值分析》 我专门去图书馆借了本数值计算  可是只有定积分的 没看到不定积分怎么求  小白求指点[/quote] 可以考虑用MATLAB来写程序，直接有现成的可以用  也可以用C调用Matlab计算

不定积分是公式演算吧。 https://www.baidu.com/s?wd=c源代码%20"公式演算"

引用 3 楼 paschen 的回复:计算机通常使用数值积分来计算，可参看《数值分析》 我专门去图书馆借了本数值计算  可是只有定积分的 没看到不定积分怎么求  小白求指点

计算机通常使用数值积分来计算，可参看《数值分析》

引用 1 楼 zhao4zhong1 的回复:https://www.baidu.com/s?wd=C源代码%20不定积分  老师  我没看懂 老师能详细讲下吗


Question: VS2012可以编译汇编语言吗？

VC++ 32位编译器支持内嵌汇编，64位编译器不支持，但是可以连接外部汇编模块，需要预先汇编为obj。

VS自带 汇编编译器 ml

推荐使用 RadASM 汇编编译器


Question: 为什么总是提示没有定义

如果想使用这种方式，有什么方法改正吗？

"movl           $_value, %ecx\n\t" 这句错了吧，C语言中的变量，不可以直接传到汇编中吧， 汇编中$后接的是立即数


Question: 大学菜鸟求解type报错怎么搞，菜鸟上路程序比较凌乱，望大牛们多多帮助

再供参考：//不带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> #include <locale.h> struct NODE {     int          data;     struct NODE *next; } *head,*p,*q,*s,*p1,*p2,*q1,**ta; int i,k,n,t,m,v,N=10; int main() {     setlocale(LC_ALL,"chs");     srand(time(NULL));      head=NULL;      printf("创建%d个节点的单链表:",N);//创建N个节点的单链表     p=head;     for (i=0;i<N;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) exit(1);         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         if (NULL==p) {             head=q;             p=head;         } else {             p->next=q;             p=q;         }     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=3;     v=5;     printf("将值为%d的结点插入到单链表的第%d个结点前:",v,k);//将值为v的结点插入到单链表的第k个结点前     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) exit(1);             q->data=v;             q->next=head;             head=q;             break;         } else {             if (k-1==n) {                 q=(struct NODE *)malloc(sizeof(struct NODE));                 if (NULL==q) exit(1);                 q->data=v;                 q->next=p->next;                 p->next=q;                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      k=5;     printf("删除第%d个节点:",k);//删除第k个节点     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==1) {             q=head;             head=head->next;             free(q);             break;         } else {             if (k-1==n) {                 q=p->next;                 if (q) {                     p->next=q->next;                     free(q);                 }                 break;             }         }         p=p->next;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      printf("从小到大排序:");//从小到大排序     for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {         for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {             if (p->data > q->data) {                  //交换data //              printf("swap %02d %02d\n",p->data,q->data); //              t=p->data;p->data=q->data;q->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->data,q->data);                 if (p==head) {//p是头                     if (p->next==q) {//pq挨着                         head=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=head;                     } else {//pq不挨着                         head=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=head;                     }                 } else {//p不是头                     if (p->next==q) {//pq挨着                         p1->next=q;                         p->next=q->next;                         q->next=p;                         q=p;                         p=p1->next;                     } else {//pq不挨着                         p1->next=q;                         p2=p->next;                         p->next=q->next;                         q->next=p2;                         q1->next=p;                         q=p;                         p=p1->next;                     }                 }                  //输出整个单链表 //              s=head; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表并计算链表长度n     n=0;     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         n++;         s=s->next;     }      printf("将整个链表逆序:");//将整个链表逆序     if (n>=2) {         p=head;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head=p;     }      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      m=4;     n=6;     printf("将单链表中前%d个结点和后%d个结点进行互换:",m,n);//将单链表中前m个结点和后n个结点进行互换,m+n为链表总长     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m==k) {             q=p;         }         s=p;         p=p->next;     }     q1=head;     head=q->next;     s->next=q1;     q->next=NULL;      //输出整个单链表     s=head;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16-> //将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16-> //删除第5个节点:08->74->05->07->03->99->31->56->88->16-> //从小到大排序:03->05->07->08->16->31->56->74->88->99-> //将整个链表逆序:99->88->74->56->31->16->08->07->05->03-> //将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56-> //

仅供参考：//带表头结点的单向链表 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <time.h> struct NODE {     int          data;     struct NODE *next; } H,*head,*p,*q,*q1,*s1,*s2,*s3,*s4,*s; int i,j,k,n,t,m; int main() {     srand(time(NULL));      //填写头节点数据     H.data=-1;     H.next=NULL;     head=&H;      //创建10个节点的单链表     p=head;     for (i=0;i<10;i++) {         q=(struct NODE *)malloc(sizeof(struct NODE));         if (NULL==q) return 1;         q->data=rand()%100;//填写0..99的随机值         q->next=NULL;         p->next=q;         p=q;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将值为5的结点插入到单链表的第k个结点前     k=3;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=(struct NODE *)malloc(sizeof(struct NODE));             if (NULL==q) return 1;             q->data=5;             q->next=p->next;             p->next=q;             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //删除第k个节点     k=5;     n=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         n++;         if (k==n) {             q=p->next;             if (q) {                 p->next=q->next;                 free(q);             }             break;         }         p=p->next;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //从小到大排序     for (p=head;p!=NULL && p->next!=NULL;p=p->next) {         for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {             if (p->next->data > q->next->data) {                  //交换data //              printf("swap %02d %02d\n",p->next->data,q->next->data); //              t=p->next->data;p->next->data=q->next->data;q->next->data=t;                  //或者                  //交换next //              printf("swap %02d %02d\n",p->next->data,q->next->data);                 s1=p->next;                 s2=p->next->next;                 s3=q->next;                 s4=q->next->next;                  if (s2!=s3) {                      p->next=s3;                     s3->next=s2;                      q->next=s1;                     s1->next=s4;                 } else {                      p->next=s3;                     s3->next=s1;                            q=s3;                     s1->next=s4;                 }                  //输出整个单链表 //              s=head->next; //              while (1) { //                  if (NULL==s) { //                      printf("\n"); //                      break; //                  } //                  printf("%02d->",s->data); //                  s=s->next; //              } //              getchar();             }         }     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将整个链表逆序     if (head->next!=NULL && head->next->next!=NULL) {         p=head->next;         q=p->next;         p->next=NULL;         while (1) {             q1=q->next;             q->next=p;             p=q;             q=q1;             if (NULL==q) break;         }         head->next=p;     }      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10     m=4;     n=6;     k=0;     p=head;     while (1) {         if (NULL==p) {             break;         }         k++;         if (m+1==k) {             q=p;         }         s=p;         p=p->next;     }     s1=head->next;     head->next=q->next;     s->next=s1;     q->next=NULL;      //输出整个单链表     s=head->next;     while (1) {         if (NULL==s) {             printf("\n");             break;         }         printf("%02d->",s->data);         s=s->next;     }      //释放所有节点     p=head->next;     while (1) {         if (NULL==p) {             break;         }         q=p->next;         free(p);         p=q;     }      return 0; } //84->28->20->23->96->19->59->97->29->41-> //84->28->05->20->23->96->19->59->97->29->41-> //84->28->05->20->96->19->59->97->29->41-> //05->19->20->28->29->41->59->84->96->97-> //97->96->84->59->41->29->28->20->19->05-> //41->29->28->20->19->05->97->96->84->59-> //

偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。

你这个程序我试了一下还是和我一样的错，4个取地址问题，不好编译

问题很多，帮你改掉了，编译没问题了。 编译问题可以根据编译器的提示一个个改，看不懂的错误可以拿去搜一下  /* 线性表得基本操作 */ #include<stdio.h> #include<conio.h> #include<stdlib.h> #define MaxSize 100 #define OVERFLOW -1 #define ok 1 typedef int DataType; typedef int Status; typedef struct { 	DataType *data; 	int length; }SqList; //线性表得初始化 Status InitList(SqList &L) { 	L.data = new DataType[MaxSize]; 	if (!L.data) exit(OVERFLOW); 	L.length = 0; 	return ok;  } //线性表得输出结果 //线性表得遍历 void Printout(SqList *L) { 	int i; 	for (i = 0; i < L->length; i++) 		printf("%4d", L->data[i]); 	printf("\n"); } //线性表得建立 void CreateList(SqList *L) { 	int i; 	int n, tmp; 	printf("请输入线性表中数据的个数: "); 	scanf("%d", &n);  	for (i = 0; i < n; i++) 	{ 		scanf("%d", &tmp); 		L->data[i] = tmp; 	} 	L->length = n; 	printf("线性表得数据：\n");   } //线性表得插入 int ListInsert(SqList &L, int i, DataType e) { 	if ((i<1) || (i>L.length + 1))  		return 0;  	if (L.length == MaxSize)  		return 0;  	for (int j = L.length - 1; j >= i - 1; j--) 		L.data[j + 1] = L.data[j]; 	L.data[i - 1] = e; 	++L.length; 	return 1; } //线性表得按值插入 void ListNumInsert(SqList *L, DataType x){ 	int k; 	if (L->length == MaxSize) 	{ 		printf("\n 顺序表是满的，没法插入"); 	} 	for (k = L->length; k >= 1; k--){ 		if (L->data[k - 1] >= x) 			L->data[k + 1] = L->data[k]; 		else 			break; 	} 	L->data[k + 1] = x; 	L->length++; } //线性表的值判断 int GetElem(SqList L, int i, DataType &e) { 	if (i<1 || i>L.length) return 0; 		e = L.data[i - 1]; 	return 1; } //线性表的表长 int ListLength(SqList *L){ 	int j = L->length; 	return j; }  //线性表的删除 int ListDelete(SqList &L, int i) { 	if (i<1 || (i>L.length)) return 0; 	for (int j = i; j <= L.length - 1; j++) 		L.data[j - 1] = L.data[j]; 	--L.length; 	return 1; }     //线性表的释放 void DestroyList(SqList *L){ 	if (L->data){ 		free(L->data); 		printf("\n线性表释放成功\n"); 	} 	else{ 		printf("\n线性表释放成功\n"); 	} } //根据值查找位置 int LocateElem(SqList L, DataType e) { 	int i; 	for (i = 0; i < L.length; i++) 	if (L.data[i] == e) return i + 1; 	return 0; }  void main() { 	SqList MyList; 	DataType x; 	int pos, y; 	int c; 	int h; 	int s1, s2; 	int n1; 	printf("-----------线性表的基本操作操作---------------\n"); 	printf("-----------1线性表的初始化---------------\n"); 	printf("-----------2线性表的建立---------------\n"); 	printf("-----------3线性表的遍历---------------\n"); 	printf("-----------4线性表的插入---------------\n"); 	printf("-----------5线性表的按值插入---------------\n"); 	printf("-----------6线性表的介于某区间的值---------------\n"); 	printf("-----------7线性表的表长---------------\n"); 	printf("-----------8线性表按值位置删除---------------\n"); 	printf("-----------9线性表按值删除---------------\n"); 	printf("-----------10查询线性表的元素---------------\n"); 	printf("-----------11退出---------------\n"); }

/* 线性表得基本操作 */ #include<stdio.h> #include<conio.h> #include<stdlib.h> #define MaxSize 100 typedef int DataType; typedef int Status; typedef struct { 	DataType data[MaxSize]; 	int length; }SqList; //线性表得初始化 Status InitList(SqList &L) { 	L.data=new DataType[MaxSize]; 	if(!L.data) exit(OVERFLOW); 	L.length =0; 	return OK;  } //线性表得输出结果 //线性表得遍历 void Printout(SqList *L) {	int i; 	for(i=0;i<L->length;i++) 		printf("%4d",L->data[i]); 		printf("\n"); } //线性表得建立 void CreateList(SqList *L) {	int i; 	int n,tmp; 	printf("请输入线性表中数据的个数: "); 	scanf("%d",&n);  	for(i=0;i<n;i++) 	{ 		scanf ("%d", &tmp); 		L->data[i] = tmp; 	} 	L->length=n; 	printf("线性表得数据：\n");      } //线性表得插入 Status ListInsert(SqList &L,int i,DataType e) { 	if((i<1)||(i>L.length+1))  		return ERROR; 	 	if(L.length==MaxSize)  		return ERROR; 	 	for(j=L.length -1;j>=i-1;j--) 		L.data[j+1]=L.elem[j]; 		L.data[i-1]=e; 		++L.length ; 		return OK; } //线性表得按值插入 void ListNumInsert(SqList *L,DataType x){ 	int k; 	if(L->length==MaxSize) 	{ 		printf("\n 顺序表是满的，没法插入"); 	} 	for(k=L->length;k>=1;k--){ 	if(L->data[k-1]>=x) 		L->data[k+1]=L->data[k]; 	else 		break; 	} 	L->data[k+1]=x; 	L->length++; } //线性表的值判断 Status GetElem(SqList L,int i,DataType &e) {	 	if(i<1||i>L.length) return ERROR; 		e=L.data[i-1]; 	return OK; } //线性表的表长 int ListLength(SqList *L){ 	int j=L->length; 	return j; }   //线性表的删除 Status ListDelete(SqList &L,int i) { 	if((i<1)||(i>l.length)) return ERROR; 	for(j=i;j<=L.length-1;j++) 		L.data[j-1]=L.data[j]; 	--L.length ; 	return OK; }     //线性表的释放 void DestroyList(SqList *L){ 	if(L->data){ 		free(L->data); 		printf("\n线性表释放成功\n"); 	} 	else{ 		printf("\n线性表释放成功\n"); 	} } 	//根据值查找位置 	int LocateElem(SqList L,DataType e) 	{ 		int i; 		for( i=0;i<L.length ;i++) 			if (L.data[i]==e) return i+1; 			return 0; 	}  	void main() 	{ 		SqList MyList; 		DataType x; 		int pos,y; 		int c; 		int h; 		int s1,s2; 		int n1; 		printf("-----------线性表的基本操作操作---------------\n"); 		printf("-----------1线性表的初始化---------------\n"); 		printf("-----------2线性表的建立---------------\n"); 		printf("-----------3线性表的遍历---------------\n"); 		printf("-----------4线性表的插入---------------\n"); 		printf("-----------5线性表的按值插入---------------\n"); 		printf("-----------6线性表的介于某区间的值---------------\n"); 		printf("-----------7线性表的表长---------------\n"); 		printf("-----------8线性表按值位置删除---------------\n"); 		printf("-----------9线性表按值删除---------------\n"); 		printf("-----------10查询线性表的元素---------------\n"); 		printf("-----------11退出---------------\n");} E:\cprojiect\zy\5.c(16) : error C2143: syntax error : missing ')' before '&' E:\cprojiect\zy\5.c(16) : error C2143: syntax error : missing '{' before '&' E:\cprojiect\zy\5.c(16) : error C2059: syntax error : '&' E:\cprojiect\zy\5.c(16) : error C2059: syntax error : ')' E:\cprojiect\zy\5.c(50) : error C2143: syntax error : missing ')' before '&' E:\cprojiect\zy\5.c(50) : error C2143: syntax error : missing '{' before '&' E:\cprojiect\zy\5.c(50) : error C2059: syntax error : '&' E:\cprojiect\zy\5.c(50) : error C2059: syntax error : ')' E:\cprojiect\zy\5.c(83) : error C2143: syntax error : missing ')' before '&' E:\cprojiect\zy\5.c(83) : error C2143: syntax error : missing '{' before '&' E:\cprojiect\zy\5.c(83) : error C2059: syntax error : '&' E:\cprojiect\zy\5.c(83) : error C2059: syntax error : ')' E:\cprojiect\zy\5.c(96) : error C2143: syntax error : missing ')' before '&' E:\cprojiect\zy\5.c(96) : error C2143: syntax error : missing '{' before '&' E:\cprojiect\zy\5.c(96) : error C2059: syntax error : '&' E:\cprojiect\zy\5.c(96) : error C2059: syntax error : ')' 我其他问题好了，我这边主要还要四个取地址没解决

可能还有其他问题，你先改着看

if((i<1||(i>l.length)) return 0;    改成  if((i<1||(i>L.length))) return 0;  大写L，且你括号不对称  还有GetElem函数中rreturn0   eturn 1后面都没有分号

你的InitList是一个宏（#define InitList）  下面又用作了函数名（Status InitList(SqList &L)）  同理其他几个函数  那那几个宏定义删了


Question: 关于C Primer Plus课后练习题

引用 12 楼 paschen 的回复:[quote=引用 10 楼 login0201 的回复:] [quote=引用 9 楼 qq423399099 的回复:] torf +2才是你所谓的移动到第三行的第一列   大神讲全了哈。 可是ptf +2 不是等于 &torf[2] 吗？这两个不等吗？ [/quote]  你的ptr是int类型的指针，所以+2移动的是两个int类型距离 而torf 是数组类型，+2移动的是两个这种类型数组的距离[/quote]  是不是如果定义为： int *ptr[2]; 这样的话，ptr +2 = &torf [2] .

引用 10 楼 login0201 的回复:[quote=引用 9 楼 qq423399099 的回复:] torf +2才是你所谓的移动到第三行的第一列   大神讲全了哈。 可是ptf +2 不是等于 &torf[2] 吗？这两个不等吗？ [/quote]  你的ptr是int类型的指针，所以+2移动的是两个int类型距离 而torf 是数组类型，+2移动的是两个这种类型数组的距离

引用 9 楼 qq423399099 的回复:torf +2才是你所谓的移动到第三行的第一列   大神讲全了哈。 可是ptf +2 不是等于 &torf[2] 吗？这两个不等吗？

torf +2才是你所谓的移动到第三行的第一列

引用 6 楼 qq_36409192 的回复:[quote=引用 4 楼 login0201的回复:][quote=引用 2 楼 qq_36409192 的回复:] 二维数组中，初始化赋值没有表示出来的部分用0表示。。那么在你这个二维数组中，其实你就是将第一行的值赋了三个值，后面两行都是0。 另外，在二维数组中，行标可以省略，列表不能省略，也就是说，你的指针其实指向的是第一行的三个数，当你在进行指针的加减的时候，其实也只是在第一行中进行移动在。。  望采纳。。   这是个两行两列的数组，怎么可能第一行有三个元素，您这解释完全不对了。[/quote] 不好意思。。看错了。。二维数组存储形式是以一行行的形式存储在一行中，所以你在访问的时候。。当你读完第一行的内容以后。。会开始读第二行，这也是为何你+2以后的值会是16。。表示的其实就是第二行的第一个数。。[/quote]   数组的记数是从0开始的，+2其实是第三行了不是，可是题目这个数组只有两行两列。

引用 5 楼 zhao4zhong1 的回复:A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价     这是二维数组，这个好像都是一维数组。

引用 4 楼 login0201的回复:[quote=引用 2 楼 qq_36409192 的回复:] 二维数组中，初始化赋值没有表示出来的部分用0表示。。那么在你这个二维数组中，其实你就是将第一行的值赋了三个值，后面两行都是0。 另外，在二维数组中，行标可以省略，列表不能省略，也就是说，你的指针其实指向的是第一行的三个数，当你在进行指针的加减的时候，其实也只是在第一行中进行移动在。。  望采纳。。   这是个两行两列的数组，怎么可能第一行有三个元素，您这解释完全不对了。[/quote] 不好意思。。看错了。。二维数组存储形式是以一行行的形式存储在一行中，所以你在访问的时候。。当你读完第一行的内容以后。。会开始读第二行，这也是为何你+2以后的值会是16。。表示的其实就是第二行的第一个数。。

引用 2 楼 qq_36409192 的回复:二维数组中，初始化赋值没有表示出来的部分用0表示。。那么在你这个二维数组中，其实你就是将第一行的值赋了三个值，后面两行都是0。 另外，在二维数组中，行标可以省略，列表不能省略，也就是说，你的指针其实指向的是第一行的三个数，当你在进行指针的加减的时候，其实也只是在第一行中进行移动在。。  望采纳。。   这是个两行两列的数组，怎么可能第一行有三个元素，您这解释完全不对了。

引用 1 楼 u012604633 的回复:*ptr即*(ptr+0)  对应a[0][0] ，*(ptr+1) 对应a[0][1]， *(ptr+2) 对应a[1][0] ，*(ptr+3) a[1][1]， 数组在内存里是按序存储的  *ptr = a[0][0] =12 这个无异议。   可是 *(ptr+1) 为什么等于 a[0][1]，为什么不是 a[1][0]。那么*(*ptr+1) 又等于什么？ 同理 *(ptr+2) 为什么不等于 a[2][0]。

首先ptr是int*的，那么ptr+2，就是ptr向前偏移了2个int的地址，ptr是a[0][0]，而数组在内存中是顺序排列的，a[0][0]偏移两个int就是a[1][0]，就是16

引用 15 楼 login0201 的回复:[quote=引用 14 楼 paschen 的回复:] [quote=引用 13 楼 login0201 的回复:] [quote=引用 12 楼 paschen 的回复:] [quote=引用 10 楼 login0201 的回复:] [quote=引用 9 楼 qq423399099 的回复:] torf +2才是你所谓的移动到第三行的第一列   大神讲全了哈。 可是ptf +2 不是等于 &torf[2] 吗？这两个不等吗？ [/quote]  你的ptr是int类型的指针，所以+2移动的是两个int类型距离 而torf 是数组类型，+2移动的是两个这种类型数组的距离[/quote]  是不是如果定义为： int *ptr[2]; 这样的话，ptr +2 = &torf [2] . [/quote]  int *ptr[2]; 是一个指针数组，int (*ptr)[2] 才是指向数组的指针[/quote]  对，丢了个(); int (*ptr)[2]; 这样的话，ptr +2 = &torf [2] 。这个表达式是没问题的吧。[/quote]  如果：  int torf [2][2] = {12, 14,16}; int (*ptr)[2] = torf;  那么ptr + 2 与  &torf[2] 类型与值都是一样的

引用 14 楼 paschen 的回复:[quote=引用 13 楼 login0201 的回复:] [quote=引用 12 楼 paschen 的回复:] [quote=引用 10 楼 login0201 的回复:] [quote=引用 9 楼 qq423399099 的回复:] torf +2才是你所谓的移动到第三行的第一列   大神讲全了哈。 可是ptf +2 不是等于 &torf[2] 吗？这两个不等吗？ [/quote]  你的ptr是int类型的指针，所以+2移动的是两个int类型距离 而torf 是数组类型，+2移动的是两个这种类型数组的距离[/quote]  是不是如果定义为： int *ptr[2]; 这样的话，ptr +2 = &torf [2] . [/quote]  int *ptr[2]; 是一个指针数组，int (*ptr)[2] 才是指向数组的指针[/quote]  对，丢了个(); int (*ptr)[2]; 这样的话，ptr +2 = &torf [2] 。这个表达式是没问题的吧。

引用 13 楼 login0201 的回复:[quote=引用 12 楼 paschen 的回复:] [quote=引用 10 楼 login0201 的回复:] [quote=引用 9 楼 qq423399099 的回复:] torf +2才是你所谓的移动到第三行的第一列   大神讲全了哈。 可是ptf +2 不是等于 &torf[2] 吗？这两个不等吗？ [/quote]  你的ptr是int类型的指针，所以+2移动的是两个int类型距离 而torf 是数组类型，+2移动的是两个这种类型数组的距离[/quote]  是不是如果定义为： int *ptr[2]; 这样的话，ptr +2 = &torf [2] . [/quote]  int *ptr[2]; 是一个指针数组，int (*ptr)[2] 才是指向数组的指针


Question: 求大神请教静态链表

你怎么只有CreateList没有InsertList函数

你每次while循环都要InitList(L);一遍？ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。


Question: Algorithms IN C中随书代码是否有问题？

引用 2 楼 paschen 的回复:会越界 不知道大师为什么写这样的程序

会越界

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: c中如何实现立即执行一段代码

引用 1 楼 u010165006 的回复:可以设置每帧时间为100ms，每过100ms，改变球拍位置，球计数器加一，计数器每达到5，改变弹力球位置，计数器置0，位置改变以后刷新帧画面。 谢谢你，问题解决了。


Question: 编码规范

astyle自动整理c,c++,java源代码格式命令行工具源代码。 用astyle --help查看使用帮助。 http://download.csdn.net/detail/zhao4zhong1/5605415

比用什么风格更重要的是在任何地方，任何时候都坚持用一种风格。 比爱哪种美眉更重要的是在任何地方，任何时候都坚持爱一个美眉。

《C语言课程设计案例精编》 C语言程序开发范例宝典 C语言经典编程282例  看题目，先自己写，写完再和书上比较一下，不过书里的代码也不是最好的，所以要取舍。

可以写个计算器软件啊，算法不复杂，有一定代码量

自己感兴趣什么就写什么，比如可以写个控制台下的小游戏，网上也会有一些别人写的源码可供你参考


Question: c语言文件操作

不要把 fopen("...","...");fscanf,fprintf,fgets,fgetc,fclose //读时把\r\n替换成\n，写时把\n替换成\r\n;读到\x1a就设置EOF;读写的内容当字符看待 和 fopen("...","...b");fseek,ftell,fread,fwrite,fgetc,fclose //不作以上替换，遇到\x1a仍继续读;读写的内容当字节看待 弄混了  英语也是一门计算机语言的说。

_chdir, _wchdir Change the current working directory.  int _chdir( const char *dirname );  int _wchdir( const wchar_t *dirname );  Routine Required Header Optional Headers Compatibility  _chdir <direct.h> <errno.h> Win 95, Win NT  _wchdir <direct.h> or <wchar.h> <errno.h> 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  Each of these functions returns a value of 0 if successful. A return value of –1 indicates that the specified path could not be found, in which case errno is set to ENOENT.  Parameter  dirname  Path of new working directory  Remarks  The _chdir function changes the current working directory to the directory specified by dirname. The dirname parameter must refer to an existing directory. This function can change the current working directory on any drive and if a new drive letter is specified in dirname, the default drive letter will be changed as well. For example, if A is the default drive letter and \BIN is the current working directory, the following call changes the current working directory for drive C and establishes C as the new default drive:  _chdir("c:\\temp");  When you use the optional backslash character (\) in paths, you must place two backslashes (\\) in a C string literal to represent a single backslash (\).  _wchdir is a wide-character version of _chdir; the dirname argument to _wchdir is a wide-character string. _wchdir and _chdir behave identically otherwise.  Generic-Text Routine Mapping:  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tchdir _chdir _chdir _wchdir    Example  /* CHGDIR.C: This program uses the _chdir function to verify  * that a given directory exists.  */  #include <direct.h> #include <stdio.h> #include <stdlib.h>  void main( int argc, char *argv[] ) {    if( _chdir( argv[1] )   )       printf( "Unable to locate the directory: %s\n", argv[1] );    else       system( "dir *.wri"); }   Output   Volume in drive C is CDRIVE  Volume Serial Number is 0E17-1702   Directory of C:\write  04/21/95  01:06p                 3,200 ERRATA.WRI 04/21/95  01:06p                 2,816 README.WRI                2 File(s)          6,016 bytes                              71,432,116 bytes free   Directory Control Routines  See Also   _mkdir, _rmdir, system

_getcwd, _wgetcwd Get the current working directory.  char *_getcwd( char *buffer, int maxlen );  wchar_t *_wgetcwd( wchar_t *buffer, int maxlen );  Routine Required Header Compatibility  _getcwd <direct.h> Win 95, Win NT  _wgetcwd <direct.h> or <wchar.h> 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  Each of these functions returns a pointer to buffer. A NULL return value indicates an error, and errno is set either to ENOMEM, indicating that there is insufficient memory to allocate maxlen bytes (when a NULL argument is given as buffer), or to ERANGE, indicating that the path is longer than maxlen characters.  Parameters  buffer  Storage location for path  maxlen  Maximum length of path in characters: char for _getcwd and wchar_t for _wgetcwd  Remarks  The _getcwd function gets the full path of the current working directory for the default drive and stores it at buffer. The integer argument maxlen specifies the maximum length for the path. An error occurs if the length of the path (including the terminating null character) exceeds maxlen. The buffer argument can be NULL; a buffer of at least size maxlen (more only if necessary) will automatically be allocated, using malloc, to store the path. This buffer can later be freed by calling free and passing it the _getcwd return value (a pointer to the allocated buffer).  _getcwd returns a string that represents the path of the current working directory. If the current working directory is the root, the string ends with a backslash ( \ ). If the current working directory is a directory other than the root, the string ends with the directory name and not with a backslash.  _wgetcwd is a wide-character version of _getcwd; the buffer argument and return value of _wgetcwd are wide-character strings. _wgetcwd and _getcwd behave identically otherwise.  Generic-Text Routine Mappings  TCHAR.H Routine  _UNICODE & _MBCS Not Defined _MBCS Defined _UNICODE Defined  _tgetcwd _getcwd _getcwd _wgetcwd    Example  // GETCWD.C /* This program places the name of the current directory in the   * buffer array, then displays the name of the current directory   * on the screen. Specifying a length of _MAX_PATH leaves room   * for the longest legal path name.  */  #include <direct.h> #include <stdlib.h> #include <stdio.h>  void main( void ) {    char buffer[_MAX_PATH];     /* Get the current working directory: */    if( _getcwd( buffer, _MAX_PATH ) == NULL )       perror( "_getcwd error" );    else       printf( "%s\n", buffer ); }   Output  C:\code   Directory Control Routines  See Also   _chdir, _mkdir, _rmdir

虽然不明白感觉好高大上的样子，可以翻译一下么

引用 7 楼 sietlkj0811 的回复:文件写入函数未必表示当场写入，有可能只是记住了要写入的内容，等收到刷新指令的时候才正式写入。退出软件时操作系统会自动帮你把文件关闭，文件关闭前会发刷新指令，你要想马上看到写入，除了关闭文件外，可以调用flush函数，具体函数名查一下，我记得是叫FLUSH 我没用fclose，直接关闭控制台，然后重新打开程序，发现之前写的文件的数据并没有保存啊

最后加上fclose

楼上代码有很多没用的部分， 代码作用是，输入软件名，和地址，打开它， 出问题的代码是，将楼上的代码  main函数中文件打开剪切到循环中。 g_judge(char k)判断函数每次调用都会使结构体数据的weight+1.写入到文件中 然后，问题是，+1后的值没有保存

/************************************************ *author：	jdz *data：		2016.10.？ *explain：	打算做一个类似数据库的系统，可以打开软件，记录东西。 * *ver： *		2016.10.18--学习了文件打开方式，对于w，r，a 和+的打开方式 *					学习了fseek()定位，随机读取文件 *					了解了feof()函数，使用条件 *					读写失败，打开失败，大多是由于文件不存在，数据不存在导致的。 *		2016.10.19--添加了修改功能，准备 ***************************************************/  #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h>  /************全局变量********************/  FILE *fp; char *f_name;//文件名 long num;//文件记录条数  long m_tree;//命令树层数  0为初始化，1高2低 long m_n; //某节点下，命令序号  /***************************************/  /*****************全局结构体********************/ typedef struct address{ 	char explain[20]; 	char addr[100]; 	int	 n;//序号，从1开始 	int	 weight; }addr;  /*********************************************/   /******************时间函数******************************** * * *******************************************************/ void Time_Init() { 	time_t t1; 	struct tm *t2; 	 	t1 = time(NULL); 	t2 = localtime(&t1); 	if((fp = fopen(f_name,"rb+")) == NULL) 	{	  		if((fp = fopen(f_name,"wb+")) == NULL) 		{ 			printf("file open error!"); 			exit(0); 		} 		num = 0; 		if((fwrite(&t1,sizeof(long),1,fp)) == NULL)//当前时间 		{ 			printf("write 1 error!"); 			//exit(0); 		}	 		if((fwrite(&t1,sizeof(long),1,fp)) == NULL)//上一次时间 		{ 			printf("write 2 error!"); 			//exit(0); 		} 		if((fwrite(&num,sizeof(long),1,fp)) == NULL)//记录条数 		{ 			printf("write 2 error!"); 			//exit(0); 		}	 	} 	else 	{ 		if((fwrite(&t1,sizeof(long),1,fp)) == NULL) 		{ 			printf("write 1 error!"); 			 		} 		fseek(fp,2*sizeof(long),0); 		if((fread(&num,sizeof(long),1,fp)) == NULL) 		{ 		printf(" judge read error!"); 		} 		 	}	 	fclose(fp); 	fp = NULL;  	printf("\n%d年%d月%d日%d\:%d:%d\n",1900+t2->tm_year,1+t2->tm_mon,t2->tm_mday,t2->tm_hour,t2->tm_min,t2->tm_sec); 	printf("num is %d\n",num); } /******************************************************************************************************/ #define  g_menu 	printf("\n按下r键返回上一级-----");\ 					if(ct)\ 					{\ 						for( ; (i < 5)&&(i < num); i++) \ 						{ \ 							if((fread(&tmp,sizeof(addr),1,fp)) == NULL) \ 							{ \ 								printf("menu read error!"); \ 							} \ 							else \ 							{ \ 								printf("\n\t%d\t%s",i,tmp.explain); \ 							} 	\ 						} \ 					}\ 						printf("\n按c键继续————"); \ 						scanf("%s",&k); /*******************判断***************************/ int g_judge(char k) { 	int i = 0; 	int n; 	addr tmp2; 	n = atoi(&k); 	fseek(fp,3*sizeof(long),0); 	fseek(fp,n*sizeof(addr),1); 	if((fread(&tmp2,sizeof(addr),1,fp)) == NULL) 	{ 		printf(" judge read error!"); 	} 	printf("%s",tmp2.addr); 	tmp2.weight =tmp2.weight + 1; 	fseek(fp,(-1)*sizeof(addr),1); 	if((fwrite(&tmp2,sizeof(addr),1,fp)) == NULL) 	{ 		printf("write error!"); 	} 	printf("\nseccess!"); 	system(tmp2.addr); 	return 0;  }  /*******************插入***************************/ void g_insert(int n) { 	addr tmp;  	printf("请输入命令："); 	scanf("%s",tmp.explain); 	printf("请输入地址："); 	scanf("%s",tmp.addr); 	tmp.weight = 0; 	tmp.n = n;  	if((fwrite(&tmp,sizeof(addr),1,fp)) == NULL) 		{ 			printf("write error!"); 		}  	num = num + 1; 	fseek(fp,2L*sizeof(long),0); 	if((fwrite(&num,sizeof(long),1,fp)) == NULL) 	{ 		printf("write 3 error!"); 			 	} 	printf("insert  seccess\n"); 	fclose(fp); 	fp = NULL; 	getchar(); } /* void g_insert(int n) { 	addr tmp;  	if((fp = fopen(f_name,"rb+")) == NULL) 	{ 		printf("file open error!"); 	} 	printf("请输入命令："); 	scanf("%s",tmp.explain); 	printf("请输入地址："); 	scanf("%s",tmp.addr); 	tmp.weight = 0; 	tmp.n = 0; 	 	fseek(fp,0L,2); 	if((fwrite(&tmp,sizeof(addr),1,fp)) == NULL) 		{ 			printf("write error!"); 		} 	//num = num + 1; 	fseek(fp,2L*sizeof(long),0); 	if((fwrite(&num,sizeof(long),1,fp)) == NULL) 	{ 		printf("write 3 error!"); 			 	} 	printf("insert  seccess\n"); 	fclose(fp); 	fp = NULL; 	getchar(); } */ /*****************交换排序**************************************/ void g_sort() { 	fseek(fp,3*sizeof(long),0); 	 } /******************查找定位****************************************/ int g_search( ) { 	//#define IS_SAME strcmp(pt,tmp.explain) == 0 	 	int i = 0; 	int n; 	//int flag = 0; 	addr tmp;  	/*****************显示所有记录***************************************/ 	fseek(fp,3*sizeof(long),0); 	printf("\n**************************\n"); 	for(i = 0; i < num; i++) 	{ 		if((fread(&tmp,sizeof(addr),1,fp)) == NULL) 		{ 			printf(" judge read error!"); 		} 		printf("\n*%d*\texplain:%s",tmp.n,tmp.explain); 		printf("\n\taddr___%s\t",tmp.addr);  	} 	printf("\n请输入操作的记录序号："); 	scanf("%d",&n); 	return n;  	/************************************************************************/ 	/* 	do{ 		if((fread(&tmp,sizeof(addr),1,fp)) == NULL) 		{ 			printf(" judge read error!"); 		} 		if(feof(fp)) 		{ 			flag = -1; 			break; 		} 	}while (IS_SAME); 	 	return flag; 	*/ } /******************删除和修改****************************************/ void g_dam(char p) { 	addr tmp; 	if( p == 'd') 	{ 		fseek(fp, sizeof(addr),1); 	} 	else if(p == 'm') 	{ 		fseek(fp,sizeof(addr),1); 		printf("请输入命令："); 		scanf("%s",tmp.explain); 		printf("请输入地址："); 		scanf("%s",tmp.addr); 		printf("请输入权重："); 		scanf("%d",&tmp.weight);   	}  	 } /***********************************************************/ void g_modify() { #define MODIFY  (n < num )&&(n > 0) #define INSERT  (n == (num+1)) 	int n; 	addr tmp;  	n = g_search(); 	fseek(fp,3*sizeof(long),0); 	fseek(fp,(n-1)*sizeof(addr),1); 	 	if(MODIFY) 	{ 		printf("请输入命令："); 		scanf("%s",tmp.explain); 		printf("请输入地址："); 		scanf("%s",tmp.addr); 		printf("%d",tmp.weight); 		tmp.n = n; 		if((fwrite(&tmp,sizeof(addr),1,fp)) == NULL) 		{ 		printf("write error!"); 		} 	} 	else if(INSERT) 	{ 		g_insert(n); 	} 	else 	{ 		printf("禁止操作！"); 	} } /************************显示命令信息**********************************/ void g_showonwcmd() { 	int n; 	addr tmp;  	n = g_search( ); 	fseek(fp,3*sizeof(long),0); 	fseek(fp,(n-1)*sizeof(addr),1); 	if((fread(&tmp,sizeof(addr),1,fp)) == NULL) 	{ 		printf(" judge read error!"); 	} 	printf("\n*%d*\texplain:%s",tmp.n,tmp.explain); 	printf("\n\taddr___%s\t",tmp.addr); 	printf("\n\tweight__%d",tmp.weight); } /*******************************************************/ void g_op() { 	#define ct (num != 0)&&(i <= num) 	int i = 0;//循环计数 	char k; 	addr tmp; 	/*************打开文件*************************/  	fseek(fp,3*sizeof(long),0); //定位  	/*************************** 	*默认进入三级菜单 	*三级菜单 	****************************/  	printf("请输入相应数字选择操作"); 	g_menu 	switch(k) 	{ 		case 'c':     //继续显示可选项 			m_tree = 3; 			g_menu 				break; 		case 'r':    //返回到二级菜单 			m_tree = 2; 				break; 		//case 3: 		//case 4: 		default: 				if(g_judge(k) == -1) 				{ 					printf("not search"); 				} 				m_tree = 3; 			break; 		} /*******************************************************/ 	/************************* 	*二级菜单 	****************************/ 	if(m_tree == 2) 	{ 		system("cls"); 		printf("----------------------------------------------------"); 		printf("\n\t*0*\t退出程序"); 		printf("\n\t*1*\t增加一条命令"); 		printf("\n\t*2*\t修改一条命令"); 		printf("\n\t*3*\t显示一条命令"); 	 		//printf("\n\t*2*\t删除一条命令"); 		printf("\n----------------------------------------------------\n"); 		scanf("%d",&m_n); 		switch(m_n) 		{ 		case 0: 			exit(0); 		case 1: 			g_modify(); 			break; 		case 2: 			g_modify(); 		case 3: 			g_showonwcmd(); 		default: 			break;  		} 	} }   int main() { 	char g_f[]= "f_general"; 	m_tree = 0; //命令树层数初始化 	f_name = g_f; 	Time_Init(); 	if((fp = fopen(f_name,"rb+")) == NULL) 	{ 		printf("file open error!"); 	} 	while(1) 	{ 	g_op(); 	} 	return 0; } /*D:\\user_program\\QQ\\Bin\\QQScLauncher.exe  */

[ 引用 2 楼 user-4 的回复:lz最好给出测试代码, 不过注意的是, fread返回的类型是size_t, C语言中，可能会将NULL定义为(void*)0, 直接与0判断即可 然而我的代码好多啊，刚自己打算写一个的但是没有成功

c语言渣渣，如有幼稚言论，请谅解


Question: 关于c语言的函数调用和编译

这个结帖给分功能有问题啊，谢谢大家了，大家的解释都很有帮助

参考gcc源代码中sizeof的实现。

因为sizeof不是函数，只是个关键字，编译时就确定了，所以不会调用函数  类似的 sizeof(++i)  也不会让i自加

自己反汇编，单步执行  引用 1 楼 qq423399099 的回复:参考特性6： 特性6：当表达式作为sizeof的操作数时，它返回表达式的计算结果的类型大小，但是它不对表达式求值！ http://blog.csdn.net/hust_sheng/article/details/50537609 i get


Question: [c语言]请问这个问题是出错在哪里？

printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  在每个最后不带\n的printf后面加fflush(stdout); 在每个不想受接收缓冲区旧内容影响的scanf前面加rewind(stdin); 另外请检查scanf的返回值。 //请今后要用 int c; scanf("%c",&c); //时，都改为 char s[2]; int c; scanf("%1s",s); c=s[0];

在scanf("%c",...)前面都加上一句fflush(stdin);清空一下输入缓冲区 也可以自己单步调试或者直接打印，看看每一步的结果是不是都如你所料 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

scanf("%c", ...)  会将之前输入的换行符接收了


Question: 关于内存[C语言]

可以看一看滴水的教程 http://www.dtdebug.com/forum.php?mod=viewthread&tid=3211

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  http://bbs.csdn.net/topics/391971215

引用 2 楼 user-4 的回复:静下心仔细看，不可能看不懂，如果还是不懂，说明你不懂的地方  http://blog.csdn.net/youoran/article/details/10990815  +1


Question: 奇怪，C语言access库函数获取文件可执行权限出错

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

引用 1 楼 paschen 的回复:http://blog.163.com/lqy_super/blog/static/199751021201302351831330/  谢谢您的回复，我的问题是取不了文件的执行权限，一运行就出错 只测试  引用 2 楼 user-3 的回复:Microsoft 的 access 函数不支持 X_OK  谢谢，这个说法感觉合理，但没找到依据，暂且就这样认为吧

引用 1 楼 paschen 的回复:http://blog.163.com/lqy_super/blog/static/199751021201302351831330/  谢谢您的回复，我的问题是取不了文件的执行权限，一运行就出错 只测试文件的读写权限正常

Microsoft 的 access 函数不支持 X_OK


Question: 小白求助，还是关于矩阵乘法，求大神相助，谢谢

引用 1 楼 user-3 的回复:r[i][k]=a[i][j]*b[j][i];  是否应该是   r[i][k]+=a[i][j]*b[j][i];  另外检查是否会越界，你循环中 i 的值会到2  而a[i][j] 中a 的范围是 [0-1][0-2]，i为2的时候是不是越界了  可以了，谢谢！

引用 1 楼 user-3 的回复:r[i][k]=a[i][j]*b[j][i];  是否应该是   r[i][k]+=a[i][j]*b[j][i];  另外检查是否会越界，你循环中 i 的值会到2  而a[i][j] 中a 的范围是 [0-1][0-2]，i为2的时候是不是越界了感觉这个方法不错

“多一少一”问题占程序员常犯错误的10%以上！ 避免“多一少一”问题的方法之一是将比如<10甚至<5的数代入程序片断，掰手指头心算验证一下程序到底应该写为 x、x-1、x+1中的哪个？ <、<=、==、>、>=中的哪个？


Question: C语言题目求解

B、  一个整型表达式

C语言中判断数据类型或者表达式长度符；不是一个函数，字节数的计算在程序编译时进行，而不是在程序执行的过程中才计算出来。这个是从百度搜索出来的，说这个不是一个函数。

C 一个整型表达式   sizeof是C语言的一种单目操作符,就像C语言的其他操作符++、--等。 它并不是函数。 sizeof操作符以字节形式给出了其操作数的存储大小。 操作数可以是一个表达式或括在括号内的类型名，如double，int等。  如sizeof(double)的值应该是8，即double型数据在内存中占8个字节。  因此答案C正确


Question: C primer plus 练习题问题

理解和讨论之前请先学会如何观察！  仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]

A[B] *(A+B) *(B+A) B[A] //以上四行等价  "abc"[1] *("abc"+1) *(1+"abc") 1["abc"] //以上四行等价  A[0] *(A) 0[A] //以上三行等价

你说的是对的，但是数组的内存是连续的，还是可以读出来的，如果你输出下   *（ptr+3）就会发现区别了。

引用 8 楼 zaidaoshinima 的回复:没搞懂 你这个二维数组少了一个啊，少的那个自动用0替代吗？  数组部分初始化的，没有初值的部分赋0，如果没有记错的话。

没搞懂 你这个二维数组少了一个啊，少的那个自动用0替代吗？

你的p是int类型的指针，所以加2移动的距离不是数组的距离，而是一个int元素的距离  torf[2][2] 实际是4个连续的int，所以 *(ptr + 2) 指向的是其中的第三个

引用 6 楼 u010165006 的回复:[quote=引用 5 楼 u010165006 的回复:] ptr = torf[0]; ———————— *ptr == ptr[0] == torf[0][0] *(ptr + 2) == ptr[2] == torf[0][2]  torf[0][2] 实际上越界了，不过int torf[2][2] = {12, 14,16}; 这个二维数组是按行连续存储的，所以 torf[0][2] == torf[1][0] （列满了就进一行，或者把二维数组当做一维来看，它们是同一个） [/quote]  把二维数组当做一维来看，比如数组int a[5][10] 对应 int b[5x10]，那么 a[i][j] 对应 b[ i*10+j ]

引用 5 楼 u010165006 的回复:ptr = torf[0]; ———————— *ptr == ptr[0] == torf[0][0] *(ptr + 2) == ptr[2] == torf[0][2]  torf[0][2] 实际上越界了，不过int torf[2][2] = {12, 14,16}; 这个二维数组是按行连续存储的，所以 torf[0][2] == torf[1][0] （列满了就进一行，或者把二维数组当做一维来看，它们是同一个）

torf[0][0]，torf[0][1]，torf[1][0]，torf[1][1] 地址连续，你用指针访问相当于访问第三个数据。 torf[1][0]，因此是16.


Question: 为什么同一段代码别人的可以编译通过自己敲的不行

引用 3 楼 user-2 的回复:引用 2 楼 qq_36151474 的回复:[quote=引用 1 楼 user-2 的回复:] 注意空格。。。     哪里 我又重新看了遍 还是没找到 SeqList*                SeqList_Create(); int SeqList_Insert(...)[/quote]   奥我明白了以后会注意的谢谢大伙

像这个SeqList *SeqList_Create(int capacity); 你写成的是SeqList*SeqList_Create(int capacity); SeqList后面需要加个空格

引用 2 楼 qq_36151474 的回复:引用 1 楼 user-2 的回复:注意空格。。。     哪里 我又重新看了遍 还是没找到 SeqList*                SeqList_Create(); int SeqList_Insert(...)

注意空格。。。


Question: 如何在#define index strchr中只替换掉函数名index,不替换变量名index?

理解和讨论之前请先学会如何观察！  VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898

处理宏的时候还不认识啥是函数，啥是变量。  你不如写个 char *index(const char *str, int c) {     return strchr(str, c); }

宏替换的时候不会区分这些，干嘛要取成一样的名字


Question: c语言 struct 和 typedef struct定义 运行时又什么区别？

// C/C++ 结构体声明： struct struct1 { int dummy; }; typedef struct { int dummy; } STRCUT2; typedef struct struct3 { int dummy; } STRCUT3;  // C/C++ 结构体定义： struct1 xxx1;           // 仅 C++ struct struct1 xxx1;    // C/C++  STRCUT2 xxx1;           // C/C++  struct3 xxx1;           // 仅 C++ struct struct3 xxx1;    // C/C++ STRCUT3 xxx1;           // C/C++除了简化写法之外，没什么区别，而且 C++ 支持省略 struct 关键字。之所以开源项目喜欢直接写 struct xxx 之类的，可能是为了体现这是一个结构体。不像 Windows 编程中，宏、数据类型、枚举、结构体一律大写，会给初学编程的人带来很大困惑。

struct student {  }  typedef struct {  } student;  我想说的是struct student a和student a有什么区别？？

最近看了几个开源项目的代码。 我发现他们似乎更喜欢用struct 而不是typedef struct。 如果没区别的话，为什么不用typedef？ 这样写起来不也更简单么

typedef，定义别名。

typedef typedef type-declaration synonym;  The typedef keyword defines a synonym for the specified type-declaration. The identifier in the type-declaration becomes another name for the type, instead of naming an instance of the type. You cannot use the typedef specifier inside a function definition.  A typedef declaration introduces a name that, within its scope, becomes a synonym for the type given by the decl-specifiers portion of the declaration. In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types — they introduce new names for existing types.  Example  // Example of the typedef keyword typedef unsigned long ulong;  ulong ul;     // Equivalent to "unsigned long ul;"  typedef struct mystructtag {    int   i;    float f;    char  c; } mystruct;  mystruct ms;   // Equivalent to "struct mystructtag ms;"  typedef int (*funcptr)();  // funcptr is synonym for "pointer                            //    to function returning int"  funcptr table[10];   // Equivalent to "int (*table[10])();"     struct struct [tag] { member-list } [declarators];  [struct] tag declarators;  The struct keyword defines a structure type and/or a variable of a structure type. See Anonymous Structures and Unsized Array in a Structure for more information.  A structure type is a user-defined composite type. It is composed of "fields" or "members" that can have different types.  In C++, a structure is the same as a class except that its members are public by default.  Using a Structure  In C, you must explicitly use the struct keyword to declare a structure. In C++, this is unnecessary once the type has been defined.  You have the option of declaring variables when the structure type is defined by placing one or more comma-separated variable names between the closing brace and the semicolon.  For related information, see class, union, and enum.  Example 1  struct PERSON              // Declare PERSON struct type {    int   age;              // Declare member types    long  ss;    float weight;    char  name[25]; } family_member;           // Define object of type PERSON     struct PERSON sister;   // C style structure declaration    PERSON brother;         // C++ style structure declaration     sister.age  = 13;       // assign values to members    brother.age =  7; Structure variables can be initialized. The initialization for each variable must be enclosed in braces.  Example 2  struct POINT            // Declare POINT structure {    int x;               // Define members x and y    int y; } spot = { 20, 40 };    // Variable spot has                         //     values x = 20, y = 40 struct POINT there;     // Variable there has POINT type struct CELL             // Declare CELL bit field {    unsigned character  : 8;  // 00000000 ????????    unsigned foreground : 3;  // 00000??? 00000000    unsigned intensity  : 1;  // 0000?000 00000000    unsigned background : 3;  // 0???0000 00000000    unsigned blink      : 1;  // ?0000000 00000000 } screen[25][80];       // Array of bit fields

C++下不用typedef也可以直接xxx a;

只是写起来简便，生成的汇编代码都一样，运行时没有区别  如果不用typedef，C语言中定义结构体变量要写成： struct xxx a;  使用了可以直接写成xxx a;


Question: 关于qrencode3.4.4（目录）如何生成qrencode可执行程序到开发板上

使用ldd命令查看可执行程序依赖的.so

恩，这个是第二个问题的解答方案！谢谢，那么，第一个问题，你能帮我解决下吗，就是怎么把二维码编译依赖的libpng库变成一个动态库，放到开发板的/usr/lib/目录下，以及怎么样在我的qrencode3.4.4目录下生成qrencode？

静态链接 ？


Question: struct结构体函数

这么做的目的是什么呢？

// 引用仅存在于 C++，指针则都可以使用。  // 指针声明/实现： void func(int *ptr) { 	*ptr = -1; } // 指针调用： int i; func(&i); printf("%d\n", i); // -1  // 引用声明/实现： void func(int &ref) { 	ref = -1; } // 引用调用： int i; func(i); printf("%d\n", i); // -1

声明中…… 使用中……

给你举个例子： 定义函数：  void fa(int d); void fb(int& d); void fc(int* pd);  使用函数：  int d = 0; fa(d); //将d的值赋值一份传给fa，这里的d和fa里的d是两回事，两个毫不相干的东西 fb(d); //将d传给fb，这里的d和fb里的d是一回事，同一个东西 fc(&d);//将d的指针传给fc，fc里的pd是一个指针，指向这里的d，你修改fc里pd的值不会影响到外面的d，但你修改fc里*pd的值，则会改变外面d的值（前提是你fc的pd一直指向d)

引用 11 楼 super_admi 的回复:[quote=引用 9 楼 WX_East 的回复:] c语言是没有引用这个概念的  貌似C99有引用吧？[/quote]  没有。C11 也没有。  楼主程序 C 语言是编不过的。

引用 9 楼 WX_East 的回复:c语言是没有引用这个概念的  貌似C99有引用吧？

先搞清楚引用的概念。，所以引用其实就是对象的别名，比如 int a(int &c); c这个就是外部的整形的变量，而不是指针。

c语言是没有引用这个概念的

引用 3 楼 loveqise 的回复:[quote=引用 1楼fefe82 的回复:]struct gas & 这是个引用 &ptr 这是个指针struct gas不是结构类型吗，&ptrip是指向struct gas类型的指针[/quote]  你需要找本教材好好看看了。 http://en.cppreference.com/w/cpp/language/pointer http://en.cppreference.com/w/cpp/language/reference

而按引用传递需要的不是一个指针！

函数声明参数中的&表示的是引用，不是取址  调用时的&是取地址  两个&不是同一回事

引用 2楼qq_36409192 的回复:你的声明问题。声明应该声明*ptr&ptr就是指针啊！

引用 1楼fefe82 的回复:struct gas & 这是个引用 &ptr 这是个指针不可以这样理解吗？

引用 1楼fefe82 的回复:struct gas & 这是个引用 &ptr 这是个指针struct gas不是结构类型吗，&ptrip是指向struct gas类型的指针

你的声明问题。声明应该声明*ptr

struct gas & 这是个引用 &ptr 这是个指针


Question: 自己写的代码希望帮忙精简一下

差不多可以了吧

仅供参考：//Round(1.234,2) = 1.23 //Round(1.234,0) = 1.0 //Round(123.4,-1) = 120.0 double Round(double dVal, short iPlaces) {     double dRetval;     double dMod = 0.0000001;     if (dVal<0.0) dMod=-0.0000001;     dRetval=dVal;     dRetval+=(5.0/pow(10.0,iPlaces+1.0));     dRetval*=pow(10.0,iPlaces);     dRetval=floor(dRetval+dMod);     dRetval/=pow(10.0,iPlaces);     return(dRetval); }  double round(double dVal, short iPlaces) //iPlaces>=0 {     unsigned char s[20];     double dRetval;      sprintf(s,"%.*lf",iPlaces,dVal);     sscanf(s,"%lf",&dRetval);     return (dRetval); }

其实我想从算法上精简一下，但是看来差不多了。非常感谢大家！

int w(n)  改成：  int w(int n)

#include<stdio.h> #include<math.h> int w(int n) {  [size=18px]   int sum=1;     while(n>=10)     {         n=n/10;         sum++;     }     return sum; } int main(void) {     int money,hours,square;     scanf("%d %d",&money,&hours);     //square=(int)((float)money/hours+0.5)*(int)((float)money/hours+0.5);     square=(int)((float)money/hours+0.5);     square=square*square;          printf("%.2f\n%d\n%d\n",(float)money/hours,(int)((float)money/hours+0.5),w(square));     printf("%d %d %d\n",(square%1000)/100,(square%100)/10,square%10); }   不知道还能更简单？    [/size]


Question: 不允许指向不完整的类型

使用tpyedef typedef struct Student{...}stu; 声明：stu *p1, *head, *p2; malloc：p1 = p2 = (stu*)malloc(LEN); 没有main函数  creat没有返回值

student拼写错误

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

struct Studnet *p1, *head, *p2;  改成：  struct Student *p1, *head, *p2;


Question: 在SVGA模式下，可以直接用graphics库中的函数么？

下载一个EasyX，安装以后，用VC来编写图形程序，跟用BC编写图形程序差不多完全一样。

引用 3 楼 tianxingkong 的回复:[quote=引用 2楼ooolinux 的回复:]楼主如果想用BC编写图形程序，可以了解一下EasyX，EasyX是Windows平台最简单的绘图函数库（名副其实），兼容BC和TC的绘图函数，在VC下用EasyX来编程跟在TC下编程绘图差不多是完全一样的。  下载一个EasyX包，里面有完整的函数手册。EasyX官网有实例。  仅供参考： 用绘图语句画机器猫（初学C语言的同学必看） http://blog.163.com/tab_98/blog/static/1192409720150316223680/在BC上运行，运行结果是，只适合C++...[/quote]  在BC上运行？还是在VC中使用EasyX？将源代码存为cpp文件就可以了。

引用 1楼赵4老师 的回复:http://www.easyx.cn用BC运行显示只适合C++

引用 2楼ooolinux 的回复:楼主如果想用BC编写图形程序，可以了解一下EasyX，EasyX是Windows平台最简单的绘图函数库（名副其实），兼容BC和TC的绘图函数，在VC下用EasyX来编程跟在TC下编程绘图差不多是完全一样的。  下载一个EasyX包，里面有完整的函数手册。EasyX官网有实例。  仅供参考： 用绘图语句画机器猫（初学C语言的同学必看） http://blog.163.com/tab_98/blog/static/1192409720150316223680/在BC上运行，运行结果是，只适合C++...

在BC上运行

然后我下了一个头文件大全，然后又提示头文件有各种error

引用 5楼ooolinux 的回复:[quote=引用 3 楼 tianxingkong 的回复:] [quote=引用 2楼ooolinux 的回复:]楼主如果想用BC编写图形程序，可以了解一下EasyX，EasyX是Windows平台最简单的绘图函数库（名副其实），兼容BC和TC的绘图函数，在VC下用EasyX来编程跟在TC下编程绘图差不多是完全一样的。  下载一个EasyX包，里面有完整的函数手册。EasyX官网有实例。  仅供参考： 用绘图语句画机器猫（初学C语言的同学必看） http://blog.163.com/tab_98/blog/static/1192409720150316223680/在BC上运行，运行结果是，只适合C++...[/quote]  在BC上运行？还是在VC中使用EasyX？将源代码存为cpp文件就可以了。[/quote]试了，结果就是缺少各种头文件...


Question: 我想任意输如一个单词，然后反序输出。但是我只能自由输出4个字母。4个以上的就被截断了 ？？求解！！！！

ss数组是未初始化，相当于strlen定义。

以上代码直接用就可以了.

#include<stdio.h> #include<string.h> int main(void) {        int N,index; char ss[30] = {0}; index=0;     N = 30; for(;index<=N;index++) { scanf("%c",&ss[index]);     if(ss[index] == '\n') break; }   printf("%c", '\n'); for(int i=index-1;i>=0;i--)  {	 printf("%c",ss[i]);  } printf("\n");	 return 0; }

首先。你的ss数组没有初始化。。那个strlen的使用是未定义的。。其次。%c会把回车也读入。。你可以直接用%s直接输入字符串(更简单)。。然后在循环输出。。  望采纳。。

引用 2 楼 ASSholeli的回复:这个问题我意识到了，但是我如果放在输入数组后面，又感觉不对。 检查输入的字符是不是\n判断是否输入完，而不是用长度去判断

这个问题我意识到了，但是我如果放在输入数组后面，又感觉不对。

strlen 获取的是以\0结尾的字符串长度  你的ss还没有初始化就使用strlen是未定义行为


Question: gdb貌似会影响运行过程中eax的值，为何?

要确认当前eip的值是在刚执行完printf函数之后。

printf 的返回值的含义参看：http://en.cppreference.com/w/c/io/fprintf


Question: 求解释这里的循环条件改成什么才能使用scanf进行输入。。急急急

#include <stdio.h> #include <string.h> #include <stdlib.h> typedef struct {     char ch[20]; } CHAR; int main() {     CHAR a[20]={0};     int n,i=0;     char ln[21];     while (1) {         printf("Enter word:");fflush(stdout);         rewind(stdin);         fgets(ln,21,stdin);         if (ln[0]=='\n') break;         sscanf(ln,"%s",&a[i].ch);         i++;         if (i>=20) break;     }     n=i;     for (i=0;i<n;i++) printf("%02d [%s]\n",i,a[i].ch);     return 0; }

引用 6 楼 赵4老师的回复:#include <stdio.h> #include <string.h> #include <stdlib.h> typedef struct {     char ch[20]; } CHAR; int main() {     CHAR a[20]={0};     int n,i=0;     char ln[21];     while (1) {         printf("Enter word:");fflush(stdout);         fgets(ln,21,stdin);         if (ln[0]=='\n') break;         sscanf(ln,"%s",&a[i].ch);         i++;         if (i>=20) break;     }     n=i;     for (i=0;i<n;i++) printf("%02d [%s]\n",i,a[i].ch);     return 0; }  请问可不可以就只改这里的循环条件？？这里用scanf的话直接按回车跳不出循环。。请老师指点下。。

引用 4 楼 qq_15369501的回复:这个条件判断是出现首个字符为0时候么？不知道楼主想在什么样的条件下跳出循环，最后加一个i得长度限定，否则可能会越界 这个其实就是循环输入。。然后如果直接输入回车。。就跳出循环。。用gets()直接回车。。那个a[i-1].ch[0]可以初始化为0，但是scanf的话就不能用这个条件。。所以我才发的这个问题。。希望大神指点一下。。

引用 1 楼 user-3的回复:%s本来就是直接输入一整个字符串，而不是一个字符一个字符的输入  所以你完全可以不用循环，直接写成；  scanf("%s",a); 而且你似乎没看懂我这个程序这一部分的意思。。

引用 1 楼 user-3的回复:%s本来就是直接输入一整个字符串，而不是一个字符一个字符的输入  所以你完全可以不用循环，直接写成；  scanf("%s",a); 我现在需要的不是说这个scanf怎么改。。而是这里我如果用这种形式进行输入的话。。这个循环条件该改成什么。。我也知道这里可以直接用gets()。。


Question: leetcode wrong answer但是输出结果是对的，是什么问题？

结尾有没有多余空格或多余换行？有可能机器很严格

我也出现过这种问题，感觉leetcode有点奇怪。。。

不是啊，截图中的例子就会导致wrong answer，但是明显一样啊

不要看一组数据的正误，你应该关注的是你的代码不能让所有测试输入得到正确输出。

边界条件 输入输出格式 ……

什么意思？可是output和expected是一样的


Question: winhex 无壳，怎样可以看到源代码

使用IDA Pro软件。

哪里说开源...


Question: 关于虚拟内存

1、栈效率高的其中一个原因是很多指令是针对于栈专门设置的  2、应用层的程序不应该考虑申请这种内存

引用 5 楼 bbsdgy 的回复:[quote=引用 1 楼 ID870177103 的回复:] 对于系统而言程序的栈没有特别意义，它也是从全局的堆上分配的 实际上你的程序根本不能直接访问物理内存，都是通过内存分页之类的系统访问的，否则一旦出现内存访问错误，整个系统都会崩溃 每个进程的内存地址都是虚拟的  栈如果也是从堆上分配的，为什么说栈的效率比堆的要高[/quote]  栈的内存直接用（只要不溢出），函数里面int a,b[10];就在栈里分配4个字节给a，40个字节给b。 堆内存是系统管理的，一块一块的空闲内存通过链表一样的数据结构被系统管理起来，当程序申请内存的时候，操作系统要找到一块合适大小的内存分配给它，根据算法不同，可能找到最小的但足够大小的内存来分配（缺点是分配以后剩余的内存空隙更小以后更不好使用），也可能找到一块比较大的内存来分配（这样这一块内存分割以后剩余的内存以后还能使用，但缺点是当程序后来申请很大的内存时可能无法找到足够大块的内存）。所以操作系统要权衡考虑这些问题（这样需要权衡的问题在操作系统中比比皆是，根本原因是因为资源是有限的，而用户对性能、响应、表现、可用性、可靠性的追求是无限的）。

栈相对效率高的原因很容易知道啊，因为它已经分配了，而堆内存使用时才分配 考虑让内存无法移动是没有意义的，应用层程序就应该只做应用层的事情，如果你要做内核的东西，在这里找不到多少帮助的

引用 7 楼 fefe82 的回复:[quote=引用 5 楼 bbsdgy 的回复:] [quote=引用 1 楼 ID870177103 的回复:] 对于系统而言程序的栈没有特别意义，它也是从全局的堆上分配的 实际上你的程序根本不能直接访问物理内存，都是通过内存分页之类的系统访问的，否则一旦出现内存访问错误，整个系统都会崩溃 每个进程的内存地址都是虚拟的  栈如果也是从堆上分配的，为什么说栈的效率比堆的要高[/quote]  此栈非彼栈，此堆非彼堆[/quote]  可以详细说一下吗，不是说访问栈内存比堆内存效率要高    引用 8 楼 fefe82 的回复:[quote=引用 楼主 bbsdgy 的回复:] 如果内存不够用，操作系统会把内存转到虚拟内存 那么对于一个程序： 1、是不是只有堆上申请的内存会被转移到虚拟内存，而栈上的不会 2、怎样让我程序申请的内存禁止被转移到虚拟内存  在现代操作系统上，你所有的内存都是虚拟的。  你所谓的“虚拟”，是不是指在硬盘上而不是物理内存中的？ 这个程序员一般无法控制。频繁访问的就会一直在屋里内存里。栈用的比较多，所以可能换出去的机会少。但是一样是可以换出去的。[/quote]  我指的虚拟内存是移到pagefile.sys中的，只讨论WINDOWS下的情况吧，正如楼上说的，任务管理器可以看到未分页内存，证明是可以申请这样的内存的，不过不知具体要怎么申请

引用 楼主 bbsdgy 的回复:如果内存不够用，操作系统会把内存转到虚拟内存 那么对于一个程序： 1、是不是只有堆上申请的内存会被转移到虚拟内存，而栈上的不会 2、怎样让我程序申请的内存禁止被转移到虚拟内存  在现代操作系统上，你所有的内存都是虚拟的。  你所谓的“虚拟”，是不是指在硬盘上而不是物理内存中的？ 这个程序员一般无法控制。频繁访问的就会一直在屋里内存里。栈用的比较多，所以可能换出去的机会少。但是一样是可以换出去的。

引用 5 楼 bbsdgy 的回复:[quote=引用 1 楼 ID870177103 的回复:] 对于系统而言程序的栈没有特别意义，它也是从全局的堆上分配的 实际上你的程序根本不能直接访问物理内存，都是通过内存分页之类的系统访问的，否则一旦出现内存访问错误，整个系统都会崩溃 每个进程的内存地址都是虚拟的  栈如果也是从堆上分配的，为什么说栈的效率比堆的要高[/quote]  此栈非彼栈，此堆非彼堆

引用 4 楼 DelphiGuy 的回复:所有应用程序的内存和大部分操作系统内存都是可交换的，可以看一下任务管理器，即便内存使用几GB，未分页内存只有几十MB到一两百MB（依据系统的不同）。 要分配非分页内存可以使用ntoskrnl.exe中的MmAllocateNonCachedMemory  谢谢，我觉得你回答的很好，不过还想问下  这么说程序栈上的内存也会移到虚拟内存里？ 另外，怎么调用MmAllocateNonCachedMemory ，要包含什么头文件？

引用 1 楼 ID870177103 的回复:对于系统而言程序的栈没有特别意义，它也是从全局的堆上分配的 实际上你的程序根本不能直接访问物理内存，都是通过内存分页之类的系统访问的，否则一旦出现内存访问错误，整个系统都会崩溃 每个进程的内存地址都是虚拟的  栈如果也是从堆上分配的，为什么说栈的效率比堆的要高

用GlobalAlloc申请的内存用GlobalLock锁定可能不会被移动

这里涉及到了一个内存映射问题，每一个进程都会对应的分配一个虚拟内存空间，该虚拟内存通过内存映射机制映射到你的物理内存上去


Question: 函数返回值

请那些喜欢将数组作为函数参数传来传去或作为函数返回值的码农思考一下为什么不把整个互联网内容当作函数参数传来传去或作为函数返回值呢？

可以用matlab

标准就这么规定的，C/C++函数返回值是通过寄存器EAX返回的，如果太多，没那么多寄存器存放  可以通过参数解决返回多个值，这样这些值是通过堆栈来返回的

就如你所说，返回多个，那应该怎么声明？？？ 怎么接收？这样就不需要结构体之类的了，也不需要引用，指针，返回了。

如果返回多个值得话  就不好声明吧

C++ 11  函数返回 std::pair类型，满足需求

快学习python吧,满足你的需求.

原因我觉得是多方面的 1.声明，使用麻烦。 2.函数调用本身就资源耗费大，多个返回值带来调用栈空间使用过多。 3.不适合对资源限制大的应用场景。 总的来说，与c++尽可能提高效率的设计原则不符。

对于C++这种编译语言，返回多个值都不好声明，对于脚本语言来说这一点很好做到，在C++中可以用结构体和指针达到你的目的

变参可以返回多个值。

如果你确实需要返回多个数据，就选择使用结构体指针

多个 可以返回结构体指针啊。

Python中看起来是可以直接返回多个，但其实内部还是做了封装，返回的是tuple，然后在接收处进行解开。 因此，如需效仿，可以返回一个数组指针、结构体、类都可以，但同样要进行结构拆除。  另外，可能最大的差异是C/C++是静态语言，Python是动态语言，因此数据细节部分需要更好规划才开始实现。

语言之前本来就是有区别的。 能返回很多个值就显得封装性好了？