Question: 关于CreateFont的疑问

引用 6 楼 六道佩恩 的回复:[quote=引用 3 楼 赵4老师 的回复:] CreateFont The CreateFont function creates a logical font that has specific characteristics. The logical font can subsequently be selected as the font for any device. 赵老师，官方文档已经看过的，但是并不懂它描述的什么[/quote] 那就逐行调试一下官方例子代码加深理解喽。

引用 楼主 六道佩恩 的回复:第4个参数cOrientation表示旋转角度，可测试没效果呀，用SetTextAlign指定基线对齐的方式也没看到效果。 对于倒数第5 到 倒数第2 这4个参数也不解，测试出来也没看到效果，看不懂官方的说明，百度的结果也大多都是照搬的 求解 我猜你可能没使用SelectObject将字体选人hdc 至于倒数第5 到 倒数第2 这4个参数，没关注过，一般只用默认值 #define GUI //* #define UNICODE #define _UNICODE //*/ #include <Windows.h> #include <tchar.h> #include <stdio.h>  #pragma comment(lib, "gdi32") #pragma comment(lib, "user32")  #pragma comment(linker, "/subsystem:windows")  LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);  int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR szCmdLine, int iCmdShow) {    static TCHAR szAppName[] = TEXT("HelloWin");    HWND         hwnd;    MSG          msg;    WNDCLASS     wndclass;           RtlZeroMemory(&wndclass, sizeof(wndclass));    wndclass.style         = CS_HREDRAW | CS_VREDRAW;    wndclass.lpfnWndProc   = WndProc;    wndclass.hInstance     = hInstance;    wndclass.hIcon         = LoadIcon(NULL, TEXT("#32512"));    wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);    wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);    wndclass.lpszMenuName  = NULL;    wndclass.lpszClassName = szAppName;     if (!RegisterClass(&wndclass))    {       MessageBox(NULL, TEXT("This program requires Windows NT series!"), szAppName, MB_ICONERROR);       return -1;    }          hwnd = CreateWindowEx(WS_EX_APPWINDOW,         // A tool window does not appear in the task bar or in the window that appears when the user presses ALT+TAB.                          szAppName,                  // window class name                          TEXT("The Hello Program"),  // window caption                          WS_OVERLAPPEDWINDOW,        // window style                          CW_USEDEFAULT,              // initial x position                          CW_USEDEFAULT,              // initial y position                          820,//CW_USEDEFAULT,              // initial x size                          620,//CW_USEDEFAULT,              // initial y size                          NULL,                          NULL,                       // window menu handle                          hInstance,                  // program instance handle                          NULL);                      // creation parameters     ShowWindow(hwnd, SW_SHOW);    UpdateWindow(hwnd);          {       BOOL bRet;       while ((bRet = GetMessage(&msg, NULL, 0, 0)) != 0)       {          if (bRet == -1)          {             MessageBox(NULL, TEXT("GetMessage Error."), TEXT("Message"), MB_ICONERROR);             return -1;          }          else          {             TranslateMessage(&msg);             DispatchMessage(&msg);          }       }    }     return msg.wParam; }  LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {    HDC         hdc;    PAINTSTRUCT ps;    HFONT       hFont;    static TCHAR szString [] = TEXT("   Rotation");    static int  cxClient, cyClient;           switch (message)    {       case WM_SIZE:          cxClient = LOWORD(lParam);          cyClient = HIWORD(lParam);          return 0;       case WM_PAINT:          hdc = BeginPaint(hwnd, &ps);          hFont = CreateFont(60,                    //字体的高度                             30,                    //字体的宽度                             300,                   //字体显示的角度                             0,                     //字体的角度                             FW_NORMAL,             //字体的磅数                             TRUE,                  //斜体字体                             TRUE,                  //带下划线的字体                             TRUE,                  //带删除线的字体                             CHINESEBIG5_CHARSET,   //所需的字符集                             OUT_CHARACTER_PRECIS,  //输出的精度                             CLIP_CHARACTER_PRECIS, //裁减的精度                              DEFAULT_QUALITY,       //逻辑字体与输出设备的实际字体之间的精度                             FF_MODERN,             //字体间距和字体集                             _T("Times New Roman")  //字体名称                            );          SelectObject(hdc, hFont);          TextOut(hdc, cxClient / 2, cyClient / 2, szString, lstrlen(szString));          DeleteObject(SelectObject(hdc, GetStockObject(SYSTEM_FONT)));          EndPaint(hwnd, &ps);          return 0;       case WM_DESTROY:          PostQuitMessage(0);          return 0;    }    return DefWindowProc(hwnd, message, wParam, lParam); }

MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl

引用 3 楼 赵4老师 的回复:CreateFont The CreateFont function creates a logical font that has specific characteristics. The logical font can subsequently be selected as the font for any device. 赵老师，官方文档已经看过的，但是并不懂它描述的什么

引用 2 楼 user-2 的回复:我猜你可能没使用SelectObject将字体选人hdc 至于倒数第5 到 倒数第2 这4个参数，没关注过，一般只用默认值 肯定有用SelectObject呀，不然我咋不说其他那些参数看不到效果 我知道一般用默认值，但即便不用默认值也没看到什么不同。。。

FontView: Font Usage  Click to open or copy the files for the FontView sample.  The FontView sample demonstrates several programming aspects. As a stand-alone application, it allows you to experiment with the various parameters of the CreateFont function, as well as examine the fonts and metrics returned by the call.  Building SDK Samples   This sample uses the following keywords:  _moveto; abs; circleblt; cos; createdlgproc; createfont; createsolidbrush; defined; deleteobject; destroywindow; dialogbox; dialogboxparam; enddialog; enumdlgproc; exttextout; fabs; freeprocinstance; getdc; getdlgitemtext; getfocus; getmenu; getstockobject; getsubmenu; getsyscolor; getsystemmenu; getwindowlong; getwindowtext; lstrcmp; lstrcpy; lstrlen; makeprocinstance; max; messagebeep; metricsdlgproc; min; moveto; movetoex; radian; releasedc; selectobject; sendmessage; setbkcolor; setdlgitemtext; settextcolor; setwindowtext; simpledlgproc; sin; updatepositions; warning; windowfrompoint; winmain

CreateFont The CreateFont function creates a logical font that has specific characteristics. The logical font can subsequently be selected as the font for any device.   HFONT CreateFont(   int nHeight,             // logical height of font   int nWidth,              // logical average character width   int nEscapement,         // angle of escapement   int nOrientation,        // base-line orientation angle   int fnWeight,            // font weight   DWORD fdwItalic,         // italic attribute flag   DWORD fdwUnderline,      // underline attribute flag   DWORD fdwStrikeOut,      // strikeout attribute flag   DWORD fdwCharSet,        // character set identifier   DWORD fdwOutputPrecision,  // output precision   DWORD fdwClipPrecision,  // clipping precision   DWORD fdwQuality,        // output quality   DWORD fdwPitchAndFamily,  // pitch and family   LPCTSTR lpszFace         // pointer to typeface name string );   Parameters nHeight  Specifies the height, in logical units, of the font's character cell or character. The character height value (also known as the em height) is the character cell height value minus the internal-leading value. The font mapper interprets the value specified in nHeight in the following manner: Value Meaning  > 0 The font mapper transforms this value into device units and matches it against the cell height of the available fonts.  0 The font mapper uses a default height value when it searches for a match.  < 0 The font mapper transforms this value into device units and matches its absolute value against the character height of the available fonts.    For all height comparisons, the font mapper looks for the largest font that does not exceed the requested size.   This mapping occurs when the font is used for the first time.   For the MM_TEXT mapping mode, you can use the following formula to specify a height for a font with a specified point size:    nHeight = -MulDiv(PointSize, GetDeviceCaps(hDC, LOGPIXELSY), 72);   nWidth  Specifies the average width, in logical units, of characters in the requested font. If this value is zero, the font mapper chooses a "closest match" value. The "closest match" value is determined by comparing the absolute values of the difference between the current device's aspect ratio and the digitized aspect ratio of available fonts.  nEscapement  Specifies the angle, in tenths of degrees, between the escapement vector and the x-axis of the device. The escapement vector is parallel to the base line of a row of text.  Windows NT: When the graphics mode is set to GM_ADVANCED, you can specify the escapement angle of the string independently of the orientation angle of the string's characters.   When the graphics mode is set to GM_COMPATIBLE, nEscapement specifies both the escapement and orientation. You should set nEscapement and nOrientation to the same value.   Windows 95: The nEscapement parameter specifies both the escapement and orientation. You should set nEscapement and nOrientation to the same value.   nOrientation  Specifies the angle, in tenths of degrees, between each character's base line and the x-axis of the device.  fnWeight  Specifies the weight of the font in the range 0 through 1000. For example, 400 is normal and 700 is bold. If this value is zero, a default weight is used.  The following values are defined for convenience: Value Weight  FW_DONTCARE 0  FW_THIN 100  FW_EXTRALIGHT 200  FW_ULTRALIGHT 200  FW_LIGHT 300  FW_NORMAL 400  FW_REGULAR 400  FW_MEDIUM 500  FW_SEMIBOLD 600  FW_DEMIBOLD 600  FW_BOLD 700  FW_EXTRABOLD 800  FW_ULTRABOLD 800  FW_HEAVY 900  FW_BLACK 900     fdwItalic  Specifies an italic font if set to TRUE.  fdwUnderline  Specifies an underlined font if set to TRUE.  fdwStrikeOut  Specifies a strikeout font if set to TRUE.  fdwCharSet  Specifies the character set. The following values are predefined:  ANSI_CHARSET BALTIC_CHARSET CHINESEBIG5_CHARSET DEFAULT_CHARSET EASTEUROPE_CHARSET GB2312_CHARSET GREEK_CHARSET HANGUL_CHARSET MAC_CHARSET OEM_CHARSET RUSSIAN_CHARSET SHIFTJIS_CHARSET SYMBOL_CHARSET TURKISH_CHARSET   Korean Windows:  JOHAB_CHARSET  Middle-Eastern Windows:  HEBREW_CHARSET ARABIC_CHARSET  Thai Windows:  THAI_CHARSET  The OEM_CHARSET value specifies a character set that is operating-system dependent.   You can use the DEFAULT_CHARSET value to allow the name and size of a font to fully describe the logical font. If the specified font name does not exist, a font from any character set can be substituted for the specified font, so you should use DEFAULT_CHARSET sparingly to avoid unexpected results.   Fonts with other character sets may exist in the operating system. If an application uses a font with an unknown character set, it should not attempt to translate or interpret strings that are rendered with that font.   This parameter is important in the font mapping process. To ensure consistent results, specify a specific character set. If you specify a typeface name in the lpszFace parameter, make sure that the fdwCharSet value matches the character set of the typeface specified in lpszFace.   fdwOutputPrecision  Specifies the output precision. The output precision defines how closely the output must match the requested font's height, width, character orientation, escapement, pitch, and font type. It can be one of the following values: Value Meaning  OUT_CHARACTER_PRECIS Not used.  OUT_DEFAULT_PRECIS Specifies the default font mapper behavior.  OUT_DEVICE_PRECIS Instructs the font mapper to choose a Device font when the system contains multiple fonts with the same name.  OUT_OUTLINE_PRECIS Windows NT: This value instructs the font mapper to choose from TrueType and other outline-based fonts.  OUT_RASTER_PRECIS Instructs the font mapper to choose a raster font when the system contains multiple fonts with the same name.  OUT_STRING_PRECIS This value is not used by the font mapper, but it is returned when raster fonts are enumerated.  OUT_STROKE_PRECIS Windows NT: This value is not used by the font mapper, but it is returned when TrueType, other outline-based fonts, and vector fonts are enumerated.  Windows 95: This value is used to map vector fonts, and is returned when TrueType or vector fonts are enumerated.    OUT_TT_ONLY_PRECIS Instructs the font mapper to choose from only TrueType fonts. If there are no TrueType fonts installed in the system, the font mapper returns to default behavior.  OUT_TT_PRECIS Instructs the font mapper to choose a TrueType font when the system contains multiple fonts with the same name.    Applications can use the OUT_DEVICE_PRECIS, OUT_RASTER_PRECIS, and OUT_TT_PRECIS values to control how the font mapper chooses a font when the operating system contains more than one font with a specified name. For example, if an operating system contains a font named Symbol in raster and TrueType form, specifying OUT_TT_PRECIS forces the font mapper to choose the TrueType version. Specifying OUT_TT_ONLY_PRECIS forces the font mapper to choose a TrueType font, even if it must substitute a TrueType font of another name.   fdwClipPrecision  Specifies the clipping precision. The clipping precision defines how to clip characters that are partially outside the clipping region. It can be one or more of the following values: Value Meaning  CLIP_DEFAULT_PRECIS Specifies default clipping behavior.  CLIP_CHARACTER_PRECIS Not used.  CLIP_STROKE_PRECIS Not used by the font mapper, but is returned when raster, vector, or TrueType fonts are enumerated. Windows NT: For compatibility, this value is always returned when enumerating fonts.   CLIP_MASK Not used.  CLIP_EMBEDDED You must specify this flag to use an embedded read-only font.  CLIP_LH_ANGLES When this value is used, the rotation for all fonts depends on whether the orientation of the coordinate system is left-handed or right-handed.  If not used, device fonts always rotate counterclockwise, but the rotation of other fonts is dependent on the orientation of the coordinate system.  For more information about the orientation of coordinate systems, see the description of the nOrientation parameter   CLIP_TT_ALWAYS Not used.    fdwQuality  Specifies the output quality. The output quality defines how carefully GDI must attempt to match the logical-font attributes to those of an actual physical font. It can be one of the following values: Value Meaning  DEFAULT_QUALITY Appearance of the font does not matter.  DRAFT_QUALITY Appearance of the font is less important than when the PROOF_QUALITY value is used. For GDI raster fonts, scaling is enabled, which means that more font sizes are available, but the quality may be lower. Bold, italic, underline, and strikeout fonts are synthesized if necessary.  PROOF_QUALITY Character quality of the font is more important than exact matching of the logical-font attributes. For GDI raster fonts, scaling is disabled and the font closest in size is chosen. Although the chosen font size may not be mapped exactly when PROOF_QUALITY is used, the quality of the font is high and there is no distortion of appearance. Bold, italic, underline, and strikeout fonts are synthesized if necessary.    fdwPitchAndFamily  Specifies the pitch and family of the font. The two low-order bits specify the pitch of the font and can be one of the following values:  DEFAULT_PITCH FIXED_PITCH VARIABLE_PITCH   The four high-order bits specify the font family and can be one of the following values: Value Description  FF_DECORATIVE Novelty fonts. Old English is an example.  FF_DONTCARE Don't care or don't know.  FF_MODERN Fonts with constant stroke width, with or without serifs. Pica, Elite, and Courier New® are examples.  FF_ROMAN Fonts with variable stroke width and with serifs. MS® Serif is an example.  FF_SCRIPT Fonts designed to look like handwriting. Script and Cursive are examples.  FF_SWISS Fonts with variable stroke width and without serifs. MS Sans Serif is an example.     An application can specify a value for the fdwPitchAndFamily parameter by using the B


Question: 为什么这个程序让我输入后就没后续了？

感谢感谢，脑子有点不清醒犯了这种错误。。。还检查了几遍。 总之帮了大忙了

while所在行尾多了个分号。


Question: 新手求帮助

这个应该到高等数学论坛去问。


Question: C语言的基础学习（一）

引用 1 楼 自信男孩 的回复：在Linux下编写，编译C/C++好像不用下载什么东西，当然也可以安装source Insight/vim等更高级的环境我这个是针对Windows系统的


Question: 经编译后产生目标模块的个数

《程序员的自我修养——链接、装载与库》

要想深入了解，建议花点功夫看看《程序员的自我修养》，对于你的问题，自己可以写一个hello world源程序，进行探究 . c源文件 . i预编译文件 . s汇编文件 . o目标文件 . exe可执行文件 printf函数将调用一些系统库函数进行系统调用，进入内核中断执行显示驱动程序，这些都是封装好的目标模块，也就是. o文件 再将这些. o文件通过链接器生成. exe文件，这里面牵扯模块中函数和数据的重定位。 . h文件在预编译阶段就展开了，一个. c文件生成一个模块。 最关键的就是：重定位

目标模块, 目标文件这两个东西一般是一样的含义。 源程序编译后产生目标文件, 对于c语言来说，一个源程序编译后产生一个目标文件。 这里源程序是指*.c文件，不是*.h文件。


Question: vs2017直接打开本体的.c文件无法调试?

不知所云，能不能清楚点？


Question: C语言文本统计，在读取目录下文件信息的时候会少读一个文件

while(p_current_pos->next!=NULL)， 这句判断是不是有问题呢，改成 while(p_current_pos !=NULL)， 试一下。 如果你用 while(p_current_pos->next!=NULL)， 那么在循环外还要输出一下才能把最后一个文件得到，因为最后一个文件节点的next就是NULL了，所以不会继续执行while的 循环体了。


Question: C语言上面程序输出的结果筛选后输出

引用 5 楼 自信男孩 的回复:通过你的代码看不出逻辑是做什么的？建议顺便把需求贴出来～  图下面我写了   图中运行的结果把dss筛选后显示出来

这个可以去掉  我是让t变成十进制字节

通过你的代码看不出逻辑是做什么的？建议顺便把需求贴出来～

t=("%d",temp1[i-1]); 这是什么操作？

求给个代码  C语言学了个半吊子

循环遍历判断呗，如果是dss模块则进行输出

我上面已经把两个输出的结果存到了两个数组里了


Question: Python

没找到这个文件，检查下是不是路径错了

引用 1 楼 caozhy 的回复：没找到这个文件，检查下是不是路径错了好   应该是路径错了


Question: 请教，这个程序编译没有显示问题，运行为何不显示输入数组信息

代码没什么问题，你是否输入了12个整型数据，只有输入满足12个整形数据时才会有输出。

谢谢大虾！谢谢！！！！！

如果你想打印数组也需要自行调用printf

你程序是直接调用scanf的，scanf 本身不提示输入，程序运行后你直接输入就可以了。 你如果希望有提示可以： printf("please input....\n"); scanf(....)


引用 18 楼 user-2 的回复:[quote=引用 17 楼 六道佩恩 的回复:] 这句话可以理解为用背景色重绘背景吗？其实我说的就是默认的情况。如果自己只绘制了一部分区域，那其他区域是用背景色自动重绘吗？ 是的，但应该说先刷背景色，后在上面绘制其他的东西[/quote] 不一定。 比如：     case WM_ERASEBKGND:         return 1;

引用 12 楼 六道佩恩 的回复:另外问下，erase  background 是指重绘窗口吗？ erase  background是指重绘前擦除背景，怎么重绘窗口是你的事情  WM_PAINT消息处理时坐标本来就是以客户区的左上角为原点的 -> 这里我只是说WM_PAINT消息处理时，一般情况下都是以客户区的左上角为原点，有的是以窗口的左上角为原点，有的是以屏幕的左上角为原点，具体看函数的MSDN说明

引用 17 楼 六道佩恩 的回复:这句话可以理解为用背景色重绘背景吗？其实我说的就是默认的情况。如果自己只绘制了一部分区域，那其他区域是用背景色自动重绘吗？ 是的，但应该说先刷背景色，后在上面绘制其他的东西

引用 15 楼 user-2 的回复:先将画布用背景色擦除背景（覆盖掉原来你画的东西） 这句话可以理解为用背景色重绘背景吗？其实我说的就是默认的情况。如果自己只绘制了一部分区域，那其他区域是用背景色自动重绘吗？

重绘是指 WM_PAINT:    BeginPaint(...);    //这中间就是重绘操作，用背景色擦除背景是BeginPaint(...);的工作    EndPaint(...);    return 0;  如果不想擦除背景，使用  case WM_ERASEBKGND: // return nonzero if it erases the background; otherwise, it should return zero.    return 0;

之前不是说默认用背景色重绘背景吗？ ---> 这个是指 WM_PAINT:    BeginPaint(...);    //这中间没有操作,默认用背景色重绘背景    EndPaint(...);    return 0;  引用 14 楼 六道佩恩 的回复:windows程序设计第五版说的是默认处理WM_PAINT是BeginPaint和EndPaint就没了，这其中按理说有重绘背景吧，可是看来看去除了PAINTSTRUCT结构里的擦除标志就没看到其他的了，所以这个“擦除背景”是不是指用背景色擦除背景，这样既算是擦除，也算是重绘？ 这么说吧，窗口上显示的东西好比是你在画布上画画。 有擦除标志时，就先将画布用背景色擦除背景（覆盖掉原来你画的东西），再在上面作画（相当于在新画布上作画） 无擦除标志时，就直接在原来的画面上接着画（相当于在旧画布上修改） 不知说清楚没有

引用 13 楼 user-2 的回复:[quote=引用 12 楼 六道佩恩 的回复:] 另外问下，erase  background 是指重绘窗口吗？ erase  background是指重绘前擦除背景，怎么重绘窗口是你的事情[/quote] 之前不是说默认用背景色重绘背景吗？ windows程序设计第五版说的是默认处理WM_PAINT是BeginPaint和EndPaint就没了，这其中按理说有重绘背景吧，可是看来看去除了PAINTSTRUCT结构里的擦除标志就没看到其他的了，所以这个“擦除背景”是不是指用背景色擦除背景，这样既算是擦除，也算是重绘？

引用 10 楼 user-2 的回复:WM_PAINT消息处理时坐标本来就是以客户区的左上角为原点的 去测试了下，PAINTSTRUCT包含的矩形的确应该是拷贝的，在绘制前修改区域后仍然全部更新，但InvalidateRect还是应该能说明问题的吧，限制区域后只有部分更新，显示的量和之前一样，说明并不是从无效区域开始显示的。另外问下，erase  background 是指重绘窗口吗？

引用 10 楼 user-2 的回复:WM_PAINT消息处理时坐标本来就是以客户区的左上角为原点的 你确定是处理WM_PAINT才有的？我觉得跟消息没关系吧，HDC是相对于客户区的，无效区域只是在系统绘图时更新的范围，我想验证的就是“hdc为无效区效的"设备环境"”这句话，我觉得这句话应该是错的

引用 7 楼 六道佩恩 的回复:我试着修改PAINTSTRUCT包含的矩形，左和上由0改为了100，结果绘制的文字仍然在客户区左上角，并没有发生改变 我觉得你修改这个是没有用的（猜测），这个只是接收系统认为的无效区域，是个副本 不过不是很明白你的用意，你想验证啥

引用 5 楼 user-2 的回复:你第一次指定一个坐标来绘制文字时（即响应第一个WN_PAINT消息时），窗口刚创建，整个客户区都是无效的 经测试，坐标应该还是相对客户区的，只有无效区被更新

自绘提高效率用。

引用 5 楼 user-2 的回复:你第一次指定一个坐标来绘制文字时（即响应第一个WN_PAINT消息时），窗口刚创建，整个客户区都是无效的 我试着修改PAINTSTRUCT包含的矩形，左和上由0改为了100，结果绘制的文字仍然在客户区左上角，并没有发生改变

引用 5 楼 user-2 的回复:你第一次指定一个坐标来绘制文字时（即响应第一个WN_PAINT消息时），窗口刚创建，整个客户区都是无效的 这个我知道，我的意思是说，之后的绘图，指定坐标（X,Y）其实就不是相对客户区的了？

引用 1 楼 赵4老师 的回复:自绘提高效率用。 不会呀。。。

引用 2 楼 user-2 的回复:1. 在Win2000和XP下，窗口被其他窗口覆盖，在其他窗口移开后，被覆盖的窗口确实会收到WM_PAINT消息，这是由于当时内存一般比较少，系统没有保存被覆盖的内容，所以要求程序自己重画，但为了效率，重画的是被覆盖的范围，即PAINTSTRUCT中的无效区域的矩形在这里起作用，WM_PAINT中hdc = BeginPaint(hwnd, &ps); //严格来讲，hdc为无效区效的"设备环境"，在此区域外的作图，都将被忽略，实际上是被裁剪了。 至于其他窗口移开后你没有收到WM_PAINT，我在Win10下也得到了同样的结果，确实没有收到，我猜可能是Win10改变了策略，现在内存一般比较大，系统保存了被覆盖的内容，当其他窗口移开后，系统直接恢复被覆盖的区域，就不要求程序自己重画了。  2. 如果图形不复杂，就不考虑无效区域，直接将整个窗口重绘一遍；如果很复杂，重画的代价很大（比如画什么要根据大量的计算后才能决定），很慢，那么还是只画无效区域。  比如绘制文字时，可以指定一个坐标来绘制，这个坐标是相对于客户区坐标的，可如果说有无效区域时只绘制无效区域，那么岂不是和这个相对于客户区的HDC相矛盾了？HDC由客户区的变成了无效区域的HDC？

引用 楼主 六道佩恩 的回复:1. 测试用其他窗口覆盖本窗口，并没有收到WM_PAINT（只收到创建处的一次，使用了BeginPaint） 2. 我们在绘图时要考虑无效区域吗？好像不用吧？应该都是遇到WM_PAINT就把整个窗口重绘一遍是吧？那这些无效区域的矩形是干嘛的？ 1. 在Win2000和XP下，窗口被其他窗口覆盖，在其他窗口移开后，被覆盖的窗口确实会收到WM_PAINT消息，这是由于当时内存一般比较少，系统没有保存被覆盖的内容，所以要求程序自己重画，但为了效率，重画的是被覆盖的范围，即PAINTSTRUCT中的无效区域的矩形在这里起作用，WM_PAINT中hdc = BeginPaint(hwnd, &ps); //严格来讲，hdc为无效区效的"设备环境"，在此区域外的作图，都将被忽略，实际上是被裁剪了。 至于其他窗口移开后你没有收到WM_PAINT，我在Win10下也得到了同样的结果，确实没有收到，我猜可能是Win10改变了策略，现在内存一般比较大，系统保存了被覆盖的内容，当其他窗口移开后，系统直接恢复被覆盖的区域，就不要求程序自己重画了。  2. 如果图形不复杂，就不考虑无效区域，直接将整个窗口重绘一遍；如果很复杂，重画的代价很大（比如画什么要根据大量的计算后才能决定），很慢，那么还是只画无效区域。


Question: 刚跟着书上学HOOK API,写了个HOOK TerminateProcess的程序, 结果有问题,vs都老是崩溃

WinAPIOverride http://jacquelin.potier.free.fr/winapioverride32/

minihook


Question: 马踏棋盘

引用 4 楼 lin5161678的回复:代码呢? 代码电脑上，用的手机问的，不是很方便弄上去

引用 3 楼 Italink的回复:是用回溯法吗？ 有没有标记去重？ 嗯嗯，回溯了，贪心光回溯太慢了，这个标记去重大概是什么思路啊，在哪个环节标记呢？

代码呢?

是用回溯法吗？ 有没有标记去重？

代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。  “给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

8*8棋盘是有很多解呀


Question: c语言问题

根据你的信息长度一点一点的调吧，%s加上宽度设置。比如%10s，或者%-10s，可以查一下这样的格式意义。 %10s长度是10个字符，右对齐；%-10s长度也是10个字符，但是是左对齐。

需要先扫描所有记录，得到每列内容的最大宽度，再按每列最大宽度显示各列。


Question: 这个代码怎么用

引用 6 楼 羽墨mcuba 的回复：引用 5 楼 Fick dich 的回复:[quote=引用 2 楼 羽墨mcuba 的回复：]输入当前目录下的一个文件名，程序会把文件里面的内容打印到屏幕上。随便任何一个文件名都可以吗？还是一定要是文本文件？ 这里用文本文件测试比较好，不然打印出来的是乱码。[/quote]好的谢谢

引用 5 楼 Fick dich 的回复:引用 2 楼 羽墨mcuba 的回复：输入当前目录下的一个文件名，程序会把文件里面的内容打印到屏幕上。随便任何一个文件名都可以吗？还是一定要是文本文件？ 这里用文本文件测试比较好，不然打印出来的是乱码。

引用 3 楼 自信男孩 的回复：#include<stdio.h> #include<stdlib.h>  int main() {     int ch;     FILE*fp;     char fname[50];     scanf("%s",fname);     fp=fopen(fname, "r");     if(fp==NULL)     {         printf("Failed to open file. Bye\n");         exit(1);     }     while((ch=getc(fp))!=EOF)     {         putchar(ch);         //fclose(fp);     }     getchar();     getchar();     fclose(fp);     return 0; } 代码有些问题，fclose不能放在循环内。  另外，怎么用？还是用的时候有问题？我不知道怎么用，我是把书上的代码抄下来了

输入当前目录下的一个文件名，程序会把文件里面的内容打印到屏幕上。

第五行多了一个\，别在意


Question: 实现tar功能

应该有类库调用吧

可以直接参考tar库源码～

为什么不直接参考tar的源代码呢？


Question: sizeof(struct)

sizeof实际上不是函数，在编译阶段就赋值了

写程序得有个电脑的，这种问题一试就知道了

何不试一下呢？写个小程序，在编译器上试一下就知道了。

sizeof(结构体名称) 或者sizeof(结构体变量) 都可以求

sizeof结构体(名)学习了

struct Student { 	char name[10]; 	int age; };  //结构体大小 int len = 0； len = sizeof(struct Student);  sizeof(结构体名称)即可获取结构体的大小。

引用 3 楼 user-8 的回复:[quote=引用 2 楼 机械高 的回复:] [quote=引用 1 楼 gouyanfen的回复:][quote=引用 楼主 机械高 的回复:] 可以这样写嘛？sizeof(struct) 不可以[/quote] 那也就是说，想知道一个结构体类型变量的字节只能自己求？[/quote]不是[/quote] struct a { int b; } sizeof(a);

引用 2 楼 机械高 的回复:[quote=引用 1 楼 gouyanfen的回复:][quote=引用 楼主 机械高 的回复:] 可以这样写嘛？sizeof(struct) 不可以[/quote] 那也就是说，想知道一个结构体类型变量的字节只能自己求？[/quote]不是

引用 1 楼 gouyanfen的回复:[quote=引用 楼主 机械高 的回复:] 可以这样写嘛？sizeof(struct) 不可以[/quote] 那也就是说，想知道一个结构体类型变量的字节只能自己求？

引用 楼主 机械高 的回复:可以这样写嘛？sizeof(struct) 不可以


Question: 带括号的简单计算器

说白了还是用栈方便，看看栈

处理成符号后置型，应该可以用数组处理

用MFc比较容易吧

哇，好复杂。   赵4老师怎么现在还在程序中用GOTO语句

涉及到优先级需要借用栈来运算，或者构造计算图，网上有很多这样的代码可以参考

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

引用 2 楼 赵4老师 的回复：谢谢谢谢！我要花一些时间看看。。不一定看得懂

仅供参考：#pragma warning(disable:4996) /*--------------------------------------- 函数型计算器(VC++6.0,Win32 Console) 功能： 目前提供了10多个常用数学函数: ⑴正弦sin ⑵余弦cos ⑶正切tan ⑷开平方sqrt ⑸反正弦arcsin ⑹反余弦arccos ⑺反正切arctan ⑻常用对数lg ⑼自然对数ln ⑽ｅ指数exp ⑾乘幂函数^ ⑿向上取整ceil ⒀向下取整floor ⒁四舍五入取整round 用法： 如果要求2的32次幂，可以打入2^32<回车> 如果要求30度角的正切可键入tan(Pi/6)<回车> 注意不能打入：tan(30)<Enter> 如果要求1.23弧度的正弦，有几种方法都有效： sin(1.23)<Enter> sin 1.23 <Enter> sin1.23  <Enter> 如果验证正余弦的平方和公式,可打入sin(1.23)^2+cos(1.23)^2 <Enter>或sin1.23^2+cos1.23^2 <Enter> 此外两函数表达式连在一起,自动理解为相乘如：sin1.23cos0.77+cos1.23sin0.77就等价于sin(1.23)*cos(0.77)+cos(1.23)*sin(0.77) 当然你还可以依据三角变换，再用sin(1.23+0.77)也即sin2验证一下。 本计算器充分考虑了运算符的优先级因此诸如：2+3*4^2 实际上相当于：2+(3*(4*4)) 另外函数名前面如果是数字,那么自动认为二者相乘. 同理，如果某数的右侧是左括号，则自动认为该数与括弧项之间隐含一乘号。 如：3sin1.2^2+5cos2.1^2 相当于3*sin2(1.2)+5*cos2(2.1) 又如：4(3-2(sqrt5-1)+ln2)+lg5 相当于4*(3-2*(√5 -1)+loge(2))+log10(5) 此外，本计算器提供了圆周率Pi键入字母时不区分大小写,以方便使用。 16进制整数以0x或0X开头。 ----------------------------------------*/ #include <iostream> #include <iomanip> #include <cstdlib> #include <cstring> #include <cctype> #include <cmath> #include <stdio.h> #include <string.h> #include <windows.h> using namespace std; const char Tab = 0x9; const int  DIGIT = 1; const int MAXLEN = 16384; char s[MAXLEN], *endss; int pcs = 15; double round(double dVal, short iPlaces) {//iPlaces>=0 	char s[30]; 	double dRetval;  	sprintf(s, "%.*lf", iPlaces, dVal); 	sscanf(s, "%lf", &dRetval); 	return (dRetval); } double fun(double x, char op[], int *iop) { 	while (op[*iop - 1]<32) //本行使得函数嵌套调用时不必加括号,如 arc sin(sin(1.234)) 只需键入arc sin sin 1.234<Enter> 		switch (op[*iop - 1]) { 		case  7: x = sin(x);    (*iop)--; break; 		case  8: x = cos(x);    (*iop)--; break; 		case  9: x = tan(x);    (*iop)--; break; 		case 10: x = sqrt(x);   (*iop)--; break; 		case 11: x = asin(x);   (*iop)--; break; 		case 12: x = acos(x);   (*iop)--; break; 		case 13: x = atan(x);   (*iop)--; break; 		case 14: x = log10(x);  (*iop)--; break; 		case 15: x = log(x);    (*iop)--; break; 		case 16: x = exp(x);    (*iop)--; break; 		case 17: x = ceil(x);   (*iop)--; break; 		case 18: x = floor(x);  (*iop)--; break; 		case 19: x = round(x, 0); (*iop)--; break; 		} 	return x; } double calc(char *expr, char **addr) { 	static int deep; //递归深度 	static char *fname[] = { "sin","cos","tan","sqrt","arcsin","arccos","arctan","lg","ln","exp","ceil","floor","round",NULL }; 	double ST[10] = { 0.0 }; //数字栈 	char op[10] = { '+' }; //运算符栈 	char c, *rexp, *pp, *pf; 	int ist = 1, iop = 1, last, i, n; 	__int64 i64;  	if (!deep) { 		pp = pf = expr; 		do { 			c = *pp++; 			if (c != ' '&& c != Tab) 				*pf++ = c; 		} while	(c != '\0'); 	} 	pp = expr; 	if ((c = *pp) == '-' || c == '+') { 		op[0] =	c; 		pp++; 	} 	last = !DIGIT; 	while ((c =	*pp) !=	'\0') { 		if (c == '(') {//左圆括弧 			deep++; 			ST[ist++] =	calc(++pp, addr); 			deep--; 			ST[ist - 1]	= fun(ST[ist - 1], op, &iop); 			pp = *addr; 			last = DIGIT; 			if (*pp	== '(' || isalpha(*pp) && strnicmp(pp, "Pi", 2)) {//目的是：当右圆括弧的右恻为左圆括弧或函数名字时，默认其为乘法 				op[iop++] =	'*'; 				last = !DIGIT; 				c =	op[--iop]; 				goto operate; 			} 		} 		else if	(c == ')') {//右圆括弧 			pp++; 			break; 		} 		else if	(isalpha(c)) { 			if (!strnicmp(pp, "Pi", 2)) { 				if (last ==	DIGIT) { 					wcout <<	L"π左侧遇）" << endl; exit(1); 				} 				ST[ist++] =	3.14159265358979323846264338328; 				ST[ist - 1]	= fun(ST[ist - 1], op, &iop); 				pp += 2; 				last = DIGIT; 				if (!strnicmp(pp, "Pi", 2)) { 					wcout <<	L"两个π相连" << endl; exit(2); 				} 				if (*pp	== '(') { 					wcout <<	L"π右侧遇（" << endl; exit(3); 				} 			} 			else { 				for	(i = 0;	(pf	= fname[i])	!= NULL; i++) 					if (!strnicmp(pp, pf, strlen(pf))) break; 				if (pf != NULL)	{ 					op[iop++] =	07 + i; 					pp += strlen(pf); 				} 				else { 					wcout <<	L"陌生函数名" << endl; exit(4); 				} 			} 		} 		else if	(c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '^') { 			char cc; 			if (last !=	DIGIT) { 				wcout <<	L"运算符粘连" << endl; exit(5); 			} 			pp++; 			if (c == '+' || c == '-') { 				do { 					cc = op[--iop]; 					--ist; 					switch (cc)	{ 					case '+':  ST[ist - 1] += ST[ist]; break; 					case '-':  ST[ist - 1] -= ST[ist]; break; 					case '*':  ST[ist - 1] *= ST[ist]; break; 					case '/':  ST[ist - 1] /= ST[ist]; break; 					case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break; 					case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break; 					} 				} while	(iop); 				op[iop++] =	c; 			} 			else if	(c == '*' || c == '/' || c == '%') { 			operate:		cc = op[iop	- 1]; 				if (cc == '+' || cc == '-') { 					op[iop++] =	c; 				} 				else { 					--ist; 					op[iop - 1]	= c; 					switch (cc)	{ 					case '*':  ST[ist - 1] *= ST[ist]; break; 					case '/':  ST[ist - 1] /= ST[ist]; break; 					case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break; 					case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break; 					} 				} 			} 			else { 				cc = op[iop	- 1]; 				if (cc == '^') { 					wcout <<	L"乘幂符连用" << endl; exit(6); 				} 				op[iop++] =	c; 			} 			last = !DIGIT; 		} 		else { 			if (last ==	DIGIT) { 				wcout <<	L"两数字粘连" << endl; exit(7); 			} 			if (pp[0] == '0' && (pp[1] == 'x' || pp[1] == 'X')) { 				sscanf(pp +	2, "%I64x%n", &i64, &n); 				rexp = pp +	2 +	n; 				ST[ist++] =	(double)i64; 			} 			else ST[ist++] = strtod(pp,	&rexp); 			ST[ist - 1]	= fun(ST[ist - 1], op, &iop); 			if (pp == rexp)	{ 				wcout <<	L"非法字符" << endl; exit(8); 			} 			pp = rexp; 			last = DIGIT; 			if (*pp	== '(' || isalpha(*pp)) { 				op[iop++] =	'*'; 				last = !DIGIT; 				c =	op[--iop]; 				goto operate; 			} 		} 	} 	*addr =	pp; 	if (iop	>= ist)	{ 		wcout <<	L"表达式有误" << endl; exit(9); 	} 	while (iop)	{ 		--ist; 		switch (op[--iop]) { 		case '+':  ST[ist - 1] += ST[ist]; break; 		case '-':  ST[ist - 1] -= ST[ist]; break; 		case '*':  ST[ist - 1] *= ST[ist]; break; 		case '/':  ST[ist - 1] /= ST[ist]; break; 		case '%':  ST[ist - 1] = fmod(ST[ist - 1], ST[ist]); break; 		case '^':  ST[ist - 1] = pow(ST[ist - 1], ST[ist]); break; 		} 	} 	return ST[0]; } int main(int argc, char **argv) { 	int	a;  	wcout.imbue(locale("chs")); 	if (argc<2)	{ 		//if (GetConsoleOutputCP() != 936) system("chcp 936>NUL");//中文代码页 		wcout <<	L"计算函数表达式的值。" << endl << L"支持(),+,-,*,/,%,^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round" << endl; 		while (1) { 			wcout <<	L"请输入表达式："; 			fgets(s,16384,stdin); 			if ('\n' == s[strlen(s)-1]) s[strlen(s) - 1] = 0; 			if (s[0] ==	0) break;// 			cout <<	s << "="; 			cout <<	setprecision(15) <<	calc(s,	&endss)	<< endl; 		} 	} 	else if	(argc == 2 && 0	== strcmp(argv[1], "/?")) { 		//if (GetConsoleOutputCP() != 936) system("chcp 936>NUL");//中文代码页 		wcout <<	L"计算由≥1个命令行参数给出的函数表达式的值。\n" 			"最后一个参数是.0～.15表示将计算结果保留小数0～15位\n" 			"最后一个参数是x表示将计算结果以16进制正整数格式输出\n" 			"支持(),+,-,*,/,%,^^,Pi,sin,cos,tan,sqrt,arcsin,arccos,arctan,lg,ln,exp,ceil,floor,round\n" 			"16进制整数以0x或0X开头\n"; 	} 	else { 		strncpy(s, argv[1],	MAXLEN - 1); s[MAXLEN -	1] = 0; 		if (argc>2)	{ 			for	(a = 2;	a<argc - 1;	a++) strncat(s,	argv[a], MAXLEN	- 1);//将空格间隔的各参数连接到s 			if (1 == sscanf(argv[a], ".%d", &pcs) && 0 <= pcs && pcs <= 15) {//最后一个参数是.0～.15表示将计算结果保留小数0～15位 				printf("%.*lf\n", pcs, calc(s, &endss)); 			} 			else if	(argv[a][0]	== 'x' || argv[a][0] == 'X') {//最后一个参数是x表示将计算结果以16进制正整数格式输出 				printf("0x%016I64x\n", (__int64)calc(s, &endss)); 			} 			else { 				strncat(s, argv[a],	MAXLEN - 1); 				printf("%.15lg\n", calc(s, &endss)); 			} 		} 		else { 			printf("%.15lg\n", calc(s, &endss)); 		} 	} 	return 0; }


Question: 关于一个简单代码的郁闷

引用 5 楼 半根棒棒糖      จุ๊บ的回复: 看 感谢您的鼎力相助!!

看

引用 3 楼 自信男孩的回复:[quote=引用 2 楼 f_y_h182 的回复:] 是的，打错了。但是改成s=s1*2+s2还是老样子。  #include<stdio.h> #include<math.h>  int main() {     const double pi=acos(-1.0);     double r,h,s1,s2,s;      scanf ("%lf%lf", &r, &h);//这里是字母l     s1 = pi*r*r;     s2 = 2*pi*r*h;     s = s1*2.0 + s2;     printf("%.3f\n",s);     return 0;  } 改成如下，没问题，r,h输入不同的值，结果也不一样。  [/quote] 试过了，可能是"自己的手排斥键盘"，一切正常。感谢各位才高八斗的大佬。

引用 2 楼 f_y_h182 的回复:是的，打错了。但是改成s=s1*2+s2还是老样子。  #include<stdio.h> #include<math.h>  int main() {     const double pi=acos(-1.0);     double r,h,s1,s2,s;      scanf ("%lf%lf", &r, &h);//这里是字母l     s1 = pi*r*r;     s2 = 2*pi*r*h;     s = s1*2.0 + s2;     printf("%.3f\n",s);     return 0;  } 改成如下，没问题，r,h输入不同的值，结果也不一样。

是的，打错了。但是改成s=s1*2+s2还是老样子。

是s= s1*2.0 + s2;吧


Bingo，默认是这样的


Question: 哪位大神可以帮忙解释下这道题？

交换的方法，记住就好了

就是a与b的值的交换

scanf();//a=1;b=2;c=3;  temp=a=1;a=b=2;b=temp=1;//此句是交换a和b的值，a=2;b=1;c=3;  a2=a1+c1=5;c2=a2-c1=(a1+c1)-c1=a1=2;a3=a2-c2=(a1+c1)-a1=c1=3;//此句是交换a和c的值，a=3;b=1;c=2;

啥疑问？这就是介绍的两种交换变量的方法呀


Question: 新手提问：一道C语言的乘方计算基础题

signed long long中signed说明是有符号数，long long可以用lld格式输入，总的来说就是用%lld格式输入。

引用 2 楼 user-2 的回复:www.cplusplus.com/reference/cstdio/printf/  默认基本类型都是 signed 所以 signed long long 直接用 %ll 就行了  另外宏定义那里，好像有问题，你应该在 _MAX 后面加上 空格，但是这个是题目内容就错了  错了，是 %lld


Question: 已知从1970年1月1日0分0秒到目前的总秒数计算当前时间

这也太复杂了，有没有直接的源代码？

这个计算会涉及到闰年。如果不会写，建议从网上搜一下locoltime的源码，学习一下

哪个大神，帮写一个，先谢谢了。

C:\Program Files (x86)\Windows Kits\10\Source\10.0.10240.0\ucrt\time\localtime.cpp // // localtime.cpp // //      Copyright (c) Microsoft Corporation.  All rights reserved. // // Defines the localtime family of functions, which convert a time_t to a tm // structure containing the local time. // #include <corecrt_internal_time.h>    // Converts a time_t value to a tm value containing the corresponding local time. // Returns zero and updates the tm structure on success; returns nonzero and // leaves the tm structure in an indeterminate state on failure. // // Assumptions: //      (1) gmtime must be called before _isindst to ensure that the tb time //          structure is initialized. //      (2) gmtime, _gtime64, localtime and _localtime64() all use a single //          statically allocated buffer. Each call to one of these routines //          destroys the contents of the previous call. //      (3) It is assumed that __time64_t is a 64-bit integer representing //          the number of seconds since 00:00:00, 01-01-70 (UTC) (i.e., the //          Posix/Unix Epoch. Only non-negative values are supported. //      (4) It is assumed that the maximum adjustment for local time is //          less than three days (include Daylight Savings Time adjustment). //          This only a concern in Posix where the specification of the TZ //          environment restricts the combined offset for time zone and //          Daylight Savings Time to 2 * (24:59:59), just under 50 hours. // If any of these assumptions are violated, the behavior is undefined. template <typename TimeType> static errno_t __cdecl common_localtime_s(     tm*             const ptm,     TimeType const* const ptime     ) throw() {     typedef __crt_time_time_t_traits<TimeType> time_traits;      _VALIDATE_RETURN_ERRCODE(ptm != nullptr, EINVAL);     memset(ptm, 0xff, sizeof(tm));      _VALIDATE_RETURN_ERRCODE(ptime != nullptr, EINVAL);      // Check for illegal time_t value:     _VALIDATE_RETURN_ERRCODE_NOEXC(*ptime >= 0,                       EINVAL);     _VALIDATE_RETURN_ERRCODE_NOEXC(*ptime <= time_traits::max_time_t, EINVAL);      __tzset();      int  daylight = 0;     long dstbias  = 0;     long timezone = 0;     _ERRCHECK(_get_daylight(&daylight));     _ERRCHECK(_get_dstbias (&dstbias ));     _ERRCHECK(_get_timezone(&timezone));      if (*ptime > 3 * _DAY_SEC && *ptime < time_traits::max_time_t - 3 * _DAY_SEC)     {         // The date does not fall within the first three or last three representable         // days; therefore, there is no possibility of overflowing or underflowing         // the time_t representation as we compensate for time zone and daylight         // savings time.         TimeType ltime = *ptime - timezone;          errno_t status0 = time_traits::gmtime_s(ptm, <ime);         if (status0 != 0)             return status0;          // Check and adjust for daylight savings time:         if (daylight && _isindst(ptm))         {             ltime -= dstbias;              errno_t const status1 = time_traits::gmtime_s(ptm, <ime);             if (status1 != 0)                 return status1;              ptm->tm_isdst = 1;         }     }     else     {         // The date falls within the first three or last three representable days;         // therefore, it is possible that the time_t representation would overflow         // or underflow while compensating for time zone and daylight savings time.         // Therefore, we make the time zone and daylight savings time adjustments         // directly in the tm structure.         errno_t const status0 = time_traits::gmtime_s(ptm, ptime);         if (status0 != 0)             return status0;          TimeType ltime = static_cast<TimeType>(ptm->tm_sec);          // First, adjust for the time zone:         if (daylight && _isindst(ptm))         {             ltime -= (timezone + dstbias);             ptm->tm_isdst = 1;         }         else         {             ltime -= timezone;         }          ptm->tm_sec = static_cast<int>(ltime % 60);         if (ptm->tm_sec < 0)         {             ptm->tm_sec += 60;             ltime -= 60;         }          ltime = static_cast<TimeType>(ptm->tm_min) + ltime / 60;         ptm->tm_min = static_cast<int>(ltime % 60);         if (ptm->tm_min < 0)         {             ptm->tm_min += 60;             ltime -= 60;         }          ltime = static_cast<TimeType>(ptm->tm_hour) + ltime / 60;         ptm->tm_hour = static_cast<int>(ltime % 24);         if (ptm->tm_hour < 0)         {             ptm->tm_hour += 24;             ltime -=24;         }          ltime /= 24;          if (ltime > 0)         {             // There is no possibility of overflowing the tm_day and tm_yday             // members because the date can be no later than January 19.             ptm->tm_wday = (ptm->tm_wday + static_cast<int>(ltime)) % 7;             ptm->tm_mday += static_cast<int>(ltime);             ptm->tm_yday += static_cast<int>(ltime);         }         else if (ltime < 0)         {             // It is possible to underflow the tm_mday and tm_yday fields.  If             // this happens, then the adjusted date must lie in December 1969:             ptm->tm_wday = (ptm->tm_wday + 7 + static_cast<int>(ltime)) % 7;             ptm->tm_mday += static_cast<int>(ltime);             if (ptm->tm_mday <= 0)             {                 ptm->tm_mday += 31;                  // Per assumption #4 above, the time zone can cause the date to                 // underflow the epoch by more than a day.                 ptm->tm_yday = ptm->tm_yday + static_cast<int>(ltime) + 365;                 ptm->tm_mon = 11;                 ptm->tm_year--;             }             else             {                 ptm->tm_yday += static_cast<int>(ltime);             }         }     }      return 0; }  extern "C" errno_t __cdecl _localtime32_s(     tm*               const ptm,     __time32_t const* const ptime     ) {     return common_localtime_s(ptm, ptime); }  extern "C" errno_t __cdecl _localtime64_s(     tm*               const ptm,     __time64_t const* const ptime     ) {     return common_localtime_s(ptm, ptime); }    // Converts a time_t value to a tm value containing the corresponding local time. // Returns a pointer to the thread-local tm buffer containing the result on // success; returns nullptr on failure. template <typename TimeType> _Success_(return != 0) static tm* __cdecl common_localtime(TimeType const* const ptime) throw() {     typedef __crt_time_time_t_traits<TimeType> time_traits;      tm* const ptm = __getgmtimebuf();     if (ptm == nullptr)         return nullptr;      errno_t const status = time_traits::localtime_s(ptm, ptime);     if (status != 0)         return nullptr;      return ptm; }  extern "C" tm* __cdecl _localtime32(__time32_t const* const ptime) {     return common_localtime(ptime); }  extern "C" tm* __cdecl _localtime64(__time64_t const* const ptime) {     return common_localtime(ptime); }


Question: 这个错误怎么改

引用 9 楼 覆陇黄 的回复:[quote=引用 7 楼 羽墨志 的回复:]  #include <stdio.h>  int main() { 	int a; 	int b; 	int c; 	int d; 	int e;  	printf("请输入一个三位数\n"); 	scanf("%d",&a);  	//提取各位数字 	b = a/100;        //百位数字 	c = a%100/10; //十位数字 	d = a%10;       //个位数字  	//重新组合 	e = d*100+c*10+b;  // 这个如果d是0的话，程序可能就不太合适 	printf("与%d的逆序的数是%d\n",a,e);          printf(与%d的逆序的数是%d%d%d\n",a,b,c,d);  	return 0; }  添加了少量注释，帮助理解。   // 这个如果d是0的话，程序可能就不太合适 printf(与%d的逆序的数是%d%d%d\n",a,b,c,d);[/quote] 谢谢指出，只帮楼主修正了语法错误，没有考虑这些细节。

引用 7 楼 羽墨志的回复: #include <stdio.h>  int main() { 	int a; 	int b; 	int c; 	int d; 	int e;  	printf("请输入一个三位数\n"); 	scanf("%d",&a);  	//提取各位数字 	b = a/100;        //百位数字 	c = a%100/10; //十位数字 	d = a%10;       //个位数字  	//重新组合 	e = d*100+c*10+b; 	printf("与%d的逆序的数是%d\n",a,e);  	return 0; }  添加了少量注释，帮助理解。 太感谢了!

引用 7 楼 羽墨志 的回复: #include <stdio.h>  int main() { 	int a; 	int b; 	int c; 	int d; 	int e;  	printf("请输入一个三位数\n"); 	scanf("%d",&a);  	//提取各位数字 	b = a/100;        //百位数字 	c = a%100/10; //十位数字 	d = a%10;       //个位数字  	//重新组合 	e = d*100+c*10+b;  // 这个如果d是0的话，程序可能就不太合适 	printf("与%d的逆序的数是%d\n",a,e);          printf(与%d的逆序的数是%d%d%d\n",a,b,c,d);  	return 0; }  添加了少量注释，帮助理解。   // 这个如果d是0的话，程序可能就不太合适 printf(与%d的逆序的数是%d%d%d\n",a,b,c,d);

重复定义了，而且前面的abcde都是int型，可以写在一个int后面，用逗号隔开。你的abcde是在主函数里面定义的，所以只能在主函数里面使用

重定义了，既然上面已经定义声明了，下面就不要在定义了。

请输入三位数那句 你应该是想用scanf输入函数吧

推荐你重新看一遍题目，语义问题也很大。int类型变量a没初始化已经打印，输入a到e，后面却把b到e重新赋值。1声明及定义（初始化）、2打印提示、3输入a、4计算bdce、5打印a到e、6你的程序20行。估计你题目是这个意思

引用 1 楼 user-7的回复:重复定义，前面定义int b; 后面再使用就不用 int b=了 直接b=a%10; 谢谢谢谢谢谢谢谢谢谢你啊!


Question: c语言playsound函数

感谢您的帮助！！！😄😄

引用 6 楼 不#曾＆轻听 的回复:[quote=引用 5 楼 赵4老师的回复:]换MCI吧！ VC++6.0或者codeblocks中怎么调用MIC？[/quote] MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl

引用 5 楼 赵4老师的回复:换MCI吧！ VC++6.0或者codeblocks中怎么调用MIC？

换MCI吧！

引用 1 楼 user-2的回复:虽然目前尚未用到playsound，不过应该是有快进这个功能的吧，暂停时记录播放位置，再次播放快进到该位置。 希望交流，不喜勿喷 如何记录播放位置，再次播放时怎么快进？


Question: 求大佬帮忙

引用 1 楼 user-3 的回复:%.2d是保留两位小数的整形，整形没有小数位的，所以小数位都是0，这就是你运行结果的原因 改成%.2f，用浮点型就可以了  %.2d注意是d，整体还是整型数，所以应该没有小数的事情。 楼主的问题是，把得到的浮点数用整型数输出肯定是有问题的，因为浮点数和整型数在内存中的表示是不一样的，得到结果是0，也是正常的。 正确的输出格式应该是%.2f，这样得到的结果是保留2位小数。 或者用%.2lf也是可以的。

你定义的float变量  输入输出用的是int型 把scanf里的%d换成%f  printf里的%.2d换成%.2f


Question: c语言小白求大佬指点

从0开始啊，你两元的for循环从2开始是什么逻辑

引用 6 楼 user-3的回复:for 里的one，two，five都从0开始，因为换零钱，不一定每一种都有，比如3元换6张5角的，one和two都是0 解决了谢谢大佬麻烦了

引用 3 楼 user-3的回复:返回到上面的循环了，但是if只有一次能够通过，因为你的two是从2开始的。即one=1，two=2，five=5满足if，所以才会只打印一次。其实你的循环都应从0起，比如one=5，two=0，five=5也可以，但是你的循环，决定了3元只有一个结果 什么是循环从零开始呢 是初始化时把one two five 都赋值为0么 如果不是的话麻烦您可以举个例子么 拜托了大佬

引用 1 楼 user-3的回复:因为3元时，five<3*10/5=6，所以five只循环一次 那five那个只循环一次不会返回到上面继续循环么


Question: 一个算法题，想问一下改进前后的速度差异为什么这么大

你那个“while (1)”如果ch不是太多”(”或”)”应该不会怎么用到temp数组和那一堆需要cpu判断的语句，只是判断下是不是回车…改前最多也就4个判断改后3个，还有临时数组应该不至于时间差距那么大。确定一下测试值是否一致，测试时有没有其它应用占用资源。再多的我没看，也许也看不出来

没有缩进，命名乱搞的代码没人有兴趣帮你解答问题

我再说一下我们的思路。读取括号串时先将单串内部的成对括号消除掉，然后计算其左右括号分别的个数，让相应的中的组里对应位置加1表示计数。 处理完所有串后，将所得的数组两两对应。

引用 3 楼 qq_18298599的回复:粗略一看，乱！我这个小白非常确定能看得懂这个程序，懒得分析。7小时没人回复是有原因的，不要站在自己的角度写文章，看到这长长的一篇已经对本文提不起兴趣了……思路还要自己分析… 哈哈，您说得对，我们写的注释不够，命名也不规范，显得表述不是很清晰，还望见谅。

测试用例刚才没截到

改进前： #include <stdio.h> #include <string.h> int main(void){ 	int T =0; 	scanf("%d",&T);    				//输入行数  	getchar();						//把输入T时候的那个回车读掉  	int xx=0;						//输出结果  	int max=0,min=100200; 	int ZHengKuoHao[100100]={0};    //下标代表预处理后左括号的数目，相应的这个数组元素的值为有ZHengKuoHao[i]行经过预处理之后有i个（  	int FuKuoHao[100100]={0};       //同上 这个为）  	int WanJinYou=0; 	for(int i=0;i<T;i++){ 		int count=0;				//这个是我读取输入的时候把预处理之后的输入存进temp数组的下标  		int temp[100020]={0}; 		int zlen=0; 		int flen=0; 		while(1){					//这是候开始边读取一行的输入，边进行预处理，每读取一个元素仅与前面一个元素相比较  			char ch=0; 			scanf("%c",&ch);			 if(ch=='(') { 				temp[count++]=-1; 				flen++; 			} 			else if(ch==')') { 				if(count>0){		//如果形成了一个相邻的合法的括号，那么下标count往前移一位，表示当前读取位与前面一位为合法括号所以可以消除了  					if(temp[count-1]==-1){ 					flen--; 					count--; 					temp[count]=0; 					} 					else{ 						temp[count++]=1; 						zlen++; 					}				 				} 				else { 				temp[count++]= 1; 				zlen++;	 				}				 			} 			else if(ch=='\n') break; 		} 		if(max<flen) max=flen; 		if(max<zlen) max=zlen; 		if(min>flen) min=flen; 		if(min>zlen) min=zlen; 		if(zlen==0&&flen==0) WanJinYou++; 		else if(zlen==0&&flen>0) FuKuoHao[flen]++; 		else if(zlen>0&&flen==0) ZHengKuoHao[zlen]++; 	} 	for(int i=min;i<=max;i++){ 		if(FuKuoHao[i]>=ZHengKuoHao[i]) xx+=ZHengKuoHao[i]; 		else xx+=FuKuoHao[i];		 	} 	xx+=WanJinYou/2; 	printf("%d\n",xx); } 改进后： #include <stdio.h> #include <string.h> int main(void){ 	int T =0; 	scanf("%d",&T);    				//输入行数  	getchar();						//把输入T时候的那个回车读掉  	int xx=0;						//输出结果  	int max=0,min=100200; 	int ZHengKuoHao[100100]={0};    //下标代表预处理后左括号的数目，相应的这个数组元素的值为有ZHengKuoHao[i]行经过预处理之后有i个（  	int FuKuoHao[100100]={0};       //同上 这个为）  	int WanJinYou=0; 	for(int i=0;i<T;i++){ 		int zlen=0; 		int flen=0; 		while(1){					 			char ch=0; 			scanf("%c",&ch);			 if(ch=='(') { 				flen++; 			} 			else if(ch==')') {  				if(flen>0)		{ 					flen--; 				} 				else zlen++; 			} 			else if(ch=='\n') break; 		} 		if(max<flen) max=flen; 		if(max<zlen) max=zlen; 		if(min>flen) min=flen; 		if(min>zlen) min=zlen; 		if(zlen==0&&flen==0) WanJinYou++; 		else if(zlen==0&&flen>0){ 		    if(ZHengKuoHao[flen]>0) { 		    	ZHengKuoHao[flen]--; 		    	xx++; 			} 		    else FuKuoHao[flen]++; 		 }  		else if(zlen>0&&flen==0) { 			if(FuKuoHao[zlen]>0){ 				FuKuoHao[zlen]--; 				xx++; 			} 			else ZHengKuoHao[zlen]++; 		} 	} 	xx+=WanJinYou/2; 	printf("%d\n",xx); }


Question: #C  扑街群众

那百度一下π，复制5000位存储到字符串中，输出就行了

引用 楼主 潞黎的回复:#C语言#萌新求问一道题  题目求 派 小数点后5000位的数字  写出来没有结果 清醒后发现貌似码不对题.. 真不是我忘了给，全英文给了也没用

这还不简单吗？百度一下π，复制5000位存储到字符串中，输出不就完了 其实我是想说的，题目呢？题目要求不给，难不成让别人给你猜题目？


Question: 取高八位与低八位

255对应的16进制就是0xff，也就是8位bit最大值。对256取模得到的值取值范围是：[0, 255]。所以对256取模可以得到低8位。 但是直接不能得到高八位，可以先把高八位移到低位，然后在取模运算也是可以得到高八位的值。

short int right,left,v=0x2244; right = v & 0x00ff; // 取右8位 left = v >> 8; //取左8位 printf("right=%#x, left=%#x\n",right,left);

#define LOBYTE(w)           ((BYTE)(((DWORD_PTR)(w)) & 0xff)) #define HIBYTE(w)           ((BYTE)((((DWORD_PTR)(w)) >> 8) & 0xff))

对于123456这个十进制数，你怎么取低三位？很简单，1取000（10³），那么剩余的高三位呢？÷1000对吧，而short占2字节，共16个二进制位，模256（2^8），就可以得到低八位，这跟十进制是一样的模


Question: C的链表建立与输出

正好刚学习这一块，链表。

#include <stdio.h> #include <stdlib.h>  #define maxsize 100  typedef struct Lnode //初始化 {     int data;     struct Lnode *next; }Lnode;  int createLNode(Lnode **head,int n) {     Lnode *s,*r;   //s指向新节点  ，r指向尾节点     int i;     *head=(Lnode*)malloc(sizeof(Lnode)); //给头结点分配存储空间     //head->next==NULL;     //*head = s;     r = *head;     printf("请输入元素值:\n");     for(i=0;i<n;i++)     {         s = (Lnode *)malloc(sizeof(Lnode));         scanf("%d", &s->data);         r->next =s;         r = s;     }     s->next =NULL;      return 0; }   void print(Lnode *head) {     Lnode *p;     p=head->next ;     while(p!=NULL)     {         printf("%d ",p->data);         p=p->next;     }     printf("\n"); }  void free_list(Lnode *phead) {     Lnode *p, *q;      while (p) {         q = p->next;         free(p);         p = q;     } }  int main() {     int n;     Lnode *p;     printf("请输入节点个数:\n");     scanf("%d",&n);     createLNode(&p,n);     printf("该链表为：\n");     print(p);     //free(p);     free_list(p);     p = NULL;     return 0; } 供参考～ 两处错误。一个是创建链表要传二重指针进去，第二个是释放链表要逐个释放，否则会导致内存泄漏（当然程序运行完会自动释放，如果程序一直运行，楼主你这样释放会导致内存泄露）。

引用 2 楼 focuslight 的回复:给你改了一下   #include <stdio.h>  #include <stdlib.h>  #define maxsize 100   typedef struct Lnode //初始化 { 		int data;      struct Lnode *next;  }Lnode;   int createLNode(Lnode *head, int n)  {     Lnode *s,*r;   //s指向新节点  ，r指向尾节点      int i;  //head=(Lnode*)malloc(sizeof(Lnode)); //给头结点分配存储空间   //head->next=NULL;  s = head;  printf("请输入元素值:\n");  for(i=0;i<n;i++)  {          r = (Lnode *)malloc(sizeof(Lnode));          scanf("%d",&r->data);          s->next =r;          s = r;  		 s->next =NULL;  }        	return 0;  }    void print(Lnode *head)  {      Lnode *p;      p=head->next;      while(p!=NULL)      {       printf("%d ",p->data);       p=p->next; 	 }  }   int main()   {          int n;      Lnode *p; 	  p=(Lnode*)malloc(sizeof(Lnode)); //给头结点分配存储空间  	  p->next=NULL;      printf("请输入节点个数:\n");      scanf("%d",&n);      createLNode(p, n);      printf("该链表为：\n");      print(p); 	 if(p!=NULL)      free(p);      return 0;  }    #include <stdio.h> #include <stdlib.h>  #define maxsize 100  typedef struct Lnode //初始化 {     int data;     struct Lnode *next; }Lnode;  int createLNode(Lnode **head,int n) {     Lnode *s,*r;   //s指向新节点  ，r指向尾节点     int i;     *head=(Lnode*)malloc(sizeof(Lnode)); //给头结点分配存储空间     //head->next==NULL;     //*head = s;     r = *head;     printf("请输入元素值:\n");     for(i=0;i<n;i++)     {         s = (Lnode *)malloc(sizeof(Lnode));         scanf("%d", &s->data);         r->next =s;         r = s;     }     s->next =NULL;      return 0; }   void print(Lnode *head) {     Lnode *p;     p=head->next ;     while(p!=NULL)     {         printf("%d ",p->data);         p=p->next;     }     printf("\n"); }  void free_list(Lnode *phead) {     Lnode *p, *q;      while (p) {         q = p->next;         free(p);         p = q;     } }  int main() {     int n;     Lnode *p;     printf("请输入节点个数:\n");     scanf("%d",&n);     createLNode(&p,n);     printf("该链表为：\n");     print(p);     //free(p);     free_list(p);     p = NULL;     return 0; }  供参考～  比较一下两种方法，那个是可行的的。有一个是有问题的。  因为创建链表时要传二重指针进去，否则不能把链表头带出来。

数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633

p=head-n>ext改为p=head


Question: 字母e前和后都一定要有数字才能是浮点型么

同楼上，字母e是科学记数法中有效数字与10的指数的截断，前后没有数字本就失去了数值的意义。1.2e-.4表示1.2*10^-0.4

这三个都有问题，建议楼主不要停留在理论上，自己写个小程序测试一下。  这个是关于科学计数的表示方法，建议看看书本上的描述

C++ Floating-Point Constants Floating-point constants specify values that must have a fractional part. These values contain decimal points (.) and can contain exponents.  Syntax  floating-constant :  fractional-constant exponent-partopt floating-suffixopt digit-sequence exponent-part floating-suffixopt  fractional-constant :  digit-sequenceopt . digit-sequence digit-sequence .  exponent-part :  e signopt digit-sequence E signopt digit-sequence  sign : one of  + –  digit-sequence :  digit digit-sequence digit  floating-suffix :one of  f l F L  Floating-point constants have a “mantissa,” which specifies the value of the number, an “exponent,” which specifies the magnitude of the number, and an optional suffix that specifies the constant’s type. The mantissa is specified as a sequence of digits followed by a period, followed by an optional sequence of digits representing the fractional part of the number. For example:  18.46 38.  The exponent, if present, specifies the magnitude of the number as a power of 10, as shown in the following example:  18.46e0      // 18.46 18.46e1      // 184.6  If an exponent is present, the trailing decimal point is unnecessary in whole numbers such as 18E0.  Floating-point constants default to type double. By using the suffixes f or l (or F or L — the suffix is not case sensitive), the constant can be specified as float or long double, respectively.  Although long double and double have the same representation, they are not the same type. For example, you can have overloaded functions like  void func( double );  and   void func( long double );


Question: 这是什么情况，写在dll文件头文件里的

引用 2 楼 赵4老师 的回复:GetModuleFileName The GetModuleFileName function retrieves the full path and filename for the executable file containing the specified module.   Windows 95: The GetModuleFilename function will return long filenames when an application's version number is greater than or equal to 4.00 and the long filename is available. Otherwise, it returns only 8.3 format filenames.  DWORD GetModuleFileName(   HMODULE hModule,    // handle to module to find filename for   LPTSTR lpFilename,  // pointer to buffer to receive module path   DWORD nSize         // size of buffer, in characters );  Parameters hModule  Handle to the module whose executable filename is being requested. If this parameter is NULL, GetModuleFileName returns the path for the file used to create the calling process.  lpFilename  Pointer to a buffer that is filled in with the path and filename of the given module.  nSize  Specifies the length, in characters, of the lpFilename buffer. If the length of the path and filename exceeds this limit, the string is truncated.  Return Values If the function succeeds, the return value is the length, in characters, of the string copied to the buffer.  If the function fails, the return value is zero. To get extended error information, call GetLastError.   Remarks If a module is loaded in two processes, its module filename in one process may differ in case from its module filename in the other process.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Unsupported.   Header: Declared in winbase.h.   Import Library: Use kernel32.lib.   Unicode: Implemented as Unicode and ANSI versions on Windows NT.  See Also Dynamic-Link Libraries Overview, Dynamic-Link Library Functions, GetModuleHandle, LoadLibrary   感谢老师，老师可以加下qq吗，以后可以直接请教你，拜托了。  1143499622，这我的

把#pragma once删掉


Question: 合法转义字符

https://baike.baidu.com/item/%E8%BD%AC%E4%B9%89%E5%AD%97%E7%AC%A6/86397?fr=aladdin  '\1011'，超过一个字符的表示值了。\1011按照八进制表示：1*8^3 + 1 * 8^1 + 1

C++ Character Constants Character constants are one or more members of the “source character set,” the character set in which a program is written, surrounded by single quotation marks ('). They are used to represent characters in the “execution character set,” the character set on the machine where the program executes.  Microsoft Specific   For Microsoft C++, the source and execution character sets are both ASCII.  END Microsoft Specific  There are three kinds of character constants:   Normal character constants   Multicharacter constants   Wide-character constants  Note   Use wide-character constants in place of multicharacter constants to ensure portability.  Character constants are specified as one or more characters enclosed in single quotation marks. For example:  char ch = 'x';          // Specify normal character constant. int mbch = 'ab';        // Specify system-dependent                         //  multicharacter constant. wchar_t wcch = L'ab';   // Specify wide-character constant.  Note that mbch is of type int. If it were declared as type char, the second byte would not be retained. A multicharacter constant has four meaningful characters; specifying more than four generates an error message.  Syntax  character-constant :  'c-char-sequence' L'c-char-sequence'  c-char-sequence :  c-char c-char-sequence c-char  c-char :  any member of the source character set except the single quotation mark ('), backslash (\), or newline character escape-sequence  escape-sequence :  simple-escape-sequence octal-escape-sequence hexadecimal-escape-sequence  simple-escape-sequence : one of  \' \" \? \\ \a \b \f \n \r \t \v  octal-escape-sequence :  \octal-digit \octal-digit octal-digit \octal-digit octal-digit octal-digit  hexadecimal-escape-sequence :  \xhexadecimal-digit hexadecimal-escape-sequence hexadecimal-digit  Microsoft C++ supports normal, multicharacter, and wide-character constants. Use wide-character constants to specify members of the extended execution character set (for example, to support an international application). Normal character constants have type char, multicharacter constants have type int, and wide-character constants have type wchar_t. (The type wchar_t is defined in the standard include files STDDEF.H, STDLIB.H, and STRING.H. The wide-character functions, however, are prototyped only in STDLIB.H.)  The only difference in specification between normal and wide-character constants is that wide-character constants are preceded by the letter L. For example:  char schar = 'x';               // Normal character constant wchar_t wchar = L'\x81\x19';    // Wide-character constant  Table 1.2 shows reserved or nongraphic characters that are system dependent or not allowed within character constants. These characters should be represented with escape sequences.  Table 1.2   C++ Reserved or Nongraphic Characters  Character ASCII  Representation ASCII  Value Escape Sequence  Newline NL (LF) 10 or 0x0a \n  Horizontal tab HT 9 \t  Vertical tab VT 11 or 0x0b \v  Backspace BS 8 \b  Carriage return CR 13 or 0x0d \r  Formfeed FF 12 or 0x0c \f  Alert BEL 7 \a  Backslash \ 92 or 0x5c \\  Question mark ? 63 or 0x3f \?  Single quotation mark ' 39 or 0x27 \'  Double quotation mark " 34 or 0x22 \"  Octal number ooo — \ooo  Hexadecimal number hhh — \xhhh  Null character NUL 0 \0    If the character following the backslash does not specify a legal escape sequence, the result is implementation defined. In Microsoft C++, the character following the backslash is taken literally, as though the escape were not present, and a level 1 warning (“unrecognized character escape sequence”) is issued.  Octal escape sequences, specified in the form \ooo, consist of a backslash and one, two, or three octal characters. Hexadecimal escape sequences, specified in the form \xhhh, consist of the characters \x followed by a sequence of hexadecimal digits. Unlike octal escape constants, there is no limit on the number of hexadecimal digits in an escape sequence.  Octal escape sequences are terminated by the first character that is not an octal digit, or when three characters are seen. For example:  wchar_t och = L'\076a';  // Sequence terminates at a char    ch = '\233';     // Sequence terminates after 3 characters  Similarly, hexadecimal escape sequences terminate at the first character that is not a hexadecimal digit. Because hexadecimal digits include the letters a through f (and A through F), make sure the escape sequence terminates at the intended digit.  Because the single quotation mark (') encloses character constants, use the escape sequence \' to represent enclosed single quotation marks. The double quotation mark (") can be represented without an escape sequence. The backslash character (\) is a line-continuation character when placed at the end of a line. If you want a backslash character to appear within a character constant, you must type two backslashes in a row (\\). (SeePhases of Translation in the Preprocessor Reference for more information about line continuation.)   C++ String Literals A string literal consists of zero or more characters from the source character set surrounded by double quotation marks ("). A string literal represents a sequence of characters that, taken together, form a null-terminated string.  Syntax  string-literal :  "s-char-sequenceopt" L"s-char-sequenceopt"  s-char-sequence :  s-char s-char-sequence s-char  s-char :  any member of the source character set except the double quotation mark ("), backslash (\), or newline character escape-sequence  C++ strings have these types:   Array of char[n], where n is the length of the string (in characters) plus 1 for the terminating '\0' that marks the end of the string   Array of wchar_t, for wide-character strings  The result of modifying a string constant is undefined. For example:  char *szStr = "1234"; szStr[2] = 'A';      // Results undefined  Microsoft Specific   In some cases, identical string literals can be “pooled” to save space in the executable file. In string-literal pooling, the compiler causes all references to a particular string literal to point to the same location in memory, instead of having each reference point to a separate instance of the string literal. The/Gf compiler option enables string pooling.  END Microsoft Specific  When specifying string literals, adjacent strings are concatenated. Therefore, this declaration:  char szStr[] = "12" "34";  is identical to this declaration:  char szStr[] = "1234";  This concatenation of adjacent strings makes it easy to specify long strings across multiple lines:  cout << "Four score and seven years "         "ago, our forefathers brought forth "         "upon this continent a new nation.";  In the preceding example, the entire string Four score and seven years ago, our forefathers brought forth upon this continent a new nation. is spliced together. This string can also be specified using line splicing as follows:  cout << "Four score and seven years \ ago, our forefathers brought forth \ upon this continent a new nation.";  After all adjacent strings in the constant have been concatenated, the NULL character, '\0', is appended to provide an end-of-string marker for C string-handling functions.  When the first string contains an escape character, string concatenation can yield surprising results. Consider the following two declarations:  char szStr1[] = "\01" "23"; char szStr2[] = "\0123";  Although it is natural to assume that szStr1 and szStr2 contain the same values, the values they actually contain are shown in Figure 1.1.  Figure 1.1   Escapes and String Concatenation    Microsoft Specific   The maximum length of a string literal is approximately 2,048 bytes. This limit applies to strings of type char[] and wchar_t[]. If a string literal consists of parts enclosed in double quotation marks, the preprocessor concatenates the parts into a single string, and for each line concatenated, it adds an extra byte to the total number of bytes.   For example, suppose a string consists of 40 lines with 50 characters per line (2,000 characters), and one line with 7 characters, and each line is surrounded by double quotation marks. This adds up to 2,007 bytes plus one byte for the terminating null character, for a total of 2,008 bytes. On concatenation, an extra character is added to the total number of bytes for each of the first 40 lines. This makes a total of 2,048 bytes. (The extra characters are not actually written to the string.) Note, however, that if line continuations (\) are used instead of double quotation marks, the preprocessor does not add an extra character for each line.  END Microsoft Specific  Determine the size of string objects by counting the number of characters and adding 1 for the terminating '\0' or 2 for type wchar_t.  Because the double quotation mark (") encloses strings, use the escape sequence (\") to represent enclosed double quotation marks. The single quotation mark (') can be represented without an escape sequence. The backslash character (\) is a line-continuation character when placed at the end of a line. If you want a backslash character to appear within a string, you must type two backslashes (\\). (SeePhases of Translation in the Preprocessor Reference for more information about line continuation.)  To specify a string of type wide-character (wchar_t[]), precede the opening double quotation mark with the character L. For example:  wchar_t wszStr[] = L"1a1g";  All normal escape codes listed in Character Constants are valid in string constants. For example:  cout << "First line\nSecond line"; cout << "Error! Take corrective action\a";  Because the escape code terminates at the first character that is not a hexadecimal digit, specification of string constants with embedded hexadecimal escape codes can cause unexpected results. The following example is intended to create a string literal containing ASCII 5, followed by the characters five:  \x05five"  The actual


Question: DEV-C++程序编译后运行不显示结果

保存类型选择 C source files (*.c)

引用 2 楼 大海包养了馒头的回复:为什么我用system("pause"); 不行，用getchar();就可以了？为什么要输入这个？我看的教学视频里，老师没有输入这么一句，也能正常显示。 加头文件 include<windows.h>。 百度也是可以搜到的

引用 1 楼 自信男孩 的回复:在return前加一句system("pause");或getchar();试试  为什么我用system("pause"); 不行，用getchar();就可以了？为什么要输入这个？我看的教学视频里，老师没有输入这么一句，也能正常显示。


Question: visual  studio 2019

更新到最新版本


Question: 关于c调用api的问题

#pragma comment(lib, "gdi32") //导入lib库 头文件是编译时用的 lib库是链接时用的

他这用的是gcc，#pragma comment(lib, "gdi32")应该不行，要么把user32.a、gdi32.a加入到工程，要么命令行使用-luser32 -lgdi32选项

引用 1 楼 早打大打打核战争的回复:没有添加gdi32库 请问怎么添加，gdi不是都会自带的吗

《程序员的自我修养——链接、装载与库》

头文件只是声明，函数原型（定义）是在库里的，所以如果提示未定义可能是没有加载对应的库（动态库或静态库）

没有添加gdi32库


Question: 求助，输入大于五的数结果都一样

引用 6 楼 jfhe_9954 的回复:[quote=引用 5 楼 自信男孩 的回复:] scanf("%d",&n);       //此处 n 值才确定  long  int a[n]; 这样写也是不行的，函数栈是要预先申请空间的，你这样定义的a数组是在栈上申请空间，所以还是不知道申请多大。 编译运行在许多编译器上可以的，栈在那里会留出N个long int的位置给该数组，初学的时候经常在main函数里这样写。可能是main函数的特权吧，或者说是main函数动态执行的？这方面倒是不太清楚。其他的函数里这样干应该不行，还是在堆里开辟自由空间最为合适，或者全局区预先定义好。多谢提醒！[/quote] 不是特权，这样操作有可能会导致程序异常，具有不确定性。

感谢各位大佬，谢谢谢谢

引用 楼主 qq_42440991的回复:#include<stdio.h> int main(){ 	long  int i,sum=0,n; 	long  int a[i]; 	a[1]=1; 	a[2]=1; 	printf("输入n的值为:"); 	scanf("%d",&n); 	switch(n){ 		case 1:printf("%d\n",a[1]); 		printf("sum的值为:"); 		printf("%d",sum+a[1]);break; 		case 2:sum=a[1]+a[2]; 		printf("%d %d %d",a[1],a[2],sum);break;  		default :printf("%d %d ",a[1],a[2]); 			for(i=3;i<=n;i++) 			{ 				a[i]=a[i-1]+a[i-2]; 				sum+=a[i]; 				printf("%d ",a[i]); 			} 			printf("\nsum的值为:"); 			printf("%d",sum+2);break; 	} 	return 0;} 谢谢各位大佬的帮助，我已经成功解决了

引用 5 楼 自信男孩 的回复:scanf("%d",&n);       //此处 n 值才确定  long  int a[n]; 这样写也是不行的，函数栈是要预先申请空间的，你这样定义的a数组是在栈上申请空间，所以还是不知道申请多大。 编译运行在许多编译器上可以的，栈在那里会留出N个long int的位置给该数组，初学的时候经常在main函数里这样写。可能是main函数的特权吧，或者说是main函数动态执行的？这方面倒是不太清楚。其他的函数里这样干应该不行，还是在堆里开辟自由空间最为合适，或者全局区预先定义好。多谢提醒！

#include<stdio.h> int main(){ long  int i,sum=0,n;   //此处 n 还没确定   //printf("%d\n", i);   //i是？ //printf("%d\n", n);   //n是？  //long  int a[i];     //数组大小？个，数组使用前要定义大小，要用n个的话 在后面再定义  printf("输入n的值为:"); scanf("%d",&n);       //此处 n 值才确定  long  int a[n];       //放在已接收到确定值的 n 后面  a[1]=1; a[2]=1; switch(n){ case 1:printf("%d\n",a[1]); printf("sum的值为:"); printf("%d",sum+a[1]);break; case 2:sum=a[1]+a[2]; printf("%d %d %d",a[1],a[2],sum);break;  default :printf("%d %d ",a[1],a[2]); for(i=3;i<=n;i++) { a[i]=a[i-1]+a[i-2]; sum+=a[i]; printf("%d ",a[i]); } printf("\nsum的值为:"); printf("%d",sum+2);break; } return 0;}   这是初学者用的方法，或者说是适合于小数组的写法，在函数栈里声明数组。C或C++定义数组大小都是固定的，不赞成数组大小随意变化，一般用常数先定义好空间大小；若是用变量的话，则变量得有初始值（此处为接收到输入）。上面几楼的大佬们是经验丰富的，用malloc和free在堆里分配大量空间，堆里适合做大量存储, 栈适合少量存储

要么改成long  int a[1000]这种，要么改成楼上所写的动态申请数组

#include<stdio.h> #include <stdlib.h>  int main() {     long  int i,sum=0,n;     int *a;     printf("输入n的值为:");     scanf("%ld", &n);     a = (int *)malloc(sizeof(int) * n);     if (!a)         return -1;     a[1] = 1;     a[2] = 1;      switch(n){         case 1:             printf("%d\n", a[1]);                printf("sum的值为:");                printf("%ld", sum+a[1]);                break;          case 2:                sum=a[1]+a[2];                printf("%d %d %ld",a[1],a[2],sum);                break;          default :                printf("%d %d ", a[1],a[2]);                  for(i=3;i<=n;i++)                  {                      a[i]=a[i-1]+a[i-2];                      sum+=a[i];                      printf("%d ",a[i]);                  }                  printf("\nsum的值为:");                  printf("%ld\n",sum+2);                  break;     }     free(a);     return 0; }  供参考～  可变数组C语言不支持，建议用malloc/free


Question: 大佬帮我看看我这里为什么输出不了字符串 ，

主函数里58行：StrAssign(&s, cstr)，结构体传指针进去赋值

#include <stdio.h> #include <stdlib.h> #include <string.h>     //顺序串：串中的字符被依次存放在一组连续的存储单元里。  #define MaxSize 30 typedef struct {     char data[MaxSize];   //存储字符串     int length;           //存储字符串的当前长度 }SqString;  //SqString中的串用length控制 //C语言中的字符串以'\0'标志结束  //将字符串常量cstr赋给串s，即生成其值等于cstr的串s。 void StrAssign(SqString *s, char cstr[]) {     int i;     for (i = 0; cstr[i] != '\0'; i++)     {         s->data[i] = cstr[i];     }     s->length = i; }  //显示串中的字符 void DispStr(SqString s) {     int i;     if (s.length > 0)     {         printf("1\n");         for (i = 0; i < s.length; i++)         {             printf("%c", s.data[i]);         }         printf("\n");     } } int main() {     SqString s;     memset(&s, 0, sizeof(s));     //char cstr[10] = {'d','a','r','k','s','o','u','l','s'};     char cstr[10] = {'d','a','r','k','s','o','u','l','s'};     //puts(cstr);     StrAssign(&s, cstr);     DispStr(s);     system("pause");     return 0; }  供参考～  传地址到StrAssign，否则不能把赋值之后的s带到main函数内。


Question: 求C语言顺序表删除值为X的所有结点的函数（类型为bool，判断是否删除成功）

你的代码呢？

struct student { 	int id;						//学号 	char name[20];				//姓名 	float chinese;					//语文成绩  	float math;					//数学成绩  	float english;					//英语成绩  	float total;					//总成绩  	struct student * next;			//指向下一个结构体的指针  };   void DeleteInfo( struct student *head ) { 	int id=0; 	struct student *p = head, *q;								//先把信息显示出来方便查看修改 	while(1) 	{ 		printf("\n输入待删除的学号（Ctrl+Z退出）："); 		if( scanf("%d", &id ) <=0 || id<=0 )				//id故意出错也要退出 			break; 		for( q=p=head ; p!=NULL && p->id != id ; q=p , p=p->next );	//找到该结点 		if( p == NULL ) 		{ 			printf("您没有录入过此学号！\n"); 			continue; 		} 		q->next = p->next;								//前一个结点指向当前结点的下一个结点  		if( p != head )									//释放的结点不能是头结点 			free(p);										//释放当前结点  	} }

bool ListDeleteElem(SqList*& L, ElemType e)//删除所有元素值为e的结点，删除成功时返回true，否则返回false {     int i = 0, j = 0;//, count = 0;      for (j = 0; j < L->length; j++) {         if (L->data[j] != e) {             L->data[i] = L->data[j];             i++;             //count++;         }     }     if (i > 0)         return true;      return false; } 供参考～

bool ListDeleteElem(SqList*& L, ElemType e)//删除所有元素值为e的结点，删除成功时返回true，否则返回false { 	int i = 0, j = 0, count = 0; 	for (j = 0; j < L->length; j++) { 		if (L->data[j] != e) { 			L->data[i] = L->data[j]; 			i++; 			count++; 		}L->length = i; 	} }  网上找到的这种功能的函数都是void型的。我主要想问应该在哪里加上return true、return false。怎么加。希望好心人可以用代码方式解答。


Question: 程序有一处好像不太明白

改一下，改成cpu * 1.0 / 2，这样后面表达式就按照浮点数来计算了。  否则cpu是整型数，2也是，所以cpu/2按照整型除法计算了，所以3/2=1。


Question: 怎么用C或C#或C++语言写出能和powershell脚本效果一样的代码？

建议你放弃这个目标。


Question: 更新vs的microsoft help viewer文档老是说什么没有microsoft签名是怎么回事

在VS中打开HelpViewer后，更新help内容时不要关闭VS，应该就可以了。


Question: 求助，大神帮帮忙

引用 3 楼 自信男孩 的回复：[quote=引用 2 楼 Arms� 的回复:] [quote=引用 1 楼 自信男孩 的回复：]你的代码呢？ 是不是调用system呢？用的 system(“pause”);[/quote] 那正常，去掉就好了。或者用getchar();替换system("pause");。  这个system在windows的编译器里比较常用，Linux上就没有这个。[/quote]谢谢

引用 2 楼 Arms� 的回复:[quote=引用 1 楼 自信男孩 的回复：]你的代码呢？ 是不是调用system呢？用的 system(“pause”);[/quote] 那正常，去掉就好了。或者用getchar();替换system("pause");。  这个system在windows的编译器里比较常用，Linux上就没有这个。

引用 1 楼 自信男孩 的回复：你的代码呢？ 是不是调用system呢？用的 system(“pause”);

你的代码呢？ 是不是调用system呢？


Question: c ++如何将十进制转为7进制？

输入一个正整数n 将其除了它本身的最大约数转化为7进制和16进制分别输出

% 7  / 7


Question: 请教Valgrind内存泄漏检查的问题

我知道，能把命令行和步骤简单说一下吗？谢谢

linux也能用valgrind呀


Question: 求助:C语言一种奇怪用法

书中描述可能不太严谨，书中代码是用typedef struct定义了一个类型Lnode， 然后用这个类型定义了一个指针变量LInkList

数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633

书上定义的LinkList是一个指针变量，类型是Lnode * 除非这样定义：typedef Lnode * LinkList;那么LinkList就是一个类型别名了，可以当成类似char， int类型来看。

书上说是类型就是类型了？LinkList是指向Lnode 类型的指针变量,就是一个指针变量


Question: C的一个题不知道哪出错了

是个题库的题，就说我全部都错误0分....

没发现什么问题，提示是什么错误？  #include<stdio.h> int main(void) {     int n, num = 0;      printf("请输入测试数据：");     scanf("%d", &n);      while (n != 1)     {         if (n % 2 == 0)         {             n = n / 2;             num++;         }         else         {             n = (3 * n + 1) / 2;             num++;         }         printf("n = %d, num  =%d\n", n, num);     }      printf("%d\n", num);      return 0; }  难道是去掉如下这句就好了？：  printf("请输入测试数据：");


Question: 传说中的数据结构，不知道哪里错了，求提点

引用 8 楼 自信男孩的回复:[quote=引用 5 楼 weixin_44775375 的回复:]   在大学里学习了一个学期了，大家大都对所学的专业有了基本的了解。许多同学也已经知道了到大二要开一门课叫做《数据结构》，那么今天给你们提前讲一下一个最简单的数据结构：栈。 栈的基本操作有3种：push，pop，top。 例如，给你一个数列：1 2 3 4 push：向栈中加入一个数，比如push 5，数列就变成1 2 3 4 5。 pop：从栈中删除最后面的数，比如 pop，数列就变成1 2 3。（数列变化，但是不输出。如果栈是空的，即不能 pop 操作，那就输出 error ，但是接下来的操作还是要继续的）。 top：找出栈最后面的数，比如 top ，你就要输出4。（如果栈中没有数的话，即不能 top 操作，那就输出 empty）。       然后，你们可以看出来了吧，其实栈就是一个先进后出（越先进去的元素越后面出来）的数据结构，很简单吧，下面要检验下你们的学习效果了。  Input  输入包含多组测试数据. 每组数据的第一行为一个整数 T(1 <= T <= 1000 )，接下来 T 行为对栈的操作。  Output  如果操作是top，那么输出最后面的数，如果栈中没有数的话，那就输出“empty”（不含引号）。 如果操作是pop且栈是空的，那么输出 “error”（不含引号）。 在每组测试数据的最后多加一次换行。  根据这个需求，也不是这么写的代码呢。应该是用数组模拟一个栈操作的吧[/quote] 对呀，我不就是这样写的吗

引用 5 楼 weixin_44775375 的回复:  在大学里学习了一个学期了，大家大都对所学的专业有了基本的了解。许多同学也已经知道了到大二要开一门课叫做《数据结构》，那么今天给你们提前讲一下一个最简单的数据结构：栈。 栈的基本操作有3种：push，pop，top。 例如，给你一个数列：1 2 3 4 push：向栈中加入一个数，比如push 5，数列就变成1 2 3 4 5。 pop：从栈中删除最后面的数，比如 pop，数列就变成1 2 3。（数列变化，但是不输出。如果栈是空的，即不能 pop 操作，那就输出 error ，但是接下来的操作还是要继续的）。 top：找出栈最后面的数，比如 top ，你就要输出4。（如果栈中没有数的话，即不能 top 操作，那就输出 empty）。       然后，你们可以看出来了吧，其实栈就是一个先进后出（越先进去的元素越后面出来）的数据结构，很简单吧，下面要检验下你们的学习效果了。  Input  输入包含多组测试数据. 每组数据的第一行为一个整数 T(1 <= T <= 1000 )，接下来 T 行为对栈的操作。  Output  如果操作是top，那么输出最后面的数，如果栈中没有数的话，那就输出“empty”（不含引号）。 如果操作是pop且栈是空的，那么输出 “error”（不含引号）。 在每组测试数据的最后多加一次换行。  根据这个需求，也不是这么写的代码呢。应该是用数组模拟一个栈操作的吧

引用 6 楼 user-2的回复:[quote=引用 4 楼 weixin_44775375 的回复:] [quote=引用 2 楼 user-2的回复:]额，这个你得把问题描述清楚一点（你想要的的结果是啥？现在的情况却是啥？），然后再上代码，而且代码尽量写些注释，让人知道你想干嘛。 你的这个是想实现栈的功能吧，用char类型数组str读取令（push入栈，pop出栈，top取栈顶），用int型数组a接收数据，其他感觉不出什么问题。 n的初始化位置不对，应该放在所有判断条件外，即scanf前写n=-1，否则一开始直接输入top或pop就错了，因为之前没对n进行初始化（没有执行n=i这条语句）。 就是C语言一个简单的数据结构的解释，等会我把题目发一下[/quote] #include <stdio.h> #include<string.h> int main() { int T,i,a[1000],n;   //a的大小1000够用吗？  char str[100]; while(~scanf("%d",&T)) { 	//给初始序列了吗？  	n = -1;          //在每个案例下先定义好n  for(i=0;i<T;i++)     //i的作用是控制循环，要用它作为数组索引？  { scanf("%s",str); if(strcmp(str,"push")==0) {  n++; scanf("%d",a+n);   //&a[n] //printf("str: %s\n", str); //scanf("%d", &a[i]);   // i做索引  //printf("n是： %d\n", n); //n=i;            //不要误此处一定会定义到n，碰到直接pop就错了  } else if(strcmp(str,"pop")==0) { 	//printf("str: %s\n", str); 	//printf("n是： %d\n", n); if(n==-1)printf("error\n"); else n--; } else if(strcmp(str,"top")==0) { 	//printf("str: %s\n", str); 	//printf("n是： %d\n", n);  if(n==-1)printf("empty\n"); else printf("%d\n",a[n]); } } printf("\n"); } return 0; }   我对C的一些函数不是怎么熟悉，大致这样先看看吧，打问号处注意看看[/quote] 谢谢你你太厉害啦

引用 4 楼 weixin_44775375 的回复:[quote=引用 2 楼 user-2的回复:]额，这个你得把问题描述清楚一点（你想要的的结果是啥？现在的情况却是啥？），然后再上代码，而且代码尽量写些注释，让人知道你想干嘛。 你的这个是想实现栈的功能吧，用char类型数组str读取令（push入栈，pop出栈，top取栈顶），用int型数组a接收数据，其他感觉不出什么问题。 n的初始化位置不对，应该放在所有判断条件外，即scanf前写n=-1，否则一开始直接输入top或pop就错了，因为之前没对n进行初始化（没有执行n=i这条语句）。 就是C语言一个简单的数据结构的解释，等会我把题目发一下[/quote] #include <stdio.h> #include<string.h> int main() { int T,i,a[1000],n;   //a的大小1000够用吗？  char str[100]; while(~scanf("%d",&T)) { 	//给初始序列了吗？  	n = -1;          //在每个案例下先定义好n  for(i=0;i<T;i++)     //i的作用是控制循环，要用它作为数组索引？  { scanf("%s",str); if(strcmp(str,"push")==0) {  n++; scanf("%d",a+n);   //&a[n] //printf("str: %s\n", str); //scanf("%d", &a[i]);   // i做索引  //printf("n是： %d\n", n); //n=i;            //不要误此处一定会定义到n，碰到直接pop就错了  } else if(strcmp(str,"pop")==0) { 	//printf("str: %s\n", str); 	//printf("n是： %d\n", n); if(n==-1)printf("error\n"); else n--; } else if(strcmp(str,"top")==0) { 	//printf("str: %s\n", str); 	//printf("n是： %d\n", n);  if(n==-1)printf("empty\n"); else printf("%d\n",a[n]); } } printf("\n"); } return 0; }   我对C的一些函数不是怎么熟悉，大致这样先看看吧，打问号处注意看看

引用 2 楼 user-2的回复:额，这个你得把问题描述清楚一点（你想要的的结果是啥？现在的情况却是啥？），然后再上代码，而且代码尽量写些注释，让人知道你想干嘛。 你的这个是想实现栈的功能吧，用char类型数组str读取令（push入栈，pop出栈，top取栈顶），用int型数组a接收数据，其他感觉不出什么问题。 n的初始化位置不对，应该放在所有判断条件外，即scanf前写n=-1，否则一开始直接输入top或pop就错了，因为之前没对n进行初始化（没有执行n=i这条语句）。 就是C语言一个简单的数据结构的解释，等会我把题目发一下

引用 1 楼 自信男孩的回复:没看出来有啥特殊的数据结构，楼主是什么问题？  另外，n为什么在进入循环之前没有初始化呢?循环里直接使用了，这个地方肯定是有问题的 必须要初始化呀好的谢谢你


Question: 用typedef定义指针实现队列的细节问题

建议还是贴代码吧，图片不清晰～


Question: 为什么老是这一块老是出现unhandled exception的错误啊

引用 5 楼 自信男孩 的回复:[quote=引用 4 楼 Garllic 的回复:] [quote=引用 3 楼 自信男孩 的回复：]建议贴出一下写文件的操作，但从目前的代码看不出问题所在我把文件打开从“r+”改成“r”就可以了 这是怎么一回事啊  我写入的时候是“a”的方式打开的[/quote] 还得看代码，从你的描述来看不应该把r+改成r就可以。[/quote] 会不会是因为我写文件的时候的方式是“a”所以不能用“r+”的方式来读文件呢？ 代码的话我现在是全改成a+和r+运行起来是可以的了，但如果把“a+”改成“a”似乎就不行了，麻烦大佬看看这是为啥呢 关于文件函数的代码在200,236,283行！！ 真是麻烦啦！！感激不尽！   #include <stdio.h> #include <stdlib.h> #include <string.h> #include <conio.h>  typedef struct Book { 	char name[54]; 	char author[54]; 	char price[12]; 	int num; } Book;  typedef struct LNode {     int num; 	Book book;     struct LNode * next;  } LNode,*Linklist;   void boss(); void menu(); void book_creat(); void book_look (); void book_change (); Book book_find_name (char name[],FILE *pf);  int main (){ 	boss(); 	menu();  	return 0; }  void boss() {	 	char mima[120]; 	int t_f; 	 	printf("**********管理员身份认证**********\n\n");  	printf("为系统安全请输入管理员密钥！\n"); 	printf("密钥："); 	scanf("%s",mima); 	 	t_f=strcmp(mima , "123");  	if(t_f!=0){ 		system ("cls"); 		printf("\n\n"); 		printf("------------------------!!!!-------------------------\n"); 		printf("密码错误，按任意键返回认证页面（注意字母区分大小写）！\n"); 		printf("-----------------------------------------------------\n"); 		getch (); 		system("cls"); 		boss(); 	} 	else  	{ 		system("cls"); 		menu(); 	} }    void menu() { 	char x;  	printf("**************图书管理系统**************\n\n");  	printf("            1.创建图书信息\n"); 	printf("            2.查看图书信息\n"); 	printf("            3.删除图书信息\n"); 	printf("            4.修改图书信息\n"); 	printf("            0.退出程序\n\n");  	printf("请选择（1-4）\n"); 	printf("****************************************\n");  	do 	{ 		x=getch(); 	}while (x<48||x>52);  	system("cls");  	switch(x) 	{ 	case '1': book_creat (); 	case '2': book_look (); 	case '3':; 	case '4': book_change(); 	case '0': return ; 	default:menu(); 	} 	 }  void book_creat() { 	char x; 	char s; 	int i=0; 	FILE *fp;  	Book book; 	Book *pbook=NULL;  	printf("**************图书管理系统---书籍录入**************\n\n");  	printf("书名："); 	scanf("%s",book.name); 	printf("作者："); 	scanf("%s",book.author); 	printf("价格："); 	scanf("%s",book.price); 	printf("数目:"); 	scanf("%d",&book.num);  	system("cls");  	do 	{ 	printf("**************图书管理系统---书籍录入**************\n"); 	printf("请确认图书信息:\n"); 	printf("书名：%s\n",book.name); 	printf("作者：%s\n",book.author); 	printf("价格：%s\n",book.price); 	printf("数目：%d\n\n",book.num);  	printf("输入“1”修改信息\n"); 	printf("输入“0”重新输入信息\n"); 	printf("其他任意键确认输入\n"); 	printf("***************************************************\n");  	x=getch (); 	system("cls");  	switch(x) 	{ 	case '0':book_creat(); 	case '1': 		printf("**************图书管理系统---书籍录入.信息更改**************\n"); 		printf("请选择更改信息:\n"); 		printf("1.书名：%s\n",book.name); 		printf("2.作者：%s\n",book.author); 		printf("3.价格：%s\n",book.price); 		printf("4.数目: %d\n",book.num); 		printf("输入任意键返回\n\n");  		printf("选择（1-3）\n"); 		printf("************************************************************\n"); 		 		s=getch(); 		system("cls");  		switch(s) 		{ 		case '1': 			printf("**************书名更改**************\n\n");  			printf("请输入书名："); 			scanf("%s",book.name); 			i=1; 			break; 		case '2': 			printf("**************作者更改**************\n\n");  			printf("请输入作者："); 			scanf("%s",book.author); 			i=1; 			break; 		case '3': 			printf("**************价格更改**************\n\n");  			printf("请输入价格："); 			scanf("%s",book.price); 			i=1; 			break; 		case '4': 			printf("**************数目更改**************\n\n");  			printf("请输入数目："); 			scanf("%d",&book.num); 			i=1; 			break; 		default: 			i=1; 			break; 		} 	default: 		i=0; 	} 	system("cls"); 	}while (i==1);  	pbook=&book;  	fp=fopen("图书管理.txt","a+"); 	fwrite(pbook,sizeof(Book),1,fp); 	fclose (fp); 	 	printf("**************图书管理系统**************\n\n");  	printf("操作成功！\n"); 	printf("继续输入请按“1”\n"); 	printf("返回菜单请按任意键\n\n");  	printf("****************************************\n");  	x=getch();  	switch(x) 	{ 	case '1': 		system("cls"); 		book_creat(); 	default: 		system("cls"); 		menu(); 	}  }  void book_look () { 	FILE *pf; 	Book book; 	Book *pbook=&book; 	int i=1; 	char x; 	int num=0; 	int ii;  	pf=fopen("图书管理.txt","r+"); 	 	fseek(pf,0,2); 	ii=ftell(pf); 	rewind(pf); 	 	while (ii!=ftell(pf)) 	{ 		fread(pbook,sizeof(Book),1,pf);  		printf("编号%04d\n",i++); 		printf("书名：%s\n",pbook->name); 		printf("作者：%s\n",pbook->author); 		printf("价格：%s\n",pbook->price); 		printf("数目：%d\n",pbook->num); 		 		num+=pbook->num; 	}  	 	fclose (pf);  	printf("--------------------------------------------\n"); 	printf("书录以打印完成！总共收录书籍%d本\n",num); 	printf("请选择：1.修改图书信息！2.删除图书信息\n"); 	printf("按任意键回到菜单\n");  	x=getch();  	switch (x) 	{ 	case '1':system ("cls");book_change(); 	case '2':system ("cls"); 	default:system ("cls");menu(); 	}  }  void book_change () { 	Book change ; 	char x; 	char find[120]; 	int i=0 ; 	FILE *pf; 	int chch=0;  	pf=fopen("图书管理.txt","r+");  		printf("**************图书管理系统---图书信息更改**************\n\n");  		printf("选择以下方式查询需要更改的书籍\n"); 		printf("1.书名索引\n"); 		printf("2.作者索引\n\n");  		printf("其它任意键返回主菜单\n"); 		printf("*******************************************************\n");  			x=getch();  		system("cls");  		switch(x) 		{ 		case '1': 			printf("**************图书管理系统---图书索引.书名**************\n\n");  			printf("请输入书名："); 			scanf( "%s", find );  			change=book_find_name(find,pf);  			break; 		case '2': 			printf("**************图书管理系统---图书索引.书名**************\n\n");  			printf("请输入作者名："); 			scanf("%s",find);  			change=book_find_author(find,pf);  			break; 		default: 			menu(); 		}  		do 		{ 		system("cls");  		printf("**************图书管理系统---图书信息更改**************\n\n");  		printf("请确认需要更改书籍信息：\n"); 		printf("1.书名：%s\n",change.name); 		printf("2.作者：%s\n",change.author); 		printf("3.价格：%s\n",change.price); 		printf("4.数目：%d\n",change.num); 		printf("0.确认更改\n\n");  		printf("请选择需要更改的信息（1-4）\n"); 		printf("按其它任意键取消此书籍更改\n"); 		printf("*******************************************************\n");  		x=getch();  		system("cls");  		switch(x) 		{ 		case '1': 			printf("**************书名更改**************\n\n");  			printf("请输入书名："); 			scanf("%s",change.name); 			break; 		case '2': 			printf("**************作者更改**************\n\n");  			printf("请输入作者："); 			scanf("%s",change.author); 			break; 		case '3': 			printf("**************价格更改**************\n\n");  			printf("请输入价格："); 			scanf("%s",change.price); 			break; 		case '4': 			printf("**************数目更改**************\n\n");  			printf("请输入数目："); 			scanf("%d",&change.num); 			break; 		case '0': 			chch=1; 			break; 		default: 			book_change(); 		} 		}while (chch==0);  		system("cls");  		fseek(pf,-sizeof(Book),1); 		fwrite(&change,sizeof(Book),1,pf);  		fclose (pf);  		printf("**************图书管理系统**************\n\n");  		printf("操作成功！\n"); 		printf("继续修改书籍请按“1”\n"); 		printf("返回菜单请按其它任意键\n\n");  		printf("****************************************\n");  		x=getch();  		switch(x) 		{ 		case '1': 			system("cls"); 			book_change(); 		default: 			system("cls"); 			menu(); 		}  }  Book book_find_name (char name[],FILE *pf) { 	Book booki; 	int ch;  	while (!feof(pf)&&ch!=0) 	{ 		fread(&booki,sizeof(Book),1,pf); 		ch=strcmp(name,booki.name); 	}  	return booki; }  Book book_find_author (char name[],FILE *pf) { 	 	 	return booki; }

引用 4 楼 Garllic 的回复:[quote=引用 3 楼 自信男孩 的回复：]建议贴出一下写文件的操作，但从目前的代码看不出问题所在我把文件打开从“r+”改成“r”就可以了 这是怎么一回事啊  我写入的时候是“a”的方式打开的[/quote] 还得看代码，从你的描述来看不应该把r+改成r就可以。

引用 3 楼 自信男孩 的回复：建议贴出一下写文件的操作，但从目前的代码看不出问题所在我把文件打开从“r+”改成“r”就可以了 这是怎么一回事啊  我写入的时候是“a”的方式打开的

建议贴出一下写文件的操作，但从目前的代码看不出问题所在

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

这是两个自己定的类型


Question: 麻烦大家看一下这道题，为什么我写的代码会超时呢？一直不输出。

#include<stdio.h> //#include <unistd.h>  int main() {     unsigned long int molecular, denominator;     int num = 3, i = 1, j;     double key, val, sum = 1.0;     scanf("%lf", &key);      val = i*1.0 / num;     while (val > key) {         sum += val;         i++;         molecular = 1;         for (j = 1; j <= i; j++)             molecular *= j;         denominator = 1;         for (j = 0; j < i; j++)             denominator = (num + j * 2) * denominator;         //printf("i = %d, molecular = %lu, denominator = %lu\n", i, molecular, denominator);         val = molecular * 1.0 / denominator;         //sleep(1);     }      printf("pi = %lf\n", (sum+val) * 2);     /*     double pi;double num=3;double tem=1;double sum=1;double k=(tem/num);double i=1;double j=3;     scanf("%lf",&a);     while(k>a)     {         sum=sum+k;         i++;         j=j+2;         num=num*j;         tem=tem*i;      }     pi=sum*2;     printf("%.6lf",pi);     */     return 0;  } 供参考～  楼主的代码逻辑有问题～其中一个是死循环了

引用 2 楼 轻箬笠的回复:k值不会在while里面发生变化，死循环 我明白了 谢谢你

k值不会在while里面发生变化，死循环

是不是我写的这个代码有什么错误呀？


Question: 我在输入scanf后的数据后，输入的year的数字仍然保留在编译器里，如图所示。请问如何在按回车后只显示printf后的东西而不保留scanf的东西

可以用楼上所说的控制台清屏指令，C语言还有一个不回显输入函数   _getch()  作用同getchar()，区别与前者输入不会显示在控制台窗口中

#include<stdio.h> #include <stdlib.h>  int main() {     int year,i,x,out;     scanf("%d", &year);      system("clear");     x = (year-2000)/4;      if (year<=2000||year>2100) {         printf("Invalid year!\n");         return 0;     }     //else{     if (year-2000>4){         for(i=1;i<=x;i++){             out = 2000+i*4;             printf("%d\n",out);         }     }else if(year-2000<4){         printf("None\n");     }     //}      return 0; } vim编辑器使用clear命令就可以实现。 不过，你完全可以加一些换行或者加一些分隔符来区别你的输入和你的输出。


Question: c语言输出三角形

每次循环比上次多4个* 你用4个变量存储需要加*的位置的下标  每次加好*之后 2个变量-- 2个变量++ 就可以找到下次需要加 * 的位置了

一个比较简单的思路  你定义一个数组 一开始全部空格  然后每次循环在指定位置赋值为 * 然后输出 就可以了

一个for循环足以，每次循环打印空格打印星打印空格打印星就好了

#include <stdio.h>  int main() { 	int N = 4;                                    //行数：4行，可自己定义  	for(int i = 0; i < N; i++) 	{ 		int k = N - i - 1 ;                     //空格控制  		for(int j = 0; j < k; j++)           //左侧空格  		    printf("%c",' '); 		for(int j = 0; j < 2*i+1; j++)    //第一个三角形  		    printf("%c", '*'); 		for(int j = 0; j < k; j++)           //中间偏左空格  		    printf("%c",' '); 		for(int j = 0; j < k; j++)           //中间偏右空格  		    printf("%c",' ');  		for(int j = 0; j < 2*i+1; j++)    //第二个三角形  		    printf("%c",'*'); 		printf("\n");                             //一行结束  	}  	return 0; }

将上图看成星号和空格的组合，找星号数量与空格数量的规律，用for循环运算输出

那就用四个for循环顺序一个嵌套三个分别表示星号和空格。

引用 1 楼 北伊的回复:直接printf啊，没星号空格 题目是要求用for循环输出

直接printf啊，没星号空格


Question: c 程序 不知道哪里错了！ 求帮看！

输入格式，要和你代码scanf里面的一样，中英文符搞错了，最好区分的就是中文符号后面会比英文符号多出一段距离，我就是这个方法来区分。 在学校这种vc没有提示的时候的小技巧。

引用 2 楼 636f6c696e 的回复：输入的问题，你输入的是中文逗号，导致b的值输入进来是0，所以必然输出第一个参数对 我也发现了

代码没什么问题，应该是输入的问题，格式有问题，注意逗号中英文要和scanf引号里一致。  也可以用一条调试打印判断一下是不是输入的问题，通过printf在scanf之后把a,b打印一下看看和你的输入的数值是否一致。

输入的问题，你输入的是中文逗号，导致b的值输入进来是0，所以必然输出第一个参数

写成这样试。 if(x>y){     z=x; }else {     z=y; }   或者 z=x; if(y>x) z=y;  或者return x>=y?x:y


Question: 给大家推荐一个求自守数的小方法

用求余的算法求10以内的都会余0

d初值应该是1吧，而且程序逻辑也有些问题，d=1应该放在循环内部 这程序根本不对吧

引用 2 楼 梦:-千寻´▽; 的回复:[quote=引用 1 楼 自信男孩的回复:]http://c.biancheng.net/view/503.html  网上有一些例子，可以自行参考一下～ 我感觉我的方法更简单一点[/quote] 那为啥不能计算十以内自守数呢

应该是a<d*10吧 这种只是数学上的简化，都谈不上优化了

for (long long i = 0, j = 10; i <= 1000000; ++i % j ? 0 : j *= 10)     if (i * i % j == i) printf("%lld\n", i);

引用 1 楼 自信男孩的回复:http://c.biancheng.net/view/503.html  网上有一些例子，可以自行参考一下～ 我感觉我的方法更简单一点


Question: 线程中的线程

学习   学习

如果不加控制，线程运行是随机的，你可以用事件、锁控制线程先后执行顺序

如果不做同步或互斥，那么线程的执行是有调度决定的。对于锁，要看你的锁是做什么的，是放在那个线程里的。建议贴出代码分析问题～

线程之间没有涵盖关系，它们都属于主进程的线程。 锁只对当前的线程起作用。


Question: codeblocks中遇到的问题

放图片啊，不放图谁知道你什么意思


Question: 递归能实现广度优先吗？

引用 20 楼 user-2 的回复:if (node->left) q.push(node->left);                 if (node->right) q.push(node->right); 请问这段代码 和 我做的      if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright); 有什么区别 我的做法是为了队列而队列  你的代码就伟大光正唯一正确? 人为何能如此自大呢 还水平特别低

引用 20 楼 user-2 的回复:二叉树的 左右存的孩子结点 你这算啥     arr[0].pleft = arr+1;     arr[0].pright = arr+2;     arr[1].pleft = arr+3;     arr[1].pright = arr+4;     arr[2].pleft = arr+5;     arr[2].pright = arr+6; 你看不出这是存了左右节点?? arr[0].pleft = arr+1; 看不懂? 这个等于 arr[0].pleft = &arr[1]; 能理解吗  arr[0].pleft 左节点是一个结构体指针  我用数组元素的地址给这个节点赋值  所以节点0的左子节点是节点1 能看懂吗 你是不是没学过指针??

引用 21 楼 user-2 的回复:一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)  def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈请百度一下尾递归

引用 19 楼 lin5161678 的回复:[quote=引用 15 楼 user-2 的回复:] 一本书上说的，我说了也不算，书上原话是： 所有递归都可以转化为循环  并没有所有循环可以转化为递归这句话，但是我觉得应该是这样，循坏可以无限复杂，递归不一样，一个正向，一个逆向，个人观点，递归人脑算起来复杂度很高死读书?? 关于是不是 全部循环都能改为递归 我也不多说什么了 就举例一个Haskell语言 知道你不会 但你总听说过吧?? 这个语言 没有循环  需要用到循环的操作 这里全部得用递归处理  你体会一下[/quote] 一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)      def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈

引用 30 楼 lin5161678 的回复:[quote=引用 25 楼 user-2 的回复:] 那尾递归无限输出可以不爆栈吗？ 可以 00861002  xor         eax,offset __imp__puts (8620A0h)   	puts("1"); 00861007  push        offset string "1" (8620F4h)   0086100C  call        esi   0086100E  add         esp,4   	tailrecsum(); 00861011  jmp         tailrecsum+7 (861007h)   这是vs2010开启优化之后的尾递归汇编 可以看到递归只是一个jmp指令 不会操作堆栈 多少层都不会造成爆栈[/quote]   引用 30 楼 lin5161678 的回复:[quote=引用 25 楼 user-2 的回复:] 那尾递归无限输出可以不爆栈吗？ 可以 00861002  xor         eax,offset __imp__puts (8620A0h)   	puts("1"); 00861007  push        offset string "1" (8620F4h)   0086100C  call        esi   0086100E  add         esp,4   	tailrecsum(); 00861011  jmp         tailrecsum+7 (861007h)   这是vs2010开启优化之后的尾递归汇编 可以看到递归只是一个jmp指令 不会操作堆栈 多少层都不会造成爆栈[/quote] 嗯，学到嘞

引用 29 楼 user-2 的回复:学习啦 俺错了 学习到东西不寒掺 不仅不寒碜 还很有风度有心胸  你这样回复反而显得我前面部分回复略显刻薄 抱歉 一时没控制住情绪

引用 25 楼 user-2 的回复:那尾递归无限输出可以不爆栈吗？ 哦 漏了代码  void tailrecsum(){ 	puts("1"); 	tailrecsum(); }

引用 25 楼 user-2 的回复:那尾递归无限输出可以不爆栈吗？ 可以 00861002  xor         eax,offset __imp__puts (8620A0h)   	puts("1"); 00861007  push        offset string "1" (8620F4h)   0086100C  call        esi   0086100E  add         esp,4   	tailrecsum(); 00861011  jmp         tailrecsum+7 (861007h)  这是vs2010开启优化之后的尾递归汇编 可以看到递归只是一个jmp指令 不会操作堆栈 多少层都不会造成爆栈

引用 22 楼 lin5161678 的回复:[quote=引用 21 楼 user-2 的回复:] 一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)      def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈请百度一下尾递归[/quote] 类似于贪吃蛇？ 就不再开辟新的内存空间了吗？  引用 24 楼 lin5161678 的回复:[quote=引用 20 楼 user-2 的回复:]                if (node->left) q.push(node->left);                 if (node->right) q.push(node->right); 请问这段代码 和 我做的      if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright); 有什么区别 我的做法是为了队列而队列  你的代码就伟大光正唯一正确? 人为何能如此自大呢 还水平特别低[/quote] 学习啦 俺错了 学习到东西不寒掺

引用 24 楼 lin5161678 的回复:[quote=引用 20 楼 user-2 的回复:]                if (node->left) q.push(node->left);                 if (node->right) q.push(node->right); 请问这段代码 和 我做的      if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright); 有什么区别 我的做法是为了队列而队列  你的代码就伟大光正唯一正确? 人为何能如此自大呢 还水平特别低[/quote] c语言就大一学过以后，没怎麽用过，我还以为你的queue是一个容量为1，就是递归顺序输出的1 2 3 4  5 6 7 8，  我一般用java和python，是我想的很局限了，当时我想的只是 return fun（） + fun（） 这种递归，它自己本身就是深度优先，所以觉得bfs应该不行，但是如果在里面维护一个队列就又可以bfs了，挺神奇的，学习到了，em。

引用 23 楼 lin5161678 的回复:[quote=引用 20 楼 user-2 的回复:] 二叉树的 左右存的孩子结点 你这算啥     arr[0].pleft = arr+1;     arr[0].pright = arr+2;     arr[1].pleft = arr+3;     arr[1].pright = arr+4;     arr[2].pleft = arr+5;     arr[2].pright = arr+6; 你看不出这是存了左右节点?? arr[0].pleft = arr+1; 看不懂? 这个等于 arr[0].pleft = &arr[1]; 能理解吗  arr[0].pleft 左节点是一个结构体指针  我用数组元素的地址给这个节点赋值  所以节点0的左子节点是节点1 能看懂吗 你是不是没学过指针??  [/quote] 嗯 学习到了 指针忘了 你这麽讲就明白了

引用 22 楼 lin5161678 的回复:[quote=引用 21 楼 user-2 的回复:] 一般 书上都是对的吧，循环不能转化为递归的，举个极端的例子 ，比如   while True:     print(0)      def dg():     print("0")     dg() dg() 我用while True可以无限打印 0  但是 递归会爆栈请百度一下尾递归[/quote] 那尾递归无限输出可以不爆栈吗？

引用 15 楼 user-2 的回复:一本书上说的，我说了也不算，书上原话是： 所有递归都可以转化为循环  并没有所有循环可以转化为递归这句话，但是我觉得应该是这样，循坏可以无限复杂，递归不一样，一个正向，一个逆向，个人观点，递归人脑算起来复杂度很高死读书?? 关于是不是 全部循环都能改为递归 我也不多说什么了 就举例一个Haskell语言 知道你不会 但你总听说过吧?? 这个语言 没有循环  需要用到循环的操作 这里全部得用递归处理  你体会一下

引用 16 楼 user-2 的回复:你这段程序解决是什么问题，在哪里体现的是广度优先，你把数组换成二叉树，用队列去维护里面的结点还差不多，一层一层递归出来，这个不借助一些其它标识应该做不到，而且这为了用队列用队列，这个也说不上来是什么吧，进去了就出来了，到这儿吧，争论也没啥意义， 哪里体现的是广度优先 我好奇这段代码 怎么就不是广度优先了?? 二叉树是  广度优先遍历输出 1234567 有什么不对 你是不是没写过广度优先遍历的代码? 导致你根本认不出来 ================================ 数组换成二叉树     arr[0].pleft = arr+1;     arr[0].pright = arr+2;     arr[1].pleft = arr+3;     arr[1].pright = arr+4;     arr[2].pleft = arr+5;     arr[2].pright = arr+6;这一段就是数组转换二叉树你看不懂吗 你是不是没学过二叉树? ================================ 为了用队列用队列 请你写一写广度优先的代码 然后你自己评价一下你的代码是不是 为了用队列用队列 ================================ 行吧 偷懒硬编码一个二叉树你看不懂 dfs建立一个二叉树可以了把 数组元素做二叉树节点不认识 new节点总认识了吧 请问 这段代码是不是递归的 广度优先的遍历了一个二叉树??  #include <iostream> #include <queue> using namespace std;   struct node {     int data;     node* pleft, *pright; };  node* dfs() { 	int n; 	scanf("%d", &n); 	if(n == 0) 		return NULL; 	node* pnode = new node; 	pnode->data = n; 	pnode->pleft = dfs(); 	pnode->pright = dfs(); 	return pnode;  }   void dfsfree(node* phead) { 	if(phead == NULL) 		return; 	dfsfree(phead->pleft); 	dfsfree(phead->pright); 	delete phead;  }   void recursion(queue<node*>& q) {     if(q.empty())     {         return;     }     node* pnode = q.front();     q.pop();     cout << pnode->data << endl;     if(pnode->pleft != NULL)         q.push(pnode->pleft);     if(pnode->pright != NULL)         q.push(pnode->pright);     recursion(q); }   void bfs(node* head) {     queue<node*> q;     q.push(head);     recursion(q); }   int main(int argc, char *argv[]) {     node* phead = dfs();     bfs(phead);     dfsfree(phead);     return 0; }

引用 16 楼 user-2的回复:[quote=引用 14 楼 lin5161678 的回复:][quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 你这段程序解决是什么问题，在哪里体现的是广度优先，你把数组换成二叉树，用队列去维护里面的结点还差不多，一层一层递归出来，这个不借助一些其它标识应该做不到，而且这为了用队列用队列，这个也说不上来是什么吧，进去了就出来了，到这儿吧，争论也没啥意义，[/quote] 你没看出这个数组就是二叉树??

引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 你这段程序解决是什么问题，在哪里体现的是广度优先，你把数组换成二叉树，用队列去维护里面的结点还差不多，一层一层递归出来，这个不借助一些其它标识应该做不到，而且这为了用队列用队列，这个也说不上来是什么吧，进去了就出来了，到这儿吧，争论也没啥意义，

引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 这个有什么实际意义吗，  引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 不是我说的 书上说的，书上的原话是： 所有的递归都可以转化为循环  引用 14 楼 lin5161678 的回复:[quote=引用 11 楼 user-2 的回复:] 是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下[/quote] 一本书上说的，我说了也不算，书上原话是： 所有递归都可以转化为循环  并没有所有循环可以转化为递归这句话，但是我觉得应该是这样，循坏可以无限复杂，递归不一样，一个正向，一个逆向，个人观点，递归人脑算起来复杂度很高

引用 11 楼 user-2 的回复:是所有递归都可以用循环实现  不是所有循环都可以递归的  先把这个搞清楚再说  看我上面的例子，看看还能不能明白，深度优先和广度优先的本质区别在数据结构上的表现就是一个是栈一个是队列， #include <iostream> #include <queue> using namespace std;  struct node { 	int data; 	node* pleft, *pright; };  void recursion(queue<node*>& q) { 	if(q.empty()) 	{ 		return; 	} 	node* pnode = q.front(); 	q.pop(); 	cout << pnode->data << endl; 	if(pnode->pleft != NULL) 		q.push(pnode->pleft); 	if(pnode->pright != NULL) 		q.push(pnode->pright); 	recursion(q); }  void bfs(node* head) { 	queue<node*> q; 	q.push(head); 	recursion(q); }  int main(int argc, char *argv[]) { 	node arr[7] = { 0 }; 	 	for(int i=0; i<7; ++i) 		arr[i].data = i+1; 		 	arr[0].pleft = arr+1; 	arr[0].pright = arr+2; 	arr[1].pleft = arr+3; 	arr[1].pright = arr+4; 	arr[2].pleft = arr+5; 	arr[2].pright = arr+6; 	bfs(arr); 	return 0; }  这不就是递归的广度优先么  还有你说  引用不是所有循环都可以递归的 请你写一个不能写为递归的循环 谢谢 我还真没遇到不能该为递归的循环 想学习一下

所有循环都能用递归实现 广度优先能用循环实现 所以广度优先必然可以用递归实现

引用 6 楼 user-2的回复:引用 3 楼 lin5161678 的回复:当然可以 只是没必要 各个方面都不如直接循环    别误导人了，就是实现不了，程序的递归就是深度优先，只有遍历才能实现广度优先 所有循环都能用递归实现 认为不行是你见识少


Question: pwm控制霓虹灯

看代码都看晕了，可以精简一点吗

课程设计 拖尾灯

啥问题？没看明白