Question: c语言

可以

自嗨啊

楼主这一波，很强势，可以的。

void killdoublemore(int n,int arr[n]) 该函数参数建议直接写成： void killdoublemore(int n,int *arr)

这是我自己修改后的代码。。。。。结贴了 #include <stdio.h> #include <stdlib.h> void killdoublemore(int n,int arr[n]); int main(void) { 	int Knumber; 	int n; 	puts("此程序删除输入数据中重复的数"); 	puts("请输入要输入的个数"); 	scanf("%d",&n); 	int arr[n]; 	printf("请输入 %d 个数\n",n); 	for(int i = 0; i < n; i ++) 		scanf("%d",&arr[i]); 		killdoublemore(n,arr); 		system("pause"); 		return 0; 	 } void killdoublemore(int n,int arr[n]) { 		for(int i = 0; i < n; i ++) 		{ 			for(int j = 0; j < n; j ++) 			{ 				if((arr[i]==arr[j])&&i==j) 				continue; 				else if(arr[i]==arr[j]) 				arr[j] = '#'; 			} 		} 		for(int i = 0; i < n; i ++) 		{ 			if(arr[i]=='#') 			continue; 			else  			printf("%d  ",arr[i]); 			if((i>=10)&&(i%10==0)) putchar('\n'); 		} }

。。。。。又搞错了，scanf（）忘了加&了。。。。。解决了，。。可以结贴了

搞错了。。。。函数开头的k打成大写了嘻嘻，但是编译通过后还是运行不了 求解

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。  请那些喜欢将数组作为函数参数传来传去或作为函数返回值的码农思考一下为什么不把整个互联网内容当作函数参数传来传去或作为函数返回值呢？


Question: C语言写文件，文件指针回退后，如何停止文件？后面的内容不要了

引用 1 楼 wwww200808008 的回复:先读afile文件判断要读到什么位置，然后再重头开始读afile 一边读afile一边写bfile，读到你前面知道的停止位置。 随着读a随着写b呢，是知道A的读到的位置的，我的问题是a中有几行不知道是否要保留。需要先按照保留来做，但是发现这几行不要的话，需要将写文件的指针回调，覆盖写入新的内容，但是新内容短的话，需要如何停止文件？谢谢

引用 2 楼 sys0613 的回复:[quote=引用 1 楼 wwww200808008 的回复:] 先读afile文件判断要读到什么位置，然后再重头开始读afile 一边读afile一边写bfile，读到你前面知道的停止位置。 随着读a随着写b呢，是知道A的读到的位置的，我的问题是a中有几行不知道是否要保留。需要先按照保留来做，但是发现这几行不要的话，需要将写文件的指针回调，覆盖写入新的内容，但是新内容短的话，需要如何停止文件？谢谢[/quote]  我的意思就是没必要用回调，你是如何知道那个位置的那段内容你需要替换，需要替换成什么内容先自己记下。后面根据写bfile文件的时候你从afile中重头开始读，到你前面知道的位置再写入你记下的内容。

HANDLE hFile=(HANDLE)_get_osfhandle(fileno(f));

SetEndOfFile The SetEndOfFile function moves the end-of-file (EOF) position for the specified file to the current position of the file pointer.   BOOL SetEndOfFile(   HANDLE hFile   // handle of file whose EOF is to be set );   Parameters hFile  Handle to the file to have its EOF position moved. The file handle must have been created with GENERIC_WRITE access to the file.  Return Values If the function succeeds, the return value is nonzero.  If the function fails, the return value is zero. To get extended error information, call GetLastError.   Remarks This function can be used to truncate or extend a file. If the file is extended, the contents of the file between the old EOF position and the new position are not defined.   If you called CreateFileMapping to create a file-mapping object for hFile, you must first call UnmapViewOfFile to unmap all views and call CloseHandle to close the file-mapping object before you can call SetEndOfFile.  QuickInfo   Windows NT: Requires version 3.1 or later.   Windows: Requires Windows 95 or later.   Windows CE: Requires version 1.0 or later.   Header: Declared in winbase.h.   Import Library: Use kernel32.lib.  See Also File I/O Overview, File Functions, CloseHandle, CreateFile, CreateFileMapping, UnmapViewOfFile


Question: 急。。。为什么输出的结果与输入不一样，请求各位大神指点一二

问题已解决， 原来是我太大意了


Question: 一道多项式加法的问题

仅供参考：//链表实现一元多项式的加法减法乘法 #include <stdio.h> #include <stdlib.h> typedef struct node {     float coef;   //系数     int expn;     //指数     struct node *next; } PolyNode;      //多项式节点 polynomial node typedef PolyNode* Polynomial; Polynomial createPolynomial() {  //创建多项式     PolyNode *p, *q, *head = (PolyNode *)malloc(sizeof(PolyNode));   //头节点     head->next = NULL;     float coef;     int expn;     printf("输入该多项式每一项的系数和指数，每项一行，输入0 0结束！\n");     while (scanf("%f %d", &coef, &expn) && coef) {   // 默认，按指数递减排列         if (head->next) {             p = head;             while (p->next && expn < p->next->expn)                 p = p->next;             if (p->next) {                 if (expn == p->next->expn) { //有相同指数的直接把系数加到原多项式                     p->next->coef += coef;                     if (p->next->coef > -0.000001 && p->next->coef < 0.000001) { //若是相加后系数为0，则舍弃该节点                         q = p->next;                         p->next = q->next;                         free(q);                     }                 } else {                     q = (PolyNode*)malloc(sizeof(PolyNode));                     q->coef = coef;                     q->expn = expn;                     q->next = p->next;                     p->next = q;                 }             } else {                 p->next = (PolyNode*)malloc(sizeof(PolyNode));                 p = p->next;                 p->coef = coef;                 p->expn = expn;                 p->next = NULL;             }         } else {             head->next = (PolyNode*)malloc(sizeof(PolyNode));             head->next->coef = coef;             head->next->expn = expn;             head->next->next = NULL;         }     }     return head; } Polynomial multiply(Polynomial poly, float coef, int expn) {  //多项式与指定单项式相乘，该单项式为 coefx^expn     PolyNode *p, *q, *Poly = (PolyNode*)malloc(sizeof(PolyNode));     p = Poly;     q = poly->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = (q->coef*coef);         p->expn = (q->expn + expn);         q = q->next;     }     p->next = NULL;     return Poly; } void add(Polynomial poly1, Polynomial poly2) {  //把 poly2 加到 poly1 上     PolyNode *p, *q, *r;     r = poly1;     p = poly1->next;  //指向第一个节点     q = poly2->next;     poly2->next = NULL;     while (p && q) {         if (p->expn > q->expn) {             r->next = p;             p = p->next;             r = r->next;         } else if (p->expn < q->expn) {             r->next = q;             q = q->next;             r = r->next;         } else {             PolyNode *t;             p->coef += q->coef;             if (!(p->coef > -0.000001 && p->coef < 0.000001)) //系数不为0             {                 r->next = p;                 r = r->next;                 p = p->next;             } else {                 t = p;                 p = p->next;                 free(t);             }             t = q;             q = q->next;             free(t);         }     }     if (p)         r->next = p;     if (q)         r->next = q; } Polynomial polySubtract(Polynomial poly1, Polynomial poly2) {  //多项式减法 poly1-poly2形成一个新的多项式     //把poly2的系数取相反数，形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode)); //构造头节点     PolyNode *p, *q;     p = poly;     q = poly2->next;     while (q) {         p->next = (PolyNode*)malloc(sizeof(PolyNode));         p = p->next;         p->coef = -(q->coef);  //系数取反         p->expn = q->expn;         q = q->next;     }     p->next = NULL;     add(poly, poly1);  //利用加法     return poly; } Polynomial polyAdd(Polynomial poly1, Polynomial poly2) { //多项式相加 poly1+poly2形成一个新的多项式     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //和多项式的头节点     poly->next = NULL;     PolyNode *p, *q, *r;     r = poly;     p = poly1->next;     q = poly2->next;     while (p&&q) {         if (p->expn > q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = p->coef;             r->expn = p->expn;             p = p->next;         } else if (p->expn < q->expn) {             r->next = (PolyNode*)malloc(sizeof(PolyNode));             r = r->next;             r->coef = q->coef;             r->expn = q->expn;             q = q->next;         } else {             float m = p->coef + q->coef;             if (!(m > -0.000001 && m < 0.000001)) {                 r->next = (PolyNode*)malloc(sizeof(PolyNode));                 r = r->next;                 r->coef = m;                 r->expn = p->expn;             }             q = q->next;             p = p->next;         }     }     while (p) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = p->coef;         r->expn = p->expn;         p = p->next;     }     while (q) {         r->next = (PolyNode*)malloc(sizeof(PolyNode));         r = r->next;         r->coef = q->coef;         r->expn = q->expn;         q = q->next;     }     r->next = NULL;     return poly; } Polynomial polyMultiply(Polynomial poly1, Polynomial poly2) {  //多项式相乘     Polynomial poly = (PolyNode*)malloc(sizeof(PolyNode));  //创建多项式和的头节点     poly->next = NULL;     PolyNode *p;     p = poly2->next;     while (p) {         add(poly, multiply(poly1, p->coef, p->expn));         p = p->next;     }     return poly; } void printPoly(Polynomial poly) {  //打印多项式     if (poly && poly->next) {         PolyNode *p = poly->next;  //p指向第一个节点         while (p->next) {             printf("%gx^%d", p->coef, p->expn);             p = p->next;             if (p && (p->coef > 0))                 printf("+");         }         if (p->expn == 0)             printf("%g", p->coef);   //打印常数项         else             printf("%gx^%d", p->coef, p->expn);         printf("\n");     } } void freePoly(Polynomial poly) {  //释放内存     if (poly && poly->next) {         PolyNode *p, *q;         p = poly;         while (p) {             q = p->next;             free(p);             p = q;         }     }     poly = NULL; } int main() {     printf("用链表实现多项式的加减法\n");     Polynomial poly1, poly2, poly3;     printf("创建多项式一\n");     poly1 = createPolynomial();     printf("多项式一：\n");     printPoly(poly1);     printf("创建多项式二\n");     poly2 = createPolynomial();     printf("多项式二：\n");     printPoly(poly2);     printf("两多项式相加，和为：\n");     poly3 = polyAdd(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两个多项式相乘，积为：\n");     poly3 = polyMultiply(poly1, poly2);     printPoly(poly3);     freePoly(poly3);     printf("两多项式相减，差为：\n");     poly3 = polySubtract(poly1, poly2);     printPoly(poly3);     freePoly(poly1);     freePoly(poly2);     freePoly(poly3);     system("pause");     return 0; }

引用 2 楼 zihui0459 的回复:[quote=引用 1 楼 qq_27186411 的回复:] P=(Polynomial)sizeof(struct PolyNode); 这句是什么是在分配空间[/quote]  Polynomial t1,t2,P,Rear,t; P=(Polynomial)malloc(sizeof(PolyNode)); P->coef=10; P->expon=10; P->link=NULL; t1=P1; t2=P2;  P=(Polynomial)sizeof(struct PolyNode);  P->link=NULL; Rear=P;  malloc哪去了，而且这还分配了两遍？

引用 1 楼 qq_27186411 的回复:P=(Polynomial)sizeof(struct PolyNode); 这句是什么是在分配空间


Question: VS系列的IDE都是收费的吗？之前用VS2015但试用期到了用不了.有没免费的？

可以注册登录微软账号，服务器会自动更新许可证

引用 3 楼 a1qwertyuiop1 的回复:安装vs2015社区版弹出这个窗口怎么办？  应该是你之前装的试用版没有卸载完全，比如注册表之类的。 百度一下，全部卸载再安装试试

引用 3 楼 a1qwertyuiop1 的回复:安装vs2015社区版弹出这个窗口怎么办？  我一年前装的，没遇到过这个问题，可能你可以试一下装2017版的

搜“彻底卸载VS2015”

网上搜索专业版和企业版的密钥即可

你不知道windows系统都是收费的么？

安装vs2015社区版弹出这个窗口怎么办？

VS不是有社区版吗，那就是免费的啊

百度如何破解vs2015


Question: 请教一个关于输出ASCII码字符的为题

0～31及127(共33个)是控制字符或通信专用字符（其余为可显示字符），如控制符：LF（换行）、CR（回车）、FF（换页）、DEL（删除）、BS（退格)、BEL（响铃）等；通信专用字符：SOH（文头）、EOT（文尾）、ACK（确认）等；ASCII值为8、9、10 和13 分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示，但会依不同的应用程序，而对文本显示有不同的影响。 以上选自百度百科: https://baike.baidu.com/item/ASCII#5 我测试时是WINDOWS自带的cmd命令窗口，输出为‘梅花’。猜测，VS2015的调试输出窗口和这个cmd对ASCII码值为5的处理不同，导致显示不同；或在查找符号时，查找结果不同。

仅供参考：#pragma comment(lib,"user32") #pragma comment(lib,"gdi32") #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <windows.h> wchar_t a2w[256]={ 0x0020,0x263a,0x263b,0x2665,0x2666,0x2663,0x2660,0x2022, 0x25d8,0x25cb,0x25d9,0x2642,0x2640,0x266a,0x266b,0x263c, 0x25ba,0x25c4,0x2195,0x203c,0x00b6,0x00a7,0x25ac,0x21a8, 0x2191,0x2193,0x2192,0x2190,0x221f,0x2194,0x25b2,0x25bc, 0x0020,0x0021,0x0022,0x0023,0x0024,0x0025,0x0026,0x0027, 0x0028,0x0029,0x002a,0x002b,0x002c,0x002d,0x002e,0x002f, 0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037, 0x0038,0x0039,0x003a,0x003b,0x003c,0x003d,0x003e,0x003f, 0x0040,0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047, 0x0048,0x0049,0x004a,0x004b,0x004c,0x004d,0x004e,0x004f, 0x0050,0x0051,0x0052,0x0053,0x0054,0x0055,0x0056,0x0057, 0x0058,0x0059,0x005a,0x005b,0x005c,0x005d,0x005e,0x005f, 0x0060,0x0061,0x0062,0x0063,0x0064,0x0065,0x0066,0x0067, 0x0068,0x0069,0x006a,0x006b,0x006c,0x006d,0x006e,0x006f, 0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077, 0x0078,0x0079,0x007a,0x007b,0x007c,0x007d,0x007e,0x2302, 0x00c7,0x00fc,0x00e9,0x00e2,0x00e4,0x00e0,0x00e5,0x00e7, 0x00ea,0x00eb,0x00e8,0x00ef,0x00ee,0x00ec,0x00c4,0x00c5, 0x00e9,0x00e6,0x00c6,0x00f4,0x00f6,0x00f2,0x00fb,0x00f9, 0x00ff,0x00d6,0x00dc,0x00a2,0x00a3,0x00a5,0x20a7,0x0192, 0x00e1,0x00ed,0x00f3,0x00fa,0x00f1,0x00d1,0x00aa,0x00ba, 0x00bf,0x2310,0x00ac,0x00bd,0x00bc,0x00a1,0x00ab,0x00bb, 0x2591,0x2592,0x2593,0x2502,0x2524,0x2561,0x2562,0x2556, 0x2555,0x2563,0x2551,0x2557,0x255d,0x255c,0x255b,0x2510, 0x2514,0x2534,0x252c,0x251c,0x2500,0x253c,0x255e,0x255f, 0x255a,0x2554,0x2569,0x2566,0x2560,0x2550,0x256c,0x2567, 0x2568,0x2564,0x2565,0x2559,0x2558,0x2552,0x2553,0x256b, 0x256a,0x2518,0x250c,0x2588,0x2584,0x258c,0x2590,0x2580, 0x03b1,0x00df,0x0393,0x03c0,0x03a3,0x03c3,0x00b5,0x03c4, 0x03a6,0x0398,0x03a9,0x03b4,0x221e,0x03c6,0x03b5,0x2229, 0x2261,0x00b1,0x2265,0x2264,0x2320,0x2321,0x00f7,0x2248, 0x00b0,0x2219,0x00b7,0x221a,0x207f,0x00b2,0x25a0,0x00ff, }; extern "C" HWND WINAPI GetConsoleWindow(); void HideTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = FALSE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } void ShowTheCursor() {     CONSOLE_CURSOR_INFO cciCursor;     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);      if(GetConsoleCursorInfo(hStdOut, &cciCursor)) {         cciCursor.bVisible = TRUE;         SetConsoleCursorInfo(hStdOut, &cciCursor);     } } int main() {     HWND  hwnd;     HDC   hdc;     HFONT hfont;     wchar_t ws[256];     unsigned char s[256];     int i;       system("color F0");     system("cls");     HideTheCursor();     hwnd  = GetConsoleWindow();     hdc   = GetDC(hwnd);     hfont = CreateFont(16,  0, 0, 0, 0, 0, 0, 0, 0           , 0, 0, 0, 0, "Lucida Console");     SelectObject(hdc,hfont);     TextOutW(hdc,10,10,L"你好",2);     for (i=0;i<256;i++) s[i]=i;     for (i=0;i<256;i++) ws[i]=a2w[s[i]];     TextOutW(hdc,10, 40,ws    ,32);     TextOutW(hdc,10, 80,ws+ 32,32);     TextOutW(hdc,10,120,ws+ 64,32);     TextOutW(hdc,10,160,ws+ 96,32);     TextOutW(hdc,10,200,ws+128,32);     TextOutW(hdc,10,240,ws+160,32);     TextOutW(hdc,10,280,ws+192,32);     TextOutW(hdc,10,320,ws+224,32);     DeleteObject(hfont);     ReleaseDC(hwnd,hdc);     getch();     system("color 07");     system("cls");     ShowTheCursor();     return 0; }

引用 5 楼 mashinas 的回复:[quote=引用 3 楼 cfjtaishan 的回复:] Oct   Dec   Hex   Char                        Oct   Dec   Hex   Char        ────────────────────────────────────────────────────────────────────────        000   0     00    NUL '\0' (null character)   100   64    40    @        001   1     01    SOH (start of heading)      101   65    41    A        002   2     02    STX (start of text)         102   66    42    B        003   3     03    ETX (end of text)           103   67    43    C        004   4     04    EOT (end of transmission)   104   68    44    D        005   5     05    ENQ (enquiry)               105   69    45    E        006   6     06    ACK (acknowledge)           106   70    46    F        007   7     07    BEL '\a' (bell)             107   71    47    G        010   8     08    BS  '\b' (backspace)        110   72    48    H        011   9     09    HT  '\t' (horizontal tab)   111   73    49    I        012   10    0A    LF  '\n' (new line)         112   74    4A    J        013   11    0B    VT  '\v' (vertical tab)     113   75    4B    K        014   12    0C    FF  '\f' (form feed)        114   76    4C    L        015   13    0D    CR  '\r' (carriage ret)     115   77    4D    M        016   14    0E    SO  (shift out)             116   78    4E    N        017   15    0F    SI  (shift in)              117   79    4F    O        020   16    10    DLE (data link escape)      120   80    50    P        021   17    11    DC1 (device control 1)      121   81    51    Q        022   18    12    DC2 (device control 2)      122   82    52    R        023   19    13    DC3 (device control 3)      123   83    53    S        024   20    14    DC4 (device control 4)      124   84    54    T        025   21    15    NAK (negative ack.)         125   85    55    U        026   22    16    SYN (synchronous idle)      126   86    56    V        027   23    17    ETB (end of trans. blk)     127   87    57    W        030   24    18    CAN (cancel)                130   88    58    X        031   25    19    EM  (end of medium)         131   89    59    Y        032   26    1A    SUB (substitute)            132   90    5A    Z        033   27    1B    ESC (escape)                133   91    5B    [        034   28    1C    FS  (file separator)        134   92    5C    \  '\\'        035   29    1D    GS  (group separator)       135   93    5D    ]        036   30    1E    RS  (record separator)      136   94    5E    ^        037   31    1F    US  (unit separator)        137   95    5F    _        040   32    20    SPACE                       140   96    60    `        041   33    21    !                           141   97    61    a        042   34    22    "                           142   98    62    b        043   35    23    #                           143   99    63    c        044   36    24    $                           144   100   64    d        045   37    25    %                           145   101   65    e        046   38    26    &                           146   102   66    f        047   39    27    '                           147   103   67    g        050   40    28    (                           150   104   68    h        051   41    29    )                           151   105   69    i        052   42    2A    *                           152   106   6A    j        053   43    2B    +                           153   107   6B    k        054   44    2C    ,                           154   108   6C    l        055   45    2D    -                           155   109   6D    m        056   46    2E    .                           156   110   6E    n        057   47    2F    /                           157   111   6F    o         060   48    30    0                           160   112   70    p        061   49    31    1                           161   113   71    q        062   50    32    2                           162   114   72    r        063   51    33    3                           163   115   73    s        064   52    34    4                           164   116   74    t        065   53    35    5                           165   117   75    u        066   54    36    6                           166   118   76    v        067   55    37    7                           167   119   77    w        070   56    38    8                           170   120   78    x        071   57    39    9                           171   121   79    y        072   58    3A    :                           172   122   7A    z        073   59    3B    ;                           173   123   7B    {        074   60    3C    <                           174   124   7C    |        075   61    3D    =                           175   125   7D    }        076   62    3E    >                           176   126   7E    ~        077   63    3F    ?                           177   127   7F    DEL   ASCII的值。5对应的ASCII码是不能像ABCD那样输出的。 我是跟着网上的八皇后算法视频学习的，视频同样的方法就能输出想要的东西，有什么办法吗[/quote] 你对比一下你们的编译环境

引用 3 楼 cfjtaishan 的回复:Oct   Dec   Hex   Char                        Oct   Dec   Hex   Char        ────────────────────────────────────────────────────────────────────────        000   0     00    NUL '\0' (null character)   100   64    40    @        001   1     01    SOH (start of heading)      101   65    41    A        002   2     02    STX (start of text)         102   66    42    B        003   3     03    ETX (end of text)           103   67    43    C        004   4     04    EOT (end of transmission)   104   68    44    D        005   5     05    ENQ (enquiry)               105   69    45    E        006   6     06    ACK (acknowledge)           106   70    46    F        007   7     07    BEL '\a' (bell)             107   71    47    G        010   8     08    BS  '\b' (backspace)        110   72    48    H        011   9     09    HT  '\t' (horizontal tab)   111   73    49    I        012   10    0A    LF  '\n' (new line)         112   74    4A    J        013   11    0B    VT  '\v' (vertical tab)     113   75    4B    K        014   12    0C    FF  '\f' (form feed)        114   76    4C    L        015   13    0D    CR  '\r' (carriage ret)     115   77    4D    M        016   14    0E    SO  (shift out)             116   78    4E    N        017   15    0F    SI  (shift in)              117   79    4F    O        020   16    10    DLE (data link escape)      120   80    50    P        021   17    11    DC1 (device control 1)      121   81    51    Q        022   18    12    DC2 (device control 2)      122   82    52    R        023   19    13    DC3 (device control 3)      123   83    53    S        024   20    14    DC4 (device control 4)      124   84    54    T        025   21    15    NAK (negative ack.)         125   85    55    U        026   22    16    SYN (synchronous idle)      126   86    56    V        027   23    17    ETB (end of trans. blk)     127   87    57    W        030   24    18    CAN (cancel)                130   88    58    X        031   25    19    EM  (end of medium)         131   89    59    Y        032   26    1A    SUB (substitute)            132   90    5A    Z        033   27    1B    ESC (escape)                133   91    5B    [        034   28    1C    FS  (file separator)        134   92    5C    \  '\\'        035   29    1D    GS  (group separator)       135   93    5D    ]        036   30    1E    RS  (record separator)      136   94    5E    ^        037   31    1F    US  (unit separator)        137   95    5F    _        040   32    20    SPACE                       140   96    60    `        041   33    21    !                           141   97    61    a        042   34    22    "                           142   98    62    b        043   35    23    #                           143   99    63    c        044   36    24    $                           144   100   64    d        045   37    25    %                           145   101   65    e        046   38    26    &                           146   102   66    f        047   39    27    '                           147   103   67    g        050   40    28    (                           150   104   68    h        051   41    29    )                           151   105   69    i        052   42    2A    *                           152   106   6A    j        053   43    2B    +                           153   107   6B    k        054   44    2C    ,                           154   108   6C    l        055   45    2D    -                           155   109   6D    m        056   46    2E    .                           156   110   6E    n        057   47    2F    /                           157   111   6F    o         060   48    30    0                           160   112   70    p        061   49    31    1                           161   113   71    q        062   50    32    2                           162   114   72    r        063   51    33    3                           163   115   73    s        064   52    34    4                           164   116   74    t        065   53    35    5                           165   117   75    u        066   54    36    6                           166   118   76    v        067   55    37    7                           167   119   77    w        070   56    38    8                           170   120   78    x        071   57    39    9                           171   121   79    y        072   58    3A    :                           172   122   7A    z        073   59    3B    ;                           173   123   7B    {        074   60    3C    <                           174   124   7C    |        075   61    3D    =                           175   125   7D    }        076   62    3E    >                           176   126   7E    ~        077   63    3F    ?                           177   127   7F    DEL   ASCII的值。5对应的ASCII码是不能像ABCD那样输出的。 我是跟着网上的八皇后算法视频学习的，视频同样的方法就能输出想要的东西，有什么办法吗

引用 2 楼 qq_38204686 的回复:出来的这个小黑框 点右键 属性 字体 设置大点  最大 变成大框框了

出来的这个小黑框 点右键 属性 字体 设置大点

我猜测应该是字符集之类的问题 像是65就能很好的输出A


Question: 怎么把版本号转成16进制

谢谢，找到解决方法了

OpenSSL不是开源的吗？


Question: 新手求教关于strstr函数

管道传输时，不是以行为单位的。 你需要缓冲管道收到的内容，自己分成一行一行的，再使用strstr过滤。

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

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

check_msq(){     FILE *fp;     if ((fp = popen("mysqlcheck -c smarthome -uroot -pcocloud", "r")) == NULL) {         //perror("popen failed");         printf("-1-1-1-1-1-1-1\n");     }     char buf[256];     while (fgets(buf, 255, fp) != NULL) { 		 		//printf("%s", buf);     } 	if(NULL == strstr(buf,"Error")){ 		printf("-2-2-2-2-2-2-2\n"); 		pclose(fp); 		return -1; 	}else{ 		printf("-3-3-3-3-3-3\n"); 		return 0; 	}   代码如上，现在怎么样都会返回-2-2-2，求大神帮我看看。


Question: 用VS2015能顺利编译，但用VC编译后却出现如下错误:

#include"stdio.h"  void bubble_sort(int *arr, int len); void function(int a[3][4]){     int i,j,b,n;     for(i=0;i<=2;i++)         for(b=0;b<=2;b++)             for(j=b;j<=3;j++)                 if(a[i][b]>a[i][j]){                     n=a[i][b];                     a[i][b]=a[i][j];                     a[i][j]=n;                 } } int main() {     int i,j,u;     u=0;     int c[3][4]={{3,2,7,3},{4,6,88,9},{33,45,777,22}}; #if 0     function(c); #else     int row = 3, col = 4;     for (i = 0; i < row; i++)         bubble_sort(c[i], col); #endif     for(i=0;i<=2;i++){         printf("{");         for(j=0;j<=3;j++)             printf("%d ",c[i][j]);         printf("}\n");         u++;         if(u==3)             printf("\b ");     } }  void bubble_sort(int *arr, int len) {     int i, j;     int tmp;      for (i = 0; i < len; i++)         for (j = 0; j < len - 1 - i; j++)             if (arr[j] > arr[j+1]) {                 tmp = arr[j];                 arr[j] = arr[j+1];                 arr[j+1] = tmp;             } } 解决你排序的一种方法；可以参考一下； 另外，你的编译错误应该是跟编译器有关，出错的编译器版本应该比较老，不支持最新或者较新的C标准。 建议改一下，所有的定义都放在前面； 把u赋值放在这条语句前面；  u = 0; //这样试试 for(i=0;i<=2;i++){

u=0;  int c[3][4]={{3,2,7,3},{4,6,88,9},{33,45,777,22}};  这两行互换下，可能是编译器只支持在开头定义变量

编译没问题，不代表运行没问题； 现在运行没问题，不代表将来运行没问题。

引用 1 楼 zhao4zhong1 的回复:偶遇到类似问题都是用 “每次用/*...*/注释掉不同部分再重新编译，直到定位到具体语法出错的位置。” 的方法解决的。 但我用VS2015编译却没问题？


Question: 猜数字项目最简算法，比谁的程序猜测总次数最少

你这个难度有点大啊

引用 3 楼 kugeniha 的回复:参考下:  #include <stdio.h> #include <stdlib.h> #include <time.h> #include <string.h> #define M 4 //猜几个数字   //交换  void swap(int*a,int*b)  { 	int t=*a; 	 *a=*b; 	*b=t;  }  //将数组随机打乱   void random_shuffle(int* a,int n)  { 	int i; 	 for(i=0;i<n;i++) 	{ 		int x=rand()%n; 		int y=rand()%n; 		if(x!=y) swap(a+x,a+y); 	}  }   //生成数位不重复的M位全部数据，存在数组a中，并打乱，备用   int  gen(int* a)  { 	int count=0,i,j; 	int max=1; 	for(i=0;i<M;++i,max*=10);  		for(i=0;i<max;++i) 		{ 			int flag[10]={0}; 			int t=i; 			for(j=0;j<M;++j) 				if(flag[t%10]) break; 				else flag[t%10]=1,t/=10; 	if(j==M) 		a[count++]=i;  	} 	random_shuffle(a,count); 	return count; }  void test(int answer,int player,int* A,int* B)  { 	int i=0,j;  	int answer_a[M]={0},player_a[M]={0}; 	*A=*B=0; 	while(answer||player) 	{ 		answer_a[i]=answer%10; 		player_a[i++]=player%10; 		answer/=10; 		player/=10; 	 } 	for(i=0;i<M;++i) 	for(j=0;j<M;++j) 		if(player_a[i]==answer_a[j]) 			if(i==j) ++*A; 			else ++*B; }  //参数AB是上一轮猜测的反馈，  //如果得到猜中的信息表示下一把的开始  int guess(int *a,int n)  {  //你的工作在这个函数  		int A=M,B=0,OA; 		int count_cur=0; 		int i,j,num,p; 		char arr[5],new_arr[5],ch; 		int flag[4]={0}; 		printf("The answer is %d\n",a[n]);//先给出答案，用以验证 		for(i=0,j=0;i<10;i++,++count_cur) 		{ 			if(4==M) 				num=i*1111; 			else  				num=i*111; 			test(a[n],num,&A,&B); 			printf("%d:%0*d,%dA%dB\n",count_cur,M,num,A,B); 			if(A==1) arr[j++]=i+48; 			if(M==j) break; 		}//经此for循环，得出要猜的数由哪些数字组成 		arr[M]=0;//尾0 		num=atoi(arr); 		//printf("%d",numA); 		test(a[n],num,&A,&B); 		count_cur++; 		printf("%d:%0*d,%dA%dB\n",count_cur,M,num,A,B); 		OA=A;//标记上一次猜测的数的位置与数都正确的个数 		if(A==M&&B==0) 		{ 			printf("答案是%s\n",arr); 			return count_cur; 		}//如果猜测与答案一样，显示答案，返回猜测步数 		p=0; 		for(i=0;i<M;i=p) 		{ 			strncpy(new_arr,arr,M); 			new_arr[M]=0; 			if(0==flag[i])//定义数组flag初始为0,表示对应下标的位置不正确，正确了后置1 			{ 				for(j=i+1;j<M;j++) 				{ 					if(0==flag[j]) 					{ 						new_arr[j]=arr[i]; 						num=atoi(new_arr); 						//printf("num=%d\n",num); 						count_cur++; 						test(a[n],num,&A,&B); 						printf("%d:%0*d,%dA%dB\n",count_cur,M,num,A,B); 						if(A>OA) //arr[i]在此次j位上，交换 						{ 							flag[j]=1; 							ch=arr[j]; 							arr[j]=arr[i]; 							arr[i]=ch; 							num=atoi(arr); 							count_cur++; 							test(a[n],num,&A,&B);//交换之后0A有可能在原基础上加1，也可能加二，所以直接调用test算出准确OA 							printf("%d:%0*d,%dA%dB\n",count_cur,M,num,A,B); 							OA=A; 							p=i; 							break; 						} 						else if(A<OA) //说明此位置原本数对应正确的位置，不可改变，对应下标置1 						{	 							flag[j]=1; 							new_arr[j]=arr[j]; 						} 					} 				}//找正确位置 				if(M==j)  				{ 					flag[i]=1; 					p=i+1; 				}//一轮for循环，没找到正确位置，说明本身所在的位置是正确的。 			} 			else p=i+1; 			//printf("p=%d\n",p); 		} 		printf("答案是%s\n",arr); 		return count_cur;  }  int main()  {     int i;  //初始生成数据      int len; 	int *a; 	int  n=3,nn=n;//玩n把     int count=0;//总猜测次数     for(len=1,i=0;i<M;++i)     len*=10-i;     a=(int *)malloc(sizeof(int)*len);	 	srand((unsigned)time(NULL)); 	//srand(2);     gen(a);  //开玩     while(n--)     { 		int count_cur=0;      //每把从猜中开始，例如玩4个数，4A0B为猜中， //此时进入下一把，会有新的数供猜测   //printf("%d\n",a[n]); 		count_cur=guess(a,n); 		printf("此轮共%d步完成\n",count_cur); 		count+=count_cur;     } 	printf("游戏结束,共计%d轮游戏,总消耗%d步\n",nn,count); 	system("pause");     return 0;  }    老哥 还能再优化一下吗，步数能减少一点就减少一点，注释再稍微详细一点，我是萌新看不懂现在就可以把分给你。

老哥这还能再优化一下吗，步数能减少一点就减少一点，注释再稍微详细一点，我是萌新看不懂现在就可以把分给你。

百度搜相关关键字。


Question: 请教一个关于代码里调用winsat的问题~

引用 10 楼 zhao4zhong1 的回复:你完全可以在资源管理器中的winsat.exe上点鼠标右键，选择以管理员身份运行。 额。。。 我的应用场景大概是这样的，正在做一个直播推流软件，在做用户引导时需要检测一下用户电脑的各项评分，然后给用户推荐相应的推流设置。。。。总不能让用户自己去运行啊~

引用 9 楼 zwfgdlc 的回复:提示什么错误呢 代码大概如下： （细节拼写错误请忽略） SHELLEXECUTEINFO shExInfo = { shExInfo.cbSize           = sizeof(shExInfo); shExInfo.hwnd             = 0; shExInfo.lpVerb           = L"runas";  /* Operation to perform */ shExInfo.lpFile           = "WinSAT.exe";    /* Application to start */ shExInfo.lpParameters     = "disk -xml disk.xml"; /* Additional parameters */ shExInfo.lpDirectory      = cwd; shExInfo.nShow            = SW_NORMAL; shExInfo.hInstApp         = 0; ShellExecuteEx(shExInfo);  运行后的cmd窗口会提示找不到WinSAT.exe。即使改成 shExInfo.lpFile  = "C:\\Windows\\System32WinSAT.exe";依旧提示找不到文件，很是不懂。

引用 12楼我是你的主体 的回复:[quote=引用 10 楼 zhao4zhong1 的回复:] 你完全可以在资源管理器中的winsat.exe上点鼠标右键，选择以管理员身份运行。 额。。。 我的应用场景大概是这样的，正在做一个直播推流软件，在做用户引导时需要检测一下用户电脑的各项评分，然后给用户推荐相应的推流设置。。。。总不能让用户自己去运行啊~[/quote]PVOID pOld; 	Wow64DisableWow64FsRedirection(&pOld); 明白了，文件重定向，你这是32位的程序，加上这个关闭重定向

百度搜“如何编程设置某个exe以管理员身份运行”

C:\>runas /? RUNAS 用法:  RUNAS [ [/noprofile | /profile] [/env] [/savecred | /netonly] ]         /user:<UserName> program  RUNAS [ [/noprofile | /profile] [/env] [/savecred] ]         /smartcard [/user:<UserName>] program     /noprofile        指定不应该加载用户的配置文件。                      这会加速应用程序加载，但                      可能会造成一些应用程序运行不正常。    /profile          指定应该加载用户的配置文件。                      这是默认值。    /env              要使用当前环境，而不是用户的环境。    /netonly          只在指定的凭据限于远程访问的情况下才使用。    /savecred         用用户以前保存的凭据。                      Windows XP Home Edition 上没有这个选项。                      该选项会被忽略。    /smartcard        如果凭据是智能卡提供的，则使用这个选项。    /user             <UserName> 应使用 USER@DOMAIN 或 DOMAIN\USER 形式    program           EXE 的命令行。请参阅下面的例子  例如: > runas /noprofile /user:mymachine\administrator cmd > runas /profile /env /user:mydomain\admin "mmc %windir%\system32\dsa.msc" > runas /env /user:user@domain.microsoft.com "notepad \"my file.txt\""  注意:  只在得到提示时才输入用户的密码。 注意:  USER@DOMAIN 跟 /netonly 不兼容。 注意:  /profile 跟 /netonly 不兼容。 注意:  /savecred 跟 /smartcard 不兼容。

引用 2 楼 zhao4zhong1 的回复://假定winsat.exe在d:\mydir文件夹下： WinExec(_T("cmd /c cd /d d:\\mydir&winsat disk -xml disk.xml"),SW_HIDE); 试试看。 试了一下也没有效果~  cmd必须要以管理员权限执行winsat XXX命令才可以。 不明白为什么我用shellexecute + "runas"参数不起作用了~可是我查windows的文档也没说这个函数不能用了啊~

有没有大佬可以指点一下萌新~  这个问题纠结了一天了。。

提示什么错误呢

引用 5 楼 zhao4zhong1 的回复:WinExec(_T("cmd /c runas /user:administrator \"cd /d d:\\mydir&winsat disk -xml disk.xml\""),SW_HIDE); 参考您在某个帖子中的回复： http://bbs.csdn.net/topics/390684999 为什么这个net命令可以运行，但是winsat不能运行呢？

引用 5 楼 zhao4zhong1 的回复:WinExec(_T("cmd /c runas /user:administrator \"cd /d d:\\mydir&winsat disk -xml disk.xml\""),SW_HIDE); 感谢大神的回复~  上面的命令貌似可以~但是程序里面不希望跳出控制台的黑框，并且也不会去提示用户输入administrator的密码。 我想知道有没有某个windows的API可以直接以管理员身份去启动cmd，而不会出现任何提示呢？


Question: 数据结构栈typedef的一些小问题

打个比方，头文件好比一个仓库货物的清单。当需要从仓库中提货时，首先从清单里查找对应物品存放在位置，和少量的备注信息。这样，再到仓库中去取货时更快更准确。如果一个仓库同时存在两个货物清单，然而这两个清单上的信息并不是完全相同，这时看清单的人就不知道哪个清单上的信息是正确的。为了避免这种情况，就发明了只用一个“清单”，也就是避免重复编译。

引用 3 楼 zihui0459 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] 第一句防止重复引入头文件，但是还需要加一句#define _Stack_h，建议使用大写。 struct node是声明类型；可以用你加的这句替换，类型是一样的。 剩下的是函数声明，是可以放到main中，如果这些函数会被其他源文件里的函数调用，只是在main的源文件里声明还是不够的。所以，考虑到这一点，还是建议把函数声明放到这个头文件里。如果，这些声明函数只在main所在的源文件里调用，那么放到main所在的源文件里声明是可以的。  #ifndef _STACK_H #define _STACK_H struct Node; typedef struct Node *PtrToNode; typedef PtrToNode stack; int IsEmpty(Stack S); Stack CreateStack(void); void DisposeStack(Stack S); void MakeEmpty(Stack S); void Push(int X,Stack S); int Top(Stack S); void Pop(Stack S); #endif能详细说下为什么要引入头文件吗，头一次看到需要写这个东西[/quote] 头文件一般会存放一些类型定义，声明，变量定义和声明（全局的），以及函数的声明（内联函数定义）；放在头文件里可以让代码更有条理性，头文件可以被多个源文件包含，提高了复用性

引用 1 楼 ccssddnn218 的回复:第一句的Stack h是什么 防止重复编译。  第二句的struct Node；是在干什么呢？ 声明Node是一种结构类型(struct)。  代码中后面有结构体的定义，typedef那两句可以用typedef struct Node* stack一句代替吗？ 可以。  剩下的那些语句都是在进行函数声明吗？ 是。  （函数声明）放在main（）中是否也可以？ 不可以。能详细说下为什么要引入头文件吗，头一次看到需要写这个东西

引用 2 楼 cfjtaishan 的回复:第一句防止重复引入头文件，但是还需要加一句#define _Stack_h，建议使用大写。 struct node是声明类型；可以用你加的这句替换，类型是一样的。 剩下的是函数声明，是可以放到main中，如果这些函数会被其他源文件里的函数调用，只是在main的源文件里声明还是不够的。所以，考虑到这一点，还是建议把函数声明放到这个头文件里。如果，这些声明函数只在main所在的源文件里调用，那么放到main所在的源文件里声明是可以的。  #ifndef _STACK_H #define _STACK_H struct Node; typedef struct Node *PtrToNode; typedef PtrToNode stack; int IsEmpty(Stack S); Stack CreateStack(void); void DisposeStack(Stack S); void MakeEmpty(Stack S); void Push(int X,Stack S); int Top(Stack S); void Pop(Stack S); #endif能详细说下为什么要引入头文件吗，头一次看到需要写这个东西


Question: 关于malloc和free的一些小问题

Readpoly 函数里面，先申请了头节点，后释放，如果不需要，可以不用申请头结点。add函数里面，指数相同时，系数想加，指数不用想加，还要考虑相加等于0情况，合并的时候改变两条链表间的指向，就不用再申请空间了，同时释放

可以这样赋值，因为指针变量的赋值也是值赋值，就是将p指向的地址空间（首地址值）赋值给t1, t2，这样t1,t2和p一样，指向同一内存空间，t1和t2可以像p一样对这块内存空间进行操作；  malloc申请空间是为了用，那么free是相反的，即不需要malloc申请的空间了，那就释放，防止内存泄露。对于链表，一般会在删除某个节点时，需要释放该节点；还有就是程序推出之前，需要释放整个链表时，需要调用free逐个释放节点。

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

t1=p; t2=p; 只不过是让t1和t2都指向那块已经分配好的内存而已，并没有分配新的内存，最后也只需释放一次

t1=p; t2=p后，三个指针都向同一块堆内存， 用其中任何一个指针来free都行，free的是指针指向的内存，不是指针本身，所以很明显的只能free一次堆内存。 至于什么时候free，就是你认为不再使用那块堆内存的时候。


Question: 关于qsort的问题

小心驶得万年船。

这个是leetcode自己传进来的int，难道传进来就越界了？

1403617094, -490450406, ...这些数的绝对值很大，怕是 int 中放不下吧

qsort没问题，是你的int越界了

没有吧，我测试的数字没有问题啊。

你写的cmp函数bug


Question: 杭电OJ判断Runtime Error (ACCESS_VIOLATION)

可以去搜索最大组数组的问题，http://blog.csdn.net/liufeng_king/article/details/8632430这个博客你可以看一看，大概就会懂了

最好把题目说出     来

or(j=1;j<=IntegerNumber;j++)         {             scanf("%d",&integer[j]); ///输入数组             if( start == 0 && integer[j] >= 0 )///确定第一个大于等于零的数作为起始位                 start = j ;         } 这个地方有可能导致越界，比如输入的IntegerNumber为1000，这个地方就越界了。下标从0开始， or(j=0;j<IntegerNumber;j++)         {             scanf("%d",&integer[j]); ///输入数组             if( start == 0 && integer[j] >= 0 )///确定第一个大于等于零的数作为起始位                 start = j ;         } 另外，对于大数组，建议定义成全局的或者静态变量。栈上的空间是稀少和宝贵的，不建议占用栈上的过多空间。  static int integer[1000];     int CaseNumber ; ///情况数     int IntegerNumber ;///每一种情况包含的数字个数     static int MaxSum[1000] ;

在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。


Question: 程序判断不正确，求指教

引用 2 楼 xian_wwq 的回复: if (0 < c < 5 && 23 <= c <=24)  这个条件是永远无法满足的 应该是 0 < c < 5 ||  23 <= c <=24吧 嗯嗯，这个事项对时间进行判断，有点想当然了

引用 1 楼 cfjtaishan 的回复:#include<stdio.h> #include<math.h>  int dayFee(int a) {     int fee1;      if(a > 0 && a <= 3){         fee1 = 13 + 1;     }else if(3 < a){         fee1 = (a - 3) * 2.3 + 12 + 1;     }else{     }     return fee1; }  int nightFee(int b) {     int fee2;      if(b > 0 && b <= 3){         fee2 = 13 + 1;     }else if (b > 3) {         fee2 = (b - 3) * 1.2 * 2.3 + 12 + 1;     }else{     }      return fee2; }  int timeNumber(int c, int d) {     int fee;      if(c >= 5 && c < 23){         dayFee(d);         return fee = dayFee(d);     }else if ((c > 0 && c < 5) && (c >= 23 && c <= 24)){         nightFee(d);         return fee = nightFee(d);     }else{         printf("error c\n");         return 0;     } }  int main() {     timeNumber(9, 12);     printf("work fee: %d\n", timeNumber(9, 12));     timeNumber(18, 12);     printf("down fee: %d\n", timeNumber(18, 12));     printf("all fee : %d\n", timeNumber(9, 12) + timeNumber(18, 12));     return 0; } 注意你的if判断，表达式有问题，建议复习一下判断表达式的写法。 了解了，请问一下，关于时间的判断有没有什么更好的方法，就是函数里的数值c


Question: 猜数字

我这有这个游戏的exe

有HTML版本的没？

不明白guess函数要写什么功能。

猜数字，计算机随机生成1个3或4位的十进制整数，各个数位上的数字各不相同，用户给出猜测，计算机回答XAYB（X个位置和数字猜中，Y个数字猜中但位置错误），重复用户猜计算机回答的过程，直到猜中为止（3A0B，4A0B）。 这里，将给出若干组相关的数据供猜测（即第i把猜123，第j把不可能是123）。比谁的程序猜测的总次数最少。 文件“猜数字测试代码.txt”是给学生的，函数int guess(int A,int B)是学生需要完成的，其中参数A和B就是计算机根据上次猜测返回的结果，若是3A0B（以猜3个数为例），表示新一把猜测的开始。目前，guess中的代码，可供人机交互，学生提交时应该删除。 文件“8数码拼图测试代码.txt”是提供给教师的，这里简单地采用“随机+排除”的方法（但针对的是不相关的数据），猜3个数的和人的水平差不多，猜4个数比人厉害。    这是要求


Question: 如何把编译好C文件后生成的exe可执行文件单独保存下来，使得能够在其他没有编译器的电脑能独立正常运行？

引用 6 楼 JILAU_WHO_AM_I_Q234 的回复:不对，system（）和getchar只是为了程序运行完了后停止让你能看到运行结果 system("pause")可以理解，但是如果用了getchar()函数岂不是最后结束时需要  引用 6 楼 JILAU_WHO_AM_I_Q234 的回复:不对，system（）和getchar只是为了程序运行完了后停止让你能看到运行结果 谢谢，我知道了，我试过两个都有效。只是没想到getchar还可以这样用。

学会使用depends.exe查看exe依赖的dll

引用 2 楼 JILAU_WHO_AM_I_Q234 的回复:可以，但是要看你的程序最后有没有停止退出的设置例如在return前加一句getchar()或者system("pause")都可以停止，因为没有这些语句，运行exe文件后，程序是运行了，但是会马上退出，所以要暂停，才能看到结果 是不是可以这样理解。只要是程序中有等待输入的函数，比如scanf（），程序就不会闪退，可执行文件就可以移植运行吧？

引用 1 楼 waji2000 的回复:看提到win10，就以windows系统为例： 一般来说就是：静态链接库与动态链接库。 若使用的是静态链接库，则可以直接运行，而不需要一堆的支持dll。 否则需要安装最小运行支持环境。 你好，我学C不深，对于静态动态库什么的还没了解到，不是很了解。我现在写的程序比较简单，如果只是做简单的输入输出以及用到了stdio.h window.h string.h等头文件，这样的程序可以直接移植可执行文件吗？


Question: C语言循环问题，真的见鬼了！！！

引用 2 楼 Pantree00的回复:这是卡布列克常数，我已经知道哪里出了问题。非常感谢你的回答。 学习了！

这是卡布列克常数，我已经知道哪里出了问题。非常感谢你的回答。

当n==6174的时候跳出循环? 感觉这个有点难吧


Question: 关于scanf函数使用的一点困惑

引用 11 楼 Lucien_zhou的回复:[quote=引用 10 楼 qq_38204686 的回复:] [quote=引用 8 楼 Lucien_zhou的回复:][quote=引用 7 楼 qq_38204686 的回复:] 关于你的第一个例子 输入:第一个字符\n 得到并输出 第一个字符 缓冲区还有 \n  输入:\n第二个字符\n 得到并输出 第二个字符 缓冲区还有\n  s 不会接受\n c 会接受\n 如果第二个输入格式是%c 就直接跳了 你说的这些我是明白的，但你感觉没弄清楚我困惑的地方？我的困惑是，如果按你说的，我两次scanf和printf操作之后，输入缓冲区已经存了两个换行符\n的话，那为什么后面的两次getchar，只有一个getchar取到了缓冲区的换行符，而另一个getchar却要等待键盘输入？[/quote] 前面那个换行符被覆盖了 我前面那一行行的推理下来不就只剩一个/n了么...[/quote] 哦哦，我重新看了下，那第二个输入是：\nxxx\n，但scanf 在输入 %s 的时候不会接受\n，所以scanf接受输入后存储的为 xxx\n，那不就相当于第一个输入的字符串的换行符\n在第二次输入字符串的时候，存储输入的字符串的时候丢弃了?[/quote] 嗯 可以这么说 虽然我不知道它到底是怎么样工作的 但结果就是丢弃 就像我先前发的链接 在有数据之前所有分隔符%s都不会读取 有数据才会读取 直到下一个分隔符 这个时候缓冲区里只有最后那个分隔符了 也就是最后一个回车

http://blog.csdn.net/weiweicsdn1/article/details/52185453 谢谢楼上的各位，scanf还有一个特性，就是忽略先导的空白符。不管是有几百个回车也好，几万个空格也罢，只要它们连续地出现在缓冲区的开头，就统统忽略他们。

引用 10 楼 qq_38204686 的回复:[quote=引用 8 楼 Lucien_zhou的回复:][quote=引用 7 楼 qq_38204686 的回复:] 关于你的第一个例子 输入:第一个字符\n 得到并输出 第一个字符 缓冲区还有 \n  输入:\n第二个字符\n 得到并输出 第二个字符 缓冲区还有\n  s 不会接受\n c 会接受\n 如果第二个输入格式是%c 就直接跳了 你说的这些我是明白的，但你感觉没弄清楚我困惑的地方？我的困惑是，如果按你说的，我两次scanf和printf操作之后，输入缓冲区已经存了两个换行符\n的话，那为什么后面的两次getchar，只有一个getchar取到了缓冲区的换行符，而另一个getchar却要等待键盘输入？[/quote] 前面那个换行符被覆盖了 我前面那一行行的推理下来不就只剩一个/n了么...[/quote] 哦哦，我重新看了下，那第二个输入是：\nxxx\n，但scanf 在输入 %s 的时候不会接受\n，所以scanf接受输入后存储的为 xxx\n，那不就相当于第一个输入的字符串的换行符\n在第二次输入字符串的时候，存储输入的字符串的时候丢弃了?

引用 8 楼 Lucien_zhou的回复:[quote=引用 7 楼 qq_38204686 的回复:] 关于你的第一个例子 输入:第一个字符\n 得到并输出 第一个字符 缓冲区还有 \n  输入:\n第二个字符\n 得到并输出 第二个字符 缓冲区还有\n  s 不会接受\n c 会接受\n 如果第二个输入格式是%c 就直接跳了 你说的这些我是明白的，但你感觉没弄清楚我困惑的地方？我的困惑是，如果按你说的，我两次scanf和printf操作之后，输入缓冲区已经存了两个换行符\n的话，那为什么后面的两次getchar，只有一个getchar取到了缓冲区的换行符，而另一个getchar却要等待键盘输入？[/quote] 前面那个换行符被覆盖了 我前面那一行行的推理下来不就只剩一个/n了么...

第一个例子中的测试用例中两次scanf 以及printf 之后，getchar 获取了一次换行符\n，我让它输出了，为10，但后面的第二个getchar函数是在等待键盘输入的，我用ctrl+c退出了

引用 7 楼 qq_38204686 的回复:关于你的第一个例子 输入:第一个字符\n 得到并输出 第一个字符 缓冲区还有 \n  输入:\n第二个字符\n 得到并输出 第二个字符 缓冲区还有\n  s 不会接受\n c 会接受\n 如果第二个输入格式是%c 就直接跳了 你说的这些我是明白的，但你感觉没弄清楚我困惑的地方？我的困惑是，如果按你说的，我两次scanf和printf操作之后，输入缓冲区已经存了两个换行符\n的话，那为什么后面的两次getchar，只有一个getchar取到了缓冲区的换行符，而另一个getchar却要等待键盘输入？

引用 5 楼 Lucien_zhou 的回复:[quote=引用 3 楼 qq_38204686 的回复:] [quote=引用 2 楼 Lucien_zhou的回复:]可是如果scanf把\n留在输入缓冲区，那我输入两次，缓冲区里不就应该有两个\n，可我自己的第一个例子里，在输入输出两次后，我用了两个getchar，根据测试结果看，缓冲区里应该只有一个\n，这个也是我困惑的。 缓冲区里有的 %s 读入的时候分隔符不读入 所以你误以为没有 你这俩例子不是证明了么[/quote] 不对的，以我自己的第一个例子来看，我在scanf 输入一次，printf输出一次，然后再scanf输入一次，printf 输出一次，这两次操作之后，我使用了两个getchar ，只有一个getchar获取到了回车符，第二个getchar是在等待键盘输入，那如果输入缓冲区内有两个回车符为什么第二个getchar 是需要从键盘输入？[/quote] 我的表述有误，因为就像你给的链接一样，我两次回车，存储的是换行符\n，而不是回车\r\n，但我困惑于到底我的第一个例子中输入缓冲区中有几个换行符？测试用例看应该是一个，不然第二个为什么从键盘输入？

引用 3 楼 qq_38204686 的回复:[quote=引用 2 楼 Lucien_zhou的回复:]可是如果scanf把\n留在输入缓冲区，那我输入两次，缓冲区里不就应该有两个\n，可我自己的第一个例子里，在输入输出两次后，我用了两个getchar，根据测试结果看，缓冲区里应该只有一个\n，这个也是我困惑的。 缓冲区里有的 %s 读入的时候分隔符不读入 所以你误以为没有 你这俩例子不是证明了么[/quote] 不对的，以我自己的第一个例子来看，我在scanf 输入一次，printf输出一次，然后再scanf输入一次，printf 输出一次，这两次操作之后，我使用了两个getchar ，只有一个getchar获取到了回车符，第二个getchar是在等待键盘输入，那如果输入缓冲区内有两个回车符为什么第二个getchar 是需要从键盘输入？

引用 2 楼 Lucien_zhou的回复:可是如果scanf把\n留在输入缓冲区，那我输入两次，缓冲区里不就应该有两个\n，可我自己的第一个例子里，在输入输出两次后，我用了两个getchar，根据测试结果看，缓冲区里应该只有一个\n，这个也是我困惑的。 缓冲区里有的 %s 读入的时候分隔符不读入 所以你误以为没有 你这俩例子不是证明了么

scanf并不会把\n丢弃，在执行前两句时候输入字符串，并回显没问题，但是scanf把\n留在缓冲区，下一个getchar把\n读取并以十进制打印


Question: 再看数组、二维数组和指针

引用 3 楼 happyendingzhb 的回复:[quote=引用 2 楼 ipqtjmqj 的回复:] 在C中，在几乎所有使用数组名的表达式中，数组名的值是一个指针常量，也就是数组第1个元素的地址 ----------------------------- 这句好像不对。数组的值就是数组的内容，比如char a[5]; 那么sizeof(a)结果为5. 之所以造成是个指针的假象，是因为c语言是弱类型语言，数组在传参是会隐式转成指向在首个元素的指针。 这个我是从《c专家编程》这本书里看来的。 《C专家编程》哪里？我查查看[/quote] download.csdn.net搜索c专家编程就有下载

引用 2 楼 ipqtjmqj 的回复:在C中，在几乎所有使用数组名的表达式中，数组名的值是一个指针常量，也就是数组第1个元素的地址 ----------------------------- 这句好像不对。数组的值就是数组的内容，比如char a[5]; 那么sizeof(a)结果为5. 之所以造成是个指针的假象，是因为c语言是弱类型语言，数组在传参是会隐式转成指向在首个元素的指针。 这个我是从《c专家编程》这本书里看来的。 《C专家编程》哪里？我查查看

引用 6 楼 happyendingzhb 的回复:[quote=引用 4 楼 ipqtjmqj 的回复:] [quote=引用 3 楼 happyendingzhb 的回复:] [quote=引用 2 楼 ipqtjmqj 的回复:] 在C中，在几乎所有使用数组名的表达式中，数组名的值是一个指针常量，也就是数组第1个元素的地址 ----------------------------- 这句好像不对。数组的值就是数组的内容，比如char a[5]; 那么sizeof(a)结果为5. 之所以造成是个指针的假象，是因为c语言是弱类型语言，数组在传参是会隐式转成指向在首个元素的指针。 这个我是从《c专家编程》这本书里看来的。 《C专家编程》哪里？我查查看[/quote] download.csdn.net搜索c专家编程就有下载[/quote]哪一章节？[/quote] 随便看一下目录应该很容易发现吧

引用 4 楼 ipqtjmqj 的回复:[quote=引用 3 楼 happyendingzhb 的回复:] [quote=引用 2 楼 ipqtjmqj 的回复:] 在C中，在几乎所有使用数组名的表达式中，数组名的值是一个指针常量，也就是数组第1个元素的地址 ----------------------------- 这句好像不对。数组的值就是数组的内容，比如char a[5]; 那么sizeof(a)结果为5. 之所以造成是个指针的假象，是因为c语言是弱类型语言，数组在传参是会隐式转成指向在首个元素的指针。 这个我是从《c专家编程》这本书里看来的。 《C专家编程》哪里？我查查看[/quote] download.csdn.net搜索c专家编程就有下载[/quote]哪一章节？

标准有规定数组的地址一定要和首元素的地址相等吗？

http://edu.csdn.net/course/detail/2516 C语言指针与汇编内存地址-三.数组和二维数组


Question: 可视化程序问题

C++ Builder是什么？  　　C++ Builder是基于可视组件技术和C++语言的快速应用程序开发工具。C++ Builder的前身是Borland C++，而Borland C++最早是Turbo C，在DOS界面编程的年代，对于每一个工科学生，几乎是无人不知。学习C++ Builder最常用的版本是C++ Builder 6.0，C++ Builder 2010等，最新的版本还支持iOS、安卓平台软件的开发。 　　Windows是图形用户界面（Graphical User Interface）操作系统，标准的Windows应用程序也是图形用户界面的。传统上，SDK方式开发Windows应用程序的GUI界面是一个很繁琐的工作，界面相关的代码量甚至占到项目总代码量的一半以上，而且业务逻辑代码和界面相关的代码是混杂在一起的，难以扩展、重用和维护。 　　C++ Builder是真正的可视化的开发工具。C++ Builder可以用鼠标拖拉控件加上设置属性轻松的“设计”出一个程序的图形用户界面，利用可视的组件/控件像“搭积木”一样，以“所见即所得”的方式搭建应用程序的界面，这也是C++ Builder这个名字中Builder的概念。这样，只需要用C++语言编写业务逻辑代码，类似于DOS下文本界面编程，只要专注于实现业务逻辑功能就可以了，代码非常简洁。数据的输入和表现，都在图形用户界面，非常直观、易用。这就是RAD开发（Rapid Application Development，快速应用程序开发）。 　　VCL是Visual Component Library的缩写，即可视组件库，它是Delphi和C++ Builder编程语言的基本类库。VCL以组件化、可视化为设计方向，是新一代的应用程序框架（Framework）。它拥有封装纯粹、可扩展性强、操作方便等特点。如果是一个非常繁杂的Win32 API，在经过VCL封装后，使用也是非常简便的。VCL对事件的支持及封装也是非常完整的，通过事件对象的声明，可以将任意的外部事件源绑定到VCL控件。 　　在VCL类库中，窗体和每一种控件都是一个类，它们和基类（比如TObject、TControl、TWinControl类等）之间通过继承关系，共同组成了VCL类库，基类有一些共同的属性、方法和事件，控件类比如TButton（按钮类）继承了它的基类的属性、方法和事件，并增加了它自己的一些属性和方法。VCL中还有一些不可视的组件（组件（Component）概念上包括可视的控件（Control）和不可视的组件），比如TTimer（定时器）。VCL类库支持了C++ Builder的RAD开发。 　　C++ Builder的VCL类库和Visual C++的MFC类库是同一个级别的概念，VCL比MFC出现较晚，在技术架构上领先了一代。它的PME架构（Property属性、Method方法、Event事件）也是VCL类库和RAD开发的基础。

界面都是浮云，不过可以使用界面库，可以结合自己的兴趣爱好，发展方向，学一个界面库。

换语言，MFC,VB,QT,C#，没有最快只有更快。。。      C语言也可以，类似代码上学的时候也写过，也参考过别人的，但是流程你恐怕没有精力和必要去学（如果你是没有任何windows编程基础，然后追求快速学会的情况，不是这种情况是精通windows编程，只用过MFC做，会分分钟学会）。。。       用C语言写windows的一个最不可思议的事是要用MFC的资源编辑器去编辑对话框资源文件（拒绝MFC，手敲资源文件也可，一般人做不到，而且这么搞的一定是傻的）。。那么问题来了，我为什么不直接用MFC呢？？？       学习用C语言做界面的时间，要大于学C#去做界面的时间，即便是你会C语言，而完全不会C#。

c++应该更好用吧

是的。qt很好用的 。。

QT 做界面，跨平台。

图形用户界面（GUI）编程可以学习C++ Builder，架构先进（和C#一样拖控件），入门比较容易。  C++ Builder的较新版本——RAD Studio XE3以上版本添加对iOS和Android的支持工具包，让开发者编写的Delphi/C++应用可以同时在Windows、OS X、iOS和Android平台上运行。现在最新版本是RAD Studio 10.2。  仅供参考： 初学者学习C++ Builder第一个程序（模拟聊天室），经典！ http://blog.163.com/tab_98/blog/static/11924097201693033057497/ C++ Builder绘图示例（模拟时钟） http://blog.163.com/tab_98/blog/static/11924097201611324819376/ 从C语言的菜单界面管理系统到C++ Builder的图形用户界面，一个简单的电话簿Demo例子 http://blog.163.com/tab_98/blog/static/1192409720158673337998/  C++ Builder写的《ZEC 纸牌游戏21点》 http://blog.163.com/tab_98/blog/static/119240972016115113039304/ C++ Builder写的《ZEC 僵尸版打地鼠》 http://blog.163.com/tab_98/blog/static/11924097201601084117748/ C++ Builder写的《ZEC 推箱子》 http://blog.163.com/tab_98/blog/static/11924097201612011839642/  书籍推荐： 《C++Builder 6程序设计教程（第二版）》 （陆卫忠，刘文亮　等编著 /2011-04-01 /科学出版社）（当当网） 《C++Builder 6编程实例精解》（赵明现），PDF，是数字版的，非扫描版的，里面还有一个俄罗斯方块游戏的完整实现。 《精彩C++Builder 6程序设计》（台湾 吴逸贤），里面有10几个简单小游戏的实现，可以自己看懂以后再重写，才是自己掌握的。 《C++ Builder 5高级编程实例精解》（刘滨 编著）都是较大的实用的程序。

引用 1 楼 棉猴的回复:用MFC啊，所见即所得  做出界面来直接调用c的代码么？我c#不太会

引用 1 楼 棉猴的回复:用MFC啊，所见即所得  这个我可以做出来，但是c#代码我不会

用MFC啊，所见即所得

VB6可视化程序设计(无锡职业技术学院)http://download.csdn.net/detail/zhao4zhong1/6824713

引用 3 楼 qq_38241541 的回复:[quote=引用 1 楼 棉猴的回复:]用MFC啊，所见即所得  做出界面来直接调用c的代码么？我c#不太会[/quote] 这是VS2015的MFC，你的C代码可以用在里面啊


Question: 求问一款无用函数清理工具

引用 2 楼 zhao4zhong1 的回复:楼上说了这么多，意思就是没必要清理无用函数。  这点无法认同，单独从一个场景下就可以否决了：  从代码的易读性来说，bug定位肯定是越快越好，在充斥着无用函数的项目，会对定位bug造成无畏的干扰。  尤其在无用函数较多并且函数名还相近的时候。当然，也许有人会说，函数内部放几个打印开关，然后在调试软件上试一遍不就知道调用哪个函数了吗？ 我认为这个方法并不妥当，一个是耗时，另一个个是有些情况下并不被允许打开打印开关，尤其是对于已经商用的产品代码。

太过依赖git或svn,不是什么好习惯。因为版本管理软件不能备份整个软硬件环境。

引用 5 楼 zhao4zhong1 的回复:因为历史总是会惊人地相似。  过去被淘汰的做法，现在很可能再次启用； 同样， 现在被淘汰的做法，未来很可能再次使用。  我觉得不应该以未来的非确定需求决定现有的系统设计，这样会造成冗余并且使设计增加部分不合理性，TDD与极限编程思想里推崇的一般也只是“轻设计”或者“不设计”理念。  其实去除无用代码如果未来需要重新启用的话，可以用git或者svn回复。  其实我个人感觉在实际项目开发中，也许无用代码未来会被启用，但是当启用时会发现，早前写的代码已经很大程度上不再适用现有的代码需求了，因为中间加入了许多迭代功能开发，需要考虑的波及分析也比较多，最后导致其实和重写并无不同。  以上仅是个人观点。

请深刻理解1楼内容。

楼上说了这么多，意思就是没必要清理无用函数。

请牢记：源代码本身的书写是否结构化或面向对象或符合设计模式或敏捷…并不重要，重要的是你是否使用结构化或面向对象或符合设计模式或敏捷…的方法命名标识符、阅读、修改、检查、测试源代码。  意思是你程序结构看上去再合理，再简洁，也不一定比看上去一团乱麻的程序结构在运行或修改时更不易出错，更方便修改，出错了更容易找到哪里出错和具体出错的原因，更容易改正错误。  试对比 图书馆（对图书的分类够结构化了吧） 和 搜索引擎（可看作是扁平化任何结构数据，仅支持全文检索） 哪个处理信息更方便、更高效。  所以 与其费劲去重构代码让其看上去更简洁、更合理 不如费劲学习grep、sed、awk、……这类全文搜索和批处理编辑的工具。  结构越复杂，越难修改，越难除错。 有时（甚至大多数时候），看上去越合理、越简洁的代码，运行起来性能越差，出错时查找原因越难，找到出错原因后改正越费劲。  程序员要做的不是尽力避免错误，而是聚焦在快速发现并改正错误。真正以快速方式轻易解决错误，“快速的失败”远胜过“预防错误”。Fred George  前微软C#编辑器的开发主管Jay Bazuzi列出的一些有助于找到正确方向的问题；他觉得前同事们应该用这些问题来问自己；实际上不管在哪里工作的开发者们都应该经常问问自己这些问题： ◆“要保证这个问题不会再出现，我该怎么做？” ◆“要想少出些Bug，我该怎么做？” ◆“要保证Bug容易被修复，我该怎么做？” ◆“要保持对变化的快速响应，我该怎么做？” ◆“要保证我的软件的运行速度，我该怎么做？” 如果大多数团队都能不时问一下自己，必定会从中得益，因为这些都是真正强而有力的问题。


Question: 求助大佬

函数返回的是结构体，你用结构体指针接收的，统一一下类型就好了

改完后提示：error C2115: '=' : incompatible types  stu = FindByName(sTranscript, 5, name);  是这一行两边不匹配 可能是我下边的那个函数类型就不对，返回值匹配不了 请问应该怎么改啊

if(arra==str[i].cName)	 改为       if (0==strcmp((char *)arra,(char *)(str[i].cName))


Question: 求大神卡看一下这个switch哪里出错了，感谢

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

写代码时，先按 Ctrl+A 全选，再按 Alt+F8，可以将代码格式化，调整为正确的缩进。

这代码写的...建议写规范点啊  就不会漏了

每个switch都要加大括号把case都扩进去

已解决，漏了一个{},谢谢

帮结贴+蹭分


Question: 萌新写个指针的帖子吧，水平有限

《深入理解C指针》

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素


Question: malloc()问题

int len = sizeof(int);//不同平台的字节大小不一样,tc2.0是2个字节,vc++6是4字节 int* d = (int*)malloc(sizeof(int));//内存块大小取决平台  //下面这种可以移动位移3次指针 int p* = (int*)malloc(sizeof(int)*3); for(int i = 0;i < 3;i++){     p++;     printf("0x%0x\n",p); }

VMMap 是进程虚拟和物理内存分析实用工具。http://technet.microsoft.com/zh-cn/sysinternals/dd535533

引用 6 楼 qq_35637956 的回复:[quote=引用 4 楼 zhao4zhong1 的回复:] 其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。 虽然我听不懂但是肯定你说的是对的~[/quote] 推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

引用 2 楼 qq_35637956 的回复:那这个+1现在是不是已经越界了~! +1已经不能使用了。也算是越界。即使使用没问题，但是也不能使用，因为+1之后的空间可能会被其他使用。

引用 4 楼 zhao4zhong1 的回复:其实电脑开机后物理内存的每个字节中都有值且都是可读写的，从来不会因为所谓的new、delete或malloc、free而被创建、销毁。区别仅在于操作系统内存管理模块在你读写时是否能发现并是否采取相应动作而已。操作系统管理内存的粒度不是字节而是页，一页通常为4KB。 虽然我听不懂但是肯定你说的是对的~

编译器是不会特意的进行越界检查的

编译器在编译阶段不会进行边界检查，需要程序员自己保证不要越界，越界的结果是未定义的，可能数据还在，可能被擦除，总之自己要确保不能越界访问

判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

引用 1 楼 user-6 的回复:不是，随机分配的内存，+1越界有风险，可能会改变其他变量的数值，再+1有可能就真的越界了。malloc最好别这么用。  那这个+1现在是不是已经越界了~!

那这个+1现在是不是已经越界了~!


Question: 将数字从小到大进行排序，但输出这个结果，不知问题出在哪?

在main()函数里     for(i=0;i<=4;i++);       printf("%d ",a[i]); for循环后面多了一个分号，去掉即可。 如果加入了这个分号，实际上就是只有for循环而没有执行语句，在该for循环结束后，i的值是5， 此时再 printf("%d ",a[i]); 实际上输出的是a[5]，已经越界，所以输出是一个很大的负数。 关于for循环的知识请参考 http://blog.csdn.net/hou09tian/article/details/77001685


Question: 求大师解答

return 0；放外面试试

case  1: case  2:  中间有空格

引用 2 楼 cfjtaishan 的回复:#include <stdio.h>  int main() {     printf("请输入月份，我来判断天数。\n");     int month;     scanf("%d",&month);     switch(month)    /* drop ;*/     {     case 1:         printf("1月有31天\n");         break;      case 2:         printf("2月有28天，\n");         break;      case 3:         printf("3月有31天，\n");         break;      default:         printf("当前程序只判断1-3月的情况。\n");         break;    /* use break replace return */     }          return 0; } 两处错误，一处是switch后面多一个分号;，一处是case1，需要加分号，否则只能认为是一个未定义的变量； case 1中间需要加空格

引用 2 楼 cfjtaishan 的回复:#include <stdio.h>  int main() {     printf("请输入月份，我来判断天数。\n");     int month;     scanf("%d",&month);     switch(month)    /* drop ;*/     {     case 1:         printf("1月有31天\n");         break;      case 2:         printf("2月有28天，\n");         break;      case 3:         printf("3月有31天，\n");         break;      default:         printf("当前程序只判断1-3月的情况。\n");         break;    /* use break replace return */     }          return 0; } 两处错误，一处是switch后面多一个分号;，一处是case1，需要加分号，否则只能认为是一个未定义的变量； 还有一处注意点时，main函数要求返回值。原文中前面几处case都没有return值。 上面这位兄弟是正解。

楼主好好学习下c语音的case用法


Question: 字符串查找

只能循环比较了

#include <stdio.h>  int main(void) {     int i, size;     char  * paraName[] ={"One","csdn","test"}, str[32];      scanf("%s", str);     size = sizeof(paraName) / sizeof(paraName[0]);     for (i = 0; i < size; i++ )         if (0 == strcmp(paraName[i], str))             break;      if (i < size)         printf("pos = %d\n", i);     else         printf("Not found!\n"); } 遍历加比较

char  * paraName[] ={"One","csdn","test"};  int findstr(const char* test){     for(int i = 0; i < sizeof(paraName)/sizeof(char*); ++ i){         if(strcmp(paraName[i],test) == 0)             return i;     }     return -1; }


Question: 求助一个计算问题？

引用 3 楼 qq_38204686 的回复:[quote=引用 2 楼 qq_38204686 的回复:] 百度 long double 的输出格式 你格式正确呀 我用你的代码可以正确输出  我的编译器是vs2008 是不是你编译器不支持啊 [/quote] 非常感谢，确实是编译器的问题，我用vs2010可以正常输出！

#include <stdio.h> int main(void) {     double jl = 0l;                   //创建距离变量,单位英寸      const double yc = 12;                        //1英寸=12英尺,换算数  const double m = 3;                      //1码=3英尺,换算数      double yc1 = 0l;             //英尺      double mb = 0l;                 //码  printf("请输入一个距离单位为(英寸):");  scanf("%lf",&jl); yc1 = jl/yc;//英寸转换英尺  mb = yc1/m;//英尺转换码  printf("输入的距离为%lf(英寸)\n",jl); printf("转换为英尺为%lf(英尺)\n",yc1); printf("转换为码为%lf(码)\n",mb); return 0; }

试试llf           。

引用 2 楼 qq_38204686 的回复:百度 long double 的输出格式 你格式正确呀 我用你的代码可以正确输出  我的编译器是vs2008 是不是你编译器不支持啊

你的类型不对，int/double 这在计算是会出现问题的

这样就对了。

百度 long double 的输出格式

#include <stdio.h> int main(void) { 	long double jl = 0l;                   //创建距离变量,单位英寸      const int yc = 12;                        //1英寸=12英尺,换算数  	const int m = 3;                      //1码=3英尺,换算数  	long double yc1 = 0l;             //英尺      long double mb = 0l;                 //码  	printf("请输入一个距离单位为(英寸):");  	scanf("%lf",&jl); 	yc1 = jl/yc;//英寸转换英尺  	mb = yc1/m;//英尺转换码  	printf("输入的距离为%lf(英寸)\n",jl); 	printf("转换为英尺为%lf(英尺)\n",yc1); 	printf("转换为码为%lf(码)\n",mb); 	return 0; }  重发一下，前面一个注释挤一块去了。


Question: 线性表

引用 5 楼 cfjtaishan 的回复:[quote=引用 3 楼 zhao4zhong1 的回复:] 也有故意加分号的宏。 楼主这个地方加上就是”故意“给自己挖坑了。[/quote]  我自己好长时间不用了，所以忘记了，谢谢各位的指点

引用 3 楼 zhao4zhong1 的回复:也有故意加分号的宏。 楼主这个地方加上就是”故意“给自己挖坑了。

引用 3 楼 zhao4zhong1 的回复:也有故意加分号的宏。 加了分号，到时候会忘记。

也有故意加分号的宏。

感谢提醒，自己粗心大意疏忽了，好长时间不用宏定义忘记了不加分号~~~

#define 定义去掉后面的分号 宏定义是在预处理阶段等价替换，所以不能有分号


Question: 进程窗口状态如何获取和改变！！

搜“Session0 穿透”

我看了一下这个Session0 穿透，这个主要实现服务用语桌面用户的交互，我查看了我服务进程和业务进程都是在Session0 不存在Session 0 隔离，这是一点。还有就是我这边的问题主要是我业务进程是隐藏的，这是必须的，但是飞天诚信的PIN输入框却又依赖我的进程窗口状态（这个PIN码输入框是Key自带的）。所以我想问一下是否可以更改进程窗口状态来让PIN输入框显示出来，或者是不是有其他的方式来达到我的目的


Question: 寻求前辈帮忙看看代码的问题

现在版本的我控制了代码量，不是电脑的问题，我觉得代码是有问题的 引用 2 楼 user-1 的回复:我的电脑上不卡，暗影精灵2

我的电脑上不卡，暗影精灵2

代码不是很长，不用全部看完，我只需要一个解决办法就是了、


Question: 硬件编程的时钟概念？

提供频率，时钟脉冲用来同步。

数电 微机原理 把上面两本书学通了 简单点说 没有时钟 硬件无法工作


Question: 问一个C语言中结构方面的问题

引用 12 楼 cfjtaishan 的回复:[quote=引用 4 楼 qq_38263433 的回复:] [quote=引用 2 楼 cfjtaishan 的回复:] strict node *next是保存下一个node的地址，通过next可以找到下一个node。 typedef是定义别名，即aNode就是struct node的别名，用aNode定义的变量就等同于struct node定义的变量。  您好，我知道typedef的作用，不过还是谢谢补充。我的理解是这样的，struct node是一个结构类型，struct node *next是这个类型的指针，并且它是stuct node的一个结构成员。这里这个指针没有指向任何变量，为什么您说可以通过next找到下一个node？这点我不是很理解。[/quote] 你在创建链表时需要用next指向下一个struct node类型的节点的。[/quote] 目前还没学到链表。。不过还是谢谢，我在学过后应该会理解更深。

引用 4 楼 qq_38263433 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] strict node *next是保存下一个node的地址，通过next可以找到下一个node。 typedef是定义别名，即aNode就是struct node的别名，用aNode定义的变量就等同于struct node定义的变量。  您好，我知道typedef的作用，不过还是谢谢补充。我的理解是这样的，struct node是一个结构类型，struct node *next是这个类型的指针，并且它是stuct node的一个结构成员。这里这个指针没有指向任何变量，为什么您说可以通过next找到下一个node？这点我不是很理解。[/quote] 你在创建链表时需要用next指向下一个struct node类型的节点的。

引用 9 楼 qq_38263433 的回复:[quote=引用 6 楼 qq_38204686 的回复:] [quote=引用 5 楼 Lii_的回复:][quote=引用 3 楼 qq_38204686 的回复:] 就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧 我知道，typedef这里没关系,但是我不理解为什么那个指针是指向这个结构类型的，next是一个指针，但它没有初始化，它是指向什么呢？？[/quote] 比如 int *a 这个指针指向int类型 所以你的指针指向结构体 它确实没有初始化  你用的时候再初始化 或者指向别的[/quote]我懂了，可以先定义好类型然后在后面单独给成员赋值，是这样的把？[/quote] 谢谢，不过我还有一个C语言 “联合” 的问题，能私下问你吗

引用 9 楼 Lii_的回复:[quote=引用 6 楼 qq_38204686 的回复:] [quote=引用 5 楼 Lii_的回复:][quote=引用 3 楼 qq_38204686 的回复:] 就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧 我知道，typedef这里没关系,但是我不理解为什么那个指针是指向这个结构类型的，next是一个指针，但它没有初始化，它是指向什么呢？？[/quote] 比如 int *a 这个指针指向int类型 所以你的指针指向结构体 它确实没有初始化  你用的时候再初始化 或者指向别的[/quote]我懂了，可以先定义好类型然后在后面单独给成员赋值，是这样的把？[/quote] 是啊 这就是结构体...!

引用 6 楼 qq_38204686 的回复:[quote=引用 5 楼 Lii_的回复:][quote=引用 3 楼 qq_38204686 的回复:] 就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧 我知道，typedef这里没关系,但是我不理解为什么那个指针是指向这个结构类型的，next是一个指针，但它没有初始化，它是指向什么呢？？[/quote] 比如 int *a 这个指针指向int类型 所以你的指针指向结构体 它确实没有初始化  你用的时候再初始化 或者指向别的[/quote]我懂了，可以先定义好类型然后在后面单独给成员赋值，是这样的把？

引用 7 楼 hdt 的回复:[quote=引用 5 楼 qq_38263433 的回复:] [quote=引用 3 楼 qq_38204686 的回复:] 就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧 我知道，typedef这里没关系,但是我不理解为什么那个指针是指向这个结构类型的，next是一个指针，但它没有初始化，它是指向什么呢？？[/quote] 这里只是定义一个类型。 只有用这个类型的一个实例的时候才需要指向一个具体内存地址，这里大意是指向一个node类型的内存地址 [/quote]明白了，谢谢

引用 5 楼 qq_38263433 的回复:[quote=引用 3 楼 qq_38204686 的回复:] 就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧 我知道，typedef这里没关系,但是我不理解为什么那个指针是指向这个结构类型的，next是一个指针，但它没有初始化，它是指向什么呢？？[/quote] 这里只是定义一个类型。 只有用这个类型的一个实例的时候才需要指向一个具体内存地址，这里大意是指向一个node类型的内存地址

引用 5 楼 Lii_的回复:[quote=引用 3 楼 qq_38204686 的回复:] 就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧 我知道，typedef这里没关系,但是我不理解为什么那个指针是指向这个结构类型的，next是一个指针，但它没有初始化，它是指向什么呢？？[/quote] 比如 int *a 这个指针指向int类型 所以你的指针指向结构体 它确实没有初始化  你用的时候再初始化 或者指向别的

引用 3 楼 qq_38204686 的回复:就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧 我知道，typedef这里没关系,但是我不理解为什么那个指针是指向这个结构类型的，next是一个指针，但它没有初始化，它是指向什么呢？？

引用 2 楼 cfjtaishan 的回复:strict node *next是保存下一个node的地址，通过next可以找到下一个node。 typedef是定义别名，即aNode就是struct node的别名，用aNode定义的变量就等同于struct node定义的变量。  您好，我知道typedef的作用，不过还是谢谢补充。我的理解是这样的，struct node是一个结构类型，struct node *next是这个类型的指针，并且它是stuct node的一个结构成员。这里这个指针没有指向任何变量，为什么您说可以通过next找到下一个node？这点我不是很理解。

就是一个指向你定义的结构体的指针  合不合法 和 typedef没关系吧

不小心按回车发出去了，高手都打错成高数。。。


Question: 新手请教，谢谢

引用 2 楼 niu91 的回复:承接二楼，用dependency walker 看一看是不是缺少了什么库  我刚才下载了dependency walker，打开exe，它显示是个16位DOS模块，所以在windows下无法运行。 卸载了之前的turbo2.0，安装了3.0。exe能在windows下执行了。  谢谢答复

DosBox下运行应该毫无压力吧。

TC（Turbo C）老代码（比如小游戏）最好看懂了以后，理解了算法和过程，用VC改写成Windows平台的。  楼主如果想用C玩玩图形、小游戏编程，可以了解一下EasyX，EasyX是Windows平台最简单的绘图函数库（名副其实），兼容BC和TC的绘图函数，在VC下用EasyX来编程跟在TC下编程绘图差不多是完全一样的。EasyX既可以绘图，也支持图像显示和处理。  下载一个EasyX包，里面有完整的函数手册EasyX_Help.chm，有示例。EasyX官网有很多网友上传的实例，包括游戏。  仅供参考： 用绘图语句画机器猫（初学C语言的同学必看） http://blog.163.com/tab_98/blog/static/1192409720150316223680/

exe可能依赖其他库  exe不是所有系统都能用  新版系统也不是向下完全兼容 比如你在win7直接跑一个16位exe就不行

应该是系统缺少程序exe运行时调用的动态库。一般都是一些函数接口，或变量类型定义等等

承接二楼，用dependency walker 看一看是不是缺少了什么库

turbo C是一个集成开发环境，很多依赖库等都做好了。 移植到其他平台，你要确认这个EXE程序所依赖的东西在新平台是否都具备，都链接了。


Question: 哪位大佬能给我解释下这三个的结果为什么不同谢谢啦

楼主的问题太长了，省略的怎么看，不过楼主的代码也够奇葩

double x= 5.16894,y; 1.	printf("%f\n",(int)(x*1000+0.5)/1000);   (int)(x*1000+0.5) =  5169    ;5169  /1000 = 5;    ;5以浮点数输出，因为浮点数和int 的存储结构不一样，以浮点数输出会出错。所以输出0。 即使你printf("%f\n",5);  也是0； ------------------------------------------------------------------------------------------- 2.	printf("%f\n",y=5169/1000);   5169/1000 = 5  ； 又因为5转double类型的y 所以输出  5.000000 ------------------------------------------------------------------------------------------- 3.	printf("%f\n",y=(int)(x*1000+0.5)/(double)1000); (int)(x*1000+0.5) = 5169 ；5169 /1000.000000 = 5.169000

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

粘代码不比截图方便吗？

这么奇葩的代码恐怕只有考试题里才有，工程上谁要是写出这样的代码恐怕饭碗不保了。 1. %f 打印 int 值，参考http://www.cnblogs.com/zhaoyl/archive/2012/04/21/2462409.html 2. int 和 int 除法，结果应是 int 值 5，然后赋值给 y，进行了 int 到 double 的类型转换，成了 float 的 5 3. 强行转换的 int 和 double 除法，运算前 int 会扩展为 double，结果是 double的

对于double类型的数据，还建议使用%lf输出。 浮点数在内存中存放的格式与int整型等不一样，建议研究一下浮点数在内存中存放知识。  网上的博客讲解还比较多的 http://blog.csdn.net/richerg85/article/details/20456969


Question: linux内核双向链表中的INIT_LIST_HEAD函数以及container_of宏的疑惑

http://www.cnblogs.com/chaozhu/p/yuan.html 知道了，谢谢

百度搜相关关键字。


Question: C99 复数定义问题

在vs中查看complex.h的头文件，只有_Dcomplex，_Fcomplex，_Lcomplex类型，没有 double _Complex，所以编译出错。

VS主要是针对C++的，可能不支持c99的_Complex关键字，此处明显是被当变量名了，然后a未定义。


Question: lighttpd配置fastcgi出现Internal Server Error

引用 1 楼 zhao4zhong1 的回复:百度搜相关关键字。 赵老师您这。 我就是从百度进的csdn的

引用 3 楼 zhao4zhong1 的回复:https://www.baidu.com/s?wd=astcgi放到lighttpd下面运行%2C然后出现“500%20-%20Internal%20Server%20Error”  郁闷了，又好了。 代码什么都没动 500 - Internal Server Error 这个错误一般是服务器的代码有问题

百度搜相关关键字。


Question: 最近关于虚拟内存的理解

虚拟内存与电脑位数有关吗，比如说我给电脑安装一个32位的操作系统和64位的操作系统。我看过一个帖子好像是有关的。

1),什么都有可能，可能是硬盘可能是内存中的虚拟硬盘，也可能是网络存储 2）不对，要看你的程序用了多大，也就是说，可以用和用到了是不一样的。

我是来看看能不能学点的。 我觉得你说的系统虚拟内存大致是那个意思。 但你说的进程的4G虚拟内存空间我没看明白。

引用 1 楼 user-6 的回复:我猜全错，楼下解释。你这一刀捅得不轻，哈哈

http://i-web.i.u-tokyo.ac.jp/edu/training/ss/msprojects/data/06-VirtualMachineArchitecture.pdf 《深入解析Windows操作系统-Windows Internals》

不懂不懂。来学习学习。求大牛。。。。。

我猜全错，楼下解释。


Question: C语言bit赋值

用0x3&数就是两位。

&    |   操作可以提出你想要的任何一位上的值。

传递 int a = 3; // 二进制11 解码 int a1 = a & 0x10; // 取高位 int a2 = a & 0x01;// 取低位

如果你是用VS2015,可以这样 int a = 0b11;

#include <stdio.h>  struct num {     unsigned int a:2; }; int main(void) {      struct num n;     n.a = 3;      printf("%x\n", n.a);     return 0; } 试试类似这样的。

仅供参考：#include <stdio.h>  #define WIRTE_UINT(des ,x ,pos ,len)  (                                   \     (des)                                                                 \     &                                                                     \        ~(                                /* 除要修改的位为0，其余都为1 */ \             (                                                             \                 (1<<(len))-1             /* 长度为len位的1             */ \             )                                                             \             <<(32-(pos)-(len))           /* 左移32-(pos)-(len)位       */ \         )                                                                 \     |                                                                     \         (                                                                 \             (x)                                                           \             <<(32-(pos)-(len))                                            \         )                                                                 \ ) #define READ_UINT(src ,pos ,len)      (                                   \     (                                                                     \         (                                                                 \             (unsigned)(src)                                               \         )                                                                 \         >>(32-(pos)-(len))               /* 逻辑右移32-(pos)-(len)位   */ \     )                                                                     \     &                                                                     \     (                                                                     \         (1<<(len))-1                     /* 长度为len位的1             */ \     )                                                                     \ )  int main()                              //                1111111111222222222233 {                                       //bit   01234567890123456789012345678901     unsigned int des = 0x661;           //      00000000000000000000011001100001     unsigned int r;      des = WIRTE_UINT(des ,3 ,28 ,2);    //      00000000000000000000011001101101     printf("des==0x%08X\n",des); 	r =	READ_UINT(des ,28 ,2);     printf("r==%d\n",r);     return 0; } //des==0x0000066D //r==3

你可以传一个字节呀，然后取出你要的两位就好了呀。比如你想取出低两位，可以这样(0x67 & 0x03)


Question: MISRA C标准问题

int *p = (int *)data1;这样的定义方式感觉不对吧？ 我在程序中定义int *p = (int *)&data1;这样定义，规则10.1没有报错了，但是10.3规则报错，不知道怎么回事！

引用 2 楼 u010188136 的回复:int *p = &data1;是这个地方赋值提示规则10.1是错误的，请问该怎样修改啊？ int *p = (int *)data1; 这样修改吗？

0x43是无符号整型，转到了有符号的data1?


Question: 还是有几个小问题

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

而且还有在一个程序里面看到a[i]--是什么意思

这个程序除100取余数原理不太懂啊

要获得一个C语言程序的运行时间，常用的方法是调用头文件time.h，其中提供了clock()函数，可以捕捉从程序开始运行到clock()被调用时所耗费的时间。这个时间单位是clock tick，即“时钟打点”。同时还有一个常数CLK_TCK，给出了机器时钟每秒所走的时钟打点数。于是为了获得一个函数f的运行时间，我们只要在调用f之前先调用clock()，获得一个时钟打点数C1；在f执行完成后再调用clock()，获得另一个时钟打点数C2；两次获得的时钟打点数之差(C2-C1)就是f运行所消耗的时钟打点数，再除以常数CLK_TCK，就得到了以秒为单位的运行时间。  这里不妨简单假设常数CLK_TCK为100。现给定被测函数前后两次获得的时钟打点数，请你给出被测函数运行的时间。

就是说a【4】里面是5  运行完以后a【4】里面的值减1变成 a【4】=4了是么   其实代码里面都懂  就是那个为啥可以代表四舍五入的概念不懂什么原理   可能就是一句话我就明白了

引用 3 楼 zxczxc233 的回复:而且还有在一个程序里面看到a[i]--是什么意思 这个是指数组啊a的第i个元素（从0开始算）的值自减1

引用 2 楼 zxczxc233 的回复:这个程序除100取余数原理不太懂啊 相差值超过50（包括等于）就认为是一秒钟。就是四舍五入，差值小于50，就舍去。


Question: 新手使用Visual studio 2015

如果感兴趣可以Linux下编程，不用考虑那么多按钮如何使用。

引用 3 楼 for_grasp 的回复:@自信男孩  因为感兴趣才学习的，那个Linux下编程是怎么弄？？我的系统是win10. 你需要装个Linux系统了，Ubuntu系统就可以。先了解一下吧

VS2015动态库编程基础篇资源汇总（文档+视频） http://blog.csdn.net/hou09tian/article/details/77046442 VS2015动态库编程提高篇之远程注入资源汇总（文档+视频） http://blog.csdn.net/hou09tian/article/details/77046459


Question: VC上正确，为什么在ACM上提示”答案错误“，哪里出错了

题目是什么  。   。

引用 6 楼 cfjtaishan 的回复:[quote=引用 4 楼 pineapple__ 的回复:] [quote=引用 2 楼 cfjtaishan 的回复:] #include<stdio.h>  void swap(char *p, int num) {     char temp;     for(int i=0;i<num;++i)         for(int j=i+1;j<num;++j)         {             if(*(p+i)>*(p+j))             {                 temp=*(p+i);                 *(p+i)=*(p+j);                 *(p+j)=temp;             }         } } int main(void) {     int N, i;     char a[4],b[4],ch;     scanf("%d",&N);     if (N > 4)         return 0;     ch = getchar();     fgets(a, N, stdin);     fgets(b, N, stdin);      swap(a, N);     for (i = 0; i < N; i++)         printf("%c ", a[i]);     putchar(10);      swap(b, N);     for (i = 0; i < N; i++)         printf("%c ", b[i]);     putchar(10);     return 0; } 代码写的太硬，灵活度不高； 有漏洞，如果按照你的代码去运行（每次输入3个字母，固定的），可能还可以。但是作为一个通用行的代码，可以输入2个，一个或者都不输入。 对对对，这样就比较灵活了，学习了，谢谢您。有个问题不太明白，fgets（）函数中的stdin是什么意思啊？[/quote] stdin是标准输入，就是键盘[/quote]  明白了，谢谢你

引用 4 楼 pineapple__ 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] #include<stdio.h>  void swap(char *p, int num) {     char temp;     for(int i=0;i<num;++i)         for(int j=i+1;j<num;++j)         {             if(*(p+i)>*(p+j))             {                 temp=*(p+i);                 *(p+i)=*(p+j);                 *(p+j)=temp;             }         } } int main(void) {     int N, i;     char a[4],b[4],ch;     scanf("%d",&N);     if (N > 4)         return 0;     ch = getchar();     fgets(a, N, stdin);     fgets(b, N, stdin);      swap(a, N);     for (i = 0; i < N; i++)         printf("%c ", a[i]);     putchar(10);      swap(b, N);     for (i = 0; i < N; i++)         printf("%c ", b[i]);     putchar(10);     return 0; } 代码写的太硬，灵活度不高； 有漏洞，如果按照你的代码去运行（每次输入3个字母，固定的），可能还可以。但是作为一个通用行的代码，可以输入2个，一个或者都不输入。 对对对，这样就比较灵活了，学习了，谢谢您。有个问题不太明白，fgets（）函数中的stdin是什么意思啊？[/quote] stdin是标准输入，就是键盘

答案错误是因为，不是固定的输入两组数据，输入多少组是变化的，不符合题意，所以错误

引用 2 楼 cfjtaishan 的回复:#include<stdio.h>  void swap(char *p, int num) {     char temp;     for(int i=0;i<num;++i)         for(int j=i+1;j<num;++j)         {             if(*(p+i)>*(p+j))             {                 temp=*(p+i);                 *(p+i)=*(p+j);                 *(p+j)=temp;             }         } } int main(void) {     int N, i;     char a[4],b[4],ch;     scanf("%d",&N);     if (N > 4)         return 0;     ch = getchar();     fgets(a, N, stdin);     fgets(b, N, stdin);      swap(a, N);     for (i = 0; i < N; i++)         printf("%c ", a[i]);     putchar(10);      swap(b, N);     for (i = 0; i < N; i++)         printf("%c ", b[i]);     putchar(10);     return 0; } 代码写的太硬，灵活度不高； 有漏洞，如果按照你的代码去运行（每次输入3个字母，固定的），可能还可以。但是作为一个通用行的代码，可以输入2个，一个或者都不输入。 对对对，这样就比较灵活了，学习了，谢谢您。有个问题不太明白，fgets（）函数中的stdin是什么意思啊？

引用 1 楼 kugeniha 的回复:题目是什么  。   。 ACM中ASCII码排序 描述 输入三个字符（可以重复）后，按各字符的ASCII码从小到大的顺序输出这三个字符。 输入 第一行输入一个数N,表示有N组测试数据。后面的N行输入多组数据，每组输入数据都是占一行，有三个字符组成，之间无空格。 输出 对于每组输入数据，输出一行，字符中间用一个空格分开。 样例输入 2 qwe asd 样例输出 e q w a d s


Question: 素数距离问题，程序放到ACM上运行超时，该怎么优化，请指教

程序要求依次输入，然后一次性输出结果，s要在while循环开始归0，不然有可能输出上次的s值，如果有个数据是1，不会进入for循环，是不是直接返回true

1w个492113你看看你要算多久

最无赖的方法，用筛法建表，并事先运行出结果，将结果贴到程序里面，然后再查表，应该没有更快的方法了。 正常的方法是在程序中用筛法建表，后面的方法同上。

先用筛法求素数方法，把1到1000000之间的所有素数都放入到一个数组A中。根据输入的数对数组A进行二分法查找，如果查找成功，说明这个数就是素数。如果查找失败，假设最后一次查找失败时的数组下标值为index；那么最近的素数一定是A[index-1]，A[index]，A[index+1]三个数之中的一个

/*************************************************************************   > File Name: prime.c   > Author: cfjtaishan   > Mail: cfj20080302@163.com    > Created Time: 2017年08月23日 星期三 21时35分59秒  ************************************************************************/  #include <stdio.h> #include <stdbool.h> #include <math.h>  bool issushu(int M); void nearest_sushu(int *p,int *q);  int main() {  	int N,M,s=0; 	scanf("%d",&N); 	while(N--) 	{  		scanf("%d",&M); 		if(issushu(M)) { 			printf("%d %d\n", M, s); 		} else { 			nearest_sushu(&M,&s); 			printf("%d %d\n",M,s); 		} 	}  	return 0; }  bool issushu(int M) {  	int a = sqrt(M); 	for(int i = 2; i <= a; ++i) 	{  		if(M % i != 0)  			continue; 		else 			return false; 			//break;   /* not perform */ 	} 	return true; }  void nearest_sushu(int *p,int *q) {  	int a = *p; 	int b = *p; 	int c = *p; 	int x,y;  	while(!issushu(--a)) 		; 	x = c - a; 	while(!issushu(++b)) 		; 	y = b - c; 	if(x <= y) 	{  		*p = a; 		*q = x; 	} 	else 	{  		*p = b; 		*q = y; 	} }  优化了一下你的判断素数的逻辑，调用了库函数sqrt，求平方，编译的时候加上-lm，即数学函数库。 相比M/2，效率提高差不多多个数量级 比如输入10001，用你的M/2，那么需要循环差不多500次，而使用sqrt(M);循环次数就是100次


Question: windows平台下，GCC在编译时，源文件的编码问题，以及如何处理，详细见贴内。

楼主使用的是vscode的话，那么可以考虑一下向工作区的设置中添加一项： "files.encoding": "gb2312"（当然这个编码看你喜好了，但是得和gcc使用的编码一致哦）   这样在工作区内读取和编写文件时都会使用的你设置的字符集编码啦

引用 3 楼 zhao4zhong1 的回复:对电脑而言没有乱码，只有二进制字节；对人脑才有乱码。啊 GBK:0xB0 0xA1,Unicode-16 LE:0x4A 0x55,Unicode-16 BE:0x55 0x4A,UTF-8:0xE5 0x95 0x8A  恩恩！谢谢！

引用 1 楼 adlay 的回复:用 -finput-charset= 指定输入文件的编码  输出到控制台乱码的问题你得看控制台使用的什么编码, 不光是程序这边  嗯嗯，我在vscode中使用的是UTF - 8，在控制台中将编码更改为 chcp 65001 之后，输出不再乱码。  谢谢提示！

引用 2 楼 trytry1992 的回复:ANSI编码的文件里的中文到底是什么编码  实际编码为： GB2312  这个应该是区域向的。

ANSI编码的文件里的中文到底是什么编码


Question: 关于链表问题

nodes[i]是一个4字节的int ,引用而已。类型跟这个地址指向的struct有关系

nodes是结构体的二重指针，你可以把notes看成一个表，第一申请的是行（申请了N个结构体指针），后面的循环是申请的列（结构体）。 nodes[i]是struct note*类型 你的这个程序不是链表操作，这个程序还是数组的使用。和栈上申请的数组不同，这个程序里的空间是在堆上申请的空间。 struct node {     int data;     struct node *next; };  链表节点应该类似这样的定义

为Node *nodes 分配N个空间等价于 Node nodes[N] 那么 nodes[i]是什么类型，是struct note* 是指向结构体的指针，如果要操作nodes[i]的成员，就要为其分配空间，或者指向现有的结构体


Question: 关于C语言调用函数出现的问题

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

单词拼写错误，这个需要细心些哦

楼上说的对，int mian ()改成int main ()就好了。

是 main  不是 mian


Question: 数组名作函数参数

void func(int* array){ // anything you want to do! }

数组名作为参数没问题的，主要是排序逻辑有点问题。

#include<stdio.h>  int main() {     void sort(int array[], int n);     int i, a[10];     printf("Please enter ten numbers:\n");     for (i = 0; i < 10; i++)         scanf_s("%d", a + i);     printf("The numbers you enter are:\n");     for (i = 0; i < 10; i++)         printf("%d ", a[i]);     printf("\n");//输入10个数，并输出展示     sort(a, 10);     printf("The sorted array:\n");     for (i = 0; i < 10; i++)         printf("%d ", a[i]);     return 0; }  void sort(int array[], int n) {     int i, j, k, t = 0;     for (i = 0; i < n - 1; i++)     {         k = i;         for (j = i + 1; j < n; j++)             if (array[j] < array[k])                 k = j;         if (k != i) {   /* here shold check if k is equal i */             t = array[k];             array[k] = array[i];             array[i] = t;         }     } }  void sort2(int array[], int n) {     int i, j, t=0;     for (i = 0; i < n - 1; i++)     {         for (j = i + 1; j < n; j++)             if (array[j] < array[i]) {   /* here shold be block */                 t = array[j];                 array[j] = array[i];                 array[i] = t;             }     } } 两个排序（选择，冒泡）都有少许问题，注意加大括号，交换数据是一个整体，不能分开。 选择排序里，交换数据有一个前提，那就是k != i


Question: 数据段，BSS段

静态变量、全局变量都在全局区，只是作用域不同而已。 字面常量在常量区。

引用 3 楼 cfjtaishan 的回复:BSS段（bss segment）通常是指用来存放程序中未初始化或初始化为0的全局变量或静态变量的一块内存区域。 数据段（data segment）通常是指用来存放程序中已初始化且不为0的全局变量或静态变量的一块内存区域 未初始化的全局变量或静态变量放在BSS段, 被初始化为 0，不占用磁盘空间，加载到内存后才分配空间。 字符串常量存放在只读数据段（数据段分为只读数据段和数据段） 局部变量不论是否初始化均在栈上申请。  谢谢

引用 3 楼 cfjtaishan 的回复:BSS段（bss segment）通常是指用来存放程序中未初始化或初始化为0的全局变量或静态变量的一块内存区域。 数据段（data segment）通常是指用来存放程序中已初始化且不为0的全局变量或静态变量的一块内存区域 未初始化的全局变量或静态变量放在BSS段, 被初始化为 0，不占用磁盘空间，加载到内存后才分配空间。 字符串常量存放在只读数据段（数据段分为只读数据段和数据段） 局部变量不论是否初始化均在栈上申请。 以上内存划分都是Linux系统上内存的划分，Windows下会有少许区别。

理解和讨论之前请先学会如何观察！  学会使用dumpbin、PEBrowser Professional、VMMap、……


Question: 新人报道------用C语言编译的程序如何添加图标？我用的是DEV C++。

右键工程属性 普通 找到图标 添加ico

换VS 20XX


Question: 很简单的一个问题，就是看不明白了

使用命令重定向操作符可以使用重定向操作符将命令输入和输出数据流从默认位置重定 向到不同的位置。输入或输出数据流的位置即为句柄。  下表将列出可用的句柄。  句柄      句柄的数字代号 描述 STDIN     0              键盘输入 STDOUT    1              输出到命令提示符窗口 STDERR    2              错误输出到命令提示符窗口 UNDEFINED 3-9            这些句柄由应用程序单独定义，并且是各个工具特定的。  数字 0 到 9 代表前 10 个句柄。可以使用命令 Cmd.exe 运行程序并将该程序前 10 个 句柄中的任何一个重定向。要指定想使用的句柄，可在重定向操作符前面键入该句柄的 数字。如果未定义句柄，则默认的 < 重定向输入操作符是 0，而默认的 > 重定向输出 操作符是 1。键入 > 或 < 操作符之后，必须指定要读取或写入数据的位置。可以指定 文件名或另一个现有的句柄。  要指定重定向到现有句柄，请使用与 (&) 字符，后面接要重定向的句柄号 （例如 &句柄#）。例如，下面的命令可以将句柄 2（即 STDERR）重定向到 句柄 1（即 STDOUT）：  2>&1  下表列出了可用于将输入和输出数据流进行重定向的操作符。  重定向操作符 描述 > 将命令输出写入到文件或设备（例如打印机）中，而不是写在命令提示符窗口或句柄中。 < 从文件中而不是从键盘或句柄中读入命令输入。 >> 将命令输出添加到文件末尾而不删除文件中的信息。 >& 将一个句柄的输出写入到另一个句柄的输入中。 <& 从一个句柄读取输入并将其写入到另一个句柄输出中。 | 从一个命令中读取输出并将其写入另一个命令的输入中。也称作管道。  默认情况下，可以从键盘将命令输入（即 STDIN 句柄）发送到 Cmd.exe，然后由 Cmd.exe 将命令输出（即 STDOUT 句柄）发送到命令提示符窗口。  重定向输入 (<) 要将键盘输入重定向到文件或设备，请使用 < 操作符。例如，要从 File.txt 获取 sort 命令的输入，请键入：  sort<file.txt  File.txt 的内容将以字母顺序列表的方式显示在命令提示符窗口中。  < 操作符可以打开具有只读访问的指定文件名。所以，不能使用该操作符向文件中写入 信息。例如，如果以 <&2 启动程序，则所有试图读取句柄 0 的操作都将失败，因为句 柄 2 最初是以只写访问打开的。   注意  0 是 < 重定向输入操作符的默认句柄。 重定向输出 (>) 几乎所有的命令都将输出发送到命令提示符窗口。即使将输出发送到驱动器或打印机的 命令也会在命令提示符窗口显示消息和提示。  要将输出从命令提示符窗口重定向到文件或设备，请使用 > 操作符。可以在许多命令中 使用该操作符。例如，要将 dir 输出重定向到 Dirlist.txt，请键入：  dir>dirlist.txt  如果 Dirlist.txt 不存在，Cmd.exe 将创建该文件。如果 Dirlist.txt 存在，Cmd.exe 将使用 dir 命令的输出替换文件中的信息。  要运行 netsh routing dump 命令，然后将输出发送到 Route.cfg，请键入：  netsh routing dump>c:\route.cfg  > 操作符可以打开具有只写访问属性的指定文件。所以，不能使用该操作符读取文件。 例如，如果使用重定向 >&0 启动程序，则所有试图写入句柄 1 的操作都将失败，因为 句柄 0 最初是以只读访问打开的。   注意  1 是 > 重定向输出操作符的默认句柄。 复制句柄 重定向操作符 & 可以将输出或输入从一个指定句柄复制到另一个指定的句柄。例如， 要将 dir 输出发送到 File.txt 并将错误输出发送到 File.txt，请键入：  dir>c:\file.txt 2>&1  复制句柄时，可以复制该句柄原状态的所有特性。例如，如果一个句柄具有只写访问的 属性，则该句柄的所有副本都具有只写访问属性。不能将一个具有只读访问属性的句柄 复制到另一个具有只写访问属性的句柄。  使用 & 操作符重定向输入和副本 要将重定向输入操作符 (<) 与复制操作符 (&) 一起使用，指定的文件必须已经存在。 如果输入文件存在，Cmd.exe 将以只读方式打开该文件，然后将文件中包含的字符作为 输入发送到此命令（如同从键盘输入一样）。如果指定了句柄，Cmd.exe 将指定的句柄 复制到系统现有的句柄中。  例如，要以句柄 0 输入读取（即 STDIN）的方式打开 File.txt，请键入：  <file.txt  要打开 File.txt，并在内容排序后将输出发送到命令提示符窗口（即 STDOUT），请键入：  sort<file.txt  要查找 File.txt，然后将句柄 1（即 STDOUT）和句柄 2（即 STDERR）重定向到 Search.txt，请键入：  findfile file.txt>search.txt 2<&1  要以句柄 0 输入读取（即 STDIN）的方式复制用户定义句柄 3，请键入：  <&3  使用 & 操作符重定向输出和复制 如果将输出重定向到文件且指定了现有的文件名，Cmd.exe 将以只写方式打开文件并覆 盖该文件内容。如果指定了句柄，Cmd.exe 将文件复制到现有句柄中。  要将用户定义句柄 3 复制到句柄 1，请键入：  >&3  要将包括句柄 2（即 STDERR）的所有输出从 ipconfig 命令重定向到 句柄 1（即 STDOUT），然后将输出重定向到 Output.log，请键入：  ipconfig.exe>>output.log 2>&1  使用 >> 重定向操作符追加输出 要从命令中将输出添加到文件末尾而不丢失文件中已存在的任何信息，请使用两个连续 的大于号（即 >>）。例如，下面的命令可以将由 dir 命令生成的目录列表追加到 Dirlist.txt 文件：  dir>>dirlist.txt  要将 netstat 命令的输出追加到 Tcpinfo.txt 的末尾，请键入：  netstat>>tcpinfo.txt  使用管道操作符 (|) 管道操作符 (|) 可以提取一个命令的输出（默认情况下是 STDOUT），然后将其导入另 一个命令的输入中（默认情况下是 STDIN）。例如，下面的命令将对目录分类：  dir | sort  在本例中，将同时启动两个命令，但随后 sort 命令会暂停，直到它接收到 dir 命令 的输出为止。sort 命令使用 dir 命令的输出作为输入，然后将输出发送到 句柄 1（即 STDOUT）。  合并带重定向操作符的命令 可以通过合并带有其他命令和文件名的筛选器命令创建自定义命令。例如，可以使用以 下命令存储包含“LOG”字符串的文件名:  dir /b | find "LOG" > loglist.txt  dir 命令的输出通过 find 筛选器命令发送。包含字符串 "LOG" 的文件名作为文件名 列表（例如，NetshConfig.log、Logdat.svd 和 Mylog.bat）存储在文件 Loglist.txt 中。  要在相同命令中使用多个筛选器，请使用管道 (|) 分隔筛选器。例如，下面的命令将 搜索 C 盘上的每个目录以查找包含 "LOG" 字符串的文件名，并且在命令提示符窗口中 每次显示一屏：  dir c:\ /s /b | find "LOG" | more  利用管道 (|) 可以将 Cmd.exe 导向为通过 find 筛选器命令发送 dir 命令输出。 find 命令只选择包含字符串 "LOG" 的文件名。more 命令可以显示由 find 命令选择 的文件名（在命令提示符窗口中每次显示一屏）。有关筛选器命令的详细信息，请参阅 使用筛选器。

cmd窗口显示不下，卷动上去了。

引用 8 楼 zhangkkit 的回复:没问题啊！printf("%d  : %#X\n",i,i); 只是将十进制的数转化为十六进制而已。 没看到我两个输出语句，第一个十进制的数输出时没有

不加上 printf（“\n”)就是正常的 加上printf（“\n”)这一行在输出时就会缺少十进制的第一个数!你们回答的什么呀？不是for循环语句的问题！！

引用 楼主 weixin_39724129 的回复: 难道没看出来十进制输出少了第一个数吗？

试试只输出3个，看看能不能输出出来。

哈哈，太多了，显示不下

是for循环看不明白么？ for循环中，第一个分号前面的语句叫做“初始化语句”，初始化语句的作用是对for循环中的变量进行初始化 i是for循环中的变量，对i的初始化放在for循环之前也是可以的，此时for循环的“初始化语句”可以为空 对于for循环的详细介绍，请参考如下文章 http://blog.csdn.net/hou09tian/article/details/77001685 希望对你有帮助

我也看不明白

我运行了一下，没发现有什么问题啊

代码没问题，逻辑上是从1开始，十六进制数输出%#x，当大于等于10，会用字母abcedf表示。

for (A;B;C) D; //等价于 {  A;  while (1) {   if (!(B)) break;   D;   C;  } }


Question: C语言怎么让一个函数一直执行而不影响另外的函数？

搜“GDI泄露检测”

多线程或者多进程可以实现你的这个要求； 如果是在Linux下写这个功能，可以查一下pthread_create, pthread_join等的使用

引用 4 楼 wyl915的回复:[quote=引用 3 楼 qq_38204686 的回复:] 开个线程  没学过线程这个东西，不知道怎么开啊![/quote] 百度有不少资料 学习学习

引用 3 楼 qq_38204686 的回复:开个线程  没学过线程这个东西，不知道怎么开啊!

开个线程

引用 1 楼 user-4 的回复:估计有 内存/GDI 泄漏， 卡死后任务管理器 查看 GDI句柄数，内存使用量   句柄数数保持在 266左右，内存占用在5900到7100之间，但是一到开始游戏，飞机发射子弹cpu占用就达到了24%

估计有 内存/GDI 泄漏， 卡死后任务管理器 查看 GDI句柄数，内存使用量


Question: free函数释放内存时产生断点

引用 2 楼 user-3的回复: pt[i] = (char *)malloc((strlen(temp) + 1) * sizeof(char)); 你忘了给 '\0' 分配空间了 嗯嗯，＋1后就解决了，谢谢

引用 4 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h> #include<string.h>  int main(void) {     char **pt=NULL;     char temp[41];     int i, num;      printf("How many words do you wish to enter?");     scanf("%d", &num);     pt = (char **)malloc(num * sizeof(char *));     printf("Enter %d words now:\n", num);     for (i = 0; i < num; i++)     {         scanf("%s", temp);         pt[i] = (char *)malloc(strlen(temp) + 1); /* add one byte for '\0' */         strcpy(pt[i], temp);     }     puts("Here are your words:");     for (i = 0; i < num; i++)     {         puts(pt[i]);         free(pt[i]);     }      free(pt);      return 0; } 申请的空间缺少一个'\0'，会导致越界； 所以你的断电应该是因为没有找到'\0'而出现的。 +1后就解决了，谢谢

引用 3 楼 cfjtaishan 的回复:[quote=引用 1 楼 qq_38204686 的回复:] 你只要最后free一次就可以了 怎么在循环了释放 楼主是循环malloc的，自然要循环释放了。 [/quote] 啊  我的锅

引用 1 楼 qq_38204686 的回复:你只要最后free一次就可以了 怎么在循环了释放 楼主是循环malloc的，自然要循环释放了。

你只要最后free一次就可以了 怎么在循环了释放


Question: 运用栈解决“ACM括号配对”的问题，程序一直调试不对，请教大神

应该是你代码不适应所有情况导致的吧，检查一下自己代码，看看有没有什么特殊情况不通过

引用 5 楼 kugeniha 的回复:先输入右括号会越界吧p[-1] 谢谢，改过来程序可以在VC上正确运行了，但是放到ACM上显示RuntimeError，运行时间过长了？还是怎么回事，经常是在VC上可以运行，在ACM上就没法通过

先输入右括号会越界吧p[-1]

第二个case少个break;还有逻辑错误，比如输入（（（（

改到1000还是不行，提交到ACM上显示 “运行时出错”，自己在VC上编译不显示错误和警告，也能运行，但是输入正确答案也是输出No,

字符串长度小于1000，你定义的char a[100]提交后肯定会出现内存溢出的。

仅供参考：#include<stdio.h> #include<malloc.h> #include<string.h> #define STACK_INIT_SIZE 10 #define STACK_GROW_SIZE 5 #define ELEMTYPE char #define OK 1 #define ERROR 0 typedef struct { /*建立一个栈的首结点*/     ELEMTYPE * base;     ELEMTYPE * top;     int stacksize; } SpStack; int InitStack(SpStack *s) { /*建立空的栈并返回首地址*/     s->base=((ELEMTYPE*)malloc(STACK_INIT_SIZE*sizeof(ELEMTYPE)));     if (!s->base) return ERROR;     s->top=s->base;     s->stacksize=STACK_INIT_SIZE;     return OK; } int StackEmpty(SpStack *s) { /*判断栈是否为空*/     if (s->top==s->base) return OK;     else                 return ERROR; } int Push(SpStack *s,ELEMTYPE e) { /*往栈顶插入元素即进栈*/     if (s->top-s->base>=s->stacksize) { /*判断是否栈满*/         s->base=((ELEMTYPE*)realloc(s->base,(s->stacksize+STACK_GROW_SIZE)*sizeof(ELEMTYPE)));         if (!s->base) return ERROR;         s->stacksize+=STACK_GROW_SIZE;         s->top=s->base+s->stacksize;     }     *s->top++=e;     return OK; } int Pop(SpStack *s,ELEMTYPE *e) { /*让栈顶元素依次输出即出栈*/     if (StackEmpty(s)) return ERROR;     *e=*(--s->top);     return OK; } int Comp(ELEMTYPE a,ELEMTYPE b) {     if ((a=='('&&b!=')')       ||(a=='['&&b!=']')       ||(a=='{'&&b!='}')) {         return ERROR;     } else return OK; } int Count(SpStack *s) {     ELEMTYPE e[STACK_INIT_SIZE*2];     ELEMTYPE e1;     int i;      InitStack(s);     fgets(e,STACK_INIT_SIZE*2,stdin);     if ('\n'==e[strlen(e)-1]) e[strlen(e)-1]=0;     printf("%s\n",e);     for (i=0;e[i]!='\0';i++) {         switch (e[i]) {         case '(':         case '[':         case '{':             Push(s,e[i]);             break;         case ')':         case ']':         case '}':             if (StackEmpty(s)) {                 printf("%*s↖右括号多余\n",i+1,"");                 return(ERROR);             } else Pop(s,&e1);             if (!Comp(e1,e[i])) {                 printf("%*s↖左右匹配出错\n",i+1,"");                 return(ERROR);             }         }     }     if (!StackEmpty(s)) {         printf("%*s↖左括号多余\n",i,"");         return(ERROR);     } else {         printf("匹配正确\n");         return(OK);     } } void main() {     SpStack s;     Count(&s);     free(s.base); }


Question: 运用栈解决“ACM括号配对”的问题，程序编号老是调试不对，一直输出No


Question: 大佬 帮忙看下哪里出错了 链式队列。

小心驶得万年船。

dequeue的问题吧，PNODE p = q->front->next;这个p在show之后应该是NULL了吧。

show()函数里修改了front，后面出队还要用到front，但是这个front已经不是队头了。

引用 2 楼 heheda7918 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] //#include "stdafx.h" #include<stdio.h> //#include<malloc.h> #include<stdlib.h>  typedef struct node {     int data;     struct node * next; }NODE, *PNODE;  typedef struct {     PNODE rear, front; }queue;  void init(queue*); void insert(queue*, int val); void show(queue*); void dequeue(queue*, int *);  int main(void) {     int val;     queue  q;     init(&q);     insert(&q, 1);     insert(&q, 12);     insert(&q, 13);     insert(&q, 14);     show(&q);     dequeue(&q, &val);     printf("%d\n", val);      return 0; }  void init(queue* q) {     q->front = q->rear = (PNODE)malloc(sizeof(NODE));     if (q->front == NULL)         exit(-1);     q->rear->next = NULL;     return; }  void insert(queue* q, int val) {     PNODE p = (PNODE)malloc(sizeof(NODE));     if (p == NULL)         exit(-1);     p->data = val;     p->next = NULL;     q->rear->next = p;     q->rear = p; }  void show(queue* q) {     PNODE p = q->front;     if (!p) {         fprintf(stdout, "queue is empty!\n");         return;     }     p = q->front->next;     while (p)     {         printf("%d ", p->data);         p = p->next;     }     printf("\n");  }  void dequeue(queue * q, int *val) {     PNODE p = q->front->next;     *val = p->data;     q->front->next = p->next;     free(p);     return; }  show函数逻辑有问题； 详见上面的代码  能告诉我我写的show为什么不对么。[/quote] 注意看一下你的show函数里，你修改了front指针，front指针已经不指向队列的头了。 show()函数不建议修改队列指针，只对队列读即可。

引用 1 楼 cfjtaishan 的回复://#include "stdafx.h" #include<stdio.h> //#include<malloc.h> #include<stdlib.h>  typedef struct node {     int data;     struct node * next; }NODE, *PNODE;  typedef struct {     PNODE rear, front; }queue;  void init(queue*); void insert(queue*, int val); void show(queue*); void dequeue(queue*, int *);  int main(void) {     int val;     queue  q;     init(&q);     insert(&q, 1);     insert(&q, 12);     insert(&q, 13);     insert(&q, 14);     show(&q);     dequeue(&q, &val);     printf("%d\n", val);      return 0; }  void init(queue* q) {     q->front = q->rear = (PNODE)malloc(sizeof(NODE));     if (q->front == NULL)         exit(-1);     q->rear->next = NULL;     return; }  void insert(queue* q, int val) {     PNODE p = (PNODE)malloc(sizeof(NODE));     if (p == NULL)         exit(-1);     p->data = val;     p->next = NULL;     q->rear->next = p;     q->rear = p; }  void show(queue* q) {     PNODE p = q->front;     if (!p) {         fprintf(stdout, "queue is empty!\n");         return;     }     p = q->front->next;     while (p)     {         printf("%d ", p->data);         p = p->next;     }     printf("\n");  }  void dequeue(queue * q, int *val) {     PNODE p = q->front->next;     *val = p->data;     q->front->next = p->next;     free(p);     return; }  show函数逻辑有问题； 详见上面的代码  能告诉我我写的show为什么不对么。


Question: 指针与内存

不要纠结各种常量了，这个世界上唯一不变的就是变化。用API WriteProcessMemory还能修改正运行的其它进程的内存里面的所谓常量呢！

引用 1 楼 zhao4zhong1 的回复:#pragma comment(linker,"/SECTION:.rdata,RW") //加这句可以让常量区可写，后果自负！  是改为这样吗？但编译时提示错误“左直指定const对象”。这里s1应该才是常量吧，因为前面有加const. #include <stdio.h> #include"stdlib.h" #pragma comment(linker,"/SECTION:.rdata,RW") main() {     const char *s1="iya";     s1[1]='o';                  printf("%s",s1);       system("pause"); } 如果改为这样：加不加这行#pragma comment(linker,"/SECTION:.rdata,RW")都可以，这里s1应该是变量吧，因为前面没加const. #include <stdio.h> #include"stdlib.h" #pragma comment(linker,"/SECTION:.rdata,RW") main() {     char *s1="iya";     s1[1]='o';                printf("%s",s1);       system("pause"); } 在本版题目中的代码不算是修改字符串常量的值只是修改了字符串变量指针的地址而已吧？（因为题目中s1,s2前面没有加const）.

s2和&s2[0]的地址值是一样的。 s2在执行完循环已经不指向字符串"abc"了，从你的for循环已经验证了。 s1 = s2；这句已经说明，因为s1 = s2是s1和s2指向相同区域，因为它是将s2的地址值赋值给s1，所以它们指向相同区域； 所以，经过循环之后，s2已经不指向字符串"abc". 这不叫修改字符常量的值，只是修改了指针变量的值（指针变量里存放的时地址值），字符串常量没变化。


Question: 为什么要用指向结构体的二重指针

//仅交换两个结构体的内容  (两个指针本身未变化, 只内容变化了) void swap(STU *p1,STU *p2) {     STU temp = *p1;     *p1 = *p2;     *p2 = temp; }  //交换指针本身(因为指针本身变化了,其指向的内容肯定也跟着变化了) void swap2(STU **p1,STU **p2) {     STU *temp = *p1;     *p1 = *p2;     *p2 = temp; }

引用 11 楼 xiaohuh421 的回复:如果你仅是想交换两个结构体的内容, 而不是指针本身, 那么不需要二重指针. 你果你要交换两个指针本身的值, 那么肯定就需要用二重指针了.能写一下具体的函数吗？交换两个结构体的内容和交换指针本身有什么不同吗

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

swap有问题，二重指针是指针的指针。

引用 9 楼 zihui0459 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 首先，你的swap函数里交换连个指针内容有问题，p1 = p2;这样时p1指向了p2指向的内存区域，但是p2并没有指向p1指向的内存区域；  其次，使用二重指针，这样能保证参数p1, p2是传出参数，即是通过swap交换之后能够得到新的内存区域（交换之后的）是因为值传递的原因吗？二重指针可以改变链表实参指针的指向吗？[/quote] 对，建议在草稿纸画画指针指向

引用 1 楼 cfjtaishan 的回复:首先，你的swap函数里交换连个指针内容有问题，p1 = p2;这样时p1指向了p2指向的内存区域，但是p2并没有指向p1指向的内存区域；  其次，使用二重指针，这样能保证参数p1, p2是传出参数，即是通过swap交换之后能够得到新的内存区域（交换之后的）是因为值传递的原因吗？二重指针可以改变链表实参指针的指向吗？

引用 4 楼 sinat_39459036 的回复:void swap(STU *p1,STU *p2) { 	STU tmp; 	//tmp = malloc(4); 	tmp = *p1; 	*p1 = *p2; 	*p2 = tmp;  	//free(tmp); 	return ; }  void swap2(STU **p1,STU **p2) { 	STU **tmp; 	tmp = malloc(4); 	*tmp = *p1; 	*p1 = *p2; 	*p2 = *tmp;  	free(tmp); 	return ; }试了一下好像换不了啊？ int main() { 	struct student *p1,*p2; 	p1=p2=(struct student*)malloc(sizeof(struct student)); 	scanf("%d %d",&(*p1).num,&(*p1).score); 	scanf("%d %d",&(*p2).num,&(*p2).score); 	swap(p1,p2); 	printf("第一位学生成绩%d %d",(*p1).num,(*p1).score); 	printf("第二位学生成绩%d %d",(*p2).num,(*p2).score); }不知道是不是我这主函数参数传的不对呢？

引用 5 楼 xiaohuh421 的回复:swap（struct student *p1,struct student *p2）//这个函数用来完成两个指针的互换。 { p1=p2; }  你确定这个能交换....  指针本身是值传递的,  除非你在内部交换它们的值   *p1 = *p2这种类似的取地址操作,  才是地址传递, 可修改值.  如果你这样写能交换, 只能说明你用的编译器有问题, 不符合标准.不小心写错了。。。我想问下这个必须要在swap函数的形参用二重指针才能完成互换吗？原理和swap（int a，int  b）这个换不了是一个道理吗？

不用二级指针不能互换吧


Question: 一个类似字典查询的程序，到最后无法输入是否继续字符。

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

#include<stdio.h> #include<stdlib.h> #include<ctype.h> #include<string.h> int main() {     char word[80],**p,ch;     char *name[]={"liuxiaoyang","shihaoren","jixiaofei","shihuaidan","yang","shuaige","fei","huaidan",NULL};     do     {         printf("please enter words: ");         scanf("%s", word);         p = name;         do         {             if(!strcmp(*p, word))             {                 puts("the meaning of the word is: ");                 puts(*(p+1));                 break;             }             if(strcmp(*p,word)!=0)                 p = p + 2;         }while((*p)!=NULL);         if((*p)==NULL)         {             printf("%s","the word is not in the dictioary");             printf("\n");         }          printf("enter y/n:");         getchar();    /*接收上面残留的输入缓冲区的回车符*/         scanf("%c", &ch);//该句无法执行     }while(toupper(ch)!='N');      system("pause");     return 0; }  在scanf("%c", &ch);上面加一句getchar();代码即可。详见上面的代码；  另外，注意你的逻辑可能会出现越界访问，导致段错误；              if(strcmp(*p,word)!=0)                 p = p + 2; 输入的word一直不和*p相同，则p会一直向后偏移。


两个串口就有两个不同的port口，你对不同的port口进行不同的操作不就好了嘛。比如说串口2接收到数据了，此时需要向串口1发送数据，你就触发一个事件来向串口发送数据好了。

百度搜相关关键字。


Question: 程序死在段错误上面，如何看gdb调试的错误代码地址？

如果生成对象文件时有带-g参数，那么有个addr2line的工具可以查出来0x002f6e28这样的地址对应于源码的行数。

判断是否越界访问，可以在数组的最后一个元素之后对应的地址处设置数据读写断点。如果该地址对应其它变量干扰判断，可将数组多声明一个元素，并设置数据读写断点在该多出元素对应的地址上。 #include <time.h> #include <stdlib.h> #include <windows.h> int main() {     int a,b[11];//本来是b[10]，为判断哪句越界，故意声明为b[11]      srand((unsigned int)time(NULL));//按两次F11，等黄色右箭头指向本行时，调试、新建断点、新建数据断点，地址：&b[10]，字节计数：4，确定。     while (1) {//按F5，会停在下面某句，此时a的值为10，b[10]已经被修改为对应0..4之一。         b[(a=rand()%11)]=0;         Sleep(100);         b[(a=rand()%11)]=1;         Sleep(100);         b[(a=rand()%11)]=2;         Sleep(100);         b[(a=rand()%11)]=3;         Sleep(100);         b[(a=rand()%11)]=4;         Sleep(100);     }     return 0; }

引用 6 楼 zhao4zhong1 的回复:排查越界访问可以使用watch命令。  2. 设置观察点(WatchPoint) 观察点一般用来观察某个表达式(变量也是一种表达式)的值是否变化了。如果有变化，马上停住程序。有下面的几种方法来设置观察点： watch <expr> 为表达式(变量)expr设置一个观察点。一旦表达式值有变化时，马上停住程序。 rwatch <expr> 当表达式(变量)expr被读时，停住程序。 awatch <expr> 当表达式(变量)的值被读或被写时，停住程序。 info watchpoints 列出当前设置的所有观察点。主要是我只知道gdb定位到这个函数内，无法定位到具体哪一行

引用 5 楼 cfjtaishan 的回复:[quote=引用 4 楼 jgh211 的回复:] 代码在楼上 很简单 代码很简单？ 从代码上看，很可能时越界访问了。建议楼主排查边界。 [/quote]主要是这是个循环，可能这个函数循环了N次之后才会段错误。越界的话，我加了越界打印，但是并没有打印过越界的信息；

引用 4 楼 jgh211 的回复:代码在楼上 很简单 代码很简单？ 从代码上看，很可能时越界访问了。建议楼主排查边界。

代码在楼上 很简单

HI_S32 iIndex = 0;     HI_U16 u16Num;     HI_U16 i, j, k;     HI_U16 u16Thr = 0;     HI_BOOL bValid;      if (pstBlob->u8RegionNum > u16RectMaxNum)     {         u16Thr = pstBlob->u16CurAreaThr;         do         {             u16Num = 0;             u16Thr += u16AreaThrStep;             for (i = 0; i < 254; i++)             {                 if (pstBlob->astRegion[i].u32Area > u16Thr)                 {                     u16Num++;                 }             }         } while (u16Num > u16RectMaxNum);     }      u16Num = 0;      for (i = 0; i < 254; i++)     {         if (pstBlob->astRegion[i].u32Area > u16Thr)         {             HI_S32 usWid, usHgt;              usWid = (HI_S32)(pstBlob->astRegion[i].u16Right - pstBlob->astRegion[i].u16Left);             usHgt = (HI_S32)(pstBlob->astRegion[i].u16Bottom - pstBlob->astRegion[i].u16Top);              //NreCode-7.11             #if 0             if (presetPos == 1 && pstBlob->astRegion[i].u16Bottom * 3 < imageHgt)             {                 usWid += 3;                 usHgt += 6;             }             #endif                  //width height 最小尺寸             //if ((usWid * 30 < imageWid) || (usHgt * 30 < imageHgt))             if ((usWid * 90 < imageWid) || (usHgt * 30 < imageHgt))             {                 continue;             }                  #if 0             if (presetPos == 1 && pstBlob->astRegion[i].u16Bottom * 3 < imageHgt)             {                 usWid -= 3;                 usHgt -= 6;             }             #endif                          if ((usWid + 88) > imageWid || (usHgt + 10) > imageHgt)             {                 continue;                }                              //NreCode_6.15             if (usWid * usHgt * 3 > imageWid * imageHgt)             {                 continue;             }              //比例异常             if (usWid > usHgt * 5 || usHgt > usWid * 10)             {                 continue;             }              //占空比异常             if (pstBlob->astRegion[i].u32Area < usWid * usHgt * 0.15)             {                 continue;             }              pstRect->astRect[u16Num].u32Area = (HI_S32)(pstBlob->astRegion[i].u32Area);              /********************************0-左上 1-右上 2-右下 3-左下*****************************/             pstRect->astRect[u16Num].astPoint[0].s32X = (HI_S32)(pstBlob->astRegion[i].u16Left) & (~1);             pstRect->astRect[u16Num].astPoint[0].s32Y = (HI_S32)(pstBlob->astRegion[i].u16Top) & (~1);              pstRect->astRect[u16Num].astPoint[1].s32X = (HI_S32)(pstBlob->astRegion[i].u16Right) & (~1);             pstRect->astRect[u16Num].astPoint[1].s32Y = (HI_S32)(pstBlob->astRegion[i].u16Top) & (~1);              pstRect->astRect[u16Num].astPoint[2].s32X = (HI_S32)(pstBlob->astRegion[i].u16Right) & (~1);             pstRect->astRect[u16Num].astPoint[2].s32Y = (HI_S32)(pstBlob->astRegion[i].u16Bottom) & (~1);              pstRect->astRect[u16Num].astPoint[3].s32X = (HI_S32)(pstBlob->astRegion[i].u16Left) & (~1);             pstRect->astRect[u16Num].astPoint[3].s32Y = (HI_S32)(pstBlob->astRegion[i].u16Bottom) & (~1);              bValid = HI_TRUE;             for (j = 0; j < 3; j++)             {                 for (k = j + 1; k < 4; k++)                 {                     if ((pstRect->astRect[u16Num].astPoint[j].s32X == pstRect->astRect[u16Num].astPoint[k].s32X)                         && (pstRect->astRect[u16Num].astPoint[j].s32Y == pstRect->astRect[u16Num].astPoint[k].s32Y))                     {                         bValid = HI_FALSE;                         break;                     }                  }             }             if (HI_TRUE == bValid)             {                 u16Num++;             }         }     }      /********************************CCL区域后期处理***************************/     for (j = 0; j < u16Num - 1; j++)     {         if (0 != pstRect->astRect[j].u32Area)         {             for (k = j + 1; k < u16Num; k++)             {                 if (0 == pstRect->astRect[k].u32Area)                 {                     continue;                 }                  int iWidj = (int)pstRect->astRect[j].astPoint[1].s32X - (int)pstRect->astRect[j].astPoint[0].s32X;                 int iHgtj = (int)pstRect->astRect[j].astPoint[2].s32Y - (int)pstRect->astRect[j].astPoint[0].s32Y;                 int iWidk = (int)pstRect->astRect[k].astPoint[1].s32X - (int)pstRect->astRect[k].astPoint[0].s32X;                 int iHgtk = (int)pstRect->astRect[k].astPoint[2].s32Y - (int)pstRect->astRect[k].astPoint[0].s32Y;                 //中心点坐标的两倍，和j、k宽高的两倍做比较，就不除以2了                 int icenterjx = (int)pstRect->astRect[j].astPoint[1].s32X + (int)pstRect->astRect[j].astPoint[0].s32X;                 int icenterjy = (int)pstRect->astRect[j].astPoint[2].s32Y + (int)pstRect->astRect[j].astPoint[0].s32Y;                 int icenterkx = (int)pstRect->astRect[k].astPoint[1].s32X + (int)pstRect->astRect[k].astPoint[0].s32X;                 int icenterky = (int)pstRect->astRect[k].astPoint[2].s32Y + (int)pstRect->astRect[k].astPoint[0].s32Y;                  if (((abs(icenterjx - icenterkx)) <= (iWidj + iWidk)) && (abs(icenterjy - icenterky) <= (iHgtj + iHgtk)))                 {                     pstRect->astRect[j].u32Area = pstRect->astRect[j].u32Area + pstRect->astRect[k].u32Area;                     pstRect->astRect[j].astPoint[0].s32X = MIN(pstRect->astRect[k].astPoint[0].s32X, pstRect->astRect[j].astPoint[0].s32X);                     pstRect->astRect[j].astPoint[0].s32Y = MIN(pstRect->astRect[k].astPoint[0].s32Y, pstRect->astRect[j].astPoint[0].s32Y);                     pstRect->astRect[j].astPoint[1].s32X = MAX(pstRect->astRect[k].astPoint[1].s32X, pstRect->astRect[j].astPoint[1].s32X);                     pstRect->astRect[j].astPoint[1].s32Y = MIN(pstRect->astRect[k].astPoint[1].s32Y, pstRect->astRect[j].astPoint[1].s32Y);                     pstRect->astRect[j].astPoint[2].s32X = MAX(pstRect->astRect[k].astPoint[2].s32X, pstRect->astRect[j].astPoint[2].s32X);                     pstRect->astRect[j].astPoint[2].s32Y = MAX(pstRect->astRect[k].astPoint[2].s32Y, pstRect->astRect[j].astPoint[2].s32Y);                     pstRect->astRect[j].astPoint[3].s32X = MIN(pstRect->astRect[k].astPoint[3].s32X, pstRect->astRect[j].astPoint[3].s32X);                     pstRect->astRect[j].astPoint[3].s32Y = MAX(pstRect->astRect[k].astPoint[3].s32Y, pstRect->astRect[j].astPoint[3].s32Y);                     pstRect->astRect[k].u32Area = 0;                 }             }         }     }          /****************过滤融合和后的目标框*******************/     for (j = 0; j < u16Num - 1; j++)     {         int iWid = pstRect->astRect[j].astPoint[1].s32X - pstRect->astRect[j].astPoint[0].s32X;         int iHgt = pstRect->astRect[j].astPoint[2].s32Y - pstRect->astRect[j].astPoint[0].s32Y;              if (iWid * 2 > imageWid)         {             pstRect->astRect[j].u32Area = 0;         }         if (iWid * iHgt * 3 > imageWid * imageHgt)         {             pstRect->astRect[j].u32Area = 0;         }          if (iWid > iHgt * 5 || iHgt > iWid * 10)         {             pstRect->astRect[j].u32Area = 0;         }     }          for (j = 0; j < u16Num; j++)     {         if (pstRect->astRect[j].u32Area > 0)         {             if (iIndex != j)             {                 memcpy(pstRect->astRect + iIndex, pstRect->astRect + j, sizeof(IVE_CCLRECT_S));             }             iIndex++;         }     }         if (iIndex < MAX_OBJ_NUM)     {         memset(pstRect->astRect + iIndex, 0, sizeof(IVE_CCLRECT_S)*(MAX_OBJ_NUM - iIndex));     }          pstRect->u16Num = iIndex;

进程意外退出会在当前目录下产生‘core’文件或形如‘core.数字’的文件比如‘core.1234’ 使用命令 gdb 运行程序名 core或core.数字 进入gdb然后使用bt命令 可以查看进程意外退出前函数调用的堆栈，内容为从上到下列出对应从里层到外层的函数调用历史。 如果进程意外退出不产生core文件，参考“ulimit -c core文件最大块大小”命令

建议把代码贴出来，段错误应该是非法地址访问了。


Question: x86系统下，输出的值为多少？

int *ptr1 = (int*)(&a+1); 因为对a再取地址加1，所以&a+1相当于&a看成一个整体，对其加1就是加了5对应的地址，即ptr1对应的是a[5]所对应的地址。所以ptr1[-1]是5.  int *ptr2 = (int*)((int)a+1);：内存中对应的数据是：00 00 00 02 00 00 00 01 ，a指向01的地址，然后给(int)a+1得到的地址是01前面的00的地址，00 00 00 02 00 00 00 01 ，所以打印的ptr2对应的值是2000000。 http://blog.csdn.net/wyyy2088511/article/details/77337301

http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素

以下是输出  首先，数组a的地址是0x00affcc4，而 int *ptr1 = (int*)(&a + 1); 所以ptr1的内容应该是a的地址加上1个“单位”，这里的“单位”指的是数组a整个的大小 （为什么1个“单位”是数组a整个的大小，请参考http://blog.csdn.net/hou09tian/article/details/75332577） 所以ptr1的值是0x00affcc4+4*5（5个int，每个int的4个字节）=0x00affcd8 对于ptr2 int *ptr2 = (int*)((int)a + 1); 此时将a看成是一个普通的int，所以ptr2的值是0x00affcc4+1=0x00affcc5 对于输出 printf("%x ,%x", ptr1[-1], *ptr2); ptr1[-1]表示向“前”移动1个“单位”，因为ptr1的类型是int的指针；所以这里的1个“单位”值得是1个int的大小，即4个字节 所以，ptr1[-1]实际上指的是0x00affcd8-4=0x00affcd4  相当于输出的数组a的第5个元素。 而对于*ptr2，因为其值是0x00affcc5，可以看下图  所以，输出的是20000000

一个老考题，主要是强转地址可能会有很多问题

引用 4楼自信男孩 的回复:#include <stdio.h>  int main() {     int a[5] ={1,2,3,4,5};     int *ptr1 = (int*)(&a+1);     int *ptr2 = (int*)((int)a+1);      printf("%p \n", a);     printf("%p , %p, %p\n", ptr1, ptr1-1, ptr2);     printf("%d\n", ptr1[-1]);     //printf("%x ,%x", ptr1[-1],*ptr2);     return 0; } 注意ptr[-1]能够得到值是5，但是ptr2就不能了，通过打印ptr2指向的内存地址就可以发现，它的地址和a的地址就相差很大。主要是因为(int)a + 1已经改变了a的地址，地址是unsigned int类型，强转int类型就改变了它的值。嗯。我搞懂了

引用 3楼das白 的回复:5,2 第一个偏移了一个数组 减一是最后一个数字5 第二个偏移了一个int     即2 感觉就是这样 但是我的编译器输出的是 5,2000000 后面的0是什么鬼证明你还没到那水平

引用 2楼user-7 的回复:x86系统就是32位的。你这代码里错误一大堆，你自己没调试？是你自己看不懂，没错的。自己去看c语言深度剖析

x86系统就是32位的。你这代码里错误一大堆，你自己没调试？

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