Datasets:

Mxode

/

CSDN-Community-C-Language-3years

like 2

[ { "cid": "1", "user": "user-1", "content": "灰常灰常简单滴啦，当然你非要什么函数的话就要增加几行代码~ #include <stdio.h> int main() { int b[1024], n = 0; for (int c; (c = getchar()) != 10;) if (c == '+' || c == '-' || (c > 47 && c < 58)) { ungetc(c, stdin); if (scanf(\"%d\", &b[n]) == 1) n++; } for (int i = 0; i < n; i++) printf(\"%d \", b[i]); puts(\"\"); return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "非常感谢大佬", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "int flg = 0; // 标记是否已经执行atoiint n = 0; // b数组下标char * str = \"abc456sd78fd123s 789df\";char * p = NULL; for (p = str; *p; ++p){ if (*p >= '0' && *p <= '9' && 0 == flg) { b[n++] = atoi(p); flg = 1; } if (*p < '0' || *p > '9' && 1 == flg) { flg = 0; }}", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "非常感谢，懂了！那要是随意输入一个字符串，去判断呢？", "referer": "user-2" }, { "cid": "5", "user": "user-0", "content": "百思不能写出稍微完美的程序", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你知道，回字有四种写法。什么时候用哪一种呢？仅仅这样问是不是挺扯？ 上下文都是简体字的时候，你自然写简体标准。上下文都是繁体字的时候，你就要写繁体写法。搞书法的时候尤其是写对联的时候呢，一般用繁体字，但是上下联用到同一个字的时候一般需要变体，于是变体也有用的地方了。 而楼主的问题就失之于表面，你不要背代码，你得理解进去，然后知该从0开始就从0开始，该从1开始就从1开始，该从2开始就从2开始...", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "这得看后续是什么功能和实现的方法吧；如排序，由于是两两比较，所以 10 个数 9 次比较就可实现一遍；如输出，就得是 10 次了。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "1！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "step-- 的缘故吧，后自减，即语句执行后再减，那就是始终是 return(func2(1000)); 了，所以，就溢出了。换 --step 试试？", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "对，是因为这个", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "spi从机是个外设，站在楼主的代码的角度看，外设那边一般没有处理器，也就没有代码，应该是靠芯片实现的功能。就好象U盘，U盘端本身一般是不运行软件代码的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "仅供参考： #include <stdio.h> void main(int argc,char *argv[]) { int i; for (i=0;i<argc;i++) { printf(\"argv[%d]=[%s]\\n\",i,argv[i]); } } //C:\\>arg 1 2 3 //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2] //argv[3]=[3] // //C:\\>arg 1 \"2 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 3] // //C:\\>arg 1 \"2 \"\"3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"3] // //C:\\>arg 1 \"2 \"\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"] //argv[3]=[3] // //C:\\>arg 1 \"2 \\\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \" 3] // //C:\\>arg 1 \"2 \\\\\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \\] //argv[3]=[3] // //C:\\>arg 1 \"2 \\\\\\\" 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \\\" 3] // //C:\\>arg 1 \"2 \\\"\\ 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"\\ 3] // //C:\\>arg 1 \"2 \\\"\\\\ 3\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[2 \"\\\\ 3] // //C:\\>arg 1 \"|\" //argv[0]=[arg] //argv[1]=[1] //argv[2]=[|] // //C:\\>arg 1 | //命令语法不正确。 // //C:\\>arg 1 ^| //argv[0]=[arg] //argv[1]=[1] //argv[2]=[|] // //C:\\>arg 1 > //命令语法不正确。 // //C:\\>arg 1 ^> //argv[0]=[arg] //argv[1]=[1] //argv[2]=[>] // //C:\\>arg 1 < //命令语法不正确。 // //C:\\>arg 1 ^< //argv[0]=[arg] //argv[1]=[1] //argv[2]=[<] // //C:\\>arg 1 & //argv[0]=[arg] //argv[1]=[1] // //C:\\>arg 1 && //命令语法不正确。 // //C:\\>arg 1 ^& //argv[0]=[arg] //argv[1]=[1] //argv[2]=[&] // //C:\\>arg 1 ^&& //argv[0]=[arg] //argv[1]=[1] //argv[2]=[&] // //C:\\>arg 1 ^&^& //argv[0]=[arg] //argv[1]=[1] //argv[2]=[&&] // //命令行解释器概述命令行解释器是一个单独的软件程序，它可以在用户和操作系统之间提供直接的通讯。非图形命令行解释器用户界面提供运行基于字符的应用程序和实用程序的环境。通过使用类似于 MS-DOS 命令解释程序 Command.com 的单独字符，命令行解释器执行程序并在屏幕上显示其输出。Windows 服务器操作系统命令行解释器使用命令解释程序 Cmd.exe（该程序加载应用程序并指导应用程序之间的信息流动）将用户输入转换为操作系统可理解的形式。 // //可以使用命令行解释器创建和编辑可自动执行常规任务的批处理文件（也称作脚本）。例如，可以使用脚本自动管理用户帐户或夜间备份。还可以使用 Windows 脚本宿主 CScript 的命令行版本在命令行解释器中运行更高级的脚本。详细信息，请参阅运行 Windows 脚本宿主。通过使用批处理文件来执行操作，可比使用用户界面更有效率。批处理文件接受命令行上可用的所有命令。有关批处理文件和脚本的详细信息，请参阅使用批处理文件。 // //您可以自定义命令提示符窗口以易于查看并增强对程序运行方式的控制。有关自定义命令提示符窗口的详细信息，请参阅配置命令提示符。 // //使用命令语法 //语法按命令及所带参数必须遵循的键入顺序出现。下面的 xcopy 命令示例显示了各种语法文本格式： // //xcopy Source [Destination] [/w] [/p] [/c] [/v] [/q] [/f] [/l] [/g] [/d[:MM-DD-YYYY]] [/u] [/i] [/s [/e]] [/t] [/k] [/r] [/h] [{/a | /m}] [/n] [/o] [/x] [/exclude:File1[+[File2]][+[File3]] [{/y | /-y}] [/z] // //下表说明如何解释不同的文本格式。 // //格式化图例 // 格式 含义 // 斜体 用户必须提供的信息 // 粗体 用户必须准确键入的要显示的元素 // 省略号 (...) 在命令行中可多次重复的参数 // 中括号 ([]) 可选项 // 大括号 ({})；选项用竖线 (|) 分隔。例如：{even|odd} 用户必须从选项集合中选择一个 // //使用多个命令和条件处理符号 //使用条件处理符号可以在单个命令行或脚本中运行多个命令。通过条件处理符号运行多个命令时，条件处理符号右边的命令根据条件处理符号左边命令的执行结果来发挥作用。例如，只有在前一个命令失败的情况下才可能需要运行一个新命令。或者，只有在前一个命令成功时才可能需要运行一个新命令。 // //可以使用下表列出的特殊字符来传递多个命令。 // //字符 语法 定义 //& [...] Command1 & Command2 用来分隔一个命令行中的多个命令。Cmd.exe 运行第一个命令，然后运行第二个命令。 //&& [...] Command1 && Command2 只有在符号 && 前面的命令成功时，才运行该符号后面的命令。Cmd.exe 运行第一个命令，然后只有在第一个命令运行成功时才运行第二个命令。 //|| [...] Command1 || Command2 只有在符号 || 前面的命令失败时，才运行符号 || 后面的命令。Cmd.exe 运行第一个命令，然后只有在第一个命令未能运行成功（接收到大于零的错误代码）时才运行第二个命令。 //( ) [...] (Command1 & Command2) 用来分组或嵌套多个命令。 // // 注意 // //“与”符号 (&)、管道符号 (|) 以及括号 () 是特殊字符，将它们作为参数传递时，必须在其前面加上转义字符 (^) 或引号。 //如果某个命令成功完成操作，该命令就返回零 (0) 退出代码或不返回任何退出代码。有关退出代码的详细信息，请参阅 Microsoft Windows 部署和资源工具包。 //嵌套命令行解释器 //通过在命令提示符下打开新的 Cmd.exe 实例，可以在 Cmd.exe 内嵌套命令行解释器。默认情况下，Cmd.exe 的每个实例继承其父 Cmd.exe 应用程序的环境。通过嵌套 Cmd.exe 的实例，可以更改局部环境，而不会影响 Cmd.exe 的父应用程序。这使您能够保留 Cmd.exe 的原始环境，并在终止嵌套的命令行解释器之后返回到原始环境。但是在嵌套的命令行解释器中所做的更改将不会被保存。 // //要嵌套命令行解释器，请在命令提示符下键入： // //cmd // //出现类似于下面内容的消息： // //Microsoft (R) Windows Server 2003 Standard Edition (TM) //(C) 版权所有 1985-2002 Microsoft Corp. //要关闭嵌套的命令行解释器，请键入 exit。 // //使用 setlocal 和 endlocal 命令，可以在 Cmd.exe 的实例中（或在脚本中）进一步将更改局部化。Setlocal 创建局部作用范围，而 endlocal 终止局部作用范围。在 setlocal 和 endlocal 作用范围内所做的更改将会被放弃，从而保持原始环境不变。这两个命令的嵌套最高可达到 32 级。有关 setlocal 和 endlocal 命令的详细信息，请参阅 Setlocal 和 Endlocal。 // //将环境变量与 Cmd.exe 一起使用 //Cmd.exe 命令行解释器环境由确定命令行解释器和操作系统行为的变量进行定义。可以使用两种类型的环境变量（系统和局部）来定义命令行解释器环境或整个操作系统环境的行为。系统环境变量定义全局操作系统环境的行为。局部环境变量定义 Cmd.exe 当前实例环境的行为。 // //系统环境变量预置于操作系统之中，并可用于所有 Windows 服务器操作系统进程。只有具有管理凭据的用户才可以更改系统变量。这些变量最常用于登录脚本。 // //局部环境变量只有在创建变量时针对的目标用户登录到计算机时才有效。HKEY_CURRENT_USER 配置单元中设置的局部变量只对当前用户有效，但它们可定义全局操作系统环境的行为。 // //下表按优先顺序的降序描述变量的各种类型： // //内置系统变量 //在 HKEY_LOCAL_MACHINE 配置单元中找到的系统变量 //在 HKEY_CURRENT_USER 配置单元中找到的局部变量 //在 Autoexec.bat 文件中设置的所有环境变量和路径 //在登录脚本（如果有的话）中设置的所有环境变量 //在脚本或批处理文件中交互使用的变量 //在命令行解释器中，Cmd.exe 的每个实例都继承其父应用程序的环境。因此，可以在不影响父应用程序环境的情况下更改新的 Cmd.exe 环境中的变量。 // //下表列出 Windows server operating system 的系统和本地环境变量。 // //变量 类型 描述 //%ALLUSERSPROFILE% 本地 返回“所有用户”配置文件的位置。 //%APPDATA% 本地 返回默认情况下应用程序存储数据的位置。 //%CD% 本地 返回当前目录字符串。 //%CMDCMDLINE% 本地 返回用来启动当前的 Cmd.exe 的准确命令行。 //%CMDEXTVERSION% 系统 返回当前的“命令处理程序扩展”的版本号。 //%COMPUTERNAME% 系统 返回计算机的名称。 //%COMSPEC% 系统 返回命令行解释器可执行程序的准确路径。 //%DATE% 系统 返回当前日期。使用与 date /t 命令相同的格式。由 Cmd.exe 生成。有关 date 命令的详细信息，请参阅 Date。 //%ERRORLEVEL% 系统 返回上一条命令的错误代码。通常用非零值表示错误。 //%HOMEDRIVE% 系统 返回连接到用户主目录的本地工作站驱动器号。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。 //%HOMEPATH% 系统 返回用户主目录的完整路径。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。 //%HOMESHARE% 系统 返回用户的共享主目录的网络路径。基于主目录值而设置。用户主目录是在“本地用户和组”中指定的。 //%LOGONSERVER% 本地 返回验证当前登录会话的域控制器的名称。 //%NUMBER_OF_PROCESSORS% 系统 指定安装在计算机上的处理器的数目。 //%OS% 系统 返回操作系统名称。Windows 2000 显示其操作系统为 Windows_NT。 //%PATH% 系统 指定可执行文件的搜索路径。 //%PATHEXT% 系统 返回操作系统认为可执行的文件扩展名的列表。 //%PROCESSOR_ARCHITECTURE% 系统 返回处理器的芯片体系结构。值：x86 或 IA64（基于 Itanium）。 //%PROCESSOR_IDENTFIER% 系统 返回处理器说明。 //%PROCESSOR_LEVEL% 系统 返回计算机上安装的处理器的型号。 //%PROCESSOR_REVISION% 系统 返回处理器的版本号。 //%PROMPT% 本地 返回当前解释程序的命令提示符设置。由 Cmd.exe 生成。 //%RANDOM% 系统 返回 0 到 32767 之间的任意十进制数字。由 Cmd.exe 生成。 //%SYSTEMDRIVE% 系统 返回包含 Windows server operating system 根目录（即系统根目录）的驱动器。 //%SYSTEMROOT% 系统 返回 Windows server operating system 根目录的位置。 //%TEMP%和%TMP% 系统和用户 返回对当前登录用户可用的应用程序所使用的默认临时目录。有些应用程序需要 TEMP，而其他应用程序则需要 TMP。 //%TIME% 系统 返回当前时间。使用与 time /t 命令相同的格式。由 Cmd.exe 生成。有关 time 命令的详细信息，请参阅 Time。 //%USERDOMAIN% 本地 返回包含用户帐户的域的名称。 //%USERNAME% 本地 返回当前登录的用户的名称。 //%USERPROFILE% 本地 返回当前用户的配置文件的位置。 //%WINDIR% 系统 返回操作系统目录的位置。 // //设置环境变量 //使用 set 命令创建、更改、删除或显示环境变量。set 命令只更改当前解释器环境中的变量。 // //要查看变量，请在命令提示符下键入： // //set VariableName // //要添加变量，请在命令提示符下键入： // //set variablename=Value // //要删除变量，请在命令提示符下键入： // //set VariableName= // //可以将大多数字符用作变量值，其中包括空格。如果使用特殊字符 <、>、|、& 或 ^，则必须在它们前面加上转义字符 (^) 或引号。如果使用引号，则必须将引号作为值的组成部分，因为等号后面的任何内容都会被视为值。请考虑下列示例： // //要创建变量值 new&name，请键入： //set varname=new^&name // //要创建变量值 \"new&name\"，请键入： //set varname=\"new&name\" // //如果在命令提示符下键入 set varname=new&name，就会出现与下面内容类似的错误消息： //“'name' 不是内部或外部文件，也不是可运行的程序或批处理文件。” //变量名不区分大小写。但是，set 显示的变量与您键入的完全相同。可以在变量名中结合使用大写字母和小写字母，这样可以使代码更具有可读性（例如，UserName）。 // // 注意 // //单个环境变量的最大大小为 8192 字节。 //所有环境变量的大小总和（包括变量名和等号）最大为 65,536 KB。 //替换环境变量值 //要在命令行或脚本中启用变量值替换，请将变量名包括在百分号之中（即，%VariableName%）。使用百分号可以确保 Cmd.exe 引用变量值，而不是进行文字比较。为变量名定义变量值之后，请将变量名包括在百分号之中。Cmd.exe 搜索该变量名的所有实例，并用定义的变量值进行替换。例如，如果创建包含不同值（例如，用户名）的脚本，并且想要用这些值为每个用户定义 USERNAME 环境变量，可以使用包括在百分号之中的 USERNAME 来编写代码。运行此脚本时，Cmd.exe 将用变量值替换 %USERNAME%，这样就消除了为每个用户手动执行此任务的必要。变量替换是不可递归的。Cmd.exe 检查变量一次。有关变量替换的详细信息，请参阅 For 和 Call。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "命令行里转义字符好像是 Shift+6 的那个上尖角符号 ^ ；引号，直接使用不对的话，试试 ^\" ?", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "p后面的方括号是多余的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "1、输入的时候敲 a=7 b=9 2、3、一样的，等号左右的表达式评估过程不分先后，所以像 *b++= *b*2; 这样写不对。 4、级别不同不好相容，所以应该写 int *p=a[0];", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "呃，前面的代码确实有考虑不全的地方。但是简洁呢，还是要的，很多年以前，在我开始学习编程的时候，一位师兄告诉我：代码不是old二，越长越好，从那之后，我一直记着这句话，作为代码的基本要求~修改一下： #include <stdio.h> int main() { int n, k, x = 0; for (int i = (scanf(\"%d%d\", &n, &k), 1); n; n /= 10, i *= k + 1) x += (n % 10 < k ? n % 10 : k) * i; printf(\"%d\\n\", x); return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "老赵的代码写得太繁琐，须知代码不是小二，越长越好~ #include <stdio.h> int main() { char n[8]; int k, x = 1; for (int i = (scanf(\"%s%d\", n, &k), 0), j; n[i]; i++) x *= (n[i] - '0' > k ? k : n[i] - '0') + 1; printf(\"%d\\n\", x - 1); return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "xs，自己代码都是错的 来说别人繁琐？", "referer": "user-1" }, { "cid": "4", "user": "user-3", "content": "#include <stdio.h> int main() { int n,k,i,t,f; char s[8],*p; scanf(\"%d%d\",&n,&k); t=0; for (i=1;i<=n;i++) { sprintf(s,\"%d\",i); f=1; p=&s[0]; while (1) { if (*p==0) break; if (*p>'0'+k) { f=0; break; } p++; } if (f) t++; } printf(\"%d\\n\",t); return 0; }", "referer": "user-0" }, { "cid": "5", "user": "user-1", "content": "灰常灰常简单滴啦～", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include <stdio.h> #include <stdlib.h> #include <malloc.h> struct PC { int a; char b; } *pc; int i; int compare( const void *arg1, const void *arg2 ) { return ((struct PC *)arg1)->b - ((struct PC *)arg2)->b; } int main() { pc=(struct PC *)malloc(3*sizeof(struct PC)); pc[0].a=1; pc[0].b='z'; pc[1].a=2; pc[1].b='y'; pc[2].a=3; pc[2].b='x'; qsort( (void *)pc, 3, sizeof(struct PC), compare ); for (i=0;i<3;i++) { printf(\"pc[%d].a:%d, pc[%d].b:'%c'\\n\",i,pc[i].a,i,pc[i].b); } free(pc); return 0; } //pc[0].a:3, pc[0].b:'x' //pc[1].a:2, pc[1].b:'y' //pc[2].a:1, pc[2].b:'z' //", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "不明白你什么意思。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "如果你熟悉MarkDown语法，在代码的前后加 ``` 可以让代码有语法高亮效果。例如： #include <stdio.h> int main(int argc,char** argv){ print(\"hello,wolrd!\"); return 0; }", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "错误不在调用上，在于你的指针没有目标空间，你得给它目标空间然后才好干活。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "谢谢！得怎么给它目标空间呢？我比较愚钝，还请明示。", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-0", "content": "谢谢！", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "SERCOM6_SPI_Write((void *)&dat, 1);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-E http://bbs.csdn.net/topics/391003898", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "#define square(x) ((x) * (x))", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "1+1*1+1=3 (1+1)*(1+1)=4", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "VC编译选项加/EP /P（项目、属性、配置属性、C/C++、预处理器、预处理到文件：是，预处理取消显示行号：是），重新编译，查看宏展开后对应的.i文件。gcc加-Ehttp://bbs.csdn.net/topics/391003898", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "3+1*3+1當然等於7啦。 #define sqr(x) (x* x)", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "( (x) * (x))", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "我一运行，他输出4,9毫无破绽啊", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "用個中間變量過度下，不要直接*i=*i**i", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "100g改爲 100 * g 还有10s也改下，%dn\\改为 %d\\n", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢你 bug已经修好啦", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "86行造成结点自循环了嘛，所以后面的结点就都丢了。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "那请问要改成啥压，，这里我改了好几遍，例如p=phead->next,pre->next=phead-next,等等，要么就是循环了，要么就是段错误 绕不出来 请帮忙做出改正和更加详细的解释谢谢谢谢谢谢", "referer": "user-2" }, { "cid": "4", "user": "user-3", "content": "p 和 pre 的 next 不应该再设置的，你只是给 p 和 pre 初始化下，表里 next 成员这时又不应该发生变动。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "也就是在这里将pre和p初始化成为一个在前一个在后的指针，然后并排跑是嘛", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-1", "content": "fat* fat1 = (fat*)(v_addr0 + BLOCKSIZE);这个不是初始化，是指向v_addr0 + BLOCKSIZE 这个偏移地址。猜测BLOCKSIZE是fat结构体的大小，那么这个偏移就是指向下一个结构体。fat1当然可以当做数组了。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "不是初始化结构体，只是让那指针指向已有的数据某部分；指针当数组，全看编译器是否支持了，指针类型确定了，作为数组指向某单元，偏移是可以确定的", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "不懂的部分就去溯源，不去找的话，大佬们也一样不懂。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "输入a 2000:1:3b 2000:1:2c 2000:1:2则输出1:2 b c1:3 a 以上本来就已经实现了既能输出“没有与别人生日相同的人”，也能输出“生日相同的人”呀？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "for (A;B;C) D; //等价于 { A; while (1) { if (!(B)) break; D; C; } }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "是的", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "gcc -v --help", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "void nao_zhong(); 这个后面的分号是否多余？", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "好像，没有太大关系", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "比较新的处理器通常是56位物理地址了，当然内存控制器一般只能支持几百GB的内存~", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "对于裸内存来说，您理解的都对。只是现有的硬件一般实现地址总线时不会搞64根，典型值是48根。所以理论上那么长的那根绳子在现阶段的实践中可能只有65536分之一的长度是实际可用的。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址；人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息…… 栈中的变量通常包括函数参数和函数里声明的临时变量。栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。而栈中的类变量退出其作用域时，会自动执行其析构函数，……所谓在栈中“申请”N字节的空间，其实只是将栈指针寄存器（16位sp，32位esp，64位rsp）的值多减N而已。 计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！） 单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。 VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解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、编译器、调试器、运行结果。并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "很欣慰，一年前你这段话还完全不理解，现在已经理解了至少80%。是你把我带进汇编这个坑里的。", "referer": "user-3" }, { "cid": "5", "user": "user-3", "content": "我都说了：【 提醒： “学习用汇编语言写程序” 和 “VC调试(TC或BC用TD调试)时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 （Linux或Unix下可以在用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。） 想要从本质上理解C指针，必须学习C和汇编的对应关系。” 不是一回事！ 】 为什么你还认为是我把你带“坑”里了呢？ (^_^)", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "《深度探索C++对象模型》 《C++反汇编与逆向分析技术揭秘》", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "使用360杀毒杀一杀你的电脑", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "虚拟机里面跑的，主机没用360，其他杀毒软件（金山毒霸，腾讯电脑管家，火绒）都没报毒，只有360和Windows Defender报毒。", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "那就虚拟机里面杀毒", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "原因是scanf会默认读取末尾空白字符并跳过，你输入的数字（比如1 2 3 4 6 7 8）后面有几个空格都无所谓，scanf会读取并抛弃，直到遇到一个非空白字符。也就是说你输入1 2之后，“1”才会被真正读取，\"2\"进入缓冲区。同理，你输入“8”之后，必须有一个非空白字符才会读取到“8”。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "你的scanf的%d后面有空格，意味着你敲完8以后也得带个空格，然后再敲回车。而不是直接敲回车。所以，%d为什么要带空格呢？", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "并不是这个原因。scanf 不会读取空格。", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "汇编更底层吧，C语言和汇编差别还是挺大的，语法也差很多，就当做一门新课程学了。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "计算机组成原理→Shell命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构…… 对学习编程者的忠告：多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！眼过千遍不如手过一遍！书看千行不如手敲一行！手敲千行不如单步一行！单步源代码千行不如单步Debug版对应汇编一行！单步Debug版对应汇编千行不如单步Release版对应汇编一行！不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！） 想要从本质上理解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和汇编的对应关系。”不是一回事！", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "汇编只对于理解高级语言生成的二进制代码有所帮助，对于高级语言编程并没有什么作用（几乎没有，如果你不使用嵌入汇编的话），二者并非楼房一层和二层之间的关系，只能说类似手工业和工业化大生产之间的关系~", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "也不是全无作用，比如没学汇编之前对C的指针和数组理解不透彻，所有文章都试图用printf解释，越解释越乱。学过汇编就能明白内存长什么样子，数组和指针就自然理解了。", "referer": "user-3" }, { "cid": "5", "user": "user-4", "content": "不能理解，走路之前为什么一定要先砍一条腿呢？", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "每天只有1个小时学习，研究C的汇编代码就没空看书，看书就没空研究汇编。", "referer": "user-4" }, { "cid": "7", "user": "user-4", "content": "问题是一个人只能有一棵技能树，独立于其他人，独特于其他人。 培养树是一辈子的事。 如果你坚持认为浇水施肥捉虫等等事情只能挑着做一件，那是没法培养树的。", "referer": "user-0" }, { "cid": "8", "user": "user-0", "content": "家里养花吗，你真的有时间天天浇水施肥捉虫？大多数时候有浇水就不错了。等退休并且没子女拖累时，才能天天养花。 实际上我们每个人都是偏科的，因为人的精力和时间有限。我40岁，学编程只在坚持活到老学到老的最求。", "referer": "user-4" } ]

[ { "cid": "1", "user": "user-1", "content": "你的代码第五行是干嘛的？你把它给忘了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "错误挺多的，首要的问题是，您没写输出有效信息的printf，运行它就不会有可见的结果啊。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "接收輸入&a[i].s改爲a[i].s或&a[i].s[0]", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "sum+=(float)1/x;", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这个是无法做到硬件无关的，好比你要测量每个人老二的大小~", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "可能我的表达有误，我的意思其实是想说，因为不同的架构所以需要不同的指令，应该有代码可以判断或者读取的，只是我似乎搜索不到这样的代码，网上已有的代码千篇一律，只能查INTEL系列的，我只想看哪里能找得到，是LINUX的内核源码吗？", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "CPUID这个词本来就是Intel的私有术语，您不能凭想象把它推广到其他硬件啊。", "referer": "user-0" }, { "cid": "4", "user": "user-2", "content": "这么说吧，如果能实现的话，Java还会这么滋润么？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "while (y != NULL && strcmp(y->bookid, p->bookid) <= 0) { yf = y; y = y->next; } if (y == NULL) { yf->next = p; } else { p->next = y; yf->next = p; } 谢谢谢大佬，已解决。y = null 时， y->bookid 已经没有值无法比较while条件前后互换一下&&", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "C编译器都支持生成lst汇编代码并且带对应C源代码注释", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "没这样的书，高级语言和低级语言之间不是一对一的关系，而是多对多的干系~", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "我学习了一段时间x86汇编，visual studio的C语言反汇编可以看懂部分。 想要看懂全部，苦于网上资料零碎，希望有书全方位介绍。", "referer": "user-2" }, { "cid": "4", "user": "user-3", "content": "我觉得作为司机没必要学习发动机制造过程中的金属表面热处理工艺。", "referer": "user-0" }, { "cid": "5", "user": "user-3", "content": "如果您写一本的话，我买一本表示一下支持。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "for(i=1;i<n;i++) { for(j=i+1;j<=n;j++) { if((p[i].a==p[j].a&&p[i].b==p[j].b) || (p[i].a==p[j].a&&p[i].c==p[j].c) || (p[i].b==p[j].b&&p[i].c==p[j].c)) ans++; } }", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢大佬！！！！！", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "Line 47把info当作字符串输出，但是从文件读出的info的内容是没有'\\0'结尾的，所以，printf函数会越过info的边界继续输出字符，直到遇到'\\0‘。而内存中info后面的内容是随机的。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "不要把fopen(\"...\",\"...\");fscanf,fprintf,fgets,fgetc,fputc,fclose //读时把\\r\\n替换成\\n，写时把\\n替换成\\r\\n;读到\\x1a就设置EOF;读写的内容当字符看待和fopen(\"...\",\"...b\");fseek,ftell,fread,fwrite,fscanf,fprintf,fgets,fgetc,fputc,fclose //不作以上替换，遇到\\x1a仍继续读;读写的内容当字节看待弄混了", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "fread本来是用来读二进制文件的，整个读结构体数组什么的很方便。你偏要用他读文本文件当然是各种别扭了。", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "想象一下给汽车去掉方向盘装上自行车车把的效果。", "referer": "user-3" }, { "cid": "5", "user": "user-0", "content": "确实，很不方便", "referer": "user-3" }, { "cid": "6", "user": "user-4", "content": "有可能是文件编码的一些问题，或者是out.txt末尾有不可见字符。如果在out.txt随便加入一些中文字符，程序的输出是？", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "我另起一行加了个“你好“，输出结果里没有中文字符，但是有更多的乱码 具体结果是这样的： Sum is: 33 Sum is: 45 浣犲ソ LOGONSERVERn?萬", "referer": "user-4" }, { "cid": "8", "user": "user-4", "content": "首先确定out.txt的编码是Windows的缺省编码。notepad点击另存为，它显示的编码是Ansi吗？ 如果是其他编码，就会出现中文打印乱码的情况。 另外，在get_info()里面，建议里面的代码改成： char* get_info(FILE*fp) { \tint size=tell_len(fp); \tchar*info= (char*)malloc(sizeof(char) *size + 1); \t..... \tfread(info,size,1,fp); \t// print %s 打印时， 字符串需要0结尾 \tinfo[size] = 0; rewind(fp); \treturn info; }", "referer": "user-0" }, { "cid": "9", "user": "user-0", "content": "out 的编码是utf-8不是ANSI", "referer": "user-4" } ]

[ { "cid": "1", "user": "user-1", "content": "已5星，欢迎回访！诚信互评⭐⭐⭐⭐⭐http://t.csdn.cn/KMfwt已5星，欢迎回访！诚信互评⭐⭐⭐⭐⭐http://t.csdn.cn/KMfwt已5星，欢迎回访！诚信互评⭐⭐⭐⭐⭐http://t.csdn.cn/KMfwt", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐：https://bbs.csdn.net/topics/611386885", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "已支持， 五星互访 https://bbs.csdn.net/topics/611390868", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "# 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606", "referer": "user-0" }, { "cid": "5", "user": "user-4", "content": "已回投", "referer": "user-0" }, { "cid": "6", "user": "user-5", "content": "https://bbs.csdn.net/topics/611390422 ， 已五星好评，谢谢！", "referer": "user-0" }, { "cid": "7", "user": "user-6", "content": "欢迎一起互访五星！https://bbs.csdn.net/topics/611390545", "referer": "user-0" }, { "cid": "8", "user": "user-7", "content": "已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953", "referer": "user-0" }, { "cid": "9", "user": "user-8", "content": "欢迎一起互访五星！！https://bbs.csdn.net/topics/611387550?spm=1001.2014.3001.6953", "referer": "user-0" }, { "cid": "10", "user": "user-9", "content": "已五星支持，http://t.csdn.cn/4YvCK", "referer": "user-0" }, { "cid": "11", "user": "user-10", "content": "⭐⭐⭐⭐⭐诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611387545⭐⭐⭐⭐⭐五星后,请留下链接🔗,必回访⭐⭐⭐⭐⭐", "referer": "user-0" }, { "cid": "12", "user": "user-11", "content": "已五星，欢迎回访https://bbs.csdn.net/topics/611390140", "referer": "user-0" }, { "cid": "13", "user": "user-12", "content": "已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2 已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2 有🧧领 ✨✨✨✨✨", "referer": "user-0" }, { "cid": "14", "user": "user-13", "content": "已投，诚信五星，五星必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X欢迎互访五星评论互投必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X", "referer": "user-0" }, { "cid": "15", "user": "user-14", "content": "已投诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261", "referer": "user-0" }, { "cid": "16", "user": "user-15", "content": "已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531", "referer": "user-0" }, { "cid": "17", "user": "user-16", "content": "已5星，http://t.csdn.cn/Xr6pq", "referer": "user-0" }, { "cid": "18", "user": "user-17", "content": "五星支持，原力7级，欢迎互投https://bbs.csdn.net/topics/611387935", "referer": "user-0" }, { "cid": "19", "user": "user-18", "content": "五星已评！⭐⭐⭐⭐⭐满级原力最高加分互相五星支持！欢迎回访：https://bbs.csdn.net/topics/611389757", "referer": "user-0" }, { "cid": "20", "user": "user-19", "content": "已五星 https://bbs.csdn.net/topics/611388380?utm_medium=notify.im.notify-business-fans.16584a08e070f000.a&username=wnn654321", "referer": "user-0" }, { "cid": "21", "user": "user-20", "content": "已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126 已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126", "referer": "user-0" }, { "cid": "22", "user": "user-21", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐ https://bbs.csdn.net/topics/611388731", "referer": "user-0" }, { "cid": "23", "user": "user-22", "content": "已五星支持。 https://bbs.csdn.net/topics/611389981", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐：https://bbs.csdn.net/topics/611386885", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "已支持， 五星互访 https://bbs.csdn.net/topics/611390868", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "# 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978 # 已五星好评，诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388978", "referer": "user-0" }, { "cid": "4", "user": "user-3", "content": "已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606 已给5星，诚信互评：https://bbs.csdn.net/topics/611387606", "referer": "user-0" }, { "cid": "5", "user": "user-4", "content": "已回投", "referer": "user-0" }, { "cid": "6", "user": "user-5", "content": "https://bbs.csdn.net/topics/611390422 ， 已五星好评，谢谢！", "referer": "user-0" }, { "cid": "7", "user": "user-6", "content": "欢迎一起互访五星！https://bbs.csdn.net/topics/611390545", "referer": "user-0" }, { "cid": "8", "user": "user-7", "content": "已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953已五星，欢迎回访,五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388675?spm=1001.2014.3001.6953", "referer": "user-0" }, { "cid": "9", "user": "user-8", "content": "欢迎一起互访五星！！https://bbs.csdn.net/topics/611387550?spm=1001.2014.3001.6953", "referer": "user-0" }, { "cid": "10", "user": "user-9", "content": "已五星支持，http://t.csdn.cn/4YvCK", "referer": "user-0" }, { "cid": "11", "user": "user-10", "content": "⭐⭐⭐⭐⭐诚信五星，五星必回⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611387545⭐⭐⭐⭐⭐五星后,请留下链接🔗,必回访⭐⭐⭐⭐⭐", "referer": "user-0" }, { "cid": "12", "user": "user-11", "content": "已五星，欢迎回访https://bbs.csdn.net/topics/611390140", "referer": "user-0" }, { "cid": "13", "user": "user-12", "content": "已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2 已给巨佬五星，期待回评。 http://t.csdn.cn/ounE2 有🧧领 ✨✨✨✨✨", "referer": "user-0" }, { "cid": "14", "user": "user-13", "content": "已投，诚信五星，五星必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X欢迎互访五星评论互投必回⭐⭐⭐⭐⭐http://t.csdn.cn/XKj1X", "referer": "user-0" }, { "cid": "15", "user": "user-14", "content": "已投诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261诚信五星互投⭐⭐⭐⭐⭐https://bbs.csdn.net/topics/611388261", "referer": "user-0" }, { "cid": "16", "user": "user-15", "content": "已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531已安排，五星，原力等级7，诚信互投https://bbs.csdn.net/topics/611389531", "referer": "user-0" }, { "cid": "17", "user": "user-16", "content": "已5星，http://t.csdn.cn/Xr6pq", "referer": "user-0" }, { "cid": "18", "user": "user-17", "content": "五星支持，原力7级，欢迎互投https://bbs.csdn.net/topics/611387935", "referer": "user-0" }, { "cid": "19", "user": "user-18", "content": "五星已评！⭐⭐⭐⭐⭐满级原力最高加分互相五星支持！欢迎回访：https://bbs.csdn.net/topics/611389757", "referer": "user-0" }, { "cid": "20", "user": "user-19", "content": "已五星 https://bbs.csdn.net/topics/611388380?utm_medium=notify.im.notify-business-fans.16584a08e070f000.a&username=wnn654321", "referer": "user-0" }, { "cid": "21", "user": "user-20", "content": "已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126 已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126已支持！诚信互访！五星必回！https://bbs.csdn.net/topics/611391126", "referer": "user-0" }, { "cid": "22", "user": "user-21", "content": "已支持，欢迎回访五星 ⭐⭐⭐⭐⭐ https://bbs.csdn.net/topics/611388731", "referer": "user-0" }, { "cid": "23", "user": "user-22", "content": "已五星支持。 https://bbs.csdn.net/topics/611389981", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "把代码重新发一下，方便查看 m=3 while m<10: n=2 while n<=m-1: if m%n==0: break if n==m-1: print(m) n+=1 m+=1 这段代码是打印<10的质数把，因为当m=6时，n从2到5循环，测试是否 m%n==0,由于6%2==0, 会执行break,所以不会打印出来 想知道满足了if语句，那么n+=1还需要执行吗？ 当 m%n==0时，会执行break, 跳出 while n<=m-1: 的循环，不会执行n+=1否则会执行", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "这里错了：scanf(\"%d %d &d\",&a,&b,&c); 应该是：scanf(\"%d%d%d\",&a,&b,&c);", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "printf(\"请输入3个整数：\"); scanf(\"%d%d%d\", &a, &b, &c); if (b > c) c += b -= c, b = c - b; if (a > b) b += a -= b, a = b - a; if (b > c) c += b -= c, b = c - b; printf(\"max = %d, min = %d, median = %d\\n\", c, a, b);", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "max太多余了，把max删了", "referer": "user-0" }, { "cid": "4", "user": "user-4", "content": "在scanf后把三個值都打出來就知道是哪的問題啦。懷疑是最後那個%d沒改，還是寫&d。", "referer": "user-0" }, { "cid": "5", "user": "user-5", "content": "scanf(\"%d %d &d\",&a,&b,&c); 改为 scanf(\"%d%d%d\",&a,&b,&c);", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "改了也不对的。我输入 3 5 9，结果显示最大值为5。", "referer": "user-5" } ]

[ { "cid": "1", "user": "user-1", "content": "用 vc2008 编译执行了，有结果：6.0， -1.0, 1.0 。那，可能是你的 data.txt 不对，不是 ascii 格式？", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "也可能是文件存放的路径不对。 VS的运行环境，当前路径是项目目录，不是exe所在目录。 总之是不知道文件打开成功没有。", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "我是用dev写的", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "struct data* p1 = new (struct data); 这个，去掉开头的 struct data* 否则是又定义了个新的变量 p1 和前面的不是一个变量，所以两处的 p1 是不一样的，就不对了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "那个是引用，不是地址。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "嗷嗷，那为什么引用和不引用都可以压，数据栈的清空有指针变化不应该只有引用可以吗", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "画面上没有证据表明可以，是你自己说可以的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf() 里的第三个多了个 % 是两个了：%%d", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "看到了", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "先来看一下C语言的运算优先级： #include<stdio.h> int main() { //定义数组 int a[]= {2,4,6,8,10}; //定义指针p指向数组a int *p=a; //指针p指向的数组元素为2，这里是(*(p++)) //实际上p++是表示指针p+1了但是返回的还是+之前的值 //再对这个值*引用，所以就是2 printf(\"%d\\n\",(*p++)); //上一行代码已经让p + 1了,这里指针p先运行(++p)指针+1 //然后在用*引用，也就是*(p + 2)的值 printf(\"%d\\n\",(* ++p)); //接着又先进行++p操作此时p指向的是8，但是执行的是(* ++p)++ //也就把8加一，只不过返回的还是8 printf(\"%d\\n\",(* ++p)++); //实际上8+1=9 printf(\"%d\\n\",*p); return 0; }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "指针的花花，头疼；结果是啥，先自己看看琢磨琢磨呗，结果记下来，再编译了运行下，看和自己的一样否。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "C DAO/ADO SQL", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "百度一搜一大堆", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "m, n, x, y 都没有初始化，遇到首单元就是最大或最小的，就不对了；另外，最大和最小，可以一个循环。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢大佬，懂了", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "看上面图，那些 FF 应该是单字节被符号扩展到了双字的缘故。加密对否，可以和标准的代码的结果比较，也可以用解密模块解密下看看是否还原。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "aes加密？加密后的数据，本来就是乱的啊；不乱的加密，往往只是简单的替换，强度在计算机面前近乎 0", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "不是我的意思是说，即使是乱码，应该也是ASCII码不是?然而返回的并不是啊", "referer": "user-1" }, { "cid": "4", "user": "user-1", "content": "应该也是 ascii? 哪来的说法? aes 是 16字节一组进行的，结果是可能任何的 16字节数据，且是一个整体，'abc' 加密了后，不可能只是 'xyz' 。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "我基础差啊，所以大侠，请假下如何屏幕打印这些字节码，以验证加密后的字符串数据是否正确？", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "明白你的問題在哪啦，把c[ temp - 47]刪掉就可以啦。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "if ( n[i]<'0' || n[i]>'9' ) continue; temp = n[i] - '0'; if ( c[temp] >= 'a' && c[temp] <= 'z' ) c[temp] &= 0x5f; if ( c[temp] >= 'A' && c[temp] <= 'Z' ) c[temp] != 0x20;", "referer": "user-0" }, { "cid": "3", "user": "user-1", "content": "哦，第二个if前应该加上 else", "referer": "user-1" }, { "cid": "4", "user": "user-0", "content": "thanks 我看看", "referer": "user-1" }, { "cid": "5", "user": "user-0", "content": "你好，我想再请教一下，按位与计算的思路是怎么来的呢？（位运算不太了解有什么用（（（", "referer": "user-1" }, { "cid": "6", "user": "user-2", "content": "竟然没看懂题意，输入的数字字符串怎样用，大小写变换的依据是", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "大小写转换的依据就是后面输入的数字，如果输入1那就是将字符数字中c［1］位转换大小写", "referer": "user-2" }, { "cid": "8", "user": "user-3", "content": "或许是对题目的理解有误。这个事儿很常见。", "referer": "user-0" }, { "cid": "9", "user": "user-0", "content": "但是我的代码执行结果跟我的预期也有出入，我想知道为什么", "referer": "user-3" }, { "cid": "10", "user": "user-3", "content": "那两个函数是处理字符串的，不是处理字符的，用在这里不合适。", "referer": "user-0" }, { "cid": "11", "user": "user-0", "content": "但是我如果取地址的话，不应该也相当于字符串吗？", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-1", "content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "递归求斐波那契数列吧", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "将25行printf(\"% 3d \",num1[i][j]);改成了printf(\" %d\",num1[i][j]);或者printf(\"%4d\",num1[i][j]);就可以了；字符里面的空格运用不当。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "%4d就占4字節啦", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "改成4运行的时候，第一列占4个宽度，第二、三列占5个宽度。", "referer": "user-1" }, { "cid": "4", "user": "user-0", "content": "已解决，谢谢。", "referer": "user-1" }, { "cid": "5", "user": "user-2", "content": "所以你在格式串里写空格的目的是什么？", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "对空格的运用不准确，已修改，谢谢。", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "先搞清楚打不开的是哪个。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你自己用常量记下数组的大小就可以了： const int len1=3, len2=3; int num1[len1]={1,2,3}; int num2[len2]={1,2,3};C因为是基础语言，很多语法糖都省略了，所以不是很适合用于开发应用软件，尤其是事务处理型软件，比如说连函数重载都不支持，不是做不到，而是为了追求简单灵活。一个C编译器，最小可以只用不到100KB源码实现，而C++编译器，比如gcc，光是前端语法解析部分，parser.c，就有12MB大小~", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "思维习惯不对呀，C里面的数组你就永远不应该企图“获取”它的大小，因为它的大小是由程序员主观意志决定的。换句话说是先有大小后有数组的。这么说吧，假如是上帝创造了人，那么上帝怎么可能需要数一数才知道人有几个手指头呢？", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢回复，我才开始学习C语言，感谢提醒。", "referer": "user-2" }, { "cid": "4", "user": "user-3", "content": "C语言不象java,c#这些， 数组可以通过length属性获取个数，在C中，静态分配的数组，比如: int num1[3], 可以通过 sizeof(num1)/sizeof(num1[0]) 获取数组的大小动态分配的数组，比如: int* num2; num2=new int[1000]; 则程序需要自己记住分配的大小至于为什么while... 有可能得不到正确的结果， 是因为，在内存中，1,2,3 后面有可能是任何其它数据，比如：1,2,3, 0 这种可以正确获得大小，但，如果是其它，就会出错。", "referer": "user-0" }, { "cid": "5", "user": "user-0", "content": "谢谢回复，我后来了解到num[3]并不是直接是的给了3个位置存放数字，就算打印num[3],num[4]也会出现结果的，但是我并不知道为什么会出现这种情况。", "referer": "user-3" }, { "cid": "6", "user": "user-3", "content": "建议从一些基础的了解开始， 比如 blog.csdn.net/weixin_55305220/article/details/116665000 当然， 适当的了解点 系统结构，数据结构 也会些帮助，网上也有很多这些资料， 加油！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "图中最后的 break 改为和上面一样的 continue ？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "函數調用改爲other_function(&resule)，函數體內也做相應修改，調用free前要判斷指針是否爲空。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "没有问题啊，如果有问题那就是其他的问题，不是申请内存的问题。所以您没有问到点儿上。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "简单一点： double funcos(double e, double x) { double f, i, v, xx, y; for (f = i = 2, xx = x * x, x = -xx, y = 1; ; i += 2) { y += v = x / f, f *= (i + 1) * (i + 2), x *= -xx; if (abs(v) < e) break; } return y; }", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "#include <stdio.h> #include <math.h> double funcos( double e, double x ); int main() { double e, x; scanf(\"%lf %lf\", &e, &x); printf(\"cos(%.2f) = %.6f\\n\", x, funcos(e, x)); return 0; } double funcos(double e,double x) { int i=2,j,t=1; double a,sum=0; if(x<e) sum=x; a=x; while(a>e||a<(-e)) { sum=sum+a; for(j=1;j<=i;j++) t=t*j; a=-(pow(x,i)/j); i=i+2; return sum; } return sum; } 注意while循环用法，你的代码while无限循环了，用break、continue、return退出", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "if（b==0 && a>=1）时即可", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "首先是if行末尾有个多余的分号。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "大神 请指点下还有啥地方是错的吧 或者逻辑哪里不对 感谢了", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "还记得HelloWorld么？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf(\"%d\\n\"... 格式里，别有 \\n 吧，如 scanf(\"%d\", &_S1);", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "程序中存在的问题：ReadLine()里面又调用 CountLine(), 程序会比较慢string.find() 返回的是 size_t , -1 表示没找到，C语言中， 只要不是0就返回true, 所以，程序的判断是否会有问题？另外，if (a.find(\"link\"&&\"code\")), \"link\"&&\"code\" 表示的是？ 字符串连接是用 \"link\" + \"code\", 还是应该是:? if (a.find(\"link\")!=string::npos && a.find(\"code\")!=string::npos)如果test.txt里面是Link , Code, 代码也应该做相应大小写改动。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "不要使用 while (条件) 更不要使用 while (组合条件) 要使用 while (1) { if (条件1) break; //... if (条件2) continue; //... if (条件3) return; //... } 因为前两种写法在语言表达意思的层面上有二义性，只有第三种才忠实反映了程序流的实际情况。 典型如： 下面两段的语义都是当文件未结束时读字符 while (!feof(f)) { a=fgetc(f); //... b=fgetc(f);//可能此时已经feof了！ //... } 而这样写就没有问题： while (1) { a=fgetc(f); if (feof(f)) break; //... b=fgetc(f); if (feof(f)) break; //... } 类似的例子还可以举很多。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "“只能读取第二个以后的”，什么意思？上面的代码运行了，可以完整显示 test.txt 的内容啊；内容再复制一份，照样能显示所有的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "因为类型提升，ca[0]被作为int传入，char默认是有符号数，所以0x83被符号扩展为0xffffff83。可以：sprintf_s(str, sizeof(str), \"%x\", (unsigned char)ca[0]);", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "都是字符型拷贝到字符型，类型怎么会提升？", "referer": "user-1" }, { "cid": "4", "user": "user-1", "content": "传入sprintf_s的参数做了类型提升，参考printf、sprintf的说明：https://en.cppreference.com/w/cpp/io/c/fprintf", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "不是多出，是0x66按照字符理解就是'f'", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "思路如下:双重for循环,j表示次数,j小于等于i，i小于等于n,然后在j循环李打印i就行了，记得换行", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "思路，就是循环啊，一行行的是外循环，行内的几个字符是内循环；其它的就是输入和输出函数。", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "能不能写一下，不太明白", "referer": "user-2" }, { "cid": "4", "user": "user-0", "content": "麻烦说说设计思路", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "CPU只认地址不认标识符，CPU根据地址访问与其建立映射关系的物理内存，读写数据。你写得源代码中的一切变量名、函数名等等标识符，都仅仅只是你自己的设想。你的源代码要变成可执行程序，最终要经过编译器编译，将它翻译成CPU可识别的指令流程编译器中的符号表数据结构会收集你源代码中的标识符，然后把它们转换成相对进程基址的偏移地址可执行文件相当于是一个进程的内存模板，它描述了进程的内存分布和初始值所有你源代码中的变量名在可执行程序中都是一个地址", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "子曰：吾日！三省吾身～～～", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "子曰，思而不学则殆。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "一般是增加个变量吧，查询前初始化为 0，后面查询到个不及格就 +1，最后看是否为 0 ；也可用逻辑类型的。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "對200多字節都覺得誇張的話改用匯編吧。", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "即便同一个编译器，不同编译选项，生成的代码也不能保证相同。至于楼主的代码，只是debug版本，如果是release版本，至少a, b都会被优化掉。", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "现代计算机平台上，两百多字节真不算大，咱不能拿单片机和1980年的计算机来与现代比较。", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "C语言不是简洁快速体积小吗？怎么没事还要搞掉那么多栈空间？", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-1", "content": "应该是 for(j=41; j<81-i+41; j++) 吧，要加上首单元序号的，上面的是 0 就可以不加了。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "感谢", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "if(j=2) 应该是 if(j==2) 吧，下面的类似；j=2 是赋值了，j 跳不出去的。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "谢谢", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "不要止步于感觉呀，验证一下。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "有问题看过来这里啊！", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "t未初始化。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你但凡不那么细心地切图，就能看见上方某处有x64或amd64字样。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "我去看看", "referer": "user-1" }, { "cid": "3", "user": "user-0", "content": "这是我的图片", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "前面定義char s[10] 最多可以用到s[9]，後面卻用到s[50]。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "float Fscore(struct Student stu…) 這個結構名首字母是大寫 函數應該有個return", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "应该是 stu[i].sum += stu[i].score[j]; 吧", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "但楼主自己说的错误应该来源于大小写不分。", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "把struct test 改成： struct test {unsigned short a :4;unsigned short b :2;unsigned short c :4;unsigned short d :6;};整个struct test占用2个字节， 它每个字段在内存中的位置是： 15 ... .. .... ........ 0ddddddccccbbaaaa注意低位在右边 av->a = 0xf;test: 000....01111 (二进制)av->b = 0x0;test: 不变av->c = 0xf;test: 00...1111001111av->d = 0xf;test: 0011 1111 1100 11113 f c f (16进制)最后输出的时候，是从低地址输出的，所以是cf 3f", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "有可能是因为一些填充的原因，在我的机器上， printf(\"sizeof = %d\\n\", sizeof(struct test))打印的是4， 而不是2建议把程序改成:struct test{ unsigned short a :4; unsigned short b :2; unsigned short c :4; unsigned short d :6;};", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "谢谢您的回答，不知道您试过没，结果是一样的， 不知道有一点您有没有注意到，这是bit赋值，添加类型应该没意义吧！", "referer": "user-1" }, { "cid": "4", "user": "user-1", "content": "你好，如果我没记错的话，unsigned a :4 这里的unsigned 定义了一个unsigned int, struct test最后是 4个字节， 如果改成 unsigned short, struct test 则为2个字节，所以还是有影响的，的确， 程序的最后输出有点晕，可能跟编译器的存放字节顺序有关。。。", "referer": "user-0" }, { "cid": "5", "user": "user-2", "content": "Android-Unity一起交流学习啊", "referer": "user-0" }, { "cid": "6", "user": "user-3", "content": "位序的问题啊，这个，得看书上怎么说的了，全是规定，搞不好不同平台还不一样", "referer": "user-0" }, { "cid": "7", "user": "user-0", "content": "位序无非是大端小端，我的平台是小端，不应该出现字节反转的现象啊", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-1", "content": "这个有点难度看不懂了……", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "Android-Unity一起交流学习啊", "referer": "user-0" }, { "cid": "3", "user": "user-3", "content": "上面提示了啊，Netbios 没定义，大概是少了相应的 .h 文件", "referer": "user-0" }, { "cid": "4", "user": "user-0", "content": "@是#include \"nb30.h\" #pragma comment(lib, \"netapi32.lib\")", "referer": "user-3" } ]

[ { "cid": "1", "user": "user-0", "content": "我查到原因了，卡巴斯基误报。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "选择了新模式后，要重新编译创建吧", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "请问如何重新编译，我只知道按F5。", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "i和c沒有初始化", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "循环里加个 printf() 语句，打印每次的 a,b,c 看看就知道了；不知题意，应该是你计算逻辑错了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "Android-Unity，一起交流啊", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "实参次序反了嘛。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "都是int类型乘积当然也是int类型。把随便哪项强转为结果的类型就好了。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "求大佬解答", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "链接选项里加入legacy_stdio_definitions.lib", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "前辈啊", "referer": "user-1" }, { "cid": "3", "user": "user-2", "content": "看编译输出提示，是不是让你用scanf_s代替？你可以在项目->属性->C/C++->预处理器->预处理器定义中添加_CRT_SECURE_NO_WARNINGS", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include <stdio.h>double Power(double x,int n); double Power(double x,int n){ if(x == 0 && n < 0) { printf(\"参数不正确\\n\"); return 0; } else { double y = x; if(n > 0) { while (--n > 0) { x*=y; } } else { while (++n < 0) { x*=y; } x = 1/x; } } return x;} int main(int argc, char const *argv[]){ double x; int n; scanf(\"%lg%d\",&x,&n); printf(\"%.8g\\n\",Power(x,n));}", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "至于你说的为什么要用指针的指针实现，如果不转这一道函数的话是可以直接用malloc的。涉及到指针的参数传递一级指针的地址就必须要二级指针才能接收", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "malloc和free就是向程序员手动向堆区申请和释放空间，了解堆区和栈区的区别吗？", "referer": "user-0" }, { "cid": "3", "user": "user-2", "content": "我不知道，我作业也是这个，求大佬解答！！", "referer": "user-1" }, { "cid": "4", "user": "user-1", "content": "建议自己先百度一下，这是一个程序员的基本素质", "referer": "user-2" } ]

[ { "cid": "1", "user": "user-1", "content": "随机最大n ，是不是没有对输入的 n 进行限定检验啊，预定义的是 100010，输入比这更大的呢？", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "仅供参考： #include <locale.h> #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct BiTNode {//二叉树结点 char data; //数据 struct BiTNode *lchild,*rchild; //左右孩子指针 } BiTNode,*BiTree; int nn=0; int CreateBiTree(BiTree *T) {//按先序序列创建二叉树 char data; scanf(\"%c\",&data);//按先序次序输入二叉树中结点的值（一个字符），‘#’表示空树 if (data == '#') { *T = NULL; } else { *T = (BiTree)malloc(sizeof(BiTNode)); nn++; (*T)->data = data; //生成根结点 CreateBiTree(&(*T)->lchild);//构造左子树 CreateBiTree(&(*T)->rchild);//构造右子树 } return 0; } void Visit(BiTree T) {//输出 if (T->data != '#') { printf(\"%c \",T->data); } } void PreOrder(BiTree T) {//先序遍历 if (T != NULL) { Visit(T); //访问根节点 PreOrder(T->lchild); //访问左子结点 PreOrder(T->rchild); //访问右子结点 } } void InOrder(BiTree T) {//中序遍历 if (T != NULL) { InOrder(T->lchild); //访问左子结点 Visit(T); //访问根节点 InOrder(T->rchild); //访问右子结点 } } void PostOrder(BiTree T) {//后序遍历 if (T != NULL) { PostOrder(T->lchild); //访问左子结点 PostOrder(T->rchild); //访问右子结点 Visit(T); //访问根节点 } } void PreOrder2(BiTree T) {//先序遍历(非递归) //访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。 BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree)); int sp=0; BiTree p = T;//p是遍历指针 while (p || sp) { //栈不空或者p不空时循环 if (p != NULL) { stack[sp]=p;sp++; //存入栈中 printf(\"%c \",p->data); //访问根节点 p = p->lchild; //遍历左子树 } else { sp--;p=stack[sp]; //退栈 p = p->rchild; //访问右子树 } } free(stack); } void InOrder2(BiTree T) {//中序遍历(非递归) //T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。 //先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。 BiTree *stack=(BiTree *)malloc(nn*sizeof(BiTree)); int sp=0; BiTree p = T;//p是遍历指针 while (p || sp) { //栈不空或者p不空时循环 if (p != NULL) { stack[sp]=p;sp++; //存入栈中 p = p->lchild; //遍历左子树 } else { sp--;p=stack[sp]; //退栈 printf(\"%c \",p->data); p = p->rchild; //访问右子树 } } free(stack); } typedef struct BiTNodePost{ BiTree biTree; char tag; } BiTNodePost,*BiTreePost; void PostOrder2(BiTree T) {//后序遍历(非递归) BiTreePost *stack=(BiTreePost *)malloc(nn*sizeof(BiTreePost)); int sp=0; BiTree p = T;//p是遍历指针 BiTreePost BT; while (p != NULL || sp) {//栈不空或者p不空时循环 while (p != NULL) {//遍历左子树 BT = (BiTreePost)malloc(sizeof(BiTNodePost)); BT->biTree = p; BT->tag = 'L';//访问过左子树 stack[sp]=BT;sp++; //存入栈中 p = p->lchild; } while (sp && (stack[sp-1])->tag == 'R') {//左右子树访问完毕访问根节点 sp--;BT=stack[sp]; //退栈 printf(\"%c \",BT->biTree->data); free(BT); } if (sp) {//遍历右子树 BT=stack[sp-1]; BT->tag = 'R';//访问过右子树 p = BT->biTree; p = p->rchild; } } free(stack); } void LevelOrder(BiTree T) {//层次遍历 BiTree p; BiTree *queue; int h=0,t=0,n=0; if (T == NULL) return; p=T; queue=(BiTree *)malloc(nn*sizeof(BiTree)); queue[t]=p;t=(t+1)%10;n++;//根节点入队 while (n) { //队列不空循环 p=queue[h]; //对头元素出队 printf(\"%c \",p->data); //访问p指向的结点 h=(h+1)%10;n--; //退出队列 if (p->lchild != NULL) {//左子树不空，将左子树入队 queue[t]=p->lchild;t=(t+1)%10;n++; } if (p->rchild != NULL) {//右子树不空，将右子树入队 queue[t]=p->rchild;t=(t+1)%10;n++; } } free(queue); } int main() { BiTree T; setlocale(LC_ALL,\"chs\"); CreateBiTree(&T); printf(\"先序遍历 ：\");PreOrder (T);printf(\"\\n\"); printf(\"先序遍历(非递归)：\");PreOrder2 (T);printf(\"\\n\"); printf(\"\\n\"); printf(\"中序遍历 ：\");InOrder (T);printf(\"\\n\"); printf(\"中序遍历(非递归)：\");InOrder2 (T);printf(\"\\n\"); printf(\"\\n\"); printf(\"后序遍历 ：\");PostOrder (T);printf(\"\\n\"); printf(\"后序遍历(非递归)：\");PostOrder2(T);printf(\"\\n\"); printf(\"\\n\"); printf(\"层次遍历 ：\");LevelOrder(T);printf(\"\\n\"); return 0; } //ABC##DE#G##F### //先序遍历 ：A B C D E G F //先序遍历(非递归)：A B C D E G F // //中序遍历 ：C B E G D F A //中序遍历(非递归)：C B E G D F A // //后序遍历 ：C G E F D B A //后序遍历(非递归)：C G E F D B A // //层次遍历 ：A B C D E F G // /// A /// / /// B /// / \\ /// C D /// / \\ /// E F /// \\ /// G", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "等程序中断在断点处或单步运行时，再看看。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "正如赵4老师所说啊，感谢感谢！", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "true 不是 ture；while(1) 应该可以吧，除非又有其它的笔误", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "package Demo; import java.util.Random;import java.util.Scanner; public class 猜数游戏 { public static void main(String[] args) { // TODO 自动生成的方法存根 // 生成1-100随机数 Random r=new Random(); int number=r.nextInt(100)+1; Scanner sc=new Scanner(System.in); System.out.println(\"请输入猜测数字：\"); int luck=sc.nextInt(); while(ture){ if(luck>number){ System.out.println(\"猜大了\"); }else if(luck<number){ System.out.println(\"猜小了\"); }else{ System.out.println(\"恭喜您 猜对了 请买单~~~\"); break; } } } }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf() 中间的 % 误输入成 & 了", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "非常感谢您的指点!", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "如果数据float data的取值范围在0.0f～255.0f，直接u8 b=(u8)data; 如果数据float data的取值范围在0.0f～65535.0f，u8 b0=((unsigned short)data)%256;u8 b1=((unsigned short)data)/256;以此类推", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "把地址限制在低40bits，想问怎么样才可以申请到符合这种条件的地址", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "int n=0; int a[n]; 的问题？vc 是不支持的，用 DEV-C 看，试了 3个 或 4个数据，没有问题。", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "我是用的dev写的，好像n输入很小的数是没问题的，但是我输入n=10就出问题了，调试的时候for循环进行到i=9就显示这个错误崩溃了", "referer": "user-1" } ]

[ { "cid": "1", "user": "user-1", "content": "所谓修改删除文件a某位置的内容，其实是读打开文件a，再将‘a中修改删除位置之前的内容＋修改删除的内容＋a中修改删除位置之后的内容’保存到文件b，关闭文件a，删除文件a，将文件b改名为与之前文件a相同的名字，仅此而已。▼ http://bbs.csdn.net/topics/391975224", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "既然你把从p到*p称之为退化， 那么很自然你也可以把从*p到&*p称为进化嘛， 进化了就变大了不是很正常么？ 因为变量p的声明中是有5存在的，编译器牢记着这个，所以不是偏偏，而是顺理成章的5 。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-0", "content": "谢谢啦", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "void PrintDec(unsigned x) { if(x>9)PrintDec(x/10) putchar(x%10+48); }", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "#include <stdio.h> int suma,sumb; void func(int x){ if(x>0) suma+=x; else if(x<0 ) sumb++; } int main(){ printf(\"输入整数:\\n\"); int x; while(scanf(\"%d\",&x)){ if(x==999) break; func(x); } printf(\"%d %d\",suma,sumb); return 0; } 不知道是不是这个意思，没做过这种题（）", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "你也说了，单线程工作，也就是每个时刻只占用单核。然后现代的系统怕CPU局部过热，所以使用的单核具体是哪一个物理核这件事是一直在变化的，以维持温度均匀。这就是上不去的原因。在进程级并发的情况下，只要保证你的并发服务进程的数量超过处理器的核数，就能上去了。", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "gets_s(c, 9); 试试？ 这个函数对字符、字符串类要求跟随有最大长度参数的。", "referer": "user-0" }, { "cid": "2", "user": "user-1", "content": "可能是没有把数组所有单元都置 0 而只是首个", "referer": "user-0" }, { "cid": "3", "user": "user-0", "content": "不是，我试了一遍，我输入8个字符最后就有个问号，输入其他个数的字符就不会", "referer": "user-1" }, { "cid": "4", "user": "user-0", "content": "我是一个大一小白，刚学c语言", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "count++递增了count的值，count怎么能不变呢", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "还没执行到那就停下来了，在停着的时间里，count 还在变化；直接运行应该是没问题的。", "referer": "user-1" }, { "cid": "3", "user": "user-1", "content": "你怎么确定没有执行，count 值变化代表程序在运行", "referer": "user-2" }, { "cid": "4", "user": "user-2", "content": "楼主上面图示的和文字叙述的很清楚啊，执行到 &lt;font color=blue&gt;int i=3;&lt;/font&gt; 就停下来了，没再继续；然后，偶尔地，光标移动到 count 上，就会提示当前的 count 值，这个值慢慢地就会变；如果 count 加到查看里，那里的内容是不变的，但删除了重加，就是变化后的值；count 实际是变了的，再运行下去，后面程序会出错，因为大于 1 的是无效的。", "referer": "user-1" }, { "cid": "5", "user": "user-2", "content": "挺好奇的，想着也不会是无中生有，就去下载了个 gcc 来在虚拟机上安装了，把上面的代码敲了进去，折腾了一番，好像还真是哦。用 windbg 打开生成的 exe 程序文件，是正常的；所以，要么这 gcc 的调试功能有问题，要么就是哪里设置有不对，我对 gcc 也不熟，所以无从解决了，主要是它不能和 vs 似的可以切换到汇编码状态，对 count 内存进行写入断点设置，这样可以抓住哪里向 count 写入的。另外，上面的代码是有问题的，main() 里的 if() 行最后不应有大括号，i++; 语句应该是和 if() 语句平齐的，再下来的 for() 的后面就多了一个大括号。", "referer": "user-0" }, { "cid": "6", "user": "user-0", "content": "好的，谢谢，错误的地方还没改，就是这个count乱跳导致无法去调试。", "referer": "user-2" }, { "cid": "7", "user": "user-0", "content": "我看了一下，我截图完之后已经改掉了。谢谢", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "scanf（）这个函数是有返回值的，返回值是它接收的格式化字符的个数（%d算一个）“ctrl + z”可以认为是取消输入，如果不输入，scanf 就没有接收值，编译器就会返回 -1循环里的 -1 != -1 判断为假就会退出循环", "referer": "user-0" }, { "cid": "2", "user": "user-2", "content": "while((scanf(\"%d\",&a)) == 1)", "referer": "user-0" } ]

[ { "cid": "1", "user": "user-1", "content": "因为e的类型不是QElemType", "referer": "user-0" }, { "cid": "2", "user": "user-0", "content": "请问应该怎么修改啊", "referer": "user-1" } ]

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