Question: 求一算法！

学习了

引用 4 楼 K8001 的回复:[quote=引用 2 楼 zhao4zhong1 的回复:] #include <stdio.h> #include <stdlib.h> int main() {     int i,j;     char b[7+1];     char bs[7+1];     printf("    Apple    Banana Tee     Juice   Milke   Meat    Water  \n");     for (i=0;i<128;i++) {         printf("%3d ",i+1);         ltoa(i,b,2);         sprintf(bs,"%07s",b);         for (j=0;j<7;j++) {             if (bs[j]=='0') printf("Yes     ");             else            printf("No      ");         }         printf("\n");     }     return 0; } //    Apple    Banana Tee     Juice   Milke   Meat    Water //  1 Yes     Yes     Yes     Yes     Yes     Yes     Yes //  2 Yes     Yes     Yes     Yes     Yes     Yes     No //  3 Yes     Yes     Yes     Yes     Yes     No      Yes //  4 Yes     Yes     Yes     Yes     Yes     No      No //  5 Yes     Yes     Yes     Yes     No      Yes     Yes //  6 Yes     Yes     Yes     Yes     No      Yes     No //  7 Yes     Yes     Yes     Yes     No      No      Yes //  8 Yes     Yes     Yes     Yes     No      No      No //  9 Yes     Yes     Yes     No      Yes     Yes     Yes // 10 Yes     Yes     Yes     No      Yes     Yes     No // 11 Yes     Yes     Yes     No      Yes     No      Yes // 12 Yes     Yes     Yes     No      Yes     No      No // 13 Yes     Yes     Yes     No      No      Yes     Yes // 14 Yes     Yes     Yes     No      No      Yes     No // 15 Yes     Yes     Yes     No      No      No      Yes // 16 Yes     Yes     Yes     No      No      No      No // 17 Yes     Yes     No      Yes     Yes     Yes     Yes // 18 Yes     Yes     No      Yes     Yes     Yes     No // 19 Yes     Yes     No      Yes     Yes     No      Yes // 20 Yes     Yes     No      Yes     Yes     No      No // 21 Yes     Yes     No      Yes     No      Yes     Yes // 22 Yes     Yes     No      Yes     No      Yes     No // 23 Yes     Yes     No      Yes     No      No      Yes // 24 Yes     Yes     No      Yes     No      No      No // 25 Yes     Yes     No      No      Yes     Yes     Yes // 26 Yes     Yes     No      No      Yes     Yes     No // 27 Yes     Yes     No      No      Yes     No      Yes // 28 Yes     Yes     No      No      Yes     No      No // 29 Yes     Yes     No      No      No      Yes     Yes // 30 Yes     Yes     No      No      No      Yes     No // 31 Yes     Yes     No      No      No      No      Yes // 32 Yes     Yes     No      No      No      No      No // 33 Yes     No      Yes     Yes     Yes     Yes     Yes // 34 Yes     No      Yes     Yes     Yes     Yes     No // 35 Yes     No      Yes     Yes     Yes     No      Yes // 36 Yes     No      Yes     Yes     Yes     No      No // 37 Yes     No      Yes     Yes     No      Yes     Yes // 38 Yes     No      Yes     Yes     No      Yes     No // 39 Yes     No      Yes     Yes     No      No      Yes // 40 Yes     No      Yes     Yes     No      No      No // 41 Yes     No      Yes     No      Yes     Yes     Yes // 42 Yes     No      Yes     No      Yes     Yes     No // 43 Yes     No      Yes     No      Yes     No      Yes // 44 Yes     No      Yes     No      Yes     No      No // 45 Yes     No      Yes     No      No      Yes     Yes // 46 Yes     No      Yes     No      No      Yes     No // 47 Yes     No      Yes     No      No      No      Yes // 48 Yes     No      Yes     No      No      No      No // 49 Yes     No      No      Yes     Yes     Yes     Yes // 50 Yes     No      No      Yes     Yes     Yes     No // 51 Yes     No      No      Yes     Yes     No      Yes // 52 Yes     No      No      Yes     Yes     No      No // 53 Yes     No      No      Yes     No      Yes     Yes // 54 Yes     No      No      Yes     No      Yes     No // 55 Yes     No      No      Yes     No      No      Yes // 56 Yes     No      No      Yes     No      No      No // 57 Yes     No      No      No      Yes     Yes     Yes // 58 Yes     No      No      No      Yes     Yes     No // 59 Yes     No      No      No      Yes     No      Yes // 60 Yes     No      No      No      Yes     No      No // 61 Yes     No      No      No      No      Yes     Yes // 62 Yes     No      No      No      No      Yes     No // 63 Yes     No      No      No      No      No      Yes // 64 Yes     No      No      No      No      No      No // 65 No      Yes     Yes     Yes     Yes     Yes     Yes // 66 No      Yes     Yes     Yes     Yes     Yes     No // 67 No      Yes     Yes     Yes     Yes     No      Yes // 68 No      Yes     Yes     Yes     Yes     No      No // 69 No      Yes     Yes     Yes     No      Yes     Yes // 70 No      Yes     Yes     Yes     No      Yes     No // 71 No      Yes     Yes     Yes     No      No      Yes // 72 No      Yes     Yes     Yes     No      No      No // 73 No      Yes     Yes     No      Yes     Yes     Yes // 74 No      Yes     Yes     No      Yes     Yes     No // 75 No      Yes     Yes     No      Yes     No      Yes // 76 No      Yes     Yes     No      Yes     No      No // 77 No      Yes     Yes     No      No      Yes     Yes // 78 No      Yes     Yes     No      No      Yes     No // 79 No      Yes     Yes     No      No      No      Yes // 80 No      Yes     Yes     No      No      No      No // 81 No      Yes     No      Yes     Yes     Yes     Yes // 82 No      Yes     No      Yes     Yes     Yes     No // 83 No      Yes     No      Yes     Yes     No      Yes // 84 No      Yes     No      Yes     Yes     No      No // 85 No      Yes     No      Yes     No      Yes     Yes // 86 No      Yes     No      Yes     No      Yes     No // 87 No      Yes     No      Yes     No      No      Yes // 88 No      Yes     No      Yes     No      No      No // 89 No      Yes     No      No      Yes     Yes     Yes // 90 No      Yes     No      No      Yes     Yes     No // 91 No      Yes     No      No      Yes     No      Yes // 92 No      Yes     No      No      Yes     No      No // 93 No      Yes     No      No      No      Yes     Yes // 94 No      Yes     No      No      No      Yes     No // 95 No      Yes     No      No      No      No      Yes // 96 No      Yes     No      No      No      No      No // 97 No      No      Yes     Yes     Yes     Yes     Yes // 98 No      No      Yes     Yes     Yes     Yes     No // 99 No      No      Yes     Yes     Yes     No      Yes //100 No      No      Yes     Yes     Yes     No      No //101 No      No      Yes     Yes     No      Yes     Yes //102 No      No      Yes     Yes     No      Yes     No //103 No      No      Yes     Yes     No      No      Yes //104 No      No      Yes     Yes     No      No      No //105 No      No      Yes     No      Yes     Yes     Yes //106 No      No      Yes     No      Yes     Yes     No //107 No      No      Yes     No      Yes     No      Yes //108 No      No      Yes     No      Yes     No      No //109 No      No      Yes     No      No      Yes     Yes //110 No      No      Yes     No      No      Yes     No //111 No      No      Yes     No      No      No      Yes //112 No      No      Yes     No      No      No      No //113 No      No      No      Yes     Yes     Yes     Yes //114 No      No      No      Yes     Yes     Yes     No //115 No      No      No      Yes     Yes     No      Yes //116 No      No      No      Yes     Yes     No      No //117 No      No      No      Yes     No      Yes     Yes //118 No      No      No      Yes     No      Yes     No //119 No      No      No      Yes     No      No      Yes //120 No      No      No      Yes     No      No      No //121 No      No      No      No      Yes     Yes     Yes //122 No      No      No      No      Yes     Yes     No //123 No      No      No      No      Yes     No      Yes //124 No      No      No      No      Yes     No      No //125 No      No      No      No      No      Yes     Yes //126 No      No      No      No      No      Yes     No //127 No      No      No      No      No      No      Yes //128 No      No      No      No      No      No      No //   写死了128不好吧[/quote] 过早的优化是万恶之源！

提醒：在cmd窗口中输入命令： cd /d 程序所在盘符和目录 程序 >output.txt 将程序的结果通过输出重定向到文件output.txt 然后在Excel中可以直接导入该output.txt文件。

引用 2 楼 zhao4zhong1 的回复:#include <stdio.h> #include <stdlib.h> int main() {     int i,j;     char b[7+1];     char bs[7+1];     printf("    Apple    Banana Tee     Juice   Milke   Meat    Water  \n");     for (i=0;i<128;i++) {         printf("%3d ",i+1);         ltoa(i,b,2);         sprintf(bs,"%07s",b);         for (j=0;j<7;j++) {             if (bs[j]=='0') printf("Yes     ");             else            printf("No      ");         }         printf("\n");     }     return 0; } //    Apple    Banana Tee     Juice   Milke   Meat    Water //  1 Yes     Yes     Yes     Yes     Yes     Yes     Yes //  2 Yes     Yes     Yes     Yes     Yes     Yes     No //  3 Yes     Yes     Yes     Yes     Yes     No      Yes //  4 Yes     Yes     Yes     Yes     Yes     No      No //  5 Yes     Yes     Yes     Yes     No      Yes     Yes //  6 Yes     Yes     Yes     Yes     No      Yes     No //  7 Yes     Yes     Yes     Yes     No      No      Yes //  8 Yes     Yes     Yes     Yes     No      No      No //  9 Yes     Yes     Yes     No      Yes     Yes     Yes // 10 Yes     Yes     Yes     No      Yes     Yes     No // 11 Yes     Yes     Yes     No      Yes     No      Yes // 12 Yes     Yes     Yes     No      Yes     No      No // 13 Yes     Yes     Yes     No      No      Yes     Yes // 14 Yes     Yes     Yes     No      No      Yes     No // 15 Yes     Yes     Yes     No      No      No      Yes // 16 Yes     Yes     Yes     No      No      No      No // 17 Yes     Yes     No      Yes     Yes     Yes     Yes // 18 Yes     Yes     No      Yes     Yes     Yes     No // 19 Yes     Yes     No      Yes     Yes     No      Yes // 20 Yes     Yes     No      Yes     Yes     No      No // 21 Yes     Yes     No      Yes     No      Yes     Yes // 22 Yes     Yes     No      Yes     No      Yes     No // 23 Yes     Yes     No      Yes     No      No      Yes // 24 Yes     Yes     No      Yes     No      No      No // 25 Yes     Yes     No      No      Yes     Yes     Yes // 26 Yes     Yes     No      No      Yes     Yes     No // 27 Yes     Yes     No      No      Yes     No      Yes // 28 Yes     Yes     No      No      Yes     No      No // 29 Yes     Yes     No      No      No      Yes     Yes // 30 Yes     Yes     No      No      No      Yes     No // 31 Yes     Yes     No      No      No      No      Yes // 32 Yes     Yes     No      No      No      No      No // 33 Yes     No      Yes     Yes     Yes     Yes     Yes // 34 Yes     No      Yes     Yes     Yes     Yes     No // 35 Yes     No      Yes     Yes     Yes     No      Yes // 36 Yes     No      Yes     Yes     Yes     No      No // 37 Yes     No      Yes     Yes     No      Yes     Yes // 38 Yes     No      Yes     Yes     No      Yes     No // 39 Yes     No      Yes     Yes     No      No      Yes // 40 Yes     No      Yes     Yes     No      No      No // 41 Yes     No      Yes     No      Yes     Yes     Yes // 42 Yes     No      Yes     No      Yes     Yes     No // 43 Yes     No      Yes     No      Yes     No      Yes // 44 Yes     No      Yes     No      Yes     No      No // 45 Yes     No      Yes     No      No      Yes     Yes // 46 Yes     No      Yes     No      No      Yes     No // 47 Yes     No      Yes     No      No      No      Yes // 48 Yes     No      Yes     No      No      No      No // 49 Yes     No      No      Yes     Yes     Yes     Yes // 50 Yes     No      No      Yes     Yes     Yes     No // 51 Yes     No      No      Yes     Yes     No      Yes // 52 Yes     No      No      Yes     Yes     No      No // 53 Yes     No      No      Yes     No      Yes     Yes // 54 Yes     No      No      Yes     No      Yes     No // 55 Yes     No      No      Yes     No      No      Yes // 56 Yes     No      No      Yes     No      No      No // 57 Yes     No      No      No      Yes     Yes     Yes // 58 Yes     No      No      No      Yes     Yes     No // 59 Yes     No      No      No      Yes     No      Yes // 60 Yes     No      No      No      Yes     No      No // 61 Yes     No      No      No      No      Yes     Yes // 62 Yes     No      No      No      No      Yes     No // 63 Yes     No      No      No      No      No      Yes // 64 Yes     No      No      No      No      No      No // 65 No      Yes     Yes     Yes     Yes     Yes     Yes // 66 No      Yes     Yes     Yes     Yes     Yes     No // 67 No      Yes     Yes     Yes     Yes     No      Yes // 68 No      Yes     Yes     Yes     Yes     No      No // 69 No      Yes     Yes     Yes     No      Yes     Yes // 70 No      Yes     Yes     Yes     No      Yes     No // 71 No      Yes     Yes     Yes     No      No      Yes // 72 No      Yes     Yes     Yes     No      No      No // 73 No      Yes     Yes     No      Yes     Yes     Yes // 74 No      Yes     Yes     No      Yes     Yes     No // 75 No      Yes     Yes     No      Yes     No      Yes // 76 No      Yes     Yes     No      Yes     No      No // 77 No      Yes     Yes     No      No      Yes     Yes // 78 No      Yes     Yes     No      No      Yes     No // 79 No      Yes     Yes     No      No      No      Yes // 80 No      Yes     Yes     No      No      No      No // 81 No      Yes     No      Yes     Yes     Yes     Yes // 82 No      Yes     No      Yes     Yes     Yes     No // 83 No      Yes     No      Yes     Yes     No      Yes // 84 No      Yes     No      Yes     Yes     No      No // 85 No      Yes     No      Yes     No      Yes     Yes // 86 No      Yes     No      Yes     No      Yes     No // 87 No      Yes     No      Yes     No      No      Yes // 88 No      Yes     No      Yes     No      No      No // 89 No      Yes     No      No      Yes     Yes     Yes // 90 No      Yes     No      No      Yes     Yes     No // 91 No      Yes     No      No      Yes     No      Yes // 92 No      Yes     No      No      Yes     No      No // 93 No      Yes     No      No      No      Yes     Yes // 94 No      Yes     No      No      No      Yes     No // 95 No      Yes     No      No      No      No      Yes // 96 No      Yes     No      No      No      No      No // 97 No      No      Yes     Yes     Yes     Yes     Yes // 98 No      No      Yes     Yes     Yes     Yes     No // 99 No      No      Yes     Yes     Yes     No      Yes //100 No      No      Yes     Yes     Yes     No      No //101 No      No      Yes     Yes     No      Yes     Yes //102 No      No      Yes     Yes     No      Yes     No //103 No      No      Yes     Yes     No      No      Yes //104 No      No      Yes     Yes     No      No      No //105 No      No      Yes     No      Yes     Yes     Yes //106 No      No      Yes     No      Yes     Yes     No //107 No      No      Yes     No      Yes     No      Yes //108 No      No      Yes     No      Yes     No      No //109 No      No      Yes     No      No      Yes     Yes //110 No      No      Yes     No      No      Yes     No //111 No      No      Yes     No      No      No      Yes //112 No      No      Yes     No      No      No      No //113 No      No      No      Yes     Yes     Yes     Yes //114 No      No      No      Yes     Yes     Yes     No //115 No      No      No      Yes     Yes     No      Yes //116 No      No      No      Yes     Yes     No      No //117 No      No      No      Yes     No      Yes     Yes //118 No      No      No      Yes     No      Yes     No //119 No      No      No      Yes     No      No      Yes //120 No      No      No      Yes     No      No      No //121 No      No      No      No      Yes     Yes     Yes //122 No      No      No      No      Yes     Yes     No //123 No      No      No      No      Yes     No      Yes //124 No      No      No      No      Yes     No      No //125 No      No      No      No      No      Yes     Yes //126 No      No      No      No      No      Yes     No //127 No      No      No      No      No      No      Yes //128 No      No      No      No      No      No      No // 谢了，赵老师！

谢谢各位，这个问题已经解决，思路如上诉所示，我用Java的按位与运算符截取Java int(32位)的后气味，从0到127的后七位，然后放进boolean的128x7的二维数组里面，然后取出判断是true就输出Yes，是false就输出No。  import java.util.Scanner;  public class Exercise4_46 { 	public static void main(String[] args) {  		// 定义二维数组 		boolean[][] result = new boolean[128][7]; 		int indexHang = 0; 		int indexLie = 0;  		for (int number = 0; number < 128; number++) { 			int value = number; 			int mask = 1; 			for (int i = 6; i >= 0; i--) { 				int temp = value >> i; 				int bit = temp & mask; 				if (bit == 1) { 					result[indexHang][indexLie++] = true; 				} else { 					result[indexHang][indexLie++] = false; 				} //				System.out.print(bit); 			} 			indexHang++; 			indexLie = 0; //			System.out.println(); 		} 		 		System.out.println("Apple\t Banana\t Tee\t Juice\t Milke\t Meat\t Water"); 		for(int i = 0; i < result.length; i++) { 			for(int j = 0; j < result[i].length; j++) { 				if(result[i][j] == true) { 					System.out.print("Yes" + " \t"); 				} else { 					System.out.print("No" + " \t"); 				} 			} 			System.out.println(); 		} 	} }  其实这是我一留学到德国的中学女同学问我的，她在某电子商城工作，不知道怎么就遇到这个问题，要统计这7种产品。输出的案例如赵四老师输出的一样，发给她看，她觉得不错，结果应该是对的，然后帮她生成Excel格式。随便也贴Java生成Excel代码吧。  import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.List; //下面是和数据导出有关的包 import org.apache.poi.hssf.usermodel.HSSFCell; import org.apache.poi.hssf.usermodel.HSSFCellStyle; import org.apache.poi.hssf.usermodel.HSSFRow; import org.apache.poi.hssf.usermodel.HSSFSheet; import org.apache.poi.hssf.usermodel.HSSFWorkbook; public class Test { 	 	public static String chage(boolean flag){ 		if(flag == true) { 			return "Yes"; 		} 		return "No"; 	} 	 	public static boolean[][] getResult() {  		// 定义二维数组 		boolean[][] result = new boolean[128][7]; 		int indexHang = 0; 		int indexLie = 0;  		for (int number = 0; number < 128; number++) { 			int value = number; 			int mask = 1; 			for (int i = 6; i >= 0; i--) { 				int temp = value >> i; 				int bit = temp & mask; 				if (bit == 1) { 					result[indexHang][indexLie++] = true; 				} else { 					result[indexHang][indexLie++] = false; 				} 			} 			indexHang++; 			indexLie = 0; 		} 		 		return result; 	}          public void Export(){     	boolean[][] result = getResult();     	         // 声明一个工作薄         HSSFWorkbook wb = new HSSFWorkbook();         //声明一个单子并命名         HSSFSheet sheet = wb.createSheet("result");         //给单子名称一个长度         sheet.setDefaultColumnWidth(10);         // 生成一个样式           HSSFCellStyle style = wb.createCellStyle();         //创建第一行（也可以称为表头）         HSSFRow row = sheet.createRow(0);         //样式字体居中         style.setAlignment(HSSFCellStyle.ALIGN_CENTER);         //给表头第一行一次创建单元格         HSSFCell cell = row.createCell(0);         cell.setCellValue("Apple");          cell.setCellStyle(style);         cell = row.createCell(1);   	        cell.setCellValue("Banana");   	        cell.setCellStyle(style);   	        cell = row.createCell(2);   	        cell.setCellValue("Tee");   	        cell.setCellStyle(style);  	        cell = row.createCell(3);   	        cell.setCellValue("Juice");   	        cell.setCellStyle(style); 	        cell = row.createCell(4);   	        cell.setCellValue("Milke");   	        cell.setCellStyle(style); 	        cell = row.createCell(5);   	        cell.setCellValue("Meat");   	        cell.setCellStyle(style);  	        cell = row.createCell(6);   	        cell.setCellValue("Water");   	        cell.setCellStyle(style);                  //向单元格里填充数据                for (int i = 0; i < result.length; i++) {             	   int j = 0; 	                row = sheet.createRow(i + 1); 	                row.createCell(0).setCellValue(chage(result[i][j++])); 	                row.createCell(1).setCellValue(chage(result[i][j++])); 	                row.createCell(2).setCellValue(chage(result[i][j++])); 	                row.createCell(3).setCellValue(chage(result[i][j++])); 	                row.createCell(4).setCellValue(chage(result[i][j++])); 	                row.createCell(5).setCellValue(chage(result[i][j++])); 	                row.createCell(6).setCellValue(chage(result[i][j++]));             }                  try {             //默认导出到E盘下             FileOutputStream out = new FileOutputStream("/home/shizongger/Documents/Result.xls");             wb.write(out);             out.close();         } catch (FileNotFoundException e) {             e.printStackTrace();         } catch (IOException e) {             e.printStackTrace();         }     }          public static void main(String[] args) { 		new Test().Export(); 	} }  这样就把以上输出案例放进excel里面了。收到她发来的感谢，感觉这也算是跨越亚欧的合作，一次国际性解决了问题了。

我觉得应该这么写:  对一个int变量, 最低位不停的加1,一直加至1111111(二进制).每加一次就根据各个二进位的情况输出一次结果.

引用 2 楼 zhao4zhong1 的回复:#include <stdio.h> #include <stdlib.h> int main() {     int i,j;     char b[7+1];     char bs[7+1];     printf("    Apple    Banana Tee     Juice   Milke   Meat    Water  \n");     for (i=0;i<128;i++) {         printf("%3d ",i+1);         ltoa(i,b,2);         sprintf(bs,"%07s",b);         for (j=0;j<7;j++) {             if (bs[j]=='0') printf("Yes     ");             else            printf("No      ");         }         printf("\n");     }     return 0; } //    Apple    Banana Tee     Juice   Milke   Meat    Water //  1 Yes     Yes     Yes     Yes     Yes     Yes     Yes //  2 Yes     Yes     Yes     Yes     Yes     Yes     No //  3 Yes     Yes     Yes     Yes     Yes     No      Yes //  4 Yes     Yes     Yes     Yes     Yes     No      No //  5 Yes     Yes     Yes     Yes     No      Yes     Yes //  6 Yes     Yes     Yes     Yes     No      Yes     No //  7 Yes     Yes     Yes     Yes     No      No      Yes //  8 Yes     Yes     Yes     Yes     No      No      No //  9 Yes     Yes     Yes     No      Yes     Yes     Yes // 10 Yes     Yes     Yes     No      Yes     Yes     No // 11 Yes     Yes     Yes     No      Yes     No      Yes // 12 Yes     Yes     Yes     No      Yes     No      No // 13 Yes     Yes     Yes     No      No      Yes     Yes // 14 Yes     Yes     Yes     No      No      Yes     No // 15 Yes     Yes     Yes     No      No      No      Yes // 16 Yes     Yes     Yes     No      No      No      No // 17 Yes     Yes     No      Yes     Yes     Yes     Yes // 18 Yes     Yes     No      Yes     Yes     Yes     No // 19 Yes     Yes     No      Yes     Yes     No      Yes // 20 Yes     Yes     No      Yes     Yes     No      No // 21 Yes     Yes     No      Yes     No      Yes     Yes // 22 Yes     Yes     No      Yes     No      Yes     No // 23 Yes     Yes     No      Yes     No      No      Yes // 24 Yes     Yes     No      Yes     No      No      No // 25 Yes     Yes     No      No      Yes     Yes     Yes // 26 Yes     Yes     No      No      Yes     Yes     No // 27 Yes     Yes     No      No      Yes     No      Yes // 28 Yes     Yes     No      No      Yes     No      No // 29 Yes     Yes     No      No      No      Yes     Yes // 30 Yes     Yes     No      No      No      Yes     No // 31 Yes     Yes     No      No      No      No      Yes // 32 Yes     Yes     No      No      No      No      No // 33 Yes     No      Yes     Yes     Yes     Yes     Yes // 34 Yes     No      Yes     Yes     Yes     Yes     No // 35 Yes     No      Yes     Yes     Yes     No      Yes // 36 Yes     No      Yes     Yes     Yes     No      No // 37 Yes     No      Yes     Yes     No      Yes     Yes // 38 Yes     No      Yes     Yes     No      Yes     No // 39 Yes     No      Yes     Yes     No      No      Yes // 40 Yes     No      Yes     Yes     No      No      No // 41 Yes     No      Yes     No      Yes     Yes     Yes // 42 Yes     No      Yes     No      Yes     Yes     No // 43 Yes     No      Yes     No      Yes     No      Yes // 44 Yes     No      Yes     No      Yes     No      No // 45 Yes     No      Yes     No      No      Yes     Yes // 46 Yes     No      Yes     No      No      Yes     No // 47 Yes     No      Yes     No      No      No      Yes // 48 Yes     No      Yes     No      No      No      No // 49 Yes     No      No      Yes     Yes     Yes     Yes // 50 Yes     No      No      Yes     Yes     Yes     No // 51 Yes     No      No      Yes     Yes     No      Yes // 52 Yes     No      No      Yes     Yes     No      No // 53 Yes     No      No      Yes     No      Yes     Yes // 54 Yes     No      No      Yes     No      Yes     No // 55 Yes     No      No      Yes     No      No      Yes // 56 Yes     No      No      Yes     No      No      No // 57 Yes     No      No      No      Yes     Yes     Yes // 58 Yes     No      No      No      Yes     Yes     No // 59 Yes     No      No      No      Yes     No      Yes // 60 Yes     No      No      No      Yes     No      No // 61 Yes     No      No      No      No      Yes     Yes // 62 Yes     No      No      No      No      Yes     No // 63 Yes     No      No      No      No      No      Yes // 64 Yes     No      No      No      No      No      No // 65 No      Yes     Yes     Yes     Yes     Yes     Yes // 66 No      Yes     Yes     Yes     Yes     Yes     No // 67 No      Yes     Yes     Yes     Yes     No      Yes // 68 No      Yes     Yes     Yes     Yes     No      No // 69 No      Yes     Yes     Yes     No      Yes     Yes // 70 No      Yes     Yes     Yes     No      Yes     No // 71 No      Yes     Yes     Yes     No      No      Yes // 72 No      Yes     Yes     Yes     No      No      No // 73 No      Yes     Yes     No      Yes     Yes     Yes // 74 No      Yes     Yes     No      Yes     Yes     No // 75 No      Yes     Yes     No      Yes     No      Yes // 76 No      Yes     Yes     No      Yes     No      No // 77 No      Yes     Yes     No      No      Yes     Yes // 78 No      Yes     Yes     No      No      Yes     No // 79 No      Yes     Yes     No      No      No      Yes // 80 No      Yes     Yes     No      No      No      No // 81 No      Yes     No      Yes     Yes     Yes     Yes // 82 No      Yes     No      Yes     Yes     Yes     No // 83 No      Yes     No      Yes     Yes     No      Yes // 84 No      Yes     No      Yes     Yes     No      No // 85 No      Yes     No      Yes     No      Yes     Yes // 86 No      Yes     No      Yes     No      Yes     No // 87 No      Yes     No      Yes     No      No      Yes // 88 No      Yes     No      Yes     No      No      No // 89 No      Yes     No      No      Yes     Yes     Yes // 90 No      Yes     No      No      Yes     Yes     No // 91 No      Yes     No      No      Yes     No      Yes // 92 No      Yes     No      No      Yes     No      No // 93 No      Yes     No      No      No      Yes     Yes // 94 No      Yes     No      No      No      Yes     No // 95 No      Yes     No      No      No      No      Yes // 96 No      Yes     No      No      No      No      No // 97 No      No      Yes     Yes     Yes     Yes     Yes // 98 No      No      Yes     Yes     Yes     Yes     No // 99 No      No      Yes     Yes     Yes     No      Yes //100 No      No      Yes     Yes     Yes     No      No //101 No      No      Yes     Yes     No      Yes     Yes //102 No      No      Yes     Yes     No      Yes     No //103 No      No      Yes     Yes     No      No      Yes //104 No      No      Yes     Yes     No      No      No //105 No      No      Yes     No      Yes     Yes     Yes //106 No      No      Yes     No      Yes     Yes     No //107 No      No      Yes     No      Yes     No      Yes //108 No      No      Yes     No      Yes     No      No //109 No      No      Yes     No      No      Yes     Yes //110 No      No      Yes     No      No      Yes     No //111 No      No      Yes     No      No      No      Yes //112 No      No      Yes     No      No      No      No //113 No      No      No      Yes     Yes     Yes     Yes //114 No      No      No      Yes     Yes     Yes     No //115 No      No      No      Yes     Yes     No      Yes //116 No      No      No      Yes     Yes     No      No //117 No      No      No      Yes     No      Yes     Yes //118 No      No      No      Yes     No      Yes     No //119 No      No      No      Yes     No      No      Yes //120 No      No      No      Yes     No      No      No //121 No      No      No      No      Yes     Yes     Yes //122 No      No      No      No      Yes     Yes     No //123 No      No      No      No      Yes     No      Yes //124 No      No      No      No      Yes     No      No //125 No      No      No      No      No      Yes     Yes //126 No      No      No      No      No      Yes     No //127 No      No      No      No      No      No      Yes //128 No      No      No      No      No      No      No //   写死了128不好吧

是要罗列出来 总数其实就是一个数学史的组合问题  用位来记录状态是个好办法 然后每次 + 1 进行递增到最大即可


Question: How to configure Environment Modules as static way?

引用 2 楼 zhao4zhong1 的回复:仅供参考：Load the math library, and print the cosine of 2.0:  #include <stdio.h> #include <dlfcn.h>  int main(int argc, char **argv) {     void *handle;     double (*cosine)(double);     char *error;      handle = dlopen ("libm.so", RTLD_LAZY);     if (!handle) {         fprintf (stderr, "%s\n", dlerror());         exit(1);     }      dlerror();    /* Clear any existing error */     *(void **) (&cosine) = dlsym(handle, "cos");     if ((error = dlerror()) != NULL)  {         fprintf (stderr, "%s\n", error);         exit(1);     }      printf ("%f\n", (*cosine)(2.0));     dlclose(handle);     return 0; }  If this program were in a file named "foo.c", you would build the program with the following command:   gcc -rdynamic -o foo foo.c -ldl   Libraries exporting _init() and _fini() will want to be compiled as follows, using bar.c as the example name:   gcc -shared -nostartfiles -o bar bar.c      您好，感谢您的回复。 这个软件是执行 configure 产生Makefile，然后make，make install 安装。 configure有很多option，我用了 --with-static，最后在 Makefile 中生成 一行 STATIC = -static。 到最后编译生成的 可执行程序，却仍然依赖 libtcl8,4.so，让人很费解。 搞了很多天了。 还是没有搞定。 有静态编译和安装过的Environment Modules的朋友可以指导下吗？

这应该是linux内容了


Question: 用C语言写一个身份证识别省区！

这个用C++的容器MAP容器很简单的。可能故意要用C实现吧。还是再好好看下hash的C语言实现吧。感觉你这个好麻烦。 内存现在不缺，用六位的二维数组就能很简单的实现。第一个成员为数字，后面的字符串代表那个省区。直接用省份证的这个值直接索引出来。

为什么不使用stl的map呢？

仅供参考  #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h>  /* ------------------结构体定义------------------ */ typedef struct _hashBucket_t { 	char* key; 	size_t key_len; 	char* data; 	size_t data_len; 	struct _hashBucket_t *next; }  hashBucket_t;  typedef struct _hashMap_t { 	size_t hash_bits; 	size_t bucket_num; 	hashBucket_t bucket[0]; } hashMap_t;  /* -----------------hashmap API ------------------ */ /* count: 预计有多少条数据 */ hashMap_t* hashMapCreate(unsigned long count); void hashMapDestroy(hashMap_t* map); void hashMapInsert(hashMap_t* map, void* key, size_t key_len, void* data, size_t data_len); int hashMapSearch(hashMap_t*   map, void* key, size_t key_len, void** data, size_t* data_len);   /* ------------------demo------------------------ */ int main(void) { 	hashMap_t* map = NULL; 	char* data = NULL; 	size_t data_len = 0; 	int ret;  	map = hashMapCreate(1000);  	hashMapInsert(map, "1+1=", 4, "2", 1); 	hashMapInsert(map, "1+2=", 4, "3", 1); 	hashMapInsert(map, "1+3=", 4, "4", 1); 	hashMapInsert(map, "1+4=", 4, "5", 1); 	hashMapInsert(map, "1+5=", 4, "6", 1); 	hashMapInsert(map, "1+6=", 4, "7", 1); 	hashMapInsert(map, "1+7=", 4, "8", 1); 	hashMapInsert(map, "1+8=", 4, "9", 1); 	hashMapInsert(map, "Hello", -1, "World", -1);  	ret = hashMapSearch(map, "Hello", -1, (void**)&data, &data_len); 	if (ret == 1) { 		printf("%s(len=%zx)\n", data, data_len); 	} 	else { 		printf("not found\n"); 	}  	hashMapDestroy(map);  }  hashMap_t* hashMapCreate(unsigned long count) { 	int i = 0; 	size_t bucket_num = 1; 	size_t hash_bits = 0; 	hashMap_t* map = NULL;  	while (1) { 		bucket_num *= 2; 		hash_bits++; 		if (bucket_num >= count) { 			break; 		} 	} 	 	map = (hashMap_t*)calloc(1, sizeof(hashMap_t) + \ 	sizeof(hashBucket_t) * bucket_num); 	map->bucket_num = bucket_num; 	map->hash_bits = hash_bits;  	return map; }  void hashMapDestroy(hashMap_t* map) { 	int i; 	hashBucket_t* bucket;	 	hashBucket_t* tmp; 	 	for (i = 0; i < map->bucket_num; i++) { 		bucket = &map->bucket[i]; 		if (bucket->key_len == 0) { 			continue; 		} 		free(bucket->data); 		free(bucket->key);  		bucket = bucket->next; 		while (bucket != NULL) { 			free(bucket->data); 			free(bucket->key); 			tmp = bucket; 			bucket = bucket->next; 			free(tmp); 		} 	} 	free(map); }  static unsigned long _calcHashValue(hashMap_t* map, void* key, size_t key_len) { 	char* ch = (char*)key; 	unsigned long seed = 131UL; 	unsigned long hash = 0UL;  	for (ch = (char*)key; ch < (char*)key + key_len; ch++) { 		hash = hash * seed + (*ch); 	}  	hash &= (~0UL >> (sizeof(unsigned long) * 8 - map->hash_bits)); 	 	return hash; }  void hashMapInsert(hashMap_t*      map, void* key, size_t key_len, void* data, size_t data_len) { 	unsigned long hash = _calcHashValue(map, key, key_len); 	hashBucket_t* bucket = &map->bucket[hash];  	if (key_len == -1) { 		key_len = strlen((char*)key); 	} 	if (data_len == -1) { 		data_len = strlen((char*)data); 	}  	if (bucket->key_len) { 		while (bucket->next != NULL) { 			bucket = bucket->next; 		}  		bucket->next = (hashBucket_t*)calloc(1, sizeof(hashBucket_t)); 		bucket = bucket->next; 	}  	bucket->key = (char*)calloc(1, key_len + 1); 	memcpy(bucket->key, key, key_len); 	bucket->key_len = key_len;  	bucket->data = (char*)calloc(1, data_len + 1); 	memcpy(bucket->data, data, data_len); 	bucket->data_len = data_len; }  int hashMapSearch(hashMap_t*   map, void* key, size_t key_len, void** data, size_t* data_len) { 	unsigned long hash = _calcHashValue(map, key, key_len); 	hashBucket_t* bucket = &map->bucket[hash];  	if (key_len == -1) { 		key_len = strlen((char*)key); 	}  	while (bucket != NULL) { 		if ((key_len == bucket->key_len) && !memcmp(key, bucket->key, key_len)) { 			if (data) { 				*data = bucket->data; 			} 			if (data_len) { 				*data_len = bucket->data_len; 			} 			return 1;	 		} 		bucket = bucket->next; 	}  	return 0; }


Question: 虚拟文件系统  操作系统

参考Linux源代码中相关片断。


Question: C语言视频教程

谢谢7楼提供的网站

慕课网上Linux C怎么学习方便？必须安装Linux操作系统吗？

http://c.biancheng.net/cpp/ http://www.51zxw.net/ http://blog.jobbole.com/category/c-cpp/ http://club.topsage.com/forum-121-1.html

谢谢各位老师和长辈的回复！

可以到慕课网去找，那里有免费的课程，老师都是各大院校的讲师，教授，很有用

可以看一下C Primer plus这本书

C语言教程（附带C语言100例）http://download.csdn.net/detail/zhao4zhong1/8830817

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。  代码功能归根结底不是别人帮自己看或讲解或注释出来的；而是被自己静下心来花足够长的时间和精力亲自动手单步或设断点或对执行到某步获得的中间结果显示或写到日志文件中一步一步分析出来的。 提醒：再牛×的老师也无法代替学生自己领悟和上厕所！ 单步调试和设断点调试（VS IDE中编译连接通过以后，按F10或F11键单步执行，按Shift+F11退出当前函数；在某行按F9设断点后按F5执行停在该断点处。）是程序员必须掌握的技能之一。

好的。谢谢赵老师


Question: 数组元素的地址

不好意思。我最近忙于考试复习，没及时回复。另外，各位的答案对我很有帮助，尤其是赵老师的视频，解开了我的疑惑，而且让我对地址有更深的了解。谢谢各位。

一个地址单元 与 一个字节 不是一码事

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

书本上说的这个地址单元是不是没有说的很详细。但是对于int类型的数组，每个元素就是占4个字节的内存，内存是一个字节为单位的，既然是一个单元，那么这个单元就是4个字节。

一楼正解，你要在意地址单元这个字眼，内存并不认识什么是地址单元，它只知道一个int类型的变量长度为4个字节，这个才是真理，其他都是浮云


Question: 请各位大哥们帮忙改一下错误，在这里感谢大家了

函数里定义函数，这是那种语言支持的语法？看你的是C语言，怎么可以这么写？ typedef 重命名的名字呢？ 代码不好改，我看有多个main，你这个是多个程序还是一个程序？

百度搜相关关键字。

这是我们的作业，课程设计。是从别的地方找来的，自己学识太浅，表示解决不了。唉。希望有大神帮忙

新手表示都看不懂，你是自学的么


Question: 关于C语言在linux下的标准输入问题

好的,谢谢大家,大致懂了～

为什么不 man 相关函数 呢？

http://en.cppreference.com/w/c/io/fscanf http://en.cppreference.com/w/c/io/gets

gets是遇到回车才会结束，中间可以有空格，tab等字符； scanf遇到回车结束，因为标准输入也是行缓冲，遇到回车就会把输入缓存里的数据刷到内存了。但是scanf输入时，刷到内存里的数据与gets不一样，若scanf遇到空格，会将空格之前的数据赋值给变量；


Question: C语言求助！急！const void*内存分配问题

引用 4 楼 paranet 的回复:fun_fix:  main:  还是内存泄露    [quote=引用 2 楼 adlay 的回复:]  int func_fix(const void** data, unsigned int* len) {     int error;         *data=func(&len, &error);     return error; }  int main() {    const void* data = NULL;    func_fix(&data  .... } [/quote]  你发一个线程退出的图片如何说明有内存泄露呢?  有内存泄露你得着释放内存的地方是不是写错了.

引用 4 楼 paranet 的回复:fun_fix:  main:  还是内存泄露    [quote=引用 2 楼 adlay 的回复:]   int func_fix(const void** data, unsigned int* len) {     int error;         *data=func(&len, &error);     return error; }  int main() {    const void* data = NULL;    func_fix(&data  .... } [/quote]  使用的时候去掉data前面的&,调用QTTSAutoGet时，也要去掉audio_len前的&

fun_fix:  main:  还是内存泄露    引用 2 楼 adlay 的回复: int func_fix(const void** data, unsigned int* len) {     int error;         *data=func(&len, &error);     return error; }  int main() {    const void* data = NULL;    func_fix(&data  .... }

int func_fix(const void** data, unsigned int* len) {     int error;         *data=func(len, &error);     return error; }  main中调用 const void* pData = NULL; unsigned int len; int error = func_fix(&pData, & len); ... if(pData)   free(pData);

func是用于申请空间的吗？


Question: 代码问题

可以说的具体一点么？因为流量、压力是需要用户设置的，所以这一串数据是说明已经设置好数据可以传输了么？后面的00 00 00是不是设置的数据值？

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

字节值

#define	R1_Lenth		4			//串口1接收缓冲长度为4，  与泵通信

这是单片机通过串口控制泵的开机、关机等

同楼上，最好能给出具体问题。

这是什么，有没有这个问题的背景？


Question: 为什么不能改变实参的值

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

引用 12 楼 weixin_38277423 的回复:还是不理解，把地址交换了，按照地址再去找，那找到的值是另外一个呀？ 理解和讨论之前请先学会如何观察！  参考9楼！

引用 10 楼 weixin_38277423 的回复:[quote=引用 2 楼 cfjtaishan 的回复:] #include<stdio.h> void fun(int *a,int *b) {     int c;     c = *a;     *a = *b;     *b = c; } int main() {     int x=3, y=5,*p=&x, *q=&y;     fun(p,q);     printf("%d,%d\n",*p,*q);     fun(&x,&y);     printf("%d,%d\n",*p,*q);     return 0; }  修改的应该是指针指向的内存单元的值，交换应该交换的是指针指向的内存单元的值，而不是交换指针指向的地址。交换了指针指向的地址，那所指的值不就和原来不一样了吗[/quote] 虽然交换了地址，但是你没有将交换的地址传出swap函数，即swap函数的两个参数只是传入参数，调用swap结束后不能将改变后的地址带出来。所以，交换地址没有起到作用，交换值，是将两个指针指向的内容交换了，那么就是交换了数组里的值

2楼和18楼可以做到数值的交换和地址的交换；  C语言只有值传递，没有地址传递，而平时我们所说的地址传递或者传指针，实际上也是一种值传递，不过这个时候传递的是一个内存地址（实际上也是一个数字）； 而值传递，则是对实参的一个拷贝，所以对备份做的操作不会反馈到实参中。  使用指针之所以能改变实参数值，则是通过地址访问到实参对应的内存而实现的；但不会改变指针指向。  类推一下，基本变量想通过传参改值，需要用到一级指针； 那么如果想对一级指针通过传参改值，则就需要用到二级指针；  建议打印一下所有你怀疑的值，包括地址，这样会更清晰一些。

引用 17 楼 versatts 的回复:void fun(int **a, int **b) { 	int*c; 	c = *a; *a = *b; *b = c; }  int _tmain(int argc, _TCHAR* argv[]) { 	int x = 3, y = 5, *p = &x, *q = &y; 	fun(&p, &q); 	printf("%d,%d\n", *p, *q); 	//fun(&x, &y); 	//printf("%d,%d\n", *p, *q);  	getchar(); 	return 0; } 这样才能交换指针的地址。

你交换的指针是指针的复本，要交换指针的值需int &*a

引用 11 楼 weixin_38277423 的回复:[quote=引用 1 楼 wanggui2015 的回复:] 你函数里面修改的是形参指针的值，而没有修改指针指向的值，改成下面这样。   int c; c=*a;*a=*b;*b=c; 实参里面的两个指针有没有交换呀？[/quote]  C语言中参数的传递都是 值传递，形参是实参的一份拷贝，你修改形参的值并不会影响实参的值。  C++中还有另外一种参数传递方式 址传递，也就是参数是引用类型，这个时候形参仅是实参的一个别名，修改形参等同于修改实参。

还是不理解，把地址交换了，按照地址再去找，那找到的值是另外一个呀？

引用 1 楼 wanggui2015 的回复:你函数里面修改的是形参指针的值，而没有修改指针指向的值，改成下面这样。   int c; c=*a;*a=*b;*b=c; 实参里面的两个指针有没有交换呀？

引用 2 楼 cfjtaishan 的回复:#include<stdio.h> void fun(int *a,int *b) {     int c;     c = *a;     *a = *b;     *b = c; } int main() {     int x=3, y=5,*p=&x, *q=&y;     fun(p,q);     printf("%d,%d\n",*p,*q);     fun(&x,&y);     printf("%d,%d\n",*p,*q);     return 0; }  修改的应该是指针指向的内存单元的值，交换应该交换的是指针指向的内存单元的值，而不是交换指针指向的地址。交换了指针指向的地址，那所指的值不就和原来不一样了吗

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

需要再理解下,  传值和传址的区别.

建议你翻一下反汇编， 看看函数的调用逻辑， 参数如何压栈。

a是一个指针，*a才是指针指向对象。

仅供参考：#include <stdio.h> #define SWAP(a,b) do ((&(a))!=(&(b)))?((a)^=(b)^=(a)^=(b)):((a)=(a)); while (0) char   *p1="1" ,*p2="2" ; char    c1=1   , c2=2   ; short   s1=1   , s2=2   ; int     i1=1   , i2=2   ; __int64 I1=1i64, I2=2i64; float   f1=1.0f, f2=2.0f; double  d1=1.0 , d2=2.0 ; void main() {     SWAP((int)p1,(int)p2);                printf("char *     %5s,   %5s\n",p1,p2);     SWAP(c1,c2);                          printf("char       %5d,   %5d\n",c1,c2);     SWAP(s1,s2);                          printf("short      %5d,   %5d\n",s1,s2);     SWAP(i1,i2);                          printf("int        %5d,   %5d\n",i1,i2);     SWAP(I1,I2);                          printf("__int64 %5I64d,%5I64d\n",I1,I2);     SWAP(*(int     *)&f1,*(int     *)&f2);printf("float      %5g,   %5g\n",f1,f2);     SWAP(*(__int64 *)&d1,*(__int64 *)&d2);printf("double    %5lg,  %5lg\n",d1,d2);      SWAP(c1,c1);     printf("%d\n",c1); } //char *         2,       1 //char           2,       1 //short          2,       1 //int            2,       1 //__int64     2,    1 //float          2,       1 //double        2,      1 //2

void fun(int*a,int*b)          {              int c;             c=*a;*a=*b;*b=c;          }


Question: 求告知红色部分代码每行的详细解释  由于用来描述边框的一些字符不能出现在文章和标题中，已经删去那部分代码，可能导致程序不能运行

VS IDE中，在不明白的符号上点鼠标右键，选转到定义。  console屏幕处理例子程序。终端窗口屏幕处理相关API使用例子。来自MSVC20\SAMPLES\win32\console\ http://download.csdn.net/detail/zhao4zhong1/3461309


Question: strlen函数返回值为？

我发现如果拿一个字面量常数直接和strlen(p)比较，就会自动把这个strlen(p)换成整型的，但是如果我拿一个整型变量和strlen(p)比较大小，就会出错！调试的时候说无法显示他们比较结果的类型，必须加个强制类型转换！惊呆了，写了两年，头一次发现

引用 9 楼 weixin_37836059 的回复:调试的时候能看到plan里面是我输入的一串数字 我之前把LINE-1改成30了，现在运行特别正常，就是调试的时候能看到strlen还是返回<void> 真搞不明白明明都是<void>了，还能跟30比较大小= = 你调试的时候是不是没有输入，所以strlen得到是null

1、tcp->content[i].plan空间要大于30，否则输入时会越界  2、在DEBUG下调试程序，strlen返回值是int，你看到的可能是个假象

strlen(tcp->content[i].plan)  调用这一句之前, 你需要检查这些东西: 1.   tcp  这个指针是否为空 2.  content中到底有几个数据,  i是否会导致越界. 3. plan 到底是什么数据, 是否会有\0结尾.

使用前给plan初始化一下试试 memset(tcp->content[i].plan ,0 ,TXT);

还有一个办法定位，那就是输出tcp->content[i].plan的值，看看是否是你输入的内容。

不是strlen的问题，这个库函数大家都在用，不可能会有问题；还是你的代码哪儿有点问题， 个人的怀疑是gets(tcp->content[i].plan); 这句前面应该还有输入，上次输入之后的回车残留在输入缓冲区，而gets遇到回车直接返回，什么数据也没输入到plan里，所以strlen的返回值是0

请参考一下这个资料 http://blog.csdn.net/libing403/article/details/73086588

随便建个工程测试下strlen 比如 int len = strlen("Why is void?");

试了还是不行，strlen还是<void>,length=strlen（...）那里调试会蹦到汇编代码那去

结构体也在这了typedef union{ 	struct{ 		int hour:6; 		int min:7; 	}; 	int _time; }UNI;  typedef struct { 	int num; 	struct 	{ 		UNI _clock[2]; 		char plan[TXT]; 	}content[LINE]; 	time_t Ftime;     time_t Stime;     time_t Etime;     char id[ID]; }_calendar;

确定返回类型：  gets(tcp->content[i].plan); int length=strlen(tcp->content[i].plan); if(length>LINE-1) {     puts("字数超出上限!");     exit(1); }


Question: 求大佬帮助

C语言版： 之前的方法使用的就是迪杰斯特拉算法 可求出任意两顶点的最短路径  #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include <math.h> #define MAX_NUM 10000001   #define false 0 #define true 1 typedef int bool;  int returnmind(int * a[500], int * b[500], int head, int x, int* seq, bool*final);//找出最短距离 void findx(int first, int N, int * a[500], int*D, int * b[500], int des);  int main() { 	printf("以下所有的输入均使用空格分开\n"); 	char  S1, DES1; 	int N, M, S, DES; 	printf("输入顶点个数和边数：\n" );  	scanf("%d %d",  &N, &M); 	printf("输入出发顶点和目的顶点：\n"); 	scanf("\n%c %c", &S1 ,&DES1);  	S = S1 - 'a'; 	DES = DES1 - 'a'; 	int D[500]; 	int* a[500], *b[500];//距离和费用 	for (int i = 0; i < 500; i++) 	{ 		a[i] = malloc(sizeof(int)* 500); 		b[i] = malloc(sizeof(int)* 500); 	} 	char first, second; 	int point1, point2, length, price = 0;//price没用用 	//初始化a，b 	for (int i = 0; i < 500; i++) 	for (int j = 0; j < 500; j++) 	{ 		a[i][j] = MAX_NUM; 		b[i][j] = MAX_NUM; 	} 	//输入数据 	for (int i = 1; i <= M; i++) 	{ 		printf( "输入第%d条边:\n",i) ; 		scanf("\n%c %c %d", &first,&second , &length); 		point1 = first - 'a'; 		point2 = second - 'a'; 		a[point1][point2] = length; 		a[point2][point1] = length; 		a[point1][point1] = 0; 		a[point2][point2] = 0; 		b[point1][point2] = 0; 		b[point2][point1] = 0; 	} 	findx(S, N, a, D, b, DES);  	//释放内存 	for (int i = 0; i < 500; i++) 	{ 		free (a[i]); 		free (b[i]); 	} 	system("pause"); 	return 0; } //找出最小的D[x] void findx(int first, int N, int * a[500], int*D, int * b[500], int des) { 	int flag = false;//判断是否找到终点，找到则true 	bool final[500]; 	int price[500];//每条最短路径的费用 	for (int i = 0; i < N; i++) 	{ 		final[i] = false; 		price[i] = MAX_NUM; 	} 	final[first] = true; 	for (int k = 0; k < N; k++)//循环次数 	{  		int seq = 0; 		int tmp;  		tmp = returnmind(a, b, first, N, &seq, final);//找到最小的距离 		D[seq] = tmp; 		final[seq] = true; 		price[seq] = b[first][seq]; 		for (int i = 0; i < N; i++) 		if (((D[seq] + a[seq][i]) <= a[first][i]) && !final[i])//如果距离更短的话 		{ 			//更新所有的距离 和费用 			if ((((D[seq] + a[seq][i]) == a[first][i]) && (b[first][seq] + b[seq][i]) < b[first][i]) || (D[seq] + a[seq][i]) < a[first][i]) 			{ 				a[first][i] = D[seq] + a[seq][i]; 				b[first][i] = b[first][seq] + b[seq][i]; 			} 		} 	} 	 	printf("\n最短路径长度：%d\n" , a[first][des] );//输出最短路径 } int returnmind(int * a[500], int * b[500], int head, int x, int *seq, bool*final)//找出最短距离 { 	int min = MAX_NUM; 	int minprice = MAX_NUM; 	for (int j = 0; j < x; j++) 	if (a[head][j] != 0 && !final[j]) 	{ 		if (min >= a[head][j])//路径最短 		{ 			if ((min == a[head][j] && minprice > b[head][j]) || min > a[head][j])//价格最低 			{ 				min = a[head][j]; 				*seq = j; 			} 		} 	} 	return min; }

越简单越好

引用 5 楼 Van_Le的回复:以下程序能完成求最短路径：  #include<iostream> #include <iomanip> #include<string.h> #define MAX_NUM 10000001 using namespace std; int returnmind(int * a[500], int * b[500], int head, int x, int &seq, bool*final);//找出最短距离 void findx(int first, int N, int * a[500], int*D, int * b[500], int des);  int main() { 	cout << "以下所有的输入均使用空格分开" << endl; 	char  S1, DES1; 	int N, M, S, DES; 	cout << "输入顶点个数和边数："<<endl;  	cin >> N >> M; 	cout << "输入出发顶点和目的顶点："<<endl; 	cin>> S1 >> DES1;  	S = S1 - 'a'; 	DES = DES1 - 'a'; 	int D[500]; 	int* a[500], *b[500];//距离和费用 	for (int i = 0; i < 500; i++) 	{ 		a[i] = new int[500]; 		b[i] = new int[500]; 	} 	char first, second; 	int point1, point2, length, price=0;//price没用用 	//初始化a，b 	for (int i = 0; i < 500; i++) 	for (int j = 0; j < 500; j++) 	{ 		a[i][j] = MAX_NUM; 		b[i][j] = MAX_NUM; 	} 	//输入数据 	for (int i = 1; i <= M; i++) 	{ 		cout << "输入第" << i << "条边:" << endl; 		cin >> first >> second >> length; 		point1 = first - 'a'; 		point2 = second - 'a'; 		a[point1][point2] = length; 		a[point2][point1] = length; 		a[point1][point1] = 0; 		a[point2][point2] = 0; 		b[point1][point2] = 0; 		b[point2][point1] = 0; 	} 	findx(S, N, a, D, b, DES);  	//释放内存 	for (int i = 0; i < 500; i++) 	{ 		delete  a[i]; 		delete  b[i]; 	} 	system("pause"); 	return 0; } //找出最小的D[x] void findx(int first, int N, int * a[500], int*D, int * b[500], int des) { 	bool final[500]; 	int price[500];//每条最短路径的费用 	for (int i = 0; i <N; i++) 	{ 		final[i] = false; 		price[i] = MAX_NUM; 	} 	final[first] = true; 	for (int k = 0; k < N; k++)//循环次数 	{  		int seq = 0; 		int tmp;  		tmp = returnmind(a, b, first, N, seq, final);//找到最小的距离 		D[seq] = tmp; 		final[seq] = true; 		price[seq] = b[first][seq]; 		for (int i = 0; i < N; i++) 		if (((D[seq] + a[seq][i]) <= a[first][i]) && !final[i])//如果距离更短的话 		{ 			//更新所有的距离 和费用 			if ((((D[seq] + a[seq][i]) == a[first][i]) && (b[first][seq] + b[seq][i]) < b[first][i]) || (D[seq] + a[seq][i]) < a[first][i]) 			{ 				a[first][i] = D[seq] + a[seq][i]; 				b[first][i] = b[first][seq] + b[seq][i]; 			} 		} 	} 	cout << endl; 	cout << "最短路径长度："<<a[first][des]  << endl;//输出最短路径 } int returnmind(int * a[500], int * b[500], int head, int x, int &seq, bool*final)//找出最短距离 { 	int min = MAX_NUM; 	int minprice = MAX_NUM; 	for (int j = 0; j < x; j++) 	if (a[head][j] != 0 && !final[j]) 	{ 		if (min >= a[head][j])//路径最短 		{ 			if ((min == a[head][j] && minprice > b[head][j]) || min > a[head][j])//价格最低 			{ 				min = a[head][j]; 				seq = j; 			} 		} 	} 	return min; }   结果：  大哥，我就是一萌新，c都没学好，你给我个c++的程序我也看不懂啊，而且这程序我们老师一看就知道不是我写的啊，求大佬给个基于floyed或者迪杰斯特拉算法的程序，最好能求出任意两点的最短路径，以及最短路径经过的点

谢谢大佬，程序我运行了下，可以运行，结果也对。

图片刚刚好像没放上去，这次再试试

这是我的运行结果，楼主可以看看符合要求不

楼上的程序我运行了下，出了6个错误，改改应该能运行，我这写了个程序，已经运行成功，楼主可以试试，望采纳。 #include "stdio.h"  #include "stdlib.h"  #include "io.h"  #include "math.h"  #include "time.h"  #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXEDGE 20 #define MAXVEX 20 #define INFINITY 65535  typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */  typedef struct {     int vexs[MAXVEX];     int arc[MAXVEX][MAXVEX];     int numVertexes, numEdges; }MGraph;  typedef int Patharc[MAXVEX][MAXVEX]; typedef int ShortPathTable[MAXVEX][MAXVEX];  /* 构件图 */ void CreateMGraph(MGraph *G) {     int i,j,k,w; 	printf("输入顶点数和边数:\n"); 	scanf("%d,%d",&G->numVertexes,&G->numEdges); /* 输入顶点数和边数 */ 	for(i = 0;i <G->numVertexes;i++) /* 读入顶点信息,建立顶点表 */ 	{ 		printf("输入图的顶点\n"); 		fflush(stdin);//清空输入缓冲区，为了确保不影响后面的数据读取 		scanf("%c",&G->vexs[i]); 		getchar(); 	}         for (i=0; i<G->numVertexes;i++)/* 初始化图 */     {         G->vexs[i]=i;     } printf("断\n");     for (i=0; i<G->numVertexes;i++)/* 初始化图 */     {         for ( j=0;j<G->numVertexes;j++)         {             if (i==j)                 G->arc[i][j]=0;             else                 G->arc[i][j] = G->arc[j][i] = INFINITY;         } 	     } for(k=0;k<G->numEdges;k++) { printf("输入边（Vi，Vj）上的下标i，下标j和权w：\n"); scanf("%d,%d,%d",&i,&j,&w); getchar(); G->arc[i][j]=w; } 	printf("断\n");        }  /* Floyd算法，求网图G中各顶点v到其余顶点w的最短路径P[v][w]及带权长度D[v][w]。 */  void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D) {      int v,w,k;      for(v=0; v<G.numVertexes; ++v) /* 初始化D与P */      {          for(w=0; w<G.numVertexes; ++w)          {             (*D)[v][w]=G.arc[v][w];    /* D[v][w]值即为对应点间的权值 */             (*P)[v][w]=w;                /* 初始化P */         }     }     for(k=0; k<G.numVertexes; ++k)      {         for(v=0; v<G.numVertexes; ++v)          {              for(w=0; w<G.numVertexes; ++w)              {                 if ((*D)[v][w]>(*D)[v][k]+(*D)[k][w])                 {/* 如果经过下标为k顶点路径比原两点间路径更短 */                     (*D)[v][w]=(*D)[v][k]+(*D)[k][w];/* 将当前两点间权值设为更小的一个 */                     (*P)[v][w]=(*P)[v][k];/* 路径设置为经过下标为k的顶点 */                 }             }         }     } }  int main(void) {      int v,w,k;      MGraph G;           Patharc P;      ShortPathTable D; /* 求某点到其余各点的最短路径 */           CreateMGraph(&G);          ShortestPath_Floyd(G,&P,&D);       printf("各顶点间最短路径如下:\n");      for(v=0; v<G.numVertexes; ++v)      {          for(w=v+1; w<G.numVertexes; w++)          {             printf("v%d-v%d weight: %d ",v,w,D[v][w]);             k=P[v][w];                /* 获得第一个路径顶点下标 */             printf(" path: %d",v);    /* 打印源点 */             while(k!=w)                /* 如果路径顶点下标不是终点 */             {                 printf(" -> %d",k);    /* 打印路径顶点 */                 k=P[k][w];            /* 获得下一个路径顶点下标 */             }             printf(" -> %d\n",w);    /* 打印终点 */         }         printf("\n");     }      printf("最短路径D\n");     for(v=0; v<G.numVertexes; ++v)      {          for(w=0; w<G.numVertexes; ++w)          {             printf("%d\t",D[v][w]);         }         printf("\n");     }     printf("最短路径P\n");     for(v=0; v<G.numVertexes; ++v)      {          for(w=0; w<G.numVertexes; ++w)          {             printf("%d ",P[v][w]);         }         printf("\n");     }      return 0; }

输入顶点只能是字母【size=14px】scanf("%c",&G->vexs[i]);[/size] 还有就是我这一段写错了scanf("%c,%c,%d",&i,&j,&w); /* 输入边(vi,vj)上的权w */ 应该是scanf("%d,%d,%d",&i,&j,&w); /* 输入边(vi,vj)上的权w */

问下你输入的 顶点的 只能是字母么？  如果只能是字母，得花点时间改，数字就好说了。

那一段我写错了，应该是%d形式的，不过该了后还是没用

你的顶点输入，只能是字母？可否是数字？


Question: 【debug】 使用指针给十个数排序

错误的选择。

引用 3 楼 adusuccessfully 的回复:1楼说的对，楼主的函数声明没有分号。 楼主写的排序代码是冒泡排序吧，感觉没有问题。  不太像冒泡排序啊，感觉更像是选择排序。

#include<stdio.h>  void num(int*a, int n);  int main(void) {     int a[10] = {1, 3, 4, 5, 7, 8, 9, 22, 77, 79};     int i;      num(a, 10);      for (i = 0; i < 10; i++)         printf("%d ", a[i]);     printf("\n");      return 0; }  void num(int *a, int n) {     int i, j, t;      for (i = 0; i < n; i++)         for (j = i + 1; j < n; j++)             if (*(a + i) < *(a + j))             {                 t = *(a + i);                 *(a + i) = *(a + j);                 *(a + j) = t;             } } 函数声明也是一条语句，所以应该加分号；

如图，把定义的void num函数申明位置改一下，就全对了

你那两个循环怎么嵌套的？没有问题？

第2行函数声明后面少了分号 void num(int*a, int n)；


Question: 凑行数

多写一些printf之类的东西嘛

1.默默地写一写些没有实际意义函数 2.把你们老师骂一顿，哪有实现了功能还要求代码行数的，当然如果可以精简，让我减少行数还可以，可是还有要求跟多行数的，无语！！！

想请问一下这是哪个学校？……

引用 9 楼 ipqtjmqj 的回复:[quote=引用 7 楼 cfjtaishan 的回复:] [quote=引用 6 楼 ipqtjmqj 的回复:] 超级简单的办法：不要用include，而是直接把头文件的内容复制到源文件 代码的行数是包含头文件（自定义的头文件）里的代码的。 如果加上头文件里的代码还不够，那么建议加功能，这个是即加分也会提高自己的办法[/quote] 我的意思是把stdio.h中的代码复制过来，或者手写也可以，比如用printf,只需写extern int printf(const char *, ...);不是一定要写include[/quote] 不建议这么做，标准头文件里的毕竟不是自己写的，如果被老师发现，岂不是画蛇添足；还不如做些其他功能能加分

什么时候写代码跟写作文一样要求行数了, 这种老师不是sb是什么?

for(int i=0;i<100;i++)  printf("\nMy computer teacher is SB!");

拒绝满足老师的无理要求

能换行的尽量换行

引用 7 楼 cfjtaishan 的回复:[quote=引用 6 楼 ipqtjmqj 的回复:] 超级简单的办法：不要用include，而是直接把头文件的内容复制到源文件 代码的行数是包含头文件（自定义的头文件）里的代码的。 如果加上头文件里的代码还不够，那么建议加功能，这个是即加分也会提高自己的办法[/quote] 我的意思是把stdio.h中的代码复制过来，或者手写也可以，比如用printf,只需写extern int printf(const char *, ...);不是一定要写include

《Visual C++ 游戏开发经典案例详解》

引用 6 楼 ipqtjmqj 的回复:超级简单的办法：不要用include，而是直接把头文件的内容复制到源文件 代码的行数是包含头文件（自定义的头文件）里的代码的。 如果加上头文件里的代码还不够，那么建议加功能，这个是即加分也会提高自己的办法

超级简单的办法：不要用include，而是直接把头文件的内容复制到源文件

也是醉了！！

加需求，加功能

问下，你们老师要求你们400行的理由是什么？ 不是代码越简洁越好么？ 老师要求的需求和功能，你都实现了，不就可以了吗？

1.函数声明和实现分开写， 2.“{”前要换行， 3.多写注释 4.只有一行语句的if..else也要加{} 5.for(int i=0;i<n;i++) {...} 改 int i; .... i=0; for(;i<n;) {     .......     i++; } 6.把一些小的工具类的函数展开写到代码里 7.变量名，函数名取长，然后一行语句太长的就有理由换行 8.函数实现的位置function(int a, int b, int c, int d) { ....}  改 function(     int a,    //this is a     int b,     //this is b     int c,      //this is c     int d)     //this is d  { ....}  。。。。。。 只要不要求代码结构规范，这些太容易了。

加功能，比如做一个成绩排行榜。 注释，用单独的行。适当的空行。


Question: 水平制表符问题

引用 1 楼 cfjtaishan 的回复:前面也是执行的了，只不过我们看到的似乎只有一个空格，而不是tab表示的空格数。不然，前9个后面就应该紧跟着“报数”了。 好像是的，有空格，但就是不懂为什么不是TAB，只有一个空格符，而且还是前面9个是空格，后面几个就是tab。

引用 3 楼 fight_in_dl 的回复:\t并不输出空格，它告诉光标到达下一个制表符位置。  序号:*9//这里用*代表空格， 一个中文字符占两个char位置，有两个汉字这里一共是4+1个冒号+1个空格+1个'9' = 7 所以只需要加一个空格 = 8 ，到达下一个制表符位置  序号:*10//这里用*代表空格， 一个中文字符占两个char位置，有两个汉字这里一共是4+1个冒号+1个空格+1个'1' +1个'0'= 8 所以需要再加8个空格 ，到达下一个制表符位置  用心回答每个问题，如果对您有帮助，请采纳答案好吗，谢谢！ 懂了，讲的很细，谢谢您。

引用 2 楼 jtidni 的回复:[quote=引用 1 楼 cfjtaishan 的回复:] 前面也是执行的了，只不过我们看到的似乎只有一个空格，而不是tab表示的空格数。不然，前9个后面就应该紧跟着“报数”了。 好像是的，有空格，但就是不懂为什么不是TAB，只有一个空格符，而且还是前面9个是空格，后面几个就是tab。[/quote]根据楼上的讲解，如果想得到你想要的输出格式，建议加数据输出宽度； 比如  printf("序号：%5d报数：%d\n", p->num, p->bs123);


Question: c语言问题

理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。  http://edu.csdn.net/course/detail/2344 C语言指针与汇编内存地址-一.代码要素 http://edu.csdn.net/course/detail/2455 C语言指针与汇编内存地址-二.函数 http://edu.csdn.net/course/detail/2516 C语言指针与汇编内存地址-三.数组和二维数组 http://edu.csdn.net/course/detail/2517 C语言指针与汇编内存地址-四.三维数组

运行一下不久OK了吗？

引用 1 楼 zanfeng 的回复:啥意思啊？ v 就是这三道题怎么做啊！？

啥意思啊？ v

呃，，我不太懂这个思路，能给我细细的讲解一下吗

问题是问题是什么

这些程序例子能锻炼一下对C指针的使用； 楼主对这些例程有什么问题吗？


Question: C语言编程，求大神给解答

#include <stdio.h> #include <string.h>  #define     ROW     10    /* Max support 10 words*/ #define     COL     32 #define     MAX_STR 80  void swap_odd_even_str(char *odd_str,  char *even_str); int get_word_list(char (*pword)[COL], char *pstr, int len);  int main(void) {     char str[MAX_STR];     char word_list[ROW][COL];     int i, len, num;      printf("Please input a string: ");     fgets(str, MAX_STR, stdin);      len = strlen(str);     str[len - 1] = 0;      num = get_word_list(word_list, str, len - 1);      for (i = 0; i <= num; i += 2)         swap_odd_even_str(word_list[i], word_list[i+1]);      for (i = 0; i <= num; i++)         puts(word_list[i]);      return 0; }  int  get_word_list(char (*pword)[COL], char *pstr, int len) {     int i, j = 0, k = 0;      for (i = 0; i < len;  i++) {         if (pstr[i] != ' ') {             pword[j][k++] = pstr[i];         } else {             pword[j][k] = 0; /* add '\0' */             j++;             k = 0;         }     }     pword[j][k] = 0;    /* add '\0' for last word */      return j; }  void swap_odd_even_str(char *odd_str,  char *even_str) {     char tmp[COL];      strcpy(tmp, odd_str);     strcpy(odd_str, even_str);     strcpy(even_str, tmp); } 参考一下吧～

看来是一个学校的，临沂，我也不会啊

引用 2 楼 jianwen0529 的回复:1L变种，不知道老师给不给分  #include <stdio.h>  #define     ROW     4 #define     COL     80  int main(void) {     char str_list[ROW][COL] = { "Lucy", "Lily", "Tom", "John" };     char *p_str_list[ROW];     int i;     char *p_temp;      for (i = 0; i < ROW; i++)         p_str_list[i] = str_list[i];      for (i = 1; i < ROW; i += 2)     {         p_temp = p_str_list[i];         p_str_list[i] = p_str_list[i - 1];         p_str_list[i - 1] = p_temp;     }      for (i = 0; i < ROW; i++)         puts(p_str_list[i]);      return 0; }    这个看着还是不会亲，怎么改成我要的那种，帮帮忙吧！亲

引用 1 楼 cfjtaishan 的回复:#include <stdio.h> #include <string.h>  #define     ROW     4 #define     COL     80  void swap_odd_even_str(char *odd_str,  char *even_str);  int main(void) {     char str_list[ROW][COL] = {"Lucy", "Lily", "Tom", "John"};     int i;      for (i = 0; i < ROW; i += 2)         swap_odd_even_str(str_list[i], str_list[i+1]);      for (i = 0; i < ROW; i++)         puts(str_list[i]);      return 0; }  void swap_odd_even_str(char *odd_str,  char *even_str) {     char tmp[COL];      strcpy(tmp, odd_str);     strcpy(odd_str, even_str);     strcpy(even_str, tmp); }   参考一下吧   这个是个固定的，怎么才是题目那样，我不会改


Question: 写了一个控制台程序模拟鼠标按键，如何不在控制台输入运行程序

我也想要。

RegisterHotKey

GetAsyncKeyState

网上搜索：注册全局快捷键


Question: 我的代码有点问题，有哪位大神帮我解答一下，感激不尽！有点急

图片表示：

测试环境：vs2013 win64 文件类型.cpp(我改为了C++类型文件，C语言没有引用)  问题： 1.函数调用出现问题 QueueTraverse 函数的第二个参数，未提供函数指针，我已添加，参见下图和源码（即缺少变量） 2.局部变量的问题 QueueLength函数的返回值即为长度，但该函数中的i和main函数中的i不是同一变量，故需要再定义相关int变量接收返回结果再打印其数值。  修改后的源码如下： #define _CRT_SECURE_NO_WARNINGS #include <cstdio> #include <cstdlib> #include <iostream> #define TRUE 1 #define FALSE 0 #define  OK 1 #define  ERROR 0 #define  INFEASIBLE -1 #define  WVERFLOW -2  typedef int Qelemtype; typedef int Status;  typedef struct Qnode { 	Qelemtype data; 	struct Qnode *next; }Qnode, *Queueptr;  typedef struct { 	Queueptr front; 	Queueptr rear; }Linkqueue;  Status Initqueue(Linkqueue &Q);//构造一个空队列 Status Destroyqueue(Linkqueue &Q);//销毁队列 Status Enqueue(Linkqueue &Q, Qelemtype e);//插入新元素 Status Dequeue(Linkqueue &Q, Qelemtype &e); //删除队头元素 Status getfirst(Linkqueue &Q);//输出队头元素 Status QueueTraverse(Linkqueue Q, void(*vi)(Qelemtype));//遍历整个队列 Status QueueLength(Linkqueue Q);//返回队列的长度   void QueuePrintf(int data);//打印节点值  void QueuePrintf(int data) { 	printf("%d ", data);  } Status Initqueue(Linkqueue &Q) { 	Q.front = Q.rear = (Queueptr)malloc(sizeof(Qnode)); 	if (!Q.front)  return (WVERFLOW); 	Q.front->next = NULL; 	return OK; }//构造一个空队列  bool QueueEmpty(Linkqueue &Q) { 	if (Q.front == Q.rear)//队列为空的情况     		return OK; 	else 		return ERROR; }//判断队列是否为空  Status Enqueue(Linkqueue &Q, Qelemtype e) { 	Queueptr p; 	p = (Queueptr)malloc(sizeof(Qnode)); 	if (!p) return(WVERFLOW); 	//scanf("%d",&e); 	p->data = e; 	p->next = NULL; 	Q.rear->next = p; 	Q.rear = p; 	return OK; }//插入新元素  Status Dequeue(Linkqueue &Q, Qelemtype &e) { 	Queueptr p; 	if (Q.front == Q.rear)  return ERROR; 	p = Q.front->next; 	e = p->data; 	Q.front->next = p->next; 	if (Q.rear == p) Q.rear = Q.front; 	free(p); 	return OK; }//删除队头元素  Status getfirst(Linkqueue &Q) { 	if (Q.front == Q.rear) 	{  		return ERROR; 	} 	else 		return Q.front->next->data; }//返回队头元素  Status QueueTraverse(Linkqueue Q, void(*vi)(Qelemtype)) { 	Queueptr p; 	p = Q.front->next; 	while (p) 	{ 		vi(p->data); 		p = p->next; 	} 	printf("\n"); 	return OK; }//遍历整个队列  Status QueueLength(Linkqueue Q) { 	Qnode *p; 	p = Q.front; 	int i = 0;//局部变量和下面的printf中的i不是同一个变量 	while (p != Q.rear) 	{ 		p = p->next; 		i++; 	} 	return i; }//返回队列的长度   Status Destroyqueue(Linkqueue &Q) { 	while (Q.front) 	{ 		Q.rear = Q.front->next; 		free(Q.front); 		Q.front = Q.rear; 	} 	return OK; }//销毁队列  int main() { 	Linkqueue Q; 	Qelemtype e, n, i=0, x; 	char select; 	do 	{ 		printf("                        主菜单                         \n"); 		printf("*******************************************************\n"); 		printf("* 1.构造一个空队列           2.判断队列是否为空       *\n"); 		printf("* 3.向队列中插入元素         4.删除队头元素           *\n"); 		printf("* 5.输出队头元素             6.遍历整个队列           *\n"); 		printf("* 7.返回队列的长度           8.销毁队列               *\n"); 		printf("*******************************************************\n"); 		printf("您的选择是:");  		select = getchar(); 		switch (select) 		{ 		case '1': 			if (Initqueue(Q)) 				printf("构造成功\n"); 			else 				printf("构造失败\n"); 			break; 		case '2': 			if (QueueEmpty(Q)) 				printf("队列为空！\n"); 			else 				printf("队列非空！\n"); 			break; 		case '3': 			scanf("%d", &e); 			if (Enqueue(Q, e)) 				printf("新元素插入成功！插入的元素是%d\n", e); 			else 				printf("元素插入失败！\n"); 			break;  		case '4': 			if (Dequeue(Q, x)) 				printf("删除的队头元素是: %d\n", x); 			else 				printf("删除失败\n"); 			break; 		case '5': 			if (Dequeue(Q, n)) 				printf("队头元素为：%d", n); 			else 				printf("输出队头元素失败！\n"); 			break; 		case '6': 			printf("队列为："); 			QueueTraverse(Q, QueuePrintf); 				//失败的逻辑自己补充 			break; 		case '7': 			if (i=QueueLength(Q))//不会发生错误 				printf("队列的长度为：%d", i); 			break; 		case '8': 			if (Destroyqueue(Q)) 				printf("销毁队列成功\n"); 			else 				printf("销毁失败\n"); 			break;  		default: 			printf("您的输入不服规范，请重新输入!"); 		} 		getchar(); 		printf("\n\n"); 	} while (select != '0');; 	return OK; }

select换一个吧

#include <stdio.h> #include <stdlib.h> #include <iostream.h> #define TRUE 1 #define FALSE 0 #define  OK 1 #define  ERROR 0 #define  INFEASIBLE -1 #define  OVERFLOW -2  typedef int Qelemtype; typedef int Status;  typedef struct Qnode {     Qelemtype data;     struct Qnode *next; }Qnode, *Queueptr;  typedef struct {     Queueptr front;     Queueptr rear; }Linkqueue;  Status Initqueue(Linkqueue &Q);//构造一个空队列 Status Destroyqueue(Linkqueue &Q);//销毁队列 Status Enqueue(Linkqueue &Q,Qelemtype e);//插入新元素 Status Dequeue(Linkqueue &Q,Qelemtype &e); //删除队头元素 Status getfirst(Linkqueue &Q);//输出队头元素 Status QueueTraverse(Linkqueue Q,void(*vi)(Qelemtype));//遍历整个队列 Status QueueLength(Linkqueue Q);//返回队列的长度  void print_data(Qelemtype data) {     printf("%d ", data); }  Status Initqueue(Linkqueue &Q) {     Q.front = Q.rear = (Queueptr) malloc (sizeof(Qnode));     if(!Q.front)  return (OVERFLOW);     Q.front ->next = NULL;     return OK; }//构造一个空队列  bool QueueEmpty(Linkqueue &Q) {     if(Q.front==Q.rear)//队列为空的情况         return OK;     else         return ERROR; }//判断队列是否为空  Status Enqueue(Linkqueue &Q,Qelemtype e) {     Queueptr p;     p = (Queueptr) malloc (sizeof(Qnode));     if(!p) return(OVERFLOW);     //scanf("%d",&e);     p->data = e;     p->next = NULL;     Q.rear->next = p;     Q.rear = p;     return OK; }//插入新元素  Status Dequeue(Linkqueue &Q,Qelemtype &e) {     Queueptr p;     if(Q.front == Q.rear)  return ERROR;     p = Q.front->next;     e = p->data;     Q.front->next = p->next;     if(Q.rear == p) Q.rear = Q.front;     free(p);     return OK; }//删除队头元素  Status getfirst(Linkqueue &Q) {     if(Q.front==Q.rear)     {          return ERROR;     }     else         return Q.front->next->data; }//返回队头元素  Status QueueTraverse(Linkqueue Q,void(*vi)(Qelemtype)) {     Queueptr p;     p=Q.front->next;     while(p)     {         vi(p->data);         p=p->next;     }     printf("\n");     return OK; }//遍历整个队列  Status QueueLength(Linkqueue Q) {     Qnode *p;     p=Q.front;     int i=0;     while(p!=Q.rear)     {         p=p->next;         i++;     }     return i; }//返回队列的长度   Status Destroyqueue(Linkqueue &Q) {     while(Q.front)     {         Q.rear = Q.front ->next;         free(Q.front);         Q.front = Q.rear;     }     return OK; }//销毁队列  int main() {     Linkqueue Q;     Qelemtype e,n,i,x;     char select;     do     {         printf("                        主菜单                         \n");         printf("*******************************************************\n");         printf("* 1.构造一个空队列           2.判断队列是否为空       *\n");         printf("* 3.向队列中插入元素         4.删除队头元素           *\n");         printf("* 5.输出队头元素             6.遍历整个队列           *\n");         printf("* 7.返回队列的长度           8.销毁队列               *\n");         printf("*******************************************************\n");         printf("您的选择是:");          select=getchar();         switch(select)         {             case '1':                 if(Initqueue(Q))                     printf("构造成功\n");                 else                     printf("构造失败\n");                 break;             case '2':                 if( QueueEmpty(Q))                     printf("队列为空！\n");                 else                     printf("队列非空！\n");                 break;             case '3':                 scanf("%d",&e);                 if(Enqueue(Q,e))                     printf("新元素插入成功！插入的元素是%d\n",e);                 else                     printf("元素插入失败！\n");                 break;              case '4':                 if(Dequeue(Q,x))                     printf("删除的队头元素是: %d\n",x);                 else                     printf("删除失败\n");                 break;             case '5':                 if(Dequeue(Q,n))                     printf("队头元素为：%d",n);                 else                     printf("输出队头元素失败！\n");                 break;             case '6':                 printf("队列为：");                 QueueTraverse(Q, print_data);                 break;             case '7':                 i = QueueLength(Q);                 printf("队列的长度为：%d",i);                 break;             case '8':                 if(Destroyqueue(Q))                     printf("销毁队列成功\n");                 else                     printf("销毁失败\n");                 break;              default:                 printf("您的输入不服规范，请重新输入!");         }         getchar();         printf("\n\n");     }while(select!='0');;     return OK; }  遍历队列和返回队列的长度调用上有问题；详见main函数的处理；另外，新加了一个回调函数，之前你的代码里没有这个函数：print_data; 其他没什么问题，在菜单设计上，个人认为初始化队列和销毁队列不用加到菜单项里，可以考虑程序起来就默认初始化队列，另外，加一个退出选项，调用退出选项先将队列销毁，然后再退出程序，这样做呢可以防止用户在使用时，在销毁队列之后，又向队列中插入数据，这样就会导致段错误了。为了防止这种情况发生，初始化队列和销毁队列做成默认的。


Question: 新手求助（双链表双向冒泡，程序编译通过但执行出错，求指导，附源码）

引用 3 楼 qq_38418863 的回复:请忽视二楼  #define chartonumber(x) (x-'0')//将char类型转换为对应数值  typedef int ElemType; typedef struct DNode { 	ElemType data; 	struct DNode *prior, *next; }DNode,	*DoubleList;  void CreateList(DoubleList L)  {  	DNode *r, *s;		//r为尾指针  	char c;				//c用于接收输入值  	int flag =1; 		//设置一个标志，初值为1，当输入"$"时，flag为0，建表结束 	L->next=L; 	L->prior=L; 	r=L;              	while(flag)          	{ 		c=getchar(); 		if(c!='$') 		{ 			s=(DNode*)malloc(sizeof(DNode)); 			s->data=chartonumber(c); 			r->next=s; 			s->prior=r; 			r=s; 		} 		else 		{ 			flag=0; 			r->next=L;    			L->prior=r; 		} 	} }  //数据结构为双向循环链表  void Creatdlist(DoubleList L){ 	DNode *p; 	L=(DNode * )malloc(sizeof(DNode)); 	printf("请输入双向链表数据!:\n"); 	CreateList(L); 	p = L->next; 	while(p != L) 	{ 		printf("%d\n",p->data); 		p = p->next; 	} }   void Shakersort(DoubleList L){ 	 //DNode *p; 	 DNode *l = L;  	 DNode *r = L->next; 	 char exchange; 	 DNode *flag; 	 while(l!=r){											//左右相遇时表示排序结束，终止循环  		for(; l->next != r; l = l->next){					//向右冒泡  			if(l->data > l->next->data){ 				exchange = l->data; 				l->data = l->next->data; 				l->next->data = exchange; 				flag = l; 			} 		} 		r = flag; 		for(r = r->prior; r->prior != l; r = r->prior){		//向左冒泡  			if(r->data > r->next->data){ 				exchange = r->data; 				r->data = r->next->data; 				r->next->data = exchange; 				flag = r->next; 			} 		} 		l = flag; 	 }  }  int main(){ 	DoubleList l;	 	Creatdlist(l); 	printf("test");  	Shakersort(l);  	return 0; }   冒泡排序的算法不是这样的。可以通过交换数据间接实现节点的交换

1楼的回复就可以了， 你排序只是排data，链表理解成数组， 数组头饰L， 结尾是L->prior

附上完整的定义+实现  #define chartonumber(x) (x-'0')//将char类型转换为对应数值  typedef int ElemType; typedef struct DNode { 	ElemType data; 	struct DNode *prior, *next; }DNode,	*DoubleList;  void CreateList(DoubleList L)  {  	DNode *r, *s;		//r为尾指针  	char c;				//c用于接收输入值  	int flag =1; 		//设置一个标志，初值为1，当输入"$"时，flag为0，建表结束 	L->next=L; 	L->prior=L; 	r=L;              	while(flag)          	{ 		c=getchar(); 		if(c!='$') 		{ 			s=(DNode*)malloc(sizeof(DNode)); 			s->data=chartonumber(c); 			r->next=s; 			s->prior=r; 			r=s; 		} 		else 		{ 			flag=0; 			r->next=L;    			L->prior=r; 		} 	} void Creatdlist(DoubleList L){ 	DNode *p; 	L=(DNode * )malloc(sizeof(DNode)); 	printf("请输入双向链表数据!:\n"); 	CreateList(L); 	p = L->next; 	while(p != L) 	{ 		printf("%d\n",p->data); 		p = p->next; 	} }   void Shakersort(DoubleList L){ 	 //DNode *p; 	 DNode *l = L;  //	 DNode *r = L->next; 	 char exchange; 	 DNode *flag; /*	 while(0){											//左右相遇时表示排序结束，终止循环  		for(; l->next != r; l = l->next){					//向右冒泡  			if(l->data > l->next->data){ 				exchange = l->data; 				l->data = l->next->data; 				l->next->data = exchange; 				flag = l; 			} 		} 		r = flag; 		for(r = r->prior; r->prior != l; r = r->prior){		//向左冒泡  			if(r->data > r->next->data){ 				exchange = r->data; 				r->data = r->next->data; 				r->next->data = exchange; 				flag = r->next; 			} 		} 		l = flag; 	 }*/  }  int main(){ 	DoubleList l;	 	Creatdlist(l); 	printf("test");  	Shakersort(l);  	return 0; }  }

看不懂 你的 DoubleList 到底是什么东西，可以强转成 DNode ？ 你到底是搞双向链表 还是 循环链表？   /* l(L) -> r -> l */ void sort(DNode* L) {      DNode *l = L;      DNode *r = L->next;      char exchange; 	  	for (l = L; l != L; l = l->next) { 		for (r = l->next; r != L; r = r->next) { 			if (r->data > l->data) { 				exchange = r->data; 				r->data = l->data; 				l->data = exchange; 			} 		}	 	} }

无返回值传参传结构体指针可以创建链表吗。


Question: 求助用c语言  解析字符 应该怎么样去解析

引用 2 楼 m0_37820090 的回复:恩  但是有些原因不能用 xml 解析的方法去解析，需要解析直接得到 按照字符串解析函数一行行的分析，会比较麻烦；

恩  但是有些原因不能用 xml 解析的方法去解析，需要解析直接得到

用msxml组件

__min Returns the smaller of two values.  type __min( type a, type b );  Routine Required Header Compatibility  __min <stdlib.h> Win 95, Win NT    For additional compatibility information, see Compatibility in the Introduction.  Libraries  LIBC.LIB Single thread static library, retail version  LIBCMT.LIB Multithread static library, retail version  MSVCRT.LIB Import library for MSVCRT.DLL, retail version    Return Value  The smaller of the two arguments  Parameters  type  Any numeric data type  a, b  Values of any numeric type to be compared  Remarks  The __min macro compares two values and returns the value of the smaller one. The arguments can be of any numeric data type, signed or unsigned. Both arguments and the return value must be of the same data type.  Example  /* MINMAX.C */  #include <stdlib.h> #include <stdio.h>  void main( void ) {    int a = 10;    int b = 21;     printf( "The larger of %d and %d is %d\n",  a, b, __max( a, b ) );    printf( "The smaller of %d and %d is %d\n", a, b, __min( a, b ) ); }   Output  The larger of 10 and 21 is 21 The smaller of 10 and 21 is 10   Floating-Point Support Routines  See Also   __max   File: "C:\Program Files\Microsoft Visual Studio 10.0\VC\include\stdlib.h"      175: #define __min(a,b)  (((a) < (b)) ? (a) : (b))

结帖了 谢谢各位

引用 4 楼 zhao4zhong1 的回复:#include <stdio.h> #include <string.h> #include <stdlib.h> char htmls[]= "htmlID=1001&MessageID=196&<rpc message-id=\"196\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\">" "<get><filter type=\"subtree\"><featurename istop=\"true\" type=\"mib\"><entPhysicalEntry position=\"iso.org.dod.internet.mgmt.mib-2.entityMIB.entityMIBObjects.entityPhysical.entPhysicalTable\"><entPhysicalSerialNum/><entPhysicalDescr/></entPhysicalEntry></featurename></filter></get></rpc>]]>]]>" "htmlID=1001&MessageID=196&<rpc message-id=\"196\" xmlns=\"urn:ietf:params:xml:ns:netconf:base:1.0\">" "<get><filter type=\"subtree\">" "<featurename istop=\"true\" type=\"mib\">" "    <EntityStateEntry position=\"iso.org.dod.internet.private.enterprises.Mgmt.Datacomm.EntityExtentMIB.EntityExtObjects.EntityState.EntityStateTable\">" "        <EntityCpuUsage/>" "        <EntityMemUsage/>" "        <EntityTemperature/>" "        <EntityCpuUsageThreshold/>" "        <EntityMemUsageThreshold/>" "        <EntityTemperatureThreshold/>" "    </EntityStateEntry>" "</featurename>" "</filter>" "</get>" "</rpc>]]>]]>"; char *s,*p,*q,t[80+1]; int L; int main() {     s=(char *)htmls;     while (1) {         p=strstr(s,"<featurename ");         if (!p) break;         s=p;         p=strstr(s,">");         if (!p) break;         s=p;         p=strstr(s,"<");         if (!p) break;         q=strstr(p," ");         if (!q) break;         L=__min(80,q-p-1);         strncpy(t,p+1,L);t[L]=0;         printf("[%s]\n",t);         s=q+1;     }     return 0; } //[entPhysicalEntry] //[EntityStateEntry] //  编译会出现   undefined reference to `_min'


Question: c语言新手，学艺不精，想请教几个关于c语言的问题

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

断点、调试 找到哪里出错  在哪里出错，就在哪里只多趴一会  哥只能帮到这么多了

我自个顶一下


Question: printf语句影响程序的运行

VC十几年，表示没出见过这种情况。 轻轻飘过……

什么平台？ 对比一下printf的实现和汇编的压栈。  压栈的时候是以几byte对齐， 寻变参的时候是以几byte对齐， 看看是否一致。

在每个最后不带\n的printf后面加fflush(stdout);

printf后面加个延时，很多时候并不是没有正确跑，而是printf对你系统的通信接口而言，实在太快了，没有显示结果而已

应该是each_ray_home需要一定的间隔才能正确运行，printf()输出的字符串越长，这个调用执行的时间也就越长。你可以不用printf，换成sleep(10),试试。不行的话，再把时间改大一点

汇编级的调试。。。。

引用 3 楼 jianwen0529 的回复:each_ray_home(p_point_one_mesh,  mc, imc, area ,xmin,xmax, ymin, ymax); 查看这个函数有没有使用非法内存，数组越界的情况 printf不会对程序运行造成不一样的影响  [quote=引用 2 楼 cfjtaishan 的回复:] 你是在什么环境下运行的？还没遇到过这么邪乎的代码； 我遇到过，到如今都不明白 http://bbs.csdn.net/topics/392061821[/quote] 你这个问题要看具体的代码，不一定在其他环境下也是这样的问题，所以问题总会解决，只是还在路上。

printf是写到缓冲区，没有马上输出到屏幕

这么奇怪的故障 不出正确结果是什么情况？有什么差异？ 遇到这种问题，还是想办法调试一下 或者变换下语句，看看问题到底出在哪

each_ray_home(p_point_one_mesh,  mc, imc, area ,xmin,xmax, ymin, ymax); 查看这个函数有没有使用非法内存，数组越界的情况 printf不会对程序运行造成不一样的影响  引用 2 楼 cfjtaishan 的回复:你是在什么环境下运行的？还没遇到过这么邪乎的代码； 我遇到过，到如今都不明白 http://bbs.csdn.net/topics/392061821

你是在什么环境下运行的？还没遇到过这么邪乎的代码；


Question: 求解一道面试题，怎么写比较优化。

//你可以参考一下这个代码,我也是刚学习的,有问题的话,还望指教. //这个程序的思想是,既然只是有<$>的地方就多一个<$> 那么 //aaaa<$>bbb<$>cccc //实例字符串 如果找到.<$>,首先记录字符串首个 '<'的索引.一次為基点 将后面的字符串拷贝到'>'的后面 即实现了添加 //字符串从后向前赋值的原因还望你自己推敲.这个对你以后也有帮助,根本原因是,这个思想从前向后赋值 因为只使用同一段内存 //,所以需要保证原本数据的完整 //你看一下把,有问题的话,望指教回复一下我   #define  MAX_SIZE   100 int main(){ 	char strTemp[MAX_SIZE] = "<$>aaaaa<$><$>bbbbb<$>ccccc<$>ddddd"; 	printf("%s\n",strTemp); 	int nLen = 0; 	char * pFirst = strTemp; 	while(*pFirst++){ 		++nLen; 	} 	pFirst = strTemp;				//头指针 	char * pEnd = strTemp+nLen;		//\0 	printf("%d\n",nLen); 	for(int i = 0;i<nLen;++i){ 		if(strTemp[i] == '<' && strTemp[i+1] == '$' && strTemp[i+2] =='>'){ 			char * TempFirst = strTemp+i;	//"<"的指针 			int nPos = pEnd - TempFirst + 1;//"<"到尾部的步长 此处加一是从\0的下一位开始计算,因为\0也要接受赋值 			char * TempEnd = pEnd +3;		//将要赋值的字符串的尾地址 			char * EndStart = pEnd;			//需要複製的起始地址 			//此处赋值 			while(nPos--){ 				*TempEnd-- = *EndStart--; 			} 			//计算新字符串的长度 			nLen = 0; 			while(*pFirst++) ++nLen ; 			pFirst = strTemp; 			pEnd+=3; 			i+=3; 		} 	} 	printf("%s\n",strTemp); 	getchar(); }

思路还是比较简单， 考察的是字符串和数组操作吧。 至于搜索字符串，估计你搞个KMP/AC/BM算法会有加分吧  #include <stdio.h>  int main(void) { 	char Text[100] = {"xxx<$><$>yyy<$>zzz"}; 	int left = 50; //剩余 50个有效字符未处理 	int i = 0, j = 0; 	int count = 0; 	int end = 0; 	 	for (i = 0; (i < 97) && (left > 2); i++) {// 97 = sizeof(Text) - sizeof("<$>") - 1 		if ((Text[i] == '<') && (Text[i+1] == '$') && (Text[i+2] == '>')) { 			end = 50 + count * sizeof("<$>")- 1; 			left -= sizeof("<$>") - 1; 			count++; 			//memmove to insert <$> 			for (j = end - 1; j > (i + 2); j--) { 				Text[j + sizeof("<$>") - 1] = Text[j]; 			}  			Text[i+3] = '<'; 			Text[i+4] = '$'; 			Text[i+5] = '>';  			i+= 4; 		} else { 			left--; 		} 	}  	printf("Text = %s\n", Text); 	return 0; }

遍历一遍这个数组，找出这个模式出现的地方，其实这个时候已经知道每个元素的新位置在哪了，然后从尾部到头赋值即可

上面错了，请楼主无视

同一个数组，两个下标变量，把要求a[i]=a[j],or a[i]='$'其中有个下标肯定不会比另一个快，赋值循环结束，加个尾零就行了

就字符串查找函数strstr的变换

可以考虑用移位的方式来实现这个功能。


Question: 数组指针

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

数组名是一个指针，打印数组元素的时候，用数组名+下标，当一个指针指向数组的时候，这个指针就与数组名是等效的了。因此用法就跟数组名一样，即指针名+下标。

p[i]里面存的是字符串的地址，如果使用*p[i]打印的就是p[i]的地址

p[i]就是表示的一个字符串地址吧

printf("%s",*(pa+i)); 还可以这样，不过这个是要加*的

前面加*就是指第二个字符串的第一个字符了，和%s就不匹配了；

因为字符串一般用字符指针来表示和输出的，不同于其他类型（int等）

因为 #include main(){  int i=1; int* a[7]; a[i]=&i; printf("%d",*a[i]); }  中a[i]前要加。。

pa[i] 的类型是 char* 字符串，输出一个字符串就是这样子 我是比较好奇你为什么认为需要加（*）呢？


Question: 用C的文件操作能做出登录系统吗

为什么不贴出完整的代码呢？

引用 1 楼 cfjtaishan 的回复:fwrite和fread是二进制形式的读写，所以你看到文件内容有部分是乱码；比如，用户名是32个字节的字符数组，你输入了“hello"5个有效字符作为用户名，fwrite写入时是写入32个字节，那么后面26（32 - 5 - 1)个字节也是要写入的，若后面的26个字节是随机值，那么写入的数据就可能是乱码了。所以，用fwrite写入的，就要用同样的格式用fread读取，这样保证读到的数据和写入的一致。 按你的意思，即使在读写数据的时候清除缓冲区也没有用啊。因为fread（）fwrite（）的参数表里就是按照数据块的大小而读（写）入的，并没有也不能检查数据块的数据是否已写满啊。。

引用 2 楼 zhao4zhong1 的回复://注册的情况： int user_register(FILE * fp1,struct user*current_user) {     int i,L;     char repassword[13];     printf("请输入用户名:");fflush(stdout);     scanf("%s",current_user->name);     while (1) {         printf("请输入注册密码:");fflush(stdout);         scanf("%s",current_user->password);         printf("请再次输入注册密码:");fflush(stdout);         scanf("%s",repassword);         if(!two_password_valid(current_user->password,repassword))         {             printf("\n两次输入的密码不一致!请重新输入！\n");         } else break;     }     L=strlen(current_user->password);     for (i=0;i<L;i++) current_user->password[i]^=0xa5;     if(fwrite(current_user,sizeof(struct user),1,fp1)!=1){         printf ("file write error\n");     }     return 1; } //登录的情况： int online_user(FILE *fp1,struct user our_users[],struct user *current_user) {     int i,L;      for(i=0;i<N;i++){         if(fread(&our_users[i],sizeof(struct user),1,fp1)!=1)             printf ("file read error\n");     }     printf("请输入您的用户名: ");fflush(stdout);     scanf("%s",current_user->name);     printf("请输入您的密码: ");fflush(stdout);     scanf("%s",current_user->password);     L=strlen(current_user->password);     for (i=0;i<L;i++) current_user->password[i]^=0xa5;     for(i=0;i<N;i++){         if((strcmp(current_user->name,our_users[i].name)==0)&&(strcmp(current_user->password,our_users[i].password)==0))         {             return 1;         }     }     return 0; }   你的意思是要清除随机数的写（读）入吗？可运行的时候登录啊还是修改密码什么的都会显示“”file write error！“” 我觉得应该是往二进制文件预存的数据有问题，如果有这种可能的话，预存数据的时候真的要自己数好格子？。。


Question: 递归调用问题

楼主最好自己体会一下递归过程是如何进行的。

请参考回溯算法的八皇后问题递归代码： #include <stdio.h>  int left[15]={0},right[15]={0},col[8]={0},q[8],cnt=0;  void print()  //按顺序输出  { 	int i,j; 	printf("这是第%d个解:\n",++cnt); 	for(i=0;i<8;i++) 	{ 		for(j=0;j<8;j++) 		{ 			if(q[i]==j) 				printf("O "); 			else printf("X "); 		} 		printf("\n"); 	} 	printf("\n"); }  void Queue (int i) { 	for(int j=0;j<8;j++) 	{ 		if(col[j]==0&&left[i+j]==0&&right[i+7-j]==0) 		{ 			q[i]=j; 			col[j]=left[i+j]=right[i+7-j]=1; 			if(i<7) 			{ 				Queue(i+1); 				col[j]=left[i+j]=right[i+7-j]=0; 			} 			else { 				print(); 				col[j]=left[i+j]=right[i+7-j]=0; 			} 		} 	} }  int main () { 	int i=0; 	Queue(i); 	return 0; }

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

除了permutation是递归函数之外，其他部分，是交换下标i和b的值；调用permutation之后再交换下标为i和b。

全排列 比如abcd 固定a 然后bcd排列.然后再交换即b acd排列,如此类推.


Question: c语言问题，改了好久还是不知道错在哪，求大神拯救

如果实在想不出怎么定义，可以考虑适当的加些注释，比如在算法逻辑方面，可以加一行的注释，也可以在文件头或者函数前加若干行注释用于描述可能不好理解的逻辑

#include <stdio.h> #include <stdlib.h> #include<math.h>  int main() {     int i,j,m=0,c=79,d=249;     float t0=226.85,tf=26.85,h=2800.0,Q=0.0,temp=0.0,N=187.0,EPS,X=1.0,e=0.1,f=0.1,delta=0.0001,sum = 0.0;     float a[80][250],t[80][250],del[80];     for(i=0;i<80;i++){         for(j=0;j<250;j++)         {             t[i][j]=100.0;             a[i][j]=100.0;             del[i]=1.0;         }     }      printf("%4.2lf\n",a[1][1]);     while(X>0.01){         m++;         for(i=0;i<=c;i++)         {             for(j=0;j<=d;j++)             {                 if(j==0&&0<=i&&i<=c)                     a[i][j]=t0;                 else if(0<j&&j<d&&i==0)                     a[i][j]=(2*t[1][j]+t[0][j+1]+t[0][j-1]+2*h*N*tf/N)/(4+2*h*delta/N);                 else if(0<j&&j<d&&i==c)                     a[i][j]=(2*t[c][j]+t[c+1][j+1]+t[c+1][j-1]+2*h*delta*tf/N)/(4+2*h*delta/N);                 else if(j==d&&0<i&&i<c)                     a[i][j]=(2*t[i][d]+t[i+1][d+1]+t[i-1][d+1]+2*h*delta*tf/N)/(4+2*h*delta/N);                 else                     a[i][j]=(t[i][j+1]+t[i][j-1]+t[i-1][j]+t[i+1][j])/4;             }         }         a[0][d+1]=(2*h*delta*tf/N+t[0][d]+t[1][d+1])/(2+2*h*delta/N);         printf("%4.2lf\n",a[0][249]);         a[c+1][d+1]=(2*h*delta*tf/N+t[c][d+1]+t[c+1][d])/(2+2*h*delta/N);         printf("%4.2lf\n",a[79][249]);         X=0.0;         for(i=0;i<=c;i++)         {             for(j=0;j<=d;j++)             {                 EPS=fabs(t[i][j]-a[i][j]);                 if(EPS>X) X=EPS;             }         }         if(m>100)             break;     }     if(m<100){         for(i=1;i<=80;i++)             del[i]=(t[i][0]-t[i][1])/delta;         sum+=del[i];         Q=N*sum*delta;         temp=t[40][249];         printf("%4.2lf %4.2lf",Q,temp);         printf("\n");      }     getchar(); } 楼主，看到你定以那么多变量（真需要那么多），并且变量大多以单个字母命令，怎么也才不出来你定义这个变量做什么，自己疯了，让别人看你的代码也感觉摸不着头脑； 程序里有多处越界，数据长度是250，那么其下标是从[0, 249]里，同理，长度是80，那么下标是从[0, 79]; 建议楼主，以后写代码可以先构思，变量不是写多了就好分析和理解了，多了自己看着头大，别人看着更是费劲。从你的程序里也看不出你的逻辑是要做什么。所以，先构思好；其次，对于一些变量有通用的命名的，比如循环变量，i, j, k;一般用在循环和数组下标，另外，n或着num一般是number的缩写，cnt是count的缩写，用于分别标识数字和计数器。总之，除了这些通用的命名法之外，定义变量和函数都建议做到见名知义。

数组越界错误： C语言数组索引从0开始，a[80][250]最大的元素索引只能到a[79][249]。  c = 79, d = 249 a[c+1][d+1]=(2*h*delta*tf/N+t[c][d+1]+t[c+1][d])/(2+2*h*delta/N); //试图设置a[80][250]，不合法。 用心回答每个问题，如果对您有帮助，请采纳答案好吗，谢谢！

引用 4 楼 zhao4zhong1 的回复:static float a[80][250],t[80][250],del[80]; 在占用内存空间较大的局部数组声明的前面加static将其从堆栈数据段挪到全局数据段即可避开因局部数组大小超过默认堆栈大小1MB造成程序不能正常运行的问题。

最简单就是4楼的办法，或者修改项目属性，改为不限制栈大小。


Question: 关于c的简单程序问题 求解释

2.课后实验内容：用单链表实现一个学生信息管理系统，     学生信息为如下表格，系统功能要求对学生信息进行录入，显示，插入一个新学生信息，删除一个学生，并实现按学号查找某学生信息。 例：现有一学生学籍信息表，该表包含如下学生信息：学号num、姓名name、年龄age、是否退学 LeaveSch。该信息表主要用于查询学生学籍信息，如有新生入学，则在表尾加入新生信息，将其LeavSch字段设为“N”：如有学生退学，则将其LeavSch字段设为 “Y”。 学号	姓名	年龄	是否退学 1101050101	王小二	18	N 1101050103	张三	21	N 1101050405	李四	18	Y 1101050406	刘小明	20	N 1201050102	杨升	19	N   #include <stdio.h> #include <string.h> #include <malloc.h>  #define MAXSIZE 100 typedef struct Student {   char no[10];   char name[20];    int   age;   char  leaveSch; }elemtype;  typedef struct {  elemtype  data[MAXSIZE];  int len; }Sequenlist;  Sequenlist *InitList(Sequenlist *L) {    L=( Sequenlist *)malloc(sizeof(Sequenlist));    L->len=0;    return(L); }  void  input(Sequenlist *L) {     int i,x;     char no[10];     char name[20];     int  age;     char leaveSch;     i=0;     printf("\n 请输入数据元素的量:");     scanf("%d",&x);     while(x!=i)     {       if(i==MAXSIZE)       {           printf("Table is overflow！！");       }       else 	  {           printf("\n Input data element,以回车键间隔:");           scanf("%s",no);           scanf("%s",name);           scanf("%d",&age);           fflush(stdin);           scanf("%c",&leaveSch);           strcpy(L->data[i].no,no);           strcpy(L->data[i].name,name);           L->data[i].age=age;           L->data[i].leaveSch=leaveSch; 	  } 	  i++;     }    L->len=i; }   void output(Sequenlist  *L) {   int i;   printf("\n  Output element of Table：\n");  for(i=0;i<L->len;i++)  {      printf("%s  ",L->data[i].no);      printf("%s  ",L->data[i].name);      printf("%d  ",L->data[i].age); 	 printf("%c  \n",L->data[i].leaveSch);  } }  int InsItem (Sequenlist *L, int i) {     int j;     char no[10];     char name[20];     int  age;     char leaveSch;     if( L->len>= MAXSIZE)     {         printf("The list is overflow.\n");         return 0;     }     else if( (i<1)||(i>L->len+1) )     {         printf("Position is not corrent.\n");         return 0;     }     else     {         printf("\n Input  new data element,以回车键间隔:");         scanf("%s",no);         scanf("%s",name);         scanf("%d",&age);         fflush(stdin);         scanf("%c",&leaveSch);         for(j=L->len-1;j>=i-1;j--)         {             L->data[j+1]=L->data[j];         }         strcpy(L->data[i-1].no,no);         strcpy(L->data[i-1].name,name);         L->data[i-1].age=age;         L->data[i-1].leaveSch=leaveSch;         L->len++;     return 1;     } }   int LocItem(Sequenlist *L,int item) {     int i,j;     j=L->len;     if(j==0)     {         printf("The sequenlist is empty");         //return 0;     }     for(i=0;i<=j;i++)     {         if(atoi(L->data[i].no)==item)         {             return (i+1);         }     }     printf("The item is not in this sequenlist");   return 0; }  int DelItem(Sequenlist *L, int i) {     int j;     if((*L).len==0)     {         printf("List is empty \n");         return 0;     }     else if( (i<1)||(i>(*L).len) )     {         printf("Delete item fail\n");         return NULL;     }     else     {         for ( j=i; j<=(*L).len-1;j++)         {             (*L).data[j-1]=(*L). data[j];         }         (*L).len--;         return 1;     }     }  main() {   int n,item;   int i;   Sequenlist *L;   L=InitList(L);   input(L);   output(L);   printf("请输入新生信息：");   InsItem(L,L->len+1);   output(L);   printf("请输入你要查找的学生的学号：");   scanf("%d",&item);   if (LocItem(L,item)==0)   {       printf("查找学生失败，不存在");   }   else   {       i=LocItem(L,item);       printf("%s  ",L->data[i-1].no);       printf("%s  ",L->data[i-1].name);       printf("%d  ",L->data[i-1].age);       printf("%c  \n",L->data[i-1].leaveSch);   }   printf("请输入你要删除的学生的学号：");   scanf("%d",&i);   DelItem(L,i);   output(L); } 我自己写的一道题，希望对你有帮助！

谢谢！ 我明白了 问题解决了！~~~

#include<stdio.h>  #define SNUM 4 /* student number */ #define CNUM 3 /* course number */ /* User Code Begin(考生可在本行后添加代码，例如结构体的定义、函数原型声明等，行数不限) */ struct student {     char num[12];     int score[3];     char name[7]; };  void DispScore(struct student aa[]); void FindNoPass(struct student aa[]);  /* User Code End(考生添加代码结束) */  int main(void) {     int i, j;     struct student stu[SNUM];      printf("Please input student num name and score:\n");     for (i=0; i<SNUM; i++)     {         printf("Student %d: ", i+1);         scanf("%s %s", stu[i].num, stu[i].name);         for (j=0; j<CNUM; j++)         {             scanf("%d", &stu[i].score[j]);         }     }      DispScore(stu);     FindNoPass(stu);      return 0; }  /* User Code Begin(考生在此后完成自定义函数的设计，行数不限) */ void DispScore(struct student aa[]) {     int i,j;     printf("\nStudent Info and Score:\n");     for (i=0; i<SNUM; i++)     {         printf("%6s %8s", aa[i].num, aa[i].name);         for (j=0; j<CNUM; j++)         {             printf("%5d", aa[i].score[j]);         }         printf("\n");     } }  void FindNoPass(struct student aa[]) {     int i,j,k;     printf("\nTwo Course No Pass Students:\n");     for (i=0; i<SNUM; i++)     {         k=0;         for (j=0; j<CNUM; j++)         {             if(aa[i].score[j]<60)             {                 k++;             }         }         if(k >= 2)         {             printf("%6s %8s", aa[i].num, aa[i].name);             for (j=0; j<CNUM; j++)             {                 if(aa[i].score[j]<60)                 {                     printf("%5d", aa[i].score[j]);                 }             }             printf("\n");         }     } } 处理不及格的学生信息的函数里，逻辑有问题；请注意与上面函数比对一下函数逻辑不同之处。 另外，num定义长度不够，因为字符串也要考虑结束标记'\0'还要占一个字节，所以，你的程序里定义的num是越界的

#include <stdio.h> #include <stdlib.h> #define SNUM 4 #define CNUM 3 struct student  {  char num[5];  int score[3];  char name[7];  };  void DispScore(struct student aa[]);  void FindNoPass(struct student aa[]);   /* User Code End(考生添加代码结束) */   int main(void)  { 	int i, j; 	struct student stu[SNUM]; 	printf("Please input student num name and score:\n"); 	for (i=0; i<SNUM; i++) 	{  		printf("Student %d: ", i+1); 		scanf("%s %s", stu[i].num, stu[i].name); 		for (j=0; j<CNUM; j++) 		{ 			scanf("%d", &stu[i].score[j]); 		} 	} 	DispScore(stu); 	FindNoPass(stu); 	system("pause"); 	return 0;  } /* User Code Begin(考生在此后完成自定义函数的设计，行数不限) */  void DispScore(struct student aa[])  { 	int i,j; 	printf("\nStudent Info and Score:\n"); 	for (i=0; i<SNUM; i++) 	{ 		printf("%6s %8s", aa[i].num, aa[i].name); 		for (j=0; j<CNUM; j++) 		{ 			printf("%5d", aa[i].score[j]); 		} 		printf("\n"); 	}  } void FindNoPass(struct student aa[]) { 	int i,j,k; 	printf("\nTwo Course No Pass Students:\n"); 	for (i=0; i<SNUM; i++) 	{ 		k=0; 		for (j=0; j<CNUM; j++) 		{ 			if(aa[i].score[j]<60) 			{ 				k++; 			} 		} 		if(k >= 2) 		{ 			printf("%6s %8s", aa[i].num, aa[i].name); 			for (j=0; j<CNUM; j++) 			{ 				if(aa[i].score[j]<60) 				{ 					printf("%5d", aa[i].score[j]); 				} 			} 			printf("\n"); 		} 	} }


Question: 奇怪的出错问题 struct 定义的结构体在函数前后的区别！！

4再增加一种方法 函数声明前加上 typedef struct student Node; //语句也行，有类似3的效果

引用 2 楼 jianwen0529 的回复:使用对象需要声明和定义可见（在前）  struct student //定义 {     char name[20];     float score;     struct student *next; }; void free_node(/*struct*/ student head); //使用对象  使用指针或者引用，需要声明可见（前置声明）  struct student; //前置声明 void free_node(/*struct*/ student *head); //使用指针   而你说一会对一会错的原因  void free_node(struct student* head); //此处的struct student有前置声明的作用，所以没有问题 //void free_node(student* head); //这样子就不行了 [code=c]struct student {     char name[20];     float score;     struct student *next; };  看了你们的回复，对我帮助很大，发贴前我己将代码反复写了十多次，有时正确，有时找不到原因，搞得都有点怀疑人生了  经过你的指点，我又将代码用不同的方法写过几次，并加以验证，总结如下： 1、方法一 ，结构体定义放在函数声明之前 struct student{ 	char name[20]; 	float score; 	struct student *next; 	          };  void input_node(struct student *head); ... 等等函数声明列系;   2、方法二，结构体类型前置声明，类型后面加;（即然这样的语法可以，我又试了，int;这样的声明，测试正确，类型后面加分号） struct student; ... 下面接函数声明;  3、方法3， 将有返回结构体类型或结构体指针类型的函数放前面声明，有类似结构体前置声明的效果 eg: struct student creat_node(struct student *head);  //52行  void input_node(struct student *head); //53行 //52行，一定要在 53行前，不然就出错， 参数类型是结构体没有用， //无法起到声明效果，但函数返回值类型在前， //可以起到声明效果，这个具体叫什么声明方式，没有找到参考资料     上面三种方式都可以正确编译与运行，第二种方式比较好  //jianwen0529 提的最后一点（函数参数类型，形参，无法做声明），我先前有时能正确运行的原因是，我将返回结构体指针函数放在了最上面，就是第三种方法起了作用

引用 4 楼 cfjtaishan 的回复:[quote=引用 2 楼 jianwen0529 的回复:] 使用对象需要声明和定义可见（在前）  struct student //定义 {     char name[20];     float score;     struct student *next; }; void free_node(/*struct*/ student head); //使用对象  使用指针或者引用，需要声明可见（前置声明）  struct student; //前置声明 void free_node(/*struct*/ student *head); //使用指针   而你说一会对一会错的原因  void free_node(struct student* head); //此处的struct student有前置声明的作用，所以没有问题 //void free_node(student* head); //这样子就不行了 struct student {     char name[20];     float score;     struct student *next; };  C语言里不支持定义的结构体是struct student类型，而用student 定义变量的形式，而是C++是支持的。[/quote] 恩，这个我还真是不知道的点。

引用 2 楼 jianwen0529 的回复:使用对象需要声明和定义可见（在前）  struct student //定义 {     char name[20];     float score;     struct student *next; }; void free_node(/*struct*/ student head); //使用对象  使用指针或者引用，需要声明可见（前置声明）  struct student; //前置声明 void free_node(/*struct*/ student *head); //使用指针   而你说一会对一会错的原因  void free_node(struct student* head); //此处的struct student有前置声明的作用，所以没有问题 //void free_node(student* head); //这样子就不行了 struct student {     char name[20];     float score;     struct student *next; };  C语言里不支持定义的结构体是struct student类型，而用student 定义变量的形式，而是C++是支持的。

不论是函数还是变量都要遵循一个先声明后使用的原则； 对于结构体的使用，也是要遵循先声明后使用，虽然声明的是一个结构体类型。

卡住发重了，管理员删 一个


Question: 为什么返回指针的函数不能返回本函数内的数组？？？

函数调用完成后， 函数栈会被清理， 存在栈内的数据都不能作为返回值。

因为本函数内的数组生命周期是函数调用开始到函数调用结束，所以返回函数内的数组是未定义行为； 函数调用结束后，其函数内定义的局部变量都会被释放。使用已经被释放的空间数据是未定义行为。

因为char数组：temp[]是函数内部的局部变量

temp是局部变量，退出函数后会被销毁 在内存被销毁之后还使用它是危险的行为

static char temp[] ={1,2,3,4,5};这样试一下

栈中的变量通常包括函数参数和函数里声明的临时变量。 栈中的基本变量退出其作用域时，没有谁执行一段代码去释放/销毁/析构它所占用的内存，仅仅是没人再去理会的留在当前栈顶上方的若干遗留下来可被后续压栈操作覆盖的无用数据而已。 而栈中的类变量退出其作用域时，会自动执行其析构函数，……

因为函数内的数组是局部变量，函数结束后就销毁了，你返回后，指针指向的是已经销毁的数组，所以是乱码

引用 6 楼 K8001 的回复:[quote=引用 5 楼 zhao4zhong1 的回复:] 理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 真心授人以渔.   另外, 为什么是小脑.[/quote] 因为编程是一门实实在在的手艺。

局部变量，出了函数就没了……

引用 5 楼 zhao4zhong1 的回复:理解和讨论之前请先学会如何观察！  计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。 真心授人以渔.   另外, 为什么是小脑.


Question: C++新人求教，万分感谢

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