question
stringlengths 1
128
| poster
stringclasses 1
value | comments
listlengths 1
23
|
|---|---|---|
简述学习编程遇到的问题，并求荐书！
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "这个思路有个问题就是，即使有这样的书，也会被抨击以偏概全。或者说适合您的思路的适合您的职业需求的，反而不适用于大多数人。就轮子来说，学机械的可能认为核心是轴承，学化工的可能认为重要的是橡胶优化，学材料的会说核心技术是滚珠的表面热处理。所以写书的人才会泛泛地说轮子。其实是留下空白，也留下无限的可能。 既然说到这儿了，再扯几句。预设过于明确的学习目标，然后围绕这个目标学习，固然看起来效率会提高，但是，我是说但是这正是现行的培养AI的思路！也就是说这样培养出来的“人材”迟早会被AI取代！！！——人类要维持自己对AI的优势，就不能走捷径，只能是广泛学习触类旁通，收敛成自己那棵与众不同的科技树。这就是人类的格。",
"referer": "user-0"
}
] |
[Error] invalid conversion from 'char' to 'char*' [-fpermissive]，这是我写的冒泡程序的一部分，标记红色字体的部分都是着给错误，望解惑
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "字符是字符，字符串是字符串",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "strcpy()是字符串拷贝函数，代码里是要对单个字符操作吗，单个字符可以直接赋值操作：d[i] = sex[i]; sex[i] = sex[min]; sex[min] = d[i];",
"referer": "user-0"
}
] |
用c语言编程的时候出现了[Error] ld returned 1 exit status，求大佬帮助
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "函数声明：int getlen(char s[]);函数实现：int gatlen(char s[]){getlen() 写成 gatlen() ，e 写成 a 了。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "好嘞，谢谢大佬",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-0",
"content": "我刚接触c语言编程，还不怎么会哈哈哈，求大佬们指点哈哈",
"referer": "user-0"
}
] |
管理代码应该看什么书？
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "期待有启发的优质回答！",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "使用笔记相关软件使用everything软件",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "工具好说，方法呢？",
"referer": "user-1"
},
{
"cid": "4",
"user": "user-1",
"content": "无他，唯手熟尔。",
"referer": "user-0"
}
] |
GetFileSize和FTell获取的大小与实际文件获取大小不同
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "是不应该，实际不是同一个文件，或，文件其时被修改了？",
"referer": "user-0"
}
] |
c语言的基础，救救我！！！
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "前面输入的回车的残留吧，先用 fflush(stdin); 语句清理下试试？",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "这是一个历史悠久的错误，fflush是用来处理输出缓冲区的，不应用来处理输入。而且不是清除，而是催促输出不要再缓了。 四老师建议使用rewind(stdin)做这个事儿。",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-0",
"content": "谢谢老师的建议，可是我还没学rewind(stdin)，不知道怎么样，我们老师说要加getchar（），但我不知道加哪里",
"referer": "user-2"
}
] |
新手小白学习C语言笔记
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "既然问题是无条件的，那么回答也是无条件且不负责任的：从全部学习C语言的人群的统计数据来看，学好的可能性不大。理智地回头吧，不要往坑里跳。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "老哥稳",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-3",
"content": "好家伙直接劝退",
"referer": "user-1"
}
] |
通过宏，怎么判断当前编译器是 gcc 还是 arm-linux-gnueabihf-gcc 呢
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "不用代码格式则连续的下划线被删除了，这个属于csdn特色？ #if defined(__GNUC__) && (defined(__arm__) || defined(__aarch64__)) // gcc ARM/ARM64 compiler #endif #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64__) || defined(__amd64__)) // gcc x86/x64 compiler #endif",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "多谢",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "#if defined(_ECLIPSE)||defined(__ANDROID__)||defined(__ARM_EABI__)",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-3",
"content": "找不到的话自己制造一个宏就好。",
"referer": "user-0"
}
] |
关于在unix中建立C语言编译环境的问题
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "系统自带的，安装好就可以用，方便。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "FreeBSD带有Linux兼容层，所以可以用大部分Linux下的软件，打开一个终端，输入命令：pkg install lang/gcc",
"referer": "user-0"
}
] |
C语言中time.h的计时是从1970年开始的，这个怎么改变，比如改为2000年
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "非常感谢大家的回复，非常感谢！",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "定义一个偏移量常数，宏替换一下就行了。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "谢谢",
"referer": "user-1"
},
{
"cid": "4",
"user": "user-2",
"content": "自己加偏移量改变一下",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "谢谢",
"referer": "user-2"
},
{
"cid": "6",
"user": "user-3",
"content": "这个是先天的设定，库函数本身并没有修改开始时间的功能，你只好自己写代码进行转换。",
"referer": "user-0"
},
{
"cid": "7",
"user": "user-0",
"content": "谢谢",
"referer": "user-3"
}
] |
大佬们帮忙看看C语言代码，vs2019可以跑，但是vc6反而报错
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "C不够地道，当然不行。改用C++，就行了。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "代码不够ANSI，应该啥也没做之前声明所有变量，包括i，然后再干活。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "明白了",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-3",
"content": "源代码扩展名改为.cpp",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "VC6根本不给我出输出窗口",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-4",
"content": "抱什么错？",
"referer": "user-0"
},
{
"cid": "7",
"user": "user-0",
"content": "vs6调试只给了errors（1） 要是知道哪有问题我就自己解决了",
"referer": "user-4"
},
{
"cid": "8",
"user": "user-0",
"content": "学校非要用vc6上课",
"referer": "user-4"
},
{
"cid": "9",
"user": "user-4",
"content": "我没有vc6,你把输出窗口的内容贴出来",
"referer": "user-0"
}
] |
做作业的时候遇到的问题，求大佬帮看看
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "要ANSI把变量c的声明提到前面去。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "具体最后代码是什么样的呢，急！",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "行 7 类型前少了分号，看前面好像没少，那可能是误输入了汉字全角的分号？",
"referer": "user-0"
}
] |
biosdisk函数报错0x09
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "这年头很难找到运行这个的硬件啊。所以我倾向于认为是系统或硬件不支持。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "在dos下创建了软盘",
"referer": "user-1"
}
] |
大佬帮忙看看哪里出问题了，刚学编程的小白...
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "学会单步和设断点调试",
"referer": "user-0"
}
] |
为什么从txt文件读入的数据不能在其他功能上应用
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "学会单步和设断点调试程序",
"referer": "user-0"
}
] |
请问是在哪里添加分号呢
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "第二行末？不过这行完全可以不要，它是主程，无需什么声明或预定义的，毕竟其意义明确，也不会有哪个会引用到它。",
"referer": "user-0"
}
] |
c语言帮忙帮忙！！！
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "Visual C++ 2010 Express简体中文版 ▼ http://pan.baidu.com/s/1bnwRVLt",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "好的谢谢！",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-0",
"content": "还有其他的吗",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-2",
"content": "你是要学习C语言的软件还是能编译C语言的软件",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "能编译c语言的软件 因为平时学的时候自己也想上手一下",
"referer": "user-2"
}
] |
初学者求解关于建立C程序的最基本问题
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "printf(\"a=%d(10)=%o(8)=%x(16)\", a, a, a);",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "谢谢！",
"referer": "user-1"
}
] |
这个指针为什么无法输出元素，
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "最后一个 printf() 输出的是指针吧，不是指向的元素；要输出指向的元素的值，应加上取值的 * 如 printf(..., *p, *v, *u);",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "谢谢，大佬。那大佬怎么保存vs2019的对与处理器的修改。",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-0",
"content": "什么是指针指向多维数组？ int a； p=a 那＊p=a是否相等？＊p改变了a改变吗？",
"referer": "user-1"
},
{
"cid": "4",
"user": "user-1",
"content": "多维数组，就是如 aArrp[6][8] 这样的有两个或以上下标的数组，指向这样数组的指针就是了。 不相等，应该是 p=&a; 吧，就是把 a 的地址给 p 即让 p 指向 a；这样，*p=b; 就会改变 a 的，使其和 b 内容一样。",
"referer": "user-0"
}
] |
C语言求助一题，如何归并两个本就有序的文本文件
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "可以当cvs文件处理",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "好像是有些麻烦，不如分两步，首先简单合并如 A aaa\\nA bbb\\nA ccc\\nB aaa\\n... 然后再对其进行关键字同项合并。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "好像就是这样，谢谢！但是怎么才能同项合并呢",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-2",
"content": "同项合并简单吧，读入一行，分解为关键字和值，比较此关键字和前面是否一样，若一样，输出空格和本次值，若不一样输出回车换行、本次关键字、空格、本次值；继续读入下一行到文件末。",
"referer": "user-0"
}
] |
x+z%3*(int)(x+y)%2/4这里的int 是什么意思？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "(type)...将...强转为type类型",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "(int)(x+y) 将 x+y 得到的值取整。",
"referer": "user-0"
}
] |
求大神帮忙解答一下为什么程序有时候可以正常运行有时候会崩掉
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "MakeNode() 里的 malloc() 里的 sizeof(ElemType) 是不对的，应该是 sizeof(LNode)",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "好像确实是这个问题 不过那为什么总会在第二个循环出错",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-1",
"content": "不是总的，我在 win7 32位下用 vc2008 生成，有时第一行就出错的，但在 Ollydbg 加载执行却又能正常，没去细究，大致就是堆内存管理上结构被破坏导致内存访问了错误的地方（malloc() 函数里重设内存块部分）。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "哦哦 好的谢谢",
"referer": "user-1"
}
] |
C语言1-100求和
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "for后面的；",
"referer": "user-0"
}
] |
输入a,b两个数字，求解n的取值范围（新人），求大佬帮忙解惑
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "int a = 2010, b = 2011; int n = 1; double tx = 1; double lf = 1; bool bf = false; while (true) { if (tx >= a && !bf) { cout << n<<endl; bf = true; } if (tx > b) { cout << n - 1; break; } n++; lf = lf + 1.0 / n; tx = tx + 1.0 / lf; }",
"referer": "user-0"
}
] |
深度解析 Filebeat 工作原理，轻松玩转大数据！
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "1",
"referer": "user-0"
}
] |
贪吃蛇（队列实现）
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "#include <iostream> #include <iomanip> #include <vector> using namespace std; int main() { int dir[4][2]{ {0,1},{1,0},{0,-1},{-1,0} }; int n; std::cin >> n; int r = n - 1; int u = 1; int d = n - 1; int l = 0; vector<vector<int>> board(n, vector<int>(n)); int x = 0, y = 0; int dict = 0; for (int i = 0; i < n * n; i++) { board[x][y] = i; if (y == r && dict == 0) { dict=(dict+1)%4; r--; } if (y == l && dict == 2) { dict = (dict + 1) % 4; l++; } if (x == u && dict == 3) { dict = (dict + 1) % 4; u++; } if (x == d && dict == 1) { dict = (dict + 1) % 4; d--; } x += dir[dict][0]; y += dir[dict][1]; } for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { cout <<setw(4) << board[i][j]; } } }",
"referer": "user-0"
}
] |
多线程间的消息通知机制
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "你觉得会有这样的机制吗？",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "这个，好像不需要吧，线程1 写就是了，写完了给线程2 发个自定义消息让它去读；因为要隔段时间才设置一次，不会发生线程1 在写时，上次的线程2 还没读完，除非线程2 读一个字符处理半天再读下一个字符。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "您没明白我的意思，线程2线程1操作共享内存，肯定是要有同步机制的， 但是我还不知道怎么设置同步机制，让他不阻塞，因为像互斥锁这样的同步机制得不到锁是不向下运行的",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-2",
"content": "WaitForSingleObject() 这样的函数不是有 dTimeOut 参数吗，到点了即便没拿到所有权，也是会返回的，不会死锁。",
"referer": "user-0"
}
] |
低级问题。。。。。。。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "按你的代码，输入的时候71.82和A之间不能留空格。或者按你的输入，最后一个scanf的第一个%c前面留个空格试试。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "噢，是哦，我就说为什么从=c1没输出，原来是输出了空格",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-0",
"content": "感谢感谢",
"referer": "user-1"
},
{
"cid": "4",
"user": "user-2",
"content": "scanf(\"a=%d b=%d\", &a, &b)改为scanf(%d %d\", &a, &b)scanf(\"%c,%c\", &c1, &c2)改为scanf(%c %c\", &c1, &c2)x,y的值小数点后那么多位是咋回事?在printf中，可以限定小数位的个数为2个，改x=%6.2f,y=%6.2f",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "感谢",
"referer": "user-2"
},
{
"cid": "6",
"user": "user-0",
"content": "两个%c中间不能用逗号隔开吗？",
"referer": "user-2"
}
] |
大佬们，为什么这个程序中第12行sum=sum+1.0/c;是对的，sum=sum+1/c;就错了呢？这个.0有什么讲究吗？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "因为常量也有类型",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "sum=sum+1.0/c;算出来是浮点数，sum=sum+1/c;算出来是整数，而且，C语言的整数除法跟我们的算术除法是不同，它不会帮你四舍五入，它是直接不要小数部份，算出来的结果当然是不对了。",
"referer": "user-0"
}
] |
大佬们，这咋回事啊，什么意思啊
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "double后面是分号不是逗号这里printf拼写错误",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "请仔细校对标点符号和拼写。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "%lf %16.7lf",
"referer": "user-0"
}
] |
学校让做一个词典，加载的时候出问题了，不报错，自动进调试页面 ，希望大佬给看看怎么回事
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "自己改过了 运行成功",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "希望大佬看看是哪里的错误，指正一下",
"referer": "user-0"
}
] |
1~4组成无重复数字的三位数
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "#include <iostream> #include <vector> using namespace std; void func(int nums[4],int pos,int len,int item[3]){ if (len == 0) { for (int i = 0; i < 3; i++) printf(\"%d \", item[i]); printf(\"\\n\"); return; } for (int i = pos; i < 4; i++) { item[pos]=nums[i]; swap(nums[pos], nums[i]); func(nums, pos + 1, len - 1, item); swap(nums[pos], nums[i]); } } void pailie(int nums[4], int len) { int item[3]{ 0 }; func(nums, 0, len, item); } int main() { int nums[4]{ 1,2,3,4 }; pailie(nums, 3); }",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "//qplw.cpp #include <stdio.h> #include <string.h> #include <stdlib.h> int v=0; int w=0; int m;//记录字符串长度 int n;//记录字符串中的字符种类数 char map[256];//记录是哪几种字符 int count[256];//记录每种字符有多少个 int stack[1000];//递归用的栈，并记录当前生成的排列 void Make_Map(char *str) {//统计字符串的相关信息 int s[256]; int i; memset(s,0,sizeof(s)); memset(count,0,sizeof(count)); m=strlen(str); if (w<1 || m<w) w=m; while(*str) { s[*str]++; str++; } n=0; for (i=0;i<256;i++) if (s[i]) { map[n]=i; count[n]=s[i]; n++; } } void Find(int depth) {//递归式回溯法生成全排列 if (depth==w) { int i; for (i=0;i<depth;i++) putchar(map[stack[i]]); putchar('\\n'); } else { int i; if (v && depth>0) { for (i=0;i<depth;i++) putchar(map[stack[i]]); putchar('\\n'); } for (i=0;i<n;i++) if (count[i]) { stack[depth]=i; count[i]--; Find(depth+1); count[i]++; } } } void main(int argc,char**argv) { if (argc<2) { printf(\"%s 要产生全排列的字符串 [限定长度|-1]\\n\",argv[0]); return; } if (argc>=3) w=atoi(argv[2]); if (-1==w) v=1; Make_Map(argv[1]); Find(0); } //C:\\test>qplw //qplw 要产生全排列的字符串 [限定长度|-1] // //C:\\test>qplw 123 //123 //132 //213 //231 //312 //321 // //C:\\test>qplw 123 2 //12 //13 //21 //23 //31 //32 // //C:\\test>qplw 122333 3 //122 //123 //132 //133 //212 //213 //221 //223 //231 //232 //233 //312 //313 //321 //322 //323 //331 //332 //333 // //C:\\test>qplw 123 -1 //1 //12 //123 //13 //132 //2 //21 //213 //23 //231 //3 //31 //312 //32 //321 // 运行qplw 1234 3输出123124132134142143213214231234241243312314321324341342412413421423431432",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "同学，请参考： #include <stdio.h> int main() { int number[] = {1, 2, 3, 4}; for (int indexI = 0; indexI < 4; indexI++) { for (int indexJ = 0; indexJ < 4; indexJ++) { for(int indexK = 0; indexK < 4; indexK++) { // 保证不重复 if (indexI!=indexJ && indexI !=indexK &&indexJ!=indexK) { printf(\"%d%d%d\\t\", number[indexI], number[indexJ], number[indexK]); } } } printf(\"\\n\"); } }",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-4",
"content": "排列数4x3x2种",
"referer": "user-0"
}
] |
问一下为什么LocateList里运行到L->length或L->data程序就会结束
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "同学，你这个 CreateList传入的是一个指向结构体的二级指针，在此函数内使用了malloc分配后，它的地址与你传入的地址是不同的，所以，CreateList返回后，L指向的一个空指针或野指针，所以，你应该传入L的一级指针。还有malloc分配的空间也借了。这个CreateList函数建议简单点，直接传入一个需要创建的元素个数即可，然后，返回创建好的指针，我将它改成这样： /*函数的声明*/ SeqList* CreateList(int n) { // L = (SeqList *)malloc(ListSize * sizeof(int)); // 原式是错的，分配内存空间与实际的不符 SeqList *L = (SeqList *)malloc(sizeof(SeqList)); printf(\"要输入的元素:\"); for (int i = 0; i < n; i++) { int p; scanf(\"%d\", &p); L->data[i] = p; } printf(\"顺序表创建成功:\"); L->length = n - 1; for (int j = 0; j < n; j++) { printf(\"%d \", L->data[j]); } printf(\"\\n\"); return L; // 返回创建好的指针 }",
"referer": "user-0"
}
] |
C语言写简单猜数游戏
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "前几天也有同学发了这个： https://bbs.csdn.net/topics/601319902 呵呵，你们是不是同一学校？ #include <stdio.h> #include <time.h> #include <stdlib.h> #include <math.h> int main() { srand(time(0)); int weishu; printf(\"请选择猜的位数【1为一位数 2为2位数 3为三位数】\"); scanf(\"%d\", &weishu); int a = 0; int n = 0; int number = rand() % ((int) pow(10, weishu)) + 1; printf(\"number = %d\\n\", number); printf(\"请输入%d以内的数字\\n\", (int) pow(10, weishu)); do { n++; printf(\"输入你认为的数是：\"); scanf(\"%d\", &a); if (number > a) { printf(\"小了\\n\"); } else if (number < a) { printf(\"大了\\n\"); } } while (number != a); printf(\"对了，你用%d次了\\n\", n); system(\"pause\"); return 0; }",
"referer": "user-0"
}
] |
要输出这样一个3*3的二维数组 1 2 3 4 5 6 7 8 9 为什么我这个只有123？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "1、数组的下标是从0开始，你的2个for循环已经越界2、printf函数的数据类型也不对3、第2个for循环完了后就可以直接换行，为什么要if条件？我把它改了，应该这样就可以了： int main () { float a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; int i, j; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { printf(\"%3.0f\", a[i][j]); } printf(\"\\n\"); } return 0;}",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "#include<stdio.h> int main() { float a[3][3] = {{1,2,3},{4,5,6},{7,8,9}}; int i,j,n; for(i=0;i<3;i++){ for(j=0;j<3;j++,n++) { if(n%3==0) printf(\"\\n\"); printf(\"%3.f\",a[i][j]); } } }",
"referer": "user-0"
}
] |
为什么会出错代码本身并没有错
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "//scanf_s(\"%s\", name,sizeof(name)); scanf_s(\"%s\", name);好像这儿不对。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "我没看到上面的C代码里面什么地方引用memset，所以无法理解两个图之间的联系。另外，忠告是关注一下两个warning，也许有什么线索呢。",
"referer": "user-0"
}
] |
如何学好C语言，个人认为不错的一篇文章
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "这个文章也许有部分说得有道理，但是有一个最大的问题：提出了问题，却没有给出解决问题的办法",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "学好C语言，关键是遇到一个会教C语言的老师。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "写这些文章的人，只有两种可能：大牛，扯蛋。对号入座。。如：C语言，谭浩强的C，确实有很多瑕疵，但是适合入门。一个没编程基础的人，看K & R的C，无疑天书。。",
"referer": "user-0"
}
] |
统计一个排列中逆序对 的个数
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "如果用的是计算机而不是手机APP的话，往下方看。",
"referer": "user-0"
}
] |
跪求大神指导 安装fftw3时 ./configure --enable-mpi CC=mpicc CXX=mpiCC F77=mpif77，结果出来下面的错误
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "楼主解决了吗 我的也是了！求解",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "--with-compiler=/path/to/gcc",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "try sudo",
"referer": "user-0"
}
] |
vc6代码正确，输入数值，不显示结果
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "好的好的谢谢谢谢",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "BTW:scanf的格式串里面，字符是不转义的。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-1",
"content": "如果你认定了代码没错的话，那就只能是输入的错了你得输入 11\\n这样然后再敲回车，这样才能满足scanf的胃口。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-2",
"content": "代码是没有错，你错在scanf(\"%d\\n\",&x); 这里不应该多加一个换行符\\n，去掉之后，输入数字，直接回车，就可以计算出来了。 但是你加了这个换行符，就相当于你一定要先换行，再输入，才可以。",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-2",
"content": "代码是没有错，你错在 scanf(\"%d\\n\",&x);",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-3",
"content": "scanf()里，把那个 \\n 去掉试试？",
"referer": "user-0"
}
] |
求帮助！帮忙改下错误（萌新遇难）
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "前两个拼写错误吧，第一个是前面预定义时错写了个小写成 SearchPresentplan，第二个是前面预定义时多敲了个字母 t 成 Intput...第三个，就是定义和使用的类型上不一样，自己看着怎么改吧。",
"referer": "user-0"
}
] |
想做一个译码的题，除了把大写字母比如A就专程A+4的字母 ，但是大写字母可以了输入数字或者小写就乱码是什么问题呢，不知道怎么将数组中是数字的单个元素输出，查了百度说如果是用%c输出要将单个元素加''
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "主要问题在于关系运算符不能连着用。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "同学，首先，你不能直接循环整个字符数组，如果输入小于10个字符你就出错了，所以，循环条件改用sizeof更好。大写字母那个条件改为：if (ch[i] >= 65 && ch[i] <=90)，小写字母的条件改为if(ch[i]>=97 && ch[i] <=122)，还要增加一个数字的条件：if(ch[i]>=30 && ch[i] <=39)",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "老师，请问一下在循环条件里面怎么用sizeof",
"referer": "user-2"
}
] |
求大佬们支个招呀！！！！
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "我用Dev C++可以跑起来",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "代码在哪里？",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "重新发了一下",
"referer": "user-1"
}
] |
刚大一，这个看不懂，希望老哥们帮忙看一下
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "此贴终结，输入的时候输入成10,10了，不能用逗号，要用空格",
"referer": "user-0"
}
] |
，大一新手。pta一个题目怎么都过不了。麻烦好心人看看哪里错了。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "供参考： #include<stdio.h> int main() { int T,n,k,s; scanf(\"%d\",&T); while(T--) { scanf(\"%d\",&n); s = 0; while(n--) { scanf(\"%d\",&k); s += k; } if(s%5==0 && s%7==0 && s%3==0) printf(\"YES\\n\"); else printf(\"NO\\n\"); } return 0; }",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "感谢！感谢！",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "第一，你想的太多了。只要判断一组就输出一个结论就行了，不必煞费苦心地“一起输出”。因为OJ系统没有交互式输入，不会乱的。第二，你想的太少了。要是数据组数稍微多一点，你的a根本就不够用。第三，非必要不用浮点数，因为浮点数不精确。我的意思是不要用pow函数。 当然，落实了第一，后面就都是多余的了。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "按照您的思路确实是对的！",
"referer": "user-2"
},
{
"cid": "5",
"user": "user-0",
"content": "我的代码再要输出十几组是就会出错",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-0",
"content": "感谢！",
"referer": "user-2"
}
] |
第一次在csdn发帖，本人新手刚入门c语言
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "同学，提示你变量a和number重复定义了，而且，你写的也太复杂 了，我把它简化了：#include <stdio.h>#include <time.h>#include <stdlib.h>#include <math.h> int main() { srand(time(0)); int weishu; printf(\"请选择猜的位数【1为一位数 2为2位数 3为三位数】\"); scanf(\"%d\", &weishu); int a = 0; int n = 0; int number = rand() % ((int) pow(10, weishu)) + 1; printf(\"number = %d\\n\", number); printf(\"请输入%d以内的数字\\n\", (int) pow(10, weishu)); do { n++; printf(\"输入你认为的数是：\"); scanf(\"%d\", &a); if (number > a) { printf(\"小了\\n\"); } else if (number < a) { printf(\"大了\\n\"); } } while (number != a); printf(\"对了，你用%d次了\\n\", n); system(\"pause\"); return 0; }",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "出错理由你的图片里已经说的很清楚了。你可以把三个case下面具体的内容分别用花括号括起来试试。",
"referer": "user-0"
}
] |
realloc, 静态数组，扩容。为什么可行？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "请明白什么是堆，什么是栈，堆是自由存储区，一般使用链表。栈是连续存储区，堆可以改变一个单元大小，但需要你自己去操作他的生死。栈是连续的，有系统自动创建和回收。也就是说一个单元大小确定了就不能更改。因为更改它会影响下一个单元。realloc，malloc free这些都是针对堆，而不能针对栈。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "实践是检验真理的唯一标准。这句话经常有意无意地被误解或者曲解。这种追求易传易记的口号实际上要求简短，所以实际上省略了很多修饰语和限定词。至少不是随便什么行为都有资格称为实践，也不是所有的实践都有资格检验真理的。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-2",
"content": "如果这样运行是可以的，那么去掉里面realloc那行以后运行，结果将还是一样的。这就足以说明那句realloc实际上不起作用。 异想天开并非进取之道，还是要把思维调整回到C语言的规范轨道上来。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-3",
"content": "这个，应该不可以吧，应该检查一下 realloc() 的返回值。",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "既然realloc这么好用，就没有什么风险吗？",
"referer": "user-0"
}
] |
c语言贪吃蛇游戏 网上找的代码，根据自己的编译环境作了修改
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "看看我跟老师学的雷霆战机，有文档、素材、源代码全套： https://space.bilibili.com/1901488254",
"referer": "user-0"
}
] |
哪位大吓有C的题来刷一下
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "// 下面是我写的代码，使用了二维数组，没有使用结构体#include <stdio.h>#include <string.h> #define STUDENTS 5 // 宏定义学生的人数：5个#define SUBJECTS 5 // 宏定义每个学生的科目：英语、数学、语文、体育、音乐 char Name[STUDENTS][11]; // 定义学生的姓名字符数组：Name[0]=\"小明\"，Name[1]=\"王一呜\"float Score[STUDENTS][SUBJECTS + 1]; // 总成绩=英语+数学+语文+体育+音乐 // 函数的声明// 输入学生的姓名和它每科的成绩void inputDate();// 打印排序前的学生的姓名和成绩void printData();// 按学生的总成绩排序（从高到低：冒泡排序）void sortData(); int main() { // 1、输入学生的姓名和它每科的成绩 inputDate(); // 2、打印排序前的学生的姓名和成绩 printf(\"排序前的学生的姓名和成绩：\\n\"); printData(); // 3、按学生的总成绩排序（从高到低） sortData(); // 4、打印排序后的学生的姓名和成绩 printf(\"排序后的学生的姓名和成绩：\\n\"); printData(); return 0;} // 函数的定义// 输入学生的姓名和它每科的成绩void inputDate() { // 使用for循环，输入每个学生的姓名和他们每科的成绩 for (int indexI = 0; indexI < STUDENTS; indexI++) { // 1、输入学生的姓名 printf(\"请输入第%d个学生的姓名（一共%d个）：\", indexI + 1, STUDENTS); scanf(\"%s\", Name[indexI]); // 2、输入这个学生的每科成绩 printf(\"请输入%s的英语、数学、语文、体育、音乐成绩（使用逗号分隔它们）：\", Name[indexI]); scanf(\"%f,%f,%f,%f,%f\", &Score[indexI][0], &Score[indexI][1], &Score[indexI][2], &Score[indexI][3], &Score[indexI][4]); // 3、统计这个学生的总成绩 // Score[indexI][SUBJECTS] = Score[indexI][0] + Score[indexI][1] + Score[indexI][2] +Score[indexI][3] +Score[indexI][4]; Score[indexI][SUBJECTS] = 0.00; // 初始化总成绩为0.00 for (int indexJ = 0; indexJ < SUBJECTS; indexJ++) { Score[indexI][SUBJECTS] += Score[indexI][indexJ]; } // printf(\"%s的英语=%8.2f、数学=%8.2f、语文=%8.2f、体育=%8.2f、音乐=%8.2f、总成绩=%8.2f\\n\", Name[indexI], Score[indexI][0], // Score[indexI][1], Score[indexI][2], Score[indexI][3], Score[indexI][4], Score[indexI][5]); }} // 打印排序前的学生的姓名和成绩void printData() { // 1、打印标题 printf(\"+----------+--------+--------+--------+--------+--------+--------+\\n\"); printf(\"| 姓名 | 英语 | 数学 | 语文 | 体育 | 音乐 | 总成绩 |\\n\"); printf(\"+----------+--------+--------+--------+--------+--------+--------+\\n\"); // 2、使用for循环打印每个学生的姓名和成绩 for (int indexI = 0; indexI < STUDENTS; indexI++) { printf(\"|%10s|\", Name[indexI]); // 打印学生的姓名 for (int indexJ = 0; indexJ < SUBJECTS + 1; indexJ++) { printf(\"%8.2f|\", Score[indexI][indexJ]); // 打印学生每科的成绩（包括总成绩） } printf(\"\\n\" ); printf(\"+----------+--------+--------+--------+--------+--------+--------+\\n\"); }} // 按学生的总成绩排（从高到低：冒泡排序）void sortData() { for (int indexI = 0; indexI < STUDENTS - 1; indexI++) { for (int indexJ = 0; indexJ < STUDENTS - 1 - indexI; indexJ++) { if (Score[indexJ][SUBJECTS] < Score[indexJ + 1][SUBJECTS]) { // 1、交换他们的姓名 char tempName[11]; strcpy(tempName, Name[indexJ]); // 把当前位置学生的姓名拷贝到临时变量中 strcpy(Name[indexJ], Name[indexJ + 1]); // 把下一个位置的学生姓名拷贝到当前位置 strcpy(Name[indexJ + 1], tempName); // 把临时变量拷贝到下一个位置的学生姓名中 // 2、交换他们每一科的成绩 for (int indexK = 0; indexK < SUBJECTS + 1; indexK++) { float tempScore = Score[indexJ][indexK]; // 把当前位置学生的每一科成绩存放到临时变量中 Score[indexJ][indexK] = Score[indexJ + 1][indexK]; // 把下一个位置的学生成绩存放到当前位置上 Score[indexJ + 1][indexK] = tempScore; // 把临时变量存放到下一个位置的学生成绩中 } } } }}",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "#include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996) #define N 5 struct Student { int name; float chinese; float mathematics; float english; float sports; float music; float total_score; }stu[N]; struct Student* p; int main() { printf(\"please enter the grades of Nstudents in each subject:\\n\"); int y; for (y=0;y<N;y++) { scanf(\"%d,%f,%f,%f,%f,%f\",&stu[y].name, &stu[y].chinese, &stu[y].mathematics, &stu[y].english, &stu[y].sports, &stu[y].music ); stu[y].total_score = (stu[y].chinese + stu[y].mathematics + stu[y].english + stu[y].sports + stu[y].music); } int i, j, k; struct Student temp; for (i = 0; i < N - 1; i++) { k = i; for (j = i + 1; j < N; j++) { if (stu[j].total_score > stu[k].total_score) k = j; temp = stu[k]; stu[k] = stu[i]; stu[i] = temp; } } printf(\"Results of %d students in each subject : \\n\",N); for (p = stu; p < stu + N; p++) { printf(\"name:%d,chinese:%0.2f,mathematics:%0.2f,english:%0.2f,sports:%0.2f,music%0.2f,totoal_socre:%0.2f\", p->name, p->chinese,p->mathematics, p->english, p->sports, p->music,p->total_score); printf(\"\\n\"); } return 0; } ```c #include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996) #define N 5 struct Student { int name; float chinese; float mathematics; float english; float sports; float music; float total_score; }stu[N]; struct Student* p; int main() { printf(\"please enter the grades of Nstudents in each subject:\\n\"); int y; for (y=0;y<N;y++) { scanf(\"%d,%f,%f,%f,%f,%f\",&stu[y].name, &stu[y].chinese, &stu[y].mathematics, &stu[y].english, &stu[y].sports, &stu[y].music ); stu[y].total_score = (stu[y].chinese + stu[y].mathematics + stu[y].english + stu[y].sports + stu[y].music); } int i, j, k; struct Student temp; for (i = 0; i < N - 1; i++) { k = i; for (j = i + 1; j < N; j++) { if (stu[j].total_score > stu[k].total_score) k = j; temp = stu[k]; stu[k] = stu[i]; stu[i] = temp; } } printf(\"Results of %d students in each subject : \\n\",N); for (p = stu; p < stu + N; p++) { printf(\"name:%d,chinese:%0.2f,mathematics:%0.2f,english:%0.2f,sports:%0.2f,music%0.2f,totoal_socre:%0.2f\", p->name, p->chinese,p->mathematics, p->english, p->sports, p->music,p->total_score); printf(\"\\n\"); } return 0; } ```",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "多复制了一份，只看一份就可以了。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-1",
"content": "我今天的作业要求：1、输入不少于5名学生的姓名和他们语文、数学、英语、体育、音乐的成绩（小数保留2位即可）2、按他们的总成绩从高到低进行排序（冒泡、选择、快速、希尔随便选一个）3、输出像如下形式的报表： +----------+--------+--------+--------+--------+--------+--------+ | 姓名 | 语文 | 数学 | 英语 | 体育 | 音乐 | 总成绩 | +----------+--------+--------+--------+--------+--------+--------",
"referer": "user-0"
}
] |
大一新生C++小白，程序错误百出，但是不知道哪里错了
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "同学，我帮你改好了，真的错了很多，最关键是C语言的case语句只能是整数（字符也是整数的特例）： #include #include #include using namespace std; int main() { double a, b; char ys; cin >> a >> b >> ys; switch (ys) { case '+': cout << a << ys << b << \"=\" << a + b; break; case '-': cout << a << ys << b << \"=\" << a - b; break; case '*': cout << a << ys << b << \"=\" << a *b; break; case '/': { if (b == 0.00) cout << \"除数不能为0\"; else cout << a << ys << b << \"=\" << a / b; } break; case '%': cout << (int)a << ys << (int)b << \"=\" << ((int)a % (int)b); break; default: cout << \"error!\"; } cout << endl; return 0; }",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "感谢感谢，我懂了",
"referer": "user-1"
}
] |
为什么gcc默认的char类型是有符号的？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "既然C语言标准放任了这个问题存在于Implementation Defined，那就是公说公理，婆说婆理的事儿了，咱们就不要企图从理上理解他了，接受就好。也就是心中不做假设。如果语义上真的只需要字符，那就上char如果需要它来表达小整数，那就按自己的需要明确使用signed char或者unsigned char",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "与硬件架构相关，gcc也不总是默认char是signed char，在ARM、PPC平台上默认就是unsigned char",
"referer": "user-0"
}
] |
求助！！新手小白的疑问
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "while (scanf_s(\"%d\", &x)!=EOF);这一句是啥意思",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "while (scanf_s(\"%d\", &x)!=EOF);",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-2",
"content": "你while语句的那行多写了一个 ;",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "谢谢！解决啦",
"referer": "user-2"
}
] |
高性能接收和处理消息问题
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "1、自己写吧，练练手，没啥难度。2、s2全局序号没任何意义。s1发送N个数据包，s2可能一次就接收完了。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "自己顶一下",
"referer": "user-0"
}
] |
老是报fopen_s参数太少，但用fopen,又报不安全。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "鼠标右键点fopen_s,再弹出的菜单中选转到定义",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "老师，转到定义之后呢，怎么操作",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-1",
"content": "按照函数定义调用函数",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "刚刚解决了，在vs2019中已经取消了fopen，在头文件从新声明（加入）#pragma warning(disable:4996) 就可以了。",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-2",
"content": "好像不太行啊大哥",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-0",
"content": "已经解决：",
"referer": "user-0"
}
] |
对于计算函数的n次方该如何用c语言写出
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "double pow(double,double)declared in math.h",
"referer": "user-0"
}
] |
实在搞不懂了，救救。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "我主要强调转义字符是一个编译期概念，编译结束以后就再也没有什么转义字符了。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "感谢感谢。",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "同学，你这个小程序至少有2个地方有问题：1、char *st;这里你只定义了一个字符指针，没有为它分配空间，它在下面读取的时候会出现不可预料的错误。2、输入的“pro\\ngrme\"，每一个都是正常可显示的字符，不是换行符也不是回车符，所以，它不可能与'\\n'或'\\0’相等如果你非要将某个字符转换为换行符或回车符，建议使用反斜杠‘/’。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "感谢感谢。",
"referer": "user-2"
}
] |
编写一个JavaScript脚本，在浏览器中输出3位整数中的所有对称数（个位和百位相同）。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "最近刚好在折腾JS 帮你改了下 <html> <body> <script> var str=\"3位整数中的所有对称数如下：<br />\"; var g,s,b,i=100; for(var i=100;i<1000;i++){ g=i%100; s=(i-i%10)/10; b=(i-i%100)/100; if(b==g){ str+=\" \"+i+\" \"; } } document.write(str); </script> </body> </html>",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "想不出来啊，有没有大佬啊",
"referer": "user-0"
}
] |
不知道为什么Compilation Error。求大佬解答
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "int m,n,x=0,y=0,i,j,k,t; int a[j]; 在这里j没有初始值，是不能定义数组a。还有一点，如果你的编译器不支持c99，数组的大小还不可以是变量。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "太谢谢了，大佬强啊👏",
"referer": "user-1"
}
] |
分享一下写了N年的自用编辑器 -- EDX
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "使用了下，不错，功能强大，把python调试环境支持下就完美了。！",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "能undo,redo吗？ 支持键盘宏/脚本宏吗？",
"referer": "user-0"
}
] |
新人求解，刚入门，很简单的
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "int a;scanf(\"%d\",&a);int b=a%10100+a/100+a%100/1010;printf(\"%d\",b); 同学，这样才对。你a还没有初值，怎么可以使用它呢？",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "int main(){ int a; scanf(\"%d\",&a);printf(\"%d\",a%10100+a/100+a%100/1010); 这个就是对的，那我原来那个错哪了",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-2",
"content": "printf语句里面不要加&",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "还是不对",
"referer": "user-2"
},
{
"cid": "5",
"user": "user-2",
"content": "a初值没有赋初值，程序是依次执行的，你要使用a就要先赋值再使用，其次，printf不要加&",
"referer": "user-0"
}
] |
学生刚入门，求解问题
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "你的输出有问题printf(\"语文成绩为 %f\\n数学成绩为 ：%f\\n\",y,s)",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "你的s有啥用吗？输入是不是得是%lf，倒数第二行差，&y，&s （我也不确定 我也是小白）",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-1",
"content": "输入的话float是%f，double是%lf，printf里面不加&",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-3",
"content": "",
"referer": "user-0"
}
] |
四则运算计算器怎么才能让输出的负数带括号
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "1、输入第1个操作数2、输入四则中任一个运算符3、输入第2个操作数4、使用switch语句，根据运算符，进行四则运算。如果在除法中，除数为0，输出“除数不能为0”。否则，在printf中输出结果，如果操作数小于0，加括号。 这位哥哥好象是大学生，我还是小学生，打扰了！",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "so easy! 妈妈再也不用担心你的学习问题～",
"referer": "user-0"
}
] |
四则运算计算器怎么才能让输出的负数带括号
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "格式字符串那里是可以换成一个字符数组名或者字符指针的。",
"referer": "user-0"
}
] |
哪里错了或者是语法错误
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "因为当把一个字符串改为整形的时候，系统是以ASCII把来输出的，无需强制转换。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "把a=int(x),修改为 a =x;",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-2",
"content": "看着没什么问题啊。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "又是你 哈哈",
"referer": "user-2"
},
{
"cid": "5",
"user": "user-2",
"content": "幸会 幸会",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-0",
"content": "该代码就是将英文字母转化为序号1,2,3，——26",
"referer": "user-0"
}
] |
我不李姐 天哪 我认为的是p=5+6+7 q=6+7+8
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "我的是vs2019，运行的结果是15，24，懒得去研究得，反正后面一般用得最多的就只是一个递增或递减，不会无聊的用到这个。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "特别安装了一个vs2019看看，果然与我用开的dev-c++是不同的，vs是遵从后置++当整行运算完成后，才改变自身的值！vs2019：15，22dev-c++：18，22",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "不同编译器不同结果，李不李姐无所谓。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-2",
"content": "1、后置++（--），是在整行运算完成后才改变自身的值，2、前置++（--），是先改变身的值，再参与整行的运算",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-2",
"content": "我认为p=5+6+7 q=6+7+8是对的，但vs不这么认为，我也不理解，呵呵",
"referer": "user-2"
}
] |
这个问题怎么解决啊 球球了 大佬们
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "C 库函数 double pow(double x, double y) 返回 x 的 y 次幂，即 xy。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "数据范围很重要，写个最简单的整数的次幂，提供大致的思路，供参考： #include<stdio.h> int fun(int n,int m) { int s=1; while(m--) s *= n; return s; } int main() { int a,b,c; scanf(\"%d%d%d\",&a,&b,&c); printf(\"%-9d%-9d%-9d\\n%-9d%-9d%-9d\\n%-9d%-9d%-9d\\n\", fun(a,1),fun(a,2),fun(a,3), fun(b,1),fun(b,2),fun(b,3), fun(c,1),fun(c,2),fun(c,3)); return 0; }",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "谢谢谢谢",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-3",
"content": "数的大小没说 那可不是写个代码就能解决的问题啊",
"referer": "user-0"
}
] |
关于字符指针定义奇怪的地方
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "你发送是一个结构体，接收也应该是一个结构体。message = (struct tcp_msg *)buf;这句肯定是错的，buf是字符串数组，怎么能强转成message结构体？",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "这个是可以的，就将字符串按照结构体的类型划分空间",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "一般是这样用吧 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <syspes.h> #include <sys/socket.h> #include <arpa/inet.h> #include <string.h> #include \"proto.h\" #define DATASIZE 128 int main(int argc,char **argv) { int sock_fd; struct sockaddr_in s_addr; uint8_t data[DATASIZE]; int res; if(argc < 2) { fprintf(stderr,\"error : %s + destip!\\n\",argv[1]); exit(1); } if((sock_fd = socket(AF_INET,SOCK_STREAM,0)) < 0) { perror(\"socket\"); exit(1); } s_addr.sin_family = AF_INET; s_addr.sin_port = htons(PORT); inet_pton(AF_INET,argv[1],&s_addr.sin_addr); if(connect(sock_fd,(void *)&s_addr,sizeof(s_addr)) < 0) { perror(\"conne);ct\"); exit(2); } while(1) { gets(data); if(!strcmp(data,\"exit\")) break; if(write(sock_fd,data,DATASIZE) < 0) { perror(\"write\"); break; } res = read(sock_fd,data,DATASIZE); if(res < 0) { perror(\"read\"); break; } if(res == 0) { printf(\"server is shutdown!\\n\"); break; } puts(data); } close(sock_fd); exit(0); }",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-2",
"content": "ssize_t send(int sockfd, const void *buf, size_t len, int flags); 这个应该传空类型的指针吧，也没见过传结构体的。",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "这个空指的是可以传任何类型的指针",
"referer": "user-2"
}
] |
在线等，a[2]={1,2,3,4};这个数组啥意思呢
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "a[2]={1,2,3,4};就是定义了一个num结构体数组，它的大小是2这样写可能有点费解，如果你把它改为这样：a[2] = {{1, 2}, {3, 4}};就很好理解了",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "谢谢您的回复，a[2]不是应该表示这个数组中的第三个元素吗？",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-1",
"content": "同学，a[2]在这个位置上是定义，不是取值，而且，你这个数组的数据类型是结构体啊，每个结构体里面定义了2个整型。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "就是这里有点糊涂，给您添麻烦了！那 *p=a;是不是表示指针指向了a数组的第一个位置呢",
"referer": "user-1"
}
] |
gbk编码中怎么区分中文和英文？判断方式是什么？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "转为Unicode，切分，转回GBK",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "IsDBCSLeadByte",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "大佬，这是什么意思？没有看懂",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-0",
"content": "IsDBCSLeadByte只是判断一个指定字节是否为一个双字节字符的头一个字符，而汉字的高字节和低字节都是大于0x80的，所以没什么区别",
"referer": "user-2"
},
{
"cid": "5",
"user": "user-2",
"content": "方法，方法，方法... 从buffer[0]开始怎么判断到需要截取的位置",
"referer": "user-0"
}
] |
求求了 想一晚上了 if语句没生效
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "没事了没事了 我处理好了 谢谢大家",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "楼主的意思，是输入三个一位数，1--9 之间？",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-2",
"content": "啥叫“当有0的时候消掉0”？",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "刚把if删了。。",
"referer": "user-0"
}
] |
为什么输出结果数据有问题？求教
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "是不是因为BMR是浮点数，而655和230都是整型",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "单步运行，看看各处的各相关值是否和预期一致，就象你这里好像没给 M 和 F 变量赋值就用上了，编译时不给 error 起码也是 warning 么？数据的输入，好像要和设定的格式完全一致的，否则可能有误。",
"referer": "user-0"
}
] |
代码看起来没有错，可是为什么不会停止
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "已解决，第一个for语句的括号位置不对：以下是正确的代码：#include <stdio.h>#include <string.h> struct Person{ char name[30]; int count; }leader[3] = { \"li\",0,\"zhang\",0,\"ran\",0 }; int main() { int i, j; for (i = 0; i < 10; i++) { char leader_name[30]; printf_s(\"please enter the name of the elector:\\n\"); scanf_s(\"%s\", leader_name, 30); for (j = 0; j < 3; j++) { if (strcmp(leader_name, leader[j].name) == 0) leader[j].count++; } } printf_s(\"\\nResult:\\n\"); for (i = 0; i < 3; i++) { printf_s(\"%s,%d\", leader[i].name, leader[i].count); } return 0;",
"referer": "user-0"
}
] |
老师们帮我看一下这个代码错在哪里。输入和输出不相符。
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "就是这个问题，非常感谢",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-1",
"content": "scanf_s要给出输入字符串的长度",
"referer": "user-0"
}
] |
json-c库的浮点型存储问题
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "浮点数格式 ▼ http://bbs.csdn.net/topics/390676437",
"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-2"
}
] |
为什么下面这段用c语言判断回文数的代码在vs2019上跑的出来，在vc++2010上跑不出来
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "#include <stdio.h> #include <string.h> #define N 80 int fun(char* str) { int sz = strlen(str); int i = 0, j = sz-1; while (str[i] == str[j]) { i++; j--; if (i >= j) break; } return (i >= j); } void main() { char s[N]; FILE* out; char* test[] = { \"1234321\",\"123421\",\"123321\",\"abcdCBA\" }; int i; printf(\"Enter a string : \"); gets(s); printf(\"\\n\\n\"); puts(s); if (fun(s)) printf(\"YES\\n\"); else printf(\"NO\\n\"); /************************************/ out = fopen(\"out.dat\", \"w\"); for (i = 0; i < 4; i++) if (fun(test[i])) fprintf(out, \"%s --> YES\\n\", test[i]); else fprintf(out, \"%s --> NO\\n\", test[i]); fclose(out); /************************************/ }",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "你的“int sz = sizeof(str) / sizeof(str[0]);”这条语句错了，sizeof(str)返回的是指针的大小，32位程序是4，64位程序是8。如果要返回空终结字符数组中元素的个数，应该用strlen(str)。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "嗯，我也不信这个代码能在vs任何版本上得到正确结果。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-4",
"content": "sz 的求取是错的，直接用求字符串长度减1 就是了。",
"referer": "user-0"
}
] |
codeblock怎么打开dev c++的项目
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "为什么要打开其他软件的项目呢？作业这种东西只需要交源程序就可以了，基本和项目无关。就算有关，也只需要在codeblock中打开源程序，编写完成后使用dev c++编译调试。 最后，我感觉你应该是对老师的要求理解有误！这种要求最多就是上机考试时只提供dev c++环境，所以叫你们熟悉它",
"referer": "user-0"
}
] |
求大佬帮忙看看这是咋了
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "同学，你错误的地方就是scanf这句用错了！使用scanf时最好给输入者清析的提示，把它改成这样就更好啦： int main() { float a, b, h, s; printf(\"请输入梯形的上、下底和高(请用,分隔它们)：\"); scanf(\"%f,%f,%f\", &a, &b, &h); s = (a + b) * h / 2; printf(\"梯形上底=%8.2f, 下底=%8.2f, 高=%8.2f, 它的面积=%8.2f\\n\", a, b, h, s); return 0; }",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "ok,感谢，想这个想了好久",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "and cut '&' off from printf",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-2",
"content": "typea=4,b=6,h=4then press enteras if your scanf format",
"referer": "user-0"
}
] |
急turboc的问题
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "应该是环境没设置好。另外没在dosbox下玩过，我在virtualbox下玩过。路径里有没有超过8个的文件名，空格等字符，dos都是不支持的 好久不见有人用这个了，你是什么学校的，竟然还在用tc？",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "图怎么换了。应该#include <graphics.h>",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "哦，图形啊，我近些年来一直认为怀念TC图形的行为只能叫做抱残守缺。是的，说的就是布置这种作业的老师。你知道让大黄蜂把自己伪装成农用小四轮拖拉机有多么困难么，居然还抱怨人家装得不像。//---------------------------------------------------------------//以上是吐槽。//---------------------------------------------------------------编译出错说明你设置的不对。回VC去加装easyx库用来模拟TC图形库是可行的方案。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-3",
"content": "貌似程序在等输入。",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-4",
"content": "代码内容帖上来",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-0",
"content": "老师求你帮忙看看",
"referer": "user-4"
},
{
"cid": "7",
"user": "user-2",
"content": "哦，你是TC都没运行起来，可能是你下载的版本有问题",
"referer": "user-0"
},
{
"cid": "8",
"user": "user-2",
"content": "Alt+F，OS Shell，再运行你的程序",
"referer": "user-0"
},
{
"cid": "9",
"user": "user-0",
"content": "大神，不行唉 我能私信问你吗",
"referer": "user-2"
}
] |
调用函数的返回类别...
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "使用struct fa就是值传递，因为它是一个结构体，所以，传递进函数需要将原数据复制一份副本，而且，你在函数内修改的是这份复制的副本，对原数据是没有影响的， 这样降低效率又不是你想要的，因此，只能是使用struct fa *传结构体的指针。另外，因为函数传进来的是结构体指针，所以，也不需要返回值。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "请不要碎片化学习，知识这玩意是有体系的，只有学习了前置内容，才能正确使用术语进行提问。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "这是一道改错题，不懂为什么调用函数返回指针的地址，其类别为什么是struct fa *,不用’*‘可以吗",
"referer": "user-2"
}
] |
简单的题但却疑惑并且新人懵逼中
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "我经常说，学习汇编和C之前，要抛弃小时候的”自动“观念，机器不会自动做任何事。我是说，你输入一个数和输出一个数之间啥也没有，在那中间机器不会自动给你做任何事。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "我懂了！谢谢！",
"referer": "user-1"
}
] |
这个错误怎么改呢，求大神
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "1、先声明函数：int insertSeqList(SeqList *L, int i);2、不能在函数里面，定义另一个函数。我刚学C语言时，最常犯的错误就是在main()函数里定义了另一个函数，呵呵。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "直译一下：函数定义不能放在这里。所以和你贴出来的部分没啥关系，问题在你没贴出来的部分里面。",
"referer": "user-0"
}
] |
怎么将b链表中有的数但a链表中没有的数插进a链表中
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "同学，参考我在B站的分享： https://space.bilibili.com/1901488254 循环A链表，遍历B链表查找，没有再插入。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "复杂度有点高了，直接用一个数组进行提前记录可以更好",
"referer": "user-1"
}
] |
二级指针的问题。。。。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "定义时： ... *p;表示p为指向...的指针 ... &r;表示r为...的引用，且只有c++才有引用 表达式中： *p表示取指针p指向的内容 &r表示取指向r的指针",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "同学，我举个简单的例子，你就明白了：int main() { int **a; int *p; int data = 100; p = &data; a = &p; printf(\"**a = %X, *a = %X, data = %d\\n\", a, p, **a); return 0; }",
"referer": "user-0"
}
] |
为什么我不能输出我的单链表
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "数据结构对单链表进行数据排序 ▼ http://bbs.csdn.net/topics/392201633",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "似乎是第38行并没有改变L，InitList对L的修改只停留在InitList内，当我在InitList内输出时就可以成功了 修改后，代码如下： #include <stdio.h> #include <stdlib.h> typedef struct LNode { int data; struct LNode *next; } LNode, *LinkList; void InitList(LinkList L) { LNode *s, *p; //S指向新申请的结点，P指向后结点 L = (LNode *)malloc(sizeof(LNode)); //建立头结点 L->data = -1; L->next = NULL; p = L; //P指向头结点 int n; scanf(\"%d\", &n); for (; n != 0;) { s = (LinkList)malloc(sizeof(LNode)); //新建结点 s->data = n; //放入data s->next = NULL; p->next = s; //P结点指向新结点S p = s; //p取代s结点 scanf(\"%d\", &n); } p->next = NULL; //终端结点不指向 outlist(L); } void outlist(LinkList L ) { LNode *p; for (p = L->next; p != NULL; p = p->next) { printf(\"%d \", p->data); } printf(\"\\n\"); } int main() { LinkList L; InitList(&L); //相当于传入一个变量，而非地址？ //outlist(L); return 0; }",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-2",
"content": "修改如下，供参考： #include <stdio.h> #include <stdlib.h> typedef struct LNode { int data; struct LNode *next; } LNode, *LinkList; void InitList(LinkList * L) { LNode *s, *p; //S指向新申请的结点，P指向后结点 (*L) = (LNode *)malloc(sizeof(LNode)); //建立头结点 (*L)->data = -1; (*L)->next = NULL; p = (*L); //P指向头结点 int n; scanf(\"%d\", &n); for (; n != 0;) { s = (LNode *)malloc(sizeof(LNode)); //新建结点 s->data = n; //放入data p->next = s; //P结点指向新结点S p = p->next; //p取代s结点 scanf(\"%d\", &n); } p->next = NULL; //终端结点不指向 } void outlist(LinkList L ) { LinkList p = L->next;//LinkList p = L; //L = L->next; while ( p != NULL ) { printf(\"%d \", p->data); p = p->next; } } int main() { LinkList L; InitList(&L); outlist(L); return 0; }",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-3",
"content": "同学，你这个程序很多错误的地方，重复的语句，你可以从我分享的网盘中下载我关于链表的实现（增、删、改、查、排序）： https://space.bilibili.com/1901488254",
"referer": "user-0"
}
] |
关于反序输出递归函数的疑问
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "reverse(&s[1]);就是reverse(s+1);嘛。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "试了一下，发现确实可以这样，谢谢大佬的建议",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "递归算法都比较烧脑，这个算法关键在于这句： reverse(&s[1]);它实质上就是每次都向右移动了字符串的首地址一个位置，你把 putchar(s[0]);换成这样：printf(\"s=%s, s[0]=%c\\n\", s, s[0]);就很容易看出，它是如何做的。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "对，就是这句 reverse(&s[1]);我不理解它是如何运作以达到这个效果的，使用了后面的方法看到了怎么“归”，就是不知道怎么递出去的 谢谢大佬解惑",
"referer": "user-2"
}
] |
sqrt的用法是怎样的。。。。。。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "常量也有类型",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "因为sqrt的函数原型的参数就是double，而不是int。如果sqrt参数是Int，那么他计算double,必然会丢失参数的浮点部分，而如果是double，int转double，是不会丢失什么的",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "那是使用数学函数时，都要转换吗",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-2",
"content": "查函数说明",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-3",
"content": "原来你关心这个，那么检查一下你的代码里头文件写对写全了么？",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-4",
"content": "不用强转吧，你什么IDE?",
"referer": "user-0"
},
{
"cid": "7",
"user": "user-3",
"content": "嗯，这是您应该做的。",
"referer": "user-0"
},
{
"cid": "8",
"user": "user-5",
"content": "k=sqrt((double(i)+100); m=sqrt((double(i)+268);同学，你粗心了，强转都写错了，应该是这样吧：k = sqrt((double)i + 100);m = sqrt((double)i + 268);",
"referer": "user-0"
},
{
"cid": "9",
"user": "user-0",
"content": "知道，但是为什么要强转后才能使用sqrt函数呢",
"referer": "user-5"
},
{
"cid": "10",
"user": "user-5",
"content": "虽然sqrt形参是double，但也不需要强转，除非你所用的编译器非常古老，否则，现在的编译器基本上都能帮你自己转换",
"referer": "user-0"
}
] |
数组传参，数组指针自加减，GCC编译报错
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "所以我们应该知道，在不同编译器上表现不同的写法应该规避。这个才是重要的。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "强转之后就是右值了",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "void* my_memcpy(void* dest, const void* src, size_t count) { char* ret = dest; assert(dest != NULL); assert(src != NULL); //char* pd = dest; //const char* ps = src; while (count--) { *(char*)dest=*(char*)src; ++dest; ++src; } return ret; } 去掉(char*)强制转换后，GCC倒是编译通过了，但是Vistual studio 又报错了。。。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-1",
"content": "前面的(char *)是蛇足啊，不加它也能保证++是加1的。加上它以后gcc认为强制转换后的结果不是左值了，所以不能++",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "谢谢，但是去掉(char*) 强制转换后vs报错。。，GCC倒是编译通过了 严重性\t代码\t说明\t项目\t文件\t行\t禁止显示状态 错误(活动)\tE0852\t表达式必须是指向完整对象类型的指针\tProject1\tD:\\Micsoft Visual Studio 2019\\source\\repos\\Project1\\struct.c\t16",
"referer": "user-1"
},
{
"cid": "6",
"user": "user-3",
"content": "不喜欢下面的代码?while((*dest++ = *src++ )!= '\\0');",
"referer": "user-0"
},
{
"cid": "7",
"user": "user-1",
"content": "楼主的意图不是复制字符串，所以无法使用空字符作为结束标准。",
"referer": "user-3"
},
{
"cid": "8",
"user": "user-0",
"content": "感谢，但是就像@forever74 所说，需求是内存拷贝，不是string拷贝。",
"referer": "user-3"
}
] |
有关if的问题。。。。。。。。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "把continue去掉就好了，因为你只有一层循环，所以当第一次执行完if的printf之后continue到了下一次循环，跳过了printf（“%d，--x”）此时第一次循环完成后的x=6，进入循环后，x--得到5，以此类推，每次遇到continue就直接进入了下一次循环，所以得到的是8542",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "int main() { int x = 8; for (; x > 0; x--) { if (x % 3) { printf(\"3x!=%d,\", x--); continue; } printf(\"3x=%d,\", --x); } return 0; }把它改为这样，你就会很容易看明白，它的结果是：3x!=8,3x=5,3x!=4,3x!=2,当最后一次x=2时，打印完后，它自减1，变成1，然后continue回到for循环，又自减1，此时，x=0，它已符合for循环的中止条件了，退出。",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "if(x%3) 相当于 if (x % 3 != 0) ，所以x=8 时，打印出 8 ，x-- =>7 ,countinue 跳到 for(;;x--) x=7-1 = 6; x=6%3==0 执行printf(\"%d\",--x)；x=6先自减1 x=5 ,打印出 5 ，回到for(;;x--) x=4 ,以此类推，输出了：8542 .",
"referer": "user-0"
}
] |
球球大神帮我看看这是为什么啊
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "可为什么我做的时候要将b=sqrt(a+100)变成b=sqrt((double)a+100)呢，不然显示错误，这是为什么呢",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "不用啊，你是不是代码打错了",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-2",
"content": "将if(bb==a+100&&cc==b+268)改为 if(bb==a+100&&cc==a+268)",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "谢谢大哥",
"referer": "user-2"
},
{
"cid": "5",
"user": "user-3",
"content": "因为您打字马虎了混淆了两个变量。",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-0",
"content": "谢谢大哥",
"referer": "user-3"
}
] |
大家好，请帮我看一下，为什么最后的字符输不出来。（chr_d）
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "另外，最后一个输入从参数上看应写为scanf_s(\"%c\",&chr_d,1);",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "在printf_s(\"please chr a number:\");之前加多一句fflush(stdin);这是因为，你在scanf_s(\"%lf\", &dbe_c);输入时，按下了回车键确认，回车符还留在键盘输入缓冲区，所以，要把它清除掉。",
"referer": "user-0"
}
] |
字符指针值可以直接相减吗
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "p-'0'相当于49-48=1，q-'0'相当于53-48=5（对应的字符ASCII码相减）也就是将字符转为整数。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "为什么不能直接用*p+*q得出结果为5呢",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-1",
"content": "‘1’的ASCII码是49，‘5’的ASCII码是53，*p+*q就变成49+53。减去字符0相当于将字符转为数字。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "感谢",
"referer": "user-1"
}
] |
关于16进制与内存地址的几个疑惑
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "首先地址在计算机中肯定是以2进制表示的。16进制只是在书写或源程序中出现。为什么书写中经常出现16进制（其实有些地方是8进制，效果和原理一样）而不是10进制，可以参考一下赵4老师的回复，原因就是：以小数点为基准，每4个2进制对应一个16进制，熟练后一眼就可以转换，10进制做不到这点。也许你要抬杠，说为什么不直接用2进制，原因是：2进制太长且一大堆0、1（对于人来说）容易搞错",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "二进制：1111 0101 1010 1000 16进制：F 5 A 8 十进制：62888",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "我觉得对这一块的理解到一定点就可以了，没有必要深究，再说也用不上。就像牛顿定理，已经告诉你这样可以实现或解决一些现象，那我们记住就可以了，没有必要再往下问，如果一直这样问下去，会影响学习，再者，老师都回答不上来。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-4",
"content": "有一点题外话。学校里的学习是循序的，每门课的大纲上都有先修课程一说，而互联网上的学习破坏了这一点。因此建议借助互联网学习的人士要自行循序，这样知识才能自洽，不至于碎片化。",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-4",
"content": "1、书上应该提到，四位二进制的组合共有16种，与十六进制数字是一一对应的，这就是转换简单的意思。2、确切地说地址就是个整数，天生是二进制的，只不过由于上述理由转换容易，经常缩写为十六进制形式而已。地址本身不用保存，可以说它就是存储单元在存储芯片上的坐标，就像经纬度不需要刻在地面上一样。但是寻址的时候需要表达这个地址，前面说了，地址就是个整数，它占用的空间大小要分开来说：物理地址长度取决于硬件平台有多少根地址总线，经典的32位硬件经常带32位地址总线，所以使用32位地址；常见的64位平台经常支持48根地址总线，所以使用48位地址。逻辑地址长度看操作系统和程序语言的喜好，它们各有各的喜好。从逻辑到物理的映射不是一个一个的，而是一块一块的，因此只需要记录用得到的块的首地址。",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-0",
"content": "1、书上应该提到，四位二进制的组合共有16种，与十六进制数字是一一对应的，这就是转换简单的意思。————书上教了。但是我觉得难易度和二进制与十进制转换方法差不多。故有此问。 2、还有什么讲这个问题比较好的书推荐么？",
"referer": "user-4"
},
{
"cid": "7",
"user": "user-4",
"content": "1、那么您心算一定很快，对于难易度的看法与普通人有一些分歧，而书本一般都假设读者是普通人。 2、有肯定是有，但因为我不记得哪件事是从哪里看到过的，所以无法推荐。前置课程大约硬的方面是数字电路和微机原理，软的方面是操作系统吧。",
"referer": "user-0"
},
{
"cid": "8",
"user": "user-5",
"content": "二进制到16进制转换只需要移位就可以了，二进制到十进制需要用到除法，怎么转换方法差不多呢？你写过这两种转换的C代码吗？",
"referer": "user-0"
}
] |
关于C语言的向上取整
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "按照 你自己的代码，我运行了一次，在我的计算机上是可以运行并计算的。并且采用了两种输入试了一下都是可以正常计算，并且按整数输出。第一次输入 ，，10，2 第二次输入，，7，3 一次输出没有小数，和一次输出有小数都呆以正常取整",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "这跟C没啥关系吧？如果i/j正好能整除呢？",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "正好整除向上取整也得加一吧，我是做题用到后者AC了，但是前者WA了，搞不懂i/j+1为什么不行",
"referer": "user-2"
},
{
"cid": "4",
"user": "user-2",
"content": "那一定是我对向上取整有误解，抱歉。",
"referer": "user-0"
}
] |
关于递归调用的理解？？？？？？？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！递归函数关注以下几个因素·退出条件·参数有哪些·返回值是什么·局部变量有哪些·全局变量有哪些·何时输出·会不会导致堆栈溢出",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "递归这里我老是肯不动。学习中",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-3",
"content": "你起床后打算吃米饭，于是你开始递归：要吃总得先盛到碗里吧，先调用盛饭函数。锅里居然是空的，先调用做饭函数。然而上次用完后锅还没刷，先调用刷锅函数。注意你的输出，1010是这样产生的：你刷了锅然后淘了米放了水点了火煮好了以后打开锅盖挖一勺到碗里开始......递归做菜",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "感谢，瞬间懂了",
"referer": "user-3"
}
] |
51单片机函数声明和函数传参的问题。
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "楼主您的代码段没有表现出和两个问题的联系，这就很难回答了。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "您好 就是 能不能把SMG1 传到函数里呢？",
"referer": "user-1"
},
{
"cid": "3",
"user": "user-1",
"content": "首先肯定是能。 但是传进来干嘛？你的函数都不使用它，直接就重新赋值，也就扔掉传进来的值了。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-0",
"content": "我明白了，他传进来，替换smg，然后又被赋值了，对吧？实际上P0,P1并没有被传进来。我应该做的是吧P0或者P1传进来，而不是把SMG1SMG2传进来。。。是这样理解吗？",
"referer": "user-1"
}
] |
{已解决}C Primer Plus初学，请教第四章的一道编程题目
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "int main() { char first_name[40]; char last_name[40]; char* p1; char* p2; p1 = first_name; p2 = last_name; printf_s(\"Please input your first name:\\n\"); gets(p1); printf_s(\"Please input your last_name:\\n\"); gets(p2); printf_s(\"%s %s\", p1, p2); return 0; }",
"referer": "user-0"
}
] |
指针，，，，，，，
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "给p赋值，是修改p的指向，并不能修改p的目标里面的内容。尤其需要这样理解的是p=\"sffd\";这句。是在内存另外的位置保存了sffd这样的内容，然后用p指向那里的意思。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "感谢",
"referer": "user-1"
}
] |
void 类型的指针可以存储任何类型的数据吗
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "感觉最好声明清楚比较好，否则后面容易混淆 void * p; int a = 3; p = &a; printf(\"%d\", *p); return 0;",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-2",
"content": "是可以的，但是在你取回原来的类型值时，就需要强转了。比如，你要拿回p指向的值（也就是整型3），就需要这样做：*(int *)p",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-0",
"content": "也就是void 指针可以存储任何类似的数据，但要使用的时候，就要用*(int*)p进行强转后取值吗",
"referer": "user-2"
}
] |
帮我看看编译错哪了？
|
user-0
|
[
{
"cid": "1",
"user": "user-1",
"content": "试一了下，还是在中文下面输入符号的问题引起。",
"referer": "user-0"
},
{
"cid": "2",
"user": "user-0",
"content": "感谢，问题已解决",
"referer": "user-0"
},
{
"cid": "3",
"user": "user-2",
"content": "printf(\"math = %d, eng = %d, comp = %d, average = %d\"，（这个逗号，你用了纯中文符号）87,72,93,（（这个括号，你用了纯中文符号）87+72+93）（这个括号，你用了纯中文符号）/3)；（这个分号，你用了纯中文符号） return 0；（这个分号，你用了纯中文符号） 我不知道你用的是什么IDE，但最好能选择一种在纯中文与英文符号有明显区别的字体。",
"referer": "user-0"
},
{
"cid": "4",
"user": "user-3",
"content": "计算的结果不是整数，跟%d不匹配",
"referer": "user-0"
},
{
"cid": "5",
"user": "user-0",
"content": "......是分号的问题可以直接输出",
"referer": "user-0"
},
{
"cid": "6",
"user": "user-4",
"content": "不能直接在输出函数中直接输入数据进行输出",
"referer": "user-0"
}
] |
关系数据库中范式的简单讲解
|
user-0
|
[
{
"cid": "1",
"user": "user-0",
"content": "数据库中的第一范式是什么意思",
"referer": "user-0"
}
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.