{ "bankKey": "computer", "version": "2026-06-26T13:53:58+08:00", "updatedAt": "2026-06-26T05:53:58.088Z", "meta": { "total": 1496, "typeCounts": { "single": 1357, "fill": 139, "judge": 0 }, "knowledgePoints": [ "函数", "排序查找与简单算法", "输入输出", "数据类型与表达式", "数组", "选择结构", "循环结构", "指针", "字符串", "综合编程/调试改错" ], "ids": [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544, 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672, 673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752, 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768, 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784, 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800, 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921, 922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937, 938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953, 954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969, 970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985, 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193, 1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353, 1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465, 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496 ], "displayTypeCounts": { "single": 1357, "fill": 0, "judge": 0, "operation": 139 } }, "questions": [ { "id": 1, "q": "以下程序的运行结果是          。\nint a=10,b=20,c;\nc=(a%b<1)||(a/b>1);\nprintf(\"%d,%d,%d \",a,b,c);", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "10 20 0", "10,20,0", "10,20,1", "10 20 1" ], "explanation": "表达式a%b<1中，10%20的结果为10，10<1为假；a/b为整型除法，10/20结果为0，0>1也为假。两个条件用||连接仍为假，因此c=0，输出为10,20,0，对应选项B。" }, { "id": 2, "q": "以下正确的整型常量是( )", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "72.0", "087", "0X35", "10000B" ], "explanation": "A选项72.0带有小数点，属于浮点型常量；B选项087以0开头表示八进制，但包含了非法数字8；D选项10000B不是C语言标准的整型常量表示法。C选项0X35是以0X开头的十六进制整型常量，完全符合C语言语法规则。" }, { "id": 3, "q": "若有定义语句： int x=12,y=8,z; 在其后执行语句 z=0.9+x/y; 则z的值为", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "1.9", "1", "2", "2.4" ], "explanation": "表达式x/y中，x和y均为整型，因此12/8进行整数除法，结果为1。接着计算0.9+1得到1.9。最后将1.9赋值给整型变量z时，会发生隐式类型转换，直接截断小数部分，因此z的最终值为1。" }, { "id": 4, "q": "已知int x=10,y=20,z=30;以下语句执行后x,y,z的值是()\nif(x>y)z=x;x=y;y=z;\nprintf(\"%d,%d,%d\\n\",x,y,z);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "10,20,30", "20,30,30", "20,30,10", "20,30,20" ], "explanation": "if语句后未加大括号，因此只控制紧随其后的z=x;这一条语句。由于x>y（10>20）为假，z=x不执行，z保持30。随后顺序执行x=y;使x变为20，再执行y=z;使y变为30。最终x、y、z的值分别为20、30、30。" }, { "id": 5, "q": "下面程序的结果是（）\nint i=1;\nwhile(i<3)\n{ printf(\"%d \", i);\ni++;\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1 2", "1 2 3", "2 3", "0 1 2 3" ], "explanation": "初始i=1，满足i<3，输出1后i自增为2；第二次判断2<3成立，输出2后i自增为3；第三次判断3<3不成立，循环结束。因此程序依次输出1和2，中间以空格分隔。" }, { "id": 6, "q": "以下程序的运行结果是（　　）。\nmain(){\nint i=10,sum=0;\nwhile(i>0){\nsum=i;\ni--;}\nprintf(\"%d\\n\",sum);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "55", "1", "54", "10" ], "explanation": "循环条件为i>0，每次循环执行sum=i;而非累加sum+=i;，因此sum的值在每次循环都会被当前的i覆盖。当i递减到1时，sum被赋值为1，随后i自减为0，不满足循环条件退出。最终sum的值为1。" }, { "id": 7, "q": "以下正确的函数声明形式是( )", "t": "single", "ans": "D", "kp": "函数", "o": [ "double fun(int x,int y)", "double fun(int x;int y)", "double fun(int ,int )", "double fun(int ,int );" ], "explanation": "C语言函数声明必须以分号结尾，故排除A和C。函数参数列表中的多个参数必须用逗号分隔，不能用分号，故排除B。D选项使用了正确的逗号分隔参数，且省略了参数名（声明时参数名可省略），并以分号结尾，是正确的声明形式。" }, { "id": 8, "q": "以下程序的运行结果是（　　）\nmain()\n{ int x[8]={1,2,3,4,5,6,7,8},i=0,j=0;\nwhile(++i<7)\nif(x[i++]%2) j+=x[i];\nprintf(\"%d\\n\",j); }", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "16", "0", "20", "15" ], "explanation": "初始i=0。第一次循环++i使i=1，判断x[1]%2即2%2为0，i自增为2，不执行累加；第二次++i使i=3，判断x[3]%2即4%2为0，i自增为4；第三次++i使i=5，判断x[5]%2即6%2为0，i自增为6；第四次++i使i=7，不满足i<7退出。j始终未累加，结果为0。" }, { "id": 9, "q": "设有定义： char *c; 以下选项中能够使c正确指向一个字符串的是（ ）", "t": "single", "ans": "A", "kp": "指针", "o": [ "char str[ ]=\"string\"; c=str;", "scanf(\"%s\",c）;", "c=getchar( );", "*c=\"string\";" ], "explanation": "A选项中，str是字符数组，数组名代表首地址，将其赋值给指针c，使c正确指向字符串。B选项c未初始化，指向未知内存，直接输入会导致段错误。C选项getchar返回字符的ASCII码，不能赋给指针。D选项*c是字符，不能将字符串常量地址赋给字符变量。" }, { "id": 10, "q": "若有定义int a[2][3]={2,4,6,8,10,12};，则值是8的数组元素是（　）。", "t": "single", "ans": "C", "kp": "数组", "o": [ "*(a+1)", "a[1]", "a[1][0]", "*a[1]+2" ], "explanation": "二维数组a按行优先存储，元素依次为a[0][0]=2, a[0][1]=4, a[0][2]=6, a[1][0]=8, a[1][1]=10, a[1][2]=12。值为8的元素是a[1][0]。A和B表示第二行的首地址，D选项*a[1]即a[1][0]值为8，加2后为10。" }, { "id": 11, "q": "下面程序的结果是（）\nint i=1;\nwhile(i<=3)\n{\ni++;\nprintf(\"%d \", i);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "2 3 4", "2 3", "1 2 3", "1 2 3 4" ], "explanation": "初始i=1。第一次循环，i<=3成立，i自增为2，输出2；第二次循环，i<=3成立，i自增为3，输出3；第三次循环，i<=3成立，i自增为4，输出4；第四次判断i<=3不成立，退出循环。因此输出结果为2 3 4。" }, { "id": 12, "q": "程序运行时，输入：Hello，下面程序的输出结果是（）。\nint n=0;\nwhile (getchar() != '\\n') n++;\nprintf(\"%d\", n);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1", "5", "4", "0" ], "explanation": "程序通过getchar()逐个读取字符，直到遇到换行符为止。输入Hello共包含5个字母字符，每次读取一个有效字符n自增1，读取到回车换行符时循环结束。因此n的值为5，输出5。" }, { "id": 13, "q": "下列程序段的输出结果是是（ ）。\nmain( )\n{ int b[10]={1,2,3,4,5,6,7,8,9,10},s=3;\nfor(i=1;i<4;i++)\ns+=*(b+i);\nprintf(\"%d\",s);}", "t": "single", "ans": "A", "kp": "数组", "o": [ "12", "15", "18", "21" ], "explanation": "数组b的元素为b[0]到b[9]。*(b+i)等价于b[i]。循环变量i从1到3，依次累加b[1]、b[2]、b[3]的值，即2、3、4。初始s=3，累加后s = 3 + 2 + 3 + 4 = 12。因此输出12。" }, { "id": 14, "q": "给定程序MODI1.C中，函数fun的功能是：分别统计出形参str所指的字符串中的大写字母和小写字母的个数，并传递回主函数输出。例如，若str所指的内容为\"BAY23Kill\"，其中大写字母数为4，小写字母数为3，则应输出：c0=4,c1=3。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "函数fun用来统计小写字母及大写字母的个数并通过形参c0和c1返回，第一处错误，对指针c0和c1初始化的语句应为：*c0 = *c1 = 0;。对数组内的元素进行操作时，数组的下标是从0开始的，故第二处应改为：for (k=0; k8)\nz=++x;\nelse\nz=++x;\nprintf(\"%d\",z);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "8", "9", "10", "11" ], "explanation": "初始x=8。判断条件x++>8中，先使用x的原值8进行比较，8>8为假，然后x自增为9。因为条件为假，执行else分支z=++x。此时x先自增为10，再赋值给z，因此z的值为10。最后输出10。" }, { "id": 17, "q": "以下程序运行完后a的值是（ ）。\nmain()\n{\nint i, a=0 ;\nfor(i=0; i<10; i++)\ni++;\na++;\nprintf(\"%d\", a);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1", "10", "11", "2" ], "explanation": "注意for循环的循环体只有i++这一条语句，因为其后没有大括号。a++和printf语句在for循环外部。for循环执行完毕后，程序继续执行a++，此时a由0变为1。最后输出a的值1。此题考查循环体作用域及代码缩进误导。" }, { "id": 18, "q": "有以下程序段\nint k=1;\nwhile(k==1) k++;\nwhile 循环执行的次数是( ) 。", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "无限次", "有语法错，不能执行", "一次也不执行", "执行1次" ], "explanation": "初始k=1，满足条件k==1，进入循环体执行k++，k变为2。再次判断条件k==1不成立，退出循环。因此循环体仅执行1次。注意区分循环条件判断次数与循环体执行次数。" }, { "id": 19, "q": "程序段的输出结果是().\nfor( i=0; i<4; i++, i++)\nfor(k=1; k<3; k++)\nprintf(\"*\");", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "********", "****", "**", "*" ], "explanation": "外层循环变量i初始为0，每次迭代后执行两次i++，即i每次增加2。i的取值依次为0和2，共执行2次。内层循环k从1递增到2，共执行2次。因此总输出星号数量为2乘2等于4个。" }, { "id": 20, "q": "若有以下定义和语句，则不能表示数组a的元素的表达式是（　）。\nint a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;", "t": "single", "ans": "B", "kp": "数组", "o": [ "*p", "a[10]", "*a", "a[p-a]" ], "explanation": "数组a定义长度为10，其合法下标范围是0到9。选项B的a[10]下标越界，不能表示数组的有效元素。选项A和C均等价于a[0]，选项D中p-a结果为0，等价于a[0]，均可正确表示数组元素。" }, { "id": 21, "q": "以下程序的运行结果是（　　）\nvoid f(int x,int *y){\nint t;\nif(x<*y){ t=x; x=*y; *y=t;}\n}\nmain(){\nint a=4,b=3,c=5;\nf(a,&b); f(a,&c);\nprintf(\"%d %d %d\\n\",a,b,c);\n}", "t": "single", "ans": "A", "kp": "指针", "o": [ "4 3 4", "4 3 5", "4 4 4", "4 4 5" ], "explanation": "函数f中x为值传递，修改x不影响实参a；y为指针传递，修改*y会改变对应实参。首次调用f(a,&b)时，4<3为假，b保持3不变。再次调用f(a,&c)时，4<5为真，*y被赋值为4，故c变为4。最终输出4 3 4。" }, { "id": 22, "q": "有以下程序\n#include \nint a=1,b=2;\nvoid fun1(int a, int b )\n{ printf(\"%d%d\",a,b ); }\nvoid fun2( )\n{ a=3; b=4; }\nmain()\n{ fun1(5,6); fun2();\nprintf(\"%d%d\\n\",a,b );\n}\n程序运行后的输出结果是( )", "t": "single", "ans": "D", "kp": "函数", "o": [ "3 4 5 6", "1 2 5 6", "5 6 1 2", "5 6 3 4" ], "explanation": "fun1中形参a和b遮蔽了全局变量，因此输出传入的实参5和6。fun2中没有局部变量，直接修改全局变量a和b的值为3和4。最后main函数输出全局变量a和b，即3和4。因此最终输出5634。" }, { "id": 23, "q": "以下关于逻辑运算符两侧运算对象的叙述中正确的是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "只能是整数0或1", "只能是整数0或非0的整数", "可以是结构体类型的数据", "可是任意合法的表达式" ], "explanation": "在C语言中，逻辑运算符（如&&、||、!）两侧的运算对象可以是任意合法的表达式。系统会根据表达式的计算结果来判断逻辑真假：结果为0代表\"假\"，非0代表\"真\"。因此不仅限于整数0或1，也不限于整型数据。" }, { "id": 24, "q": "以下选项中，能用作数据常量的是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "115", "0118", "1.5e1.5", "o115" ], "explanation": "A选项是合法的十进制整型常量。B选项以0开头表示八进制，但包含了非法数字8。C选项科学计数法中e后面的指数必须是整数，不能是1.5。D选项以字母o开头，不是合法的数字常量（若为数字0则合法）。因此只有A正确。" }, { "id": 25, "q": "若有定义 int a=12, n=5, 则表达式 a/=(n/2) 运算后, a 的值()。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "0", "1", "12", "6" ], "explanation": "首先计算括号内的表达式n/2，由于n和2都是整型，进行整数除法，5除以2结果为2。接着计算复合赋值运算a/=2，即a=a/2，12除以2结果为6。因此运算后a的值为6。" }, { "id": 26, "q": "float x=1.5; int a=1,b=3,c=2; 则正确的switch语句是()", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "switch(a+b) { case 1: printf(\"*\\n\"); case 2+1: printf(\"**\\n\"); }", "switch((int)x); { case 1: printf(\"*\\n\"); case 2: printf(\"**\\n\"); }", "switch(x) { case 1.0: printf(\"*\\n\"); case 2.0: printf(\"**\\n\"); }", "switch(a+b) { case 1: printf(\"*\\n\"); case c: printf(\"**\\n\"); }" ], "explanation": "switch语句的控制表达式必须是整型或字符型，case后面必须是常量表达式。A选项中a+b为整型，case后的1和2+1均为常量表达式，语法正确。B选项switch后多了一个分号；C选项控制表达式和case后使用了浮点型；D选项case后使用了变量c，均不合法。" }, { "id": 27, "q": "以下程序的运行结果是（　　）。\nmain(){\nint m=2,i,count=0;\nfor(i=1;i<=m;i++)\nif(i%2==0) {printf(\"%d,\",i); count++; }\nprintf(\"%d \",count);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1,1", "2,1", "2,2", "1,2,2" ], "explanation": "循环变量i从1递增到2。当i=1时，i%2==0不成立，不执行if内语句。当i=2时，条件成立，输出\"2,\"并将count加1变为1。循环结束后，执行最后的printf输出count的值1。因此最终输出结果为2,1。" }, { "id": 28, "q": "有以下程序段其输出结果是( ) 。\nint x=3;\ndo\n{ printf(\"%d\",x-=2); }\nwhile (!(x--));", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1", "1 -2", "3 0", "死循环" ], "explanation": "首先执行do循环体，x-=2使x变为1，输出1。接着判断while条件，表达式x--的值为1（非0），取逻辑非后为0（假），同时x自减为0。由于条件为假，循环结束。因此程序只输出1。" }, { "id": 29, "q": "以下程序的运行结果是( ) 。\nmain()\n{ int i,j;\nfor(i=3;i>=1;i--) {\nfor(j=1;j<=i;j++)\nprintf(\"%d\",i+j);\nprintf(\"\\n \") ;}}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "456\n34\n2", "43\n25\n43", "23\n34\n45", "45\n34\n23" ], "explanation": "外层循环i从3递减到1。当i=3时，内层循环j从1到3，依次输出i+j的值4、5、6；当i=2时，j从1到2，输出3、4；当i=1时，j为1，输出2。每次内层循环结束后换行。因此输出结果依次为456、34、2。" }, { "id": 30, "q": "以下程序的运行结果是（　　）\nint f(int x) {\nint y;\nif(x==0||x==1) return (3);\ny=x*x-f(x-2);\nreturn y;\n}\nmain(){\nint z;\nz=f(5);\nprintf(\"%d\\n\",z);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "19", "18", "17", "20" ], "explanation": "这是一个递归函数。计算f(5)时，调用f(3)；计算f(3)时，调用f(1)。当x=1时满足终止条件，返回3。回溯计算：f(3) = 3*3 - f(1) = 9 - 3 = 6；f(5) = 5*5 - f(3) = 25 - 6 = 19。因此最终输出19。" }, { "id": 31, "q": "以下能正确定义一维数组的选项是（）。", "t": "single", "ans": "B", "kp": "数组", "o": [ "int num(5*2);", "int num[5*2];", "int long[10];", "int num(10);" ], "explanation": "C语言中定义数组时，数组名后必须使用方括号[]，且方括号内必须是常量表达式。A和D选项错误地使用了圆括号。C选项中long是C语言的关键字，不能作为数组名。B选项使用方括号且5*2是合法的常量表达式，定义正确。" }, { "id": 32, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint i,t[][3]={9,8,7,6,5,4,3,2,1,9};\nfor(i=0;i<3;i++) printf(\"%d\",t[3-i][i]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "924", "834", "934", "429" ], "explanation": "二维数组t按行优先初始化，共4行3列：第0行9,8,7；第1行6,5,4；第2行3,2,1；第3行9,0,0。循环i从0到2：i=0时输出t[3][0]即9；i=1时输出t[2][1]即2；i=2时输出t[1][2]即4。因此最终输出924。" }, { "id": 33, "q": "以下程序的运行结果是（　　）。\n#define SQR(X) (X)*(X)\nmain()\n{ int a=16, k=2, m=1;\na/=SQR(k+m)/SQR(k+m);\nprintf(\"%d\\n\",a);\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "2", "16", "9" ], "explanation": "宏替换是纯文本替换。表达式展开为a/=(k+m)*(k+m)/(k+m)*(k+m)。代入k=2,m=1后变为a/=3*3/3*3。根据乘除从左到右的结合性，计算过程为3*3=9，9/3=3，3*3=9。最后执行a/=9，即16/9，整除结果为1。" }, { "id": 34, "q": "给定程序中，函数fun的功能是：计算x所指数组中N个数的平均值（规定所有数均为正数），平均值通过形参返回主函数，将小于平均值且最接近平均值的数作为函数值返回，在主函数中输出。\n例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000\n主函数中输出：m=30\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 35, "q": "以下选项中，值为1的表达式是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1-'0'", "'1'-0", "1-'\\0'", "'\\0'-'0'" ], "explanation": "'0'的ASCII码是48，'\\0'的ASCII码是0。A选项1-48=-47；B选项'1'(49)-0=49；C选项1-0=1；D选项0-48=-48。因此C选项值为1。" }, { "id": 36, "q": "关于以下程序执行情况的叙述，正确的是（　　）。\nmain(){\nint i, n;\nfor(i=0;i<10;i++)\n{ n = rand() % 5;\nswitch(n)\n{ case 1:\ncase 3: printf(\"%d\\n\",n); break;\ncase 2:\ncase 4: printf(\"%d\\n\",n);continue;\n}\nprintf(\"%d \\n\",n);\nbreak; }\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "for循环语句固定执行7次", "当产生的随机数n为1或3时结束循环操作", "当产生的随机数n为1和2时不做任何操作", "当产生的随机数n为0时结束程序运行" ], "explanation": "for循环中生成0-4的随机数n。当n为1或3时，执行printf后遇到break跳出switch，接着执行循环体最后的break结束for循环。当n为2或4时遇到continue跳过本次循环。n为0时不匹配case，执行最后的break结束循环。B选项描述符合n为1或3时的执行逻辑。" }, { "id": 37, "q": "下面是对s的初始化，其中不正确的是( )", "t": "single", "ans": "D", "kp": "字符串", "o": [ "char s[5]={“abc”};", "char s[5]={'a','b','c'};", "char s[5]=\" h\";", "char s[5]=“abcdef ”;" ], "explanation": "字符数组初始化时，若使用字符串常量，其长度（包含结束符'\\0'）不能超过数组定义的长度。D选项中字符串\"abcdef \"包含7个字符加1个'\\0'，共8个字符，超出了数组s的长度5，会导致编译错误。A、B、C选项的初始化长度均在5以内，合法。" }, { "id": 38, "q": "若程序中已给整型变量a和b分别赋值10和20，写出按以下格式：****a=10,b=20****，输出a、b值的语句 。", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "printf(\"****a=%f,b=%f****\\n\",a,b);", "printf(\"%f,%f\\n\",a,b);", "printf(\"****a=%d,b=%d****\\n\",a,b);", "printf(\"%d,%d\\n\",a,b);" ], "explanation": "题目要求输出格式为\"****a=10,b=20****\"，且a和b为整型变量。因此格式控制字符串中必须包含原样输出的\"****a=\"和\",b=\"以及\"****\"，并使用整型格式说明符\"%d\"来输出变量a和b的值。C选项完全符合该格式要求，A、B使用了浮点型%f，D缺少固定字符。" }, { "id": 39, "q": "设x为int型变量，请写出一个关系表达式          ，用以判断x同时为3和7的倍数时，关系表达式的值为真。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "x/3==0&&x/7==0", "x/3==0||x/7==0", "x%3==0&&x%7==0", "x%3==0||x%7==0" ], "explanation": "判断一个整数是否为另一个整数的倍数，应使用取余运算符\"%\"。若余数为0，则说明是倍数。题目要求\"同时\"为3和7的倍数，因此需要使用逻辑与运算符\"&&\"将两个条件连接。C选项正确表达了该逻辑，A、B错用除法，D错用逻辑或。" }, { "id": 40, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "标识符的长度不能任意长，最多只能包含16个字符", "语言中的关键字不能作变量名，但可以作为函数名", "用户自定义的标识符必须\"见名知义\"，如果随意定义，则会出编译错误", "标识符总是由字母、数字和下划线组成，且第一个字符不得为数字" ], "explanation": "C语言标识符由字母、数字和下划线组成，且首字符不能是数字，D正确。A错误，C89标准至少支持31个字符，C99支持63个字符；B错误，关键字不能用作任何用户自定义标识符（包括函数名）；C错误，标识符不要求\"见名知义\"，随意定义只要符合命名规则就不会产生编译错误。" }, { "id": 41, "q": "以下程序段运行结果是( ) 。\nint x=1, y=1, z=-1;\nx+=y+=z;\nprintf(\"%d\\n\", x\nmain()\n{\nchar a=65,b;\nb=a+32;\nprintf(\" c=%c\\n\",c+32);\n}", "#include\nmain()\n{\nchar a='A',b;\nb=a+32;\nprintf(\" c=%c\\n\",c+32);\n}", "#include\nmain()\n{\nchar a=\"A\",b;\nb=a+32;\nprintf(\" c=%c\\n\",c+32);\n}", "#include\nmain()\n{\nchar a='\\101',b;\nb=a+32;\nprintf(\" c=%c\\n\",c+32);\n}" ], "explanation": "C选项中，变量a被定义为char类型，但初始化时使用了字符串常量\"A\"（双引号），这在C语言中是不合法的，字符变量应使用单引号括起来的字符常量或ASCII码值初始化。A使用整数65，B使用字符'A'，D使用八进制转义字符，均合法。" }, { "id": 44, "q": "若变量已正确定义，以下语句段的输出结果是( ) 。\nx=0; y=2; z=3\nswitch( x ) {\ncase 0 : switch( y==2 )\n{ case 1: printf(\" * \"); break;\ncase 2: printf(\" % \"); break;\n}\ncase 1 : switch( z )\n{ case 1: printf(\" $ \");\ncase 2: printf(\" * \"); break;\ndefault: printf(\" # \");\n}\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "*", "*#", "*$", "%$" ], "explanation": "x=0，进入外层switch的case 0。内层switch(y==2)，y=2故y==2为真(1)，进入case 1，输出\"*\"并break跳出内层switch。由于外层case 0后没有break，发生穿透，继续执行case 1。内层switch(z)，z=3，不匹配case 1和2，进入default，输出\"#\"。最终输出\"*#\"。" }, { "id": 45, "q": "以下程序的输出结果是( )。\nmain()\n{ int x=2,y=-1,z=2;\nif(x0);\nprintf(\"end\\n\");", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "0 end", "1 end", "3 end", "end" ], "explanation": "初始i=5。第一次循环：i%2为1，执行i--(i变4)并continue，跳过后续语句。第二次：i=4，i%2为0，执行i--(i变3)并break跳出switch，接着if(i==3)成立，break跳出do-while循环。整个过程中printf从未被执行。最后输出\"end\"。" }, { "id": 47, "q": "该程序的执行结果是（）\nint x=43;\ndo\n{ printf(\"%d\",--x); }\nwhile(!x);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "43", "42", "死循环", "不输出任何内容" ], "explanation": "do-while循环先执行循环体。x初值为43，执行--x后x变为42并输出。接着判断条件!x，即!42，结果为0（假），循环结束。因此只输出42。" }, { "id": 48, "q": "下边程序段循环执行的次数是（ ）。\nint a= 0, j = 10;\nfor ( ; j > 3; j-- )\n{\na++;\nif ( a> 3) break ;\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "3", "4", "5", "6" ], "explanation": "循环初始j=10，a=0。第1次：j=10>3，a=1，不break，j变9；第2次：j=9>3，a=2，不break，j变8；第3次：j=8>3，a=3，不break，j变7；第4次：j=7>3，a=4，满足a>3，执行break跳出循环。共执行4次。" }, { "id": 49, "q": "以下程序段运行后的输出结果是()\nint n,s=0,m;\nfor(n=13;n<=14;n=n+2)\n{m=n;\nwhile(m)\n{s+=m%10;\nm=m/10;}\n}\nprintf(\"%d\\n\",s);", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "9", "8", "4", "5" ], "explanation": "外层for循环n初值13，步长2，条件n<=14，故只执行一次(n=13)。内层while循环计算13的各位数字之和：m=13，s+=3，m=1；s+=1，m=0。最终s=4。输出4。" }, { "id": 50, "q": "则程序的输出结果是（）\nint a=-2, b=0;\nwhile(a++) b++ ;\nprintf(\"%d,%d\\n\", a, b);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "0,1", "1,2", "1,3", "2,3" ], "explanation": "a初值-2。第1次判断a++，表达式值为-2（真），a变为-1，执行b++，b变1；第2次判断a++，值为-1（真），a变为0，执行b++，b变2；第3次判断a++，值为0（假），a变为1，不执行循环体。最终a=1，b=2。" }, { "id": 51, "q": "设int jc（int n）是函数，则表达式中jc(j)/(jc(k)*jc(j-k))函数f调用了（）次。", "t": "single", "ans": "A", "kp": "函数", "o": [ "3", "2", "1", "4" ], "explanation": "表达式jc(j)/(jc(k)*jc(j-k))中，分子调用了一次jc函数，分母中jc(k)和jc(j-k)各调用了一次，总共调用了3次。题目中的\"函数f\"应为\"函数jc\"的笔误。" }, { "id": 52, "q": "有关局部变量的说法，下列错误的是（）", "t": "single", "ans": "B", "kp": "函数", "o": [ "局部变量定义在函数内部", "局部变量可定义在函数外部", "局部变量可定义在复合语句内部", "函数的形参是该函数的局部变量" ], "explanation": "局部变量是在函数内部或复合语句内部定义的变量，其作用域仅限于定义它的函数或复合语句内。定义在函数外部的变量是全局变量，因此选项B说法错误。函数的形参也属于局部变量。" }, { "id": 53, "q": "以下程序的运行结果是（） 。\nfun(int x)\n{  if(x/3>0) fun(x/3);\n   printf(\"%d*\",x); }\nmain()\n{  fun(9); }\nA．B.  C .D.", "t": "single", "ans": "B", "kp": "函数", "o": [ "1*9*3*", "1*3*9*", "9*3*1*", "3*9*1*" ], "explanation": "调用fun(9)，9/3=3>0，递归调用fun(3)；3/3=1>0，递归调用fun(1)；1/3=0不满足条件，输出1*；返回fun(3)输出3*；返回fun(9)输出9*。最终输出1*3*9*。" }, { "id": 54, "q": "以下程序的运行结果是（　　）\nmain()\n{ int s[12]={0,2,3,4,4,3,2,1,1,1,2,3},c[5]={0},i;\nfor(i=0;i<12;i++) c[s[i]]++;\nfor(i=0;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "13332", "03332", "3332", "0333" ], "explanation": "数组c用于统计数组s中各数字出现的次数。s中包含：0出现1次，1出现3次，2出现3次，3出现3次，4出现2次。循环结束后，c[0]到c[4]的值分别为1, 3, 3, 3, 2。依次输出即为13332。" }, { "id": 55, "q": "以下程序的运行结果是（　）。\nmain()\n{ int a[3][3]={ {1,2},{3,4},{5,6} },i,j,s=0;\nfor(i=1;i<3;i++)\nfor(j=0;j<=i;j++) s+=a[i][j];\nprintf(\"%d\\n\",s); }", "t": "single", "ans": "A", "kp": "数组", "o": [ "18", "19", "20", "21" ], "explanation": "二维数组a未赋值的元素默认为0。外层i从1到2。i=1时，j从0到1，s加上a[1][0]和a[1][1]即3+4=7；i=2时，j从0到2，s加上a[2][0]、a[2][1]和a[2][2]即5+6+0=11。总计s=7+11=18。" }, { "id": 56, "q": "程序的输出结果是（）。\nint s=1,t=4,a=-2,b=-3;\nif (a<0) s=s+1;\nif (a>b) t=s+t;\nelse if (a==b) t=5;\nelse t=2*s;\nprintf(\"%d\\n\",t);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "2", "4", "5", "6" ], "explanation": "初始s=1、t=4、a=-2、b=-3。先判断a<0成立，因此s变为2；再判断a>b，即-2>-3成立，执行t=s+t，得到t=6，最终输出6。" }, { "id": 57, "q": "若有以下定义，则对数组x的数组元素的正确引用是（　　）。\nint x[10], *pt=x;", "t": "single", "ans": "B", "kp": "指针", "o": [ "*&x[10]", "* (x+3)", "* (pt+10)", "pt+3" ], "explanation": "A选项*&x[10]越界且语法冗余；B选项*(x+3)等价于x[3]，是合法的数组元素引用；C选项*(pt+10)越界访问；D选项pt+3是地址而非数组元素的值。因此B正确。" }, { "id": 58, "q": "有下列程序：\nvoid f(int *q)\n{ int i=0;\nfor(;i<5; i+ +) (*q)++;\n}\nmain( )\n{ int a[5] ={1,2,3,4,5}, i;\nf(a）;\nfor(i=0;i<5; i+ +) printf(\"%d,\", a[i]);\n}\n程序运行后的输出结果是（ ）", "t": "single", "ans": "B", "kp": "指针", "o": [ "2, 2, 3, 4, 5,", "6, 2, 3, 4, 5,", "1, 2, 3, 4, 5,", "2, 3, 4, 5, 6," ], "explanation": "函数f中，指针q指向数组a的首元素a[0]。循环5次执行(*q)++，即对a[0]自增5次，a[0]由1变为6。指针q本身未发生偏移，因此a[1]到a[4]的值保持不变。最终输出6,2,3,4,5,。" }, { "id": 59, "q": "以下程序的运行结果是( )\n#define x 5\n#define y (x+1)\n#define z y*x/2\nmain()\n{\nprintf(\"%d\",2*z);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "10", "12", "30", "15" ], "explanation": "宏替换时直接进行文本替换。z展开为(x+1)*x/2，即(5+1)*5/2。2*z展开为2*(5+1)*5/2，计算结果为30。注意宏定义中y带有括号，保证了加法优先计算。" }, { "id": 60, "q": "以下程序的运行结果是（　　）。\n#define SQR(X) X*X\nmain()\n{ int a=16, k=2, m=1;\na/=SQR(k+m)/SQR(k+m);\nprintf(\"%d\\n\",a);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "16", "1", "2", "9" ], "explanation": "宏定义SQR(X)没有为参数和整体加括号。展开后表达式为a/=k+m*k+m/k+m*k+m。代入k=2,m=1，得a/=2+1*2+1/2+1*2+1。根据优先级先算乘除：1*2=2，1/2=0，1*2=2。再算加法得7。最后a=16/7=2。" }, { "id": 61, "q": "请编写函数fun，函数的功能是查找x在s所指数组中下标的位置作为函数值返回，若x不存在，则返回-1。\n注意：部分源程序存在PROG1.C中，请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "int fun( int *s, int x)\n{int i;\nfor(i=0;i0 ? p/10 : p%3));", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "3.1", "1", "3", "0" ], "explanation": "表达式包含条件运算符。首先计算条件p/3>0，由于p=31，整除3得10，10>0为真。因此执行冒号前的表达式p/10，31整除10结果为3。最终输出3。" }, { "id": 68, "q": "以下程序段中与语句\nk=a>b?(b>c?1:0):0；功能等价的是（）。", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "if((a>b)&&(b>c)) k=1;\nelse k=0;", "if((a>b)||(b>c)) k=1\nelse k=0;", "if(a<=b) k=0;\nelse if(b<=c) k=1;", "if(a>b) k=1;\nelse if(b>c) k=1;" ], "explanation": "嵌套条件运算符a>b?(b>c?1:0):0的逻辑是：只有当a>b且b>c同时成立时，结果才为1，否则为0。这与选项A中的逻辑与&&判断完全等价。其他选项的逻辑条件均与此不符。" }, { "id": 69, "q": "若变量已正确定义，以下程序段运行结果是( ) 。\nint a=3,b=5,c=7;\nif(a>b） a=b; c=a;\nif(c!=a） c=b;\nprintf(\"%d,%d,%d\\n\",a,b,c）;", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "程序段有语法错", "3，5，3", "3，5，5", "3，5，7" ], "explanation": "第一个if语句后没有大括号，因此只控制a=b;这一条语句。由于a>b为假，a保持为3。接着顺序执行c=a;，c变为3。第二个if判断c!=a为假，c保持为3。最终输出3,5,3。" }, { "id": 70, "q": "有如下程序\nmain()\n{ int a=2,b=-1,c=3;\nif(a=0) ;", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "2", "3", "4", "5" ], "explanation": "第一次循环：b=2，a=10-4=6，a>=0成立；第二次循环：b=4，a=6-6=0，a>=0成立；第三次循环：b=6，a=0-8=-8，a>=0不成立，退出循环。do-while循环体共执行了3次。" }, { "id": 72, "q": "程序运行后输出结果是()\nint a = -1, b = 0;\nwhile (a++ && ++b) ;\nprintf(\"%d,%d\\n\", a, b );", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1,1", "0,1", "1,0", "0,0" ], "explanation": "第一次判断：a++值为-1(真)，a变为0；继续计算++b，b变为1(真)，条件成立。第二次判断：a++值为0(假)，a变为1；由于逻辑与&&的短路特性，++b不再执行，b保持为1。循环结束，输出1,1。" }, { "id": 73, "q": "以下能正确定义二维数组的选项是（　　）。", "t": "single", "ans": "C", "kp": "数组", "o": [ "char c[N ][M ];", "char c[3][N];", "#define N 10\n#define M 10\nint c[N][M];", "int x=10,y=10;\nint c[x][y];" ], "explanation": "在C语言中定义数组时，数组的维度必须是常量表达式。选项A和B使用了未定义的标识符；选项D使用了变量，在标准C中是不允许的；选项C通过宏定义将N和M定义为常量10，符合语法规则。" }, { "id": 74, "q": "若以下说明,则数值为4的表达式是（ ）。\nint a[12]={1,2,3,4,5,6,7,8,9,10};\nchar c='a',d,g;", "t": "single", "ans": "D", "kp": "数组", "o": [ "a[g-c]", "a[4]", "a['d'-'c']", "a['d'-c]" ], "explanation": "数组a中，a[0]=1，a[1]=2，a[2]=3，a[3]=4。要得到数值4，下标必须为3。选项A中g未初始化，值不确定；选项B中a[4]=5；选项C中'd'-'c'=1，a[1]=2；选项D中'd'-c即'd'-'a'=3，a[3]=4。因此选D。" }, { "id": 75, "q": "若有定义语句char s[10]= \"1234567\\0\\0\";，则strlen(s)的值是（ ）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "7", "8", "9", "10" ], "explanation": "strlen函数用于计算字符串的长度，遇到第一个'\\0'时停止计数，且不包含'\\0'本身。字符串\"1234567\\0\\0\"中，前7个字符为'1'到'7'，第8个字符为'\\0'。因此strlen(s)的值为7。选A。" }, { "id": 76, "q": "若程序中已包含头文件stdio.h，以下选项中正确运用指针变量的是（　）。", "t": "single", "ans": "D", "kp": "指针", "o": [ "int *i=NULL;\nscanf(\"%d\",i);", "float *f=NULL\n*f=10/5", "char t='m', *c=&t;\n*c=&t;", "long *L\nL='\\0';" ], "explanation": "选项A中指针i为NULL，scanf向空指针写入数据会导致段错误；选项B语法错误，缺少分号且对空指针解引用赋值非法；选项C中*c是字符，&t是地址，类型不匹配且逻辑错误；选项D中定义指针L并赋值为空字符'\\0'（即0或NULL），语法合法。选D。" }, { "id": 77, "q": "以下程序段的运行结果是( )\n#define N 6\n#define M1 N+1\n#define M2 M1*2\nmain()\n{ printf(\"%d\\n\",M2); }", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "14", "8", "9", "10" ], "explanation": "宏替换是简单的文本替换。M2被替换为M1*2，进一步替换为N+1*2，再替换为6+1*2。根据运算符优先级，先计算乘法1*2=2，再计算加法6+2=8。因此输出结果为8。选B。" }, { "id": 78, "q": "设有以下定义：\n#define Y(n) (n*n)\n则执行语句z= Y(2+1);后，z的值为（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "5", "9", "7", "出错" ], "explanation": "宏定义Y(n)展开时进行简单的文本替换。Y(2+1)会被替换为(2+1*2+1)。根据运算符优先级，先计算乘法1*2=2，再计算加法2+2+1=5。因此z的值为5。选A。" }, { "id": 79, "q": "结定程序BLANK1.C中主函数的功能是：输入一个实数a，根据迭代公式x1=(x0+a/x0)/2，计算并输出其平方根。要求误差不超过1e-6 (即0.000001)。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 80, "q": "请编写函数fun，其功能是：判断形参n中的正整数是几位数（输入数据的位数不超过4位），并将结果通过函数值返回。\n例如：若输入的数据为 123，则输出结果为：输入的数字是3位。\n注意：部分源程序存在PROG1.C中，请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入所编写的若干语句。", "t": "fill", "ans": "int fun(int n)\n{\nint k=0;\nwhile(n!=0)\n{\nn=n/10;\nk++;\n}\nreturn k;\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 81, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "每个后缀为.c的C语言源程序可以包含二个main函数。", "在C语言程序中，main函数必须放在其他函数的最前面", "每个后缀为.c的C语言源程序都可以单独进行编译。", "在C语言程序中，只有main函数才可单独进行编译。" ], "explanation": "一个C程序只能有一个main函数，A错；main函数可以放在程序的任何位置，B错；每个.c源文件都可以单独编译生成目标文件，C正确；不仅main函数，其他函数所在的源文件也可单独编译，D错。选C。" }, { "id": 82, "q": "以下选项中不能作为C语言合法常量的是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "'cd'", "0.1e+6", "\"\\a\"", "'\\011'" ], "explanation": "C语言中单引号括起来的只能是单个字符或转义字符，'cd'包含两个字符，不是合法的字符常量。0.1e+6是合法的科学计数法浮点常量；\"\\a\"是合法的字符串常量；'\\011'是合法的八进制转义字符常量。选A。" }, { "id": 83, "q": "已知：int a=3,x=5,y=6;\n则 x+a%3*(int)(x+y)%2/4 的值为( )", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "5.5", "5", "5.25", "0" ], "explanation": "表达式计算顺序：先算括号(x+y)=11，强转为(int)11；接着算a%3即3%3=0；然后0*11=0；接着0%2=0；再0/4=0；最后x+0=5+0=5。由于都是整型运算，结果为整数5。选B。" }, { "id": 84, "q": "以下程序的运行结果是（　　）\n#include\nint a=9;\nfun(int *b)\n{ int a=10;\na+=*b++;\nprintf(\"%d \",a); }\nmain()\n{ int c=23;\nfun(&c);\na+=c++;\nprintf(\"%d\\n\",a);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "33 32", "33", "33 33", "32 32" ], "explanation": "在fun函数中，局部变量a=10，*b为23，a+=23得33，输出33。此时b自增，但不影响main中的c。回到main函数，全局变量a=9，c++先取c的值23参与运算，a+=23得32，然后c自增为24。最后输出全局变量a的值32。因此输出33 32。选A。" }, { "id": 85, "q": "C 语言中 while 和 do-while 循环的主要区别是( )。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "do-while 的循环体至少无条件执行一次", "while 的循环控制条件比 do-while 的循环控制条件严格", "do-while 允许从外部转到循环体内", "do-while 的循环体不能是复合语句" ], "explanation": "while循环是先判断条件后执行循环体，若条件初始为假则一次也不执行；do-while循环是先执行一次循环体，然后再判断条件，因此循环体至少会无条件执行一次。两者条件判断机制相同，循环体都可以是复合语句。选A。" }, { "id": 86, "q": "若有以下函数首部 int fun(double x[10], int *n) 则下面针对此函数的函数声明语句中正确的是( )", "t": "single", "ans": "C", "kp": "函数", "o": [ "int fun(double , int );", "int fun(double *x, int n);", "int fun(double *, int *);", "int fun(double x, int *n);" ], "explanation": "在C语言函数参数中，一维数组名作为参数时会退化为指向其基类型的指针。因此double x[10]等价于double *x或double *。第二个参数int *n本身就是指针。所以正确的函数声明应为int fun(double *, int *);。选C。" }, { "id": 87, "q": "以下程序的输出结果是（）\nint a=4;\nint f(int n){\nint t=0;\nint a=5;\nif(n%2) t+=a++;\nelse t+=a++;\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<2;i++) s+=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "26", "27", "28", "30" ], "explanation": "全局变量a=4。main中s初始化为4。循环i=0时，调用f(0)，n%2为0，执行else，t+=a++即t=5，a变6；返回t+a++即5+6=11，a变7。s=4+11=15。循环i=1时，调用f(1)，局部变量a重新初始化为5。n%2为1，执行if，t+=a++即t=5，a变6；返回t+a++即5+6=11。s=15+11=26。输出26。选A。" }, { "id": 88, "q": "以下程序的运行结果是（ ）。\nmain()\n{ int i,t[][3]={9,8,7,6,5,4,3,2,1};\nfor(i=0;i<3;i++) printf(\"%d，\",t[2-i][i]); }", "t": "single", "ans": "D", "kp": "数组", "o": [ "1,0,0,", "1,4,7,", "3,6,7,", "3,5,7," ], "explanation": "二维数组按行优先初始化，t[0]为9,8,7，t[1]为6,5,4，t[2]为3,2,1。循环中i依次取0、1、2，分别输出t[2][0]、t[1][1]、t[0][2]，对应值为3、5、7。" }, { "id": 89, "q": "以下程序段运行后的输出结果是（ ）。\nmain( )\n{ int s=0,n,m,a[3][3]={1,2,3,5,7,9,11,13,15};\nfor(n=0;n<3;n++)\nfor(m=0;m<3;m++)\nif(n==m)\ns=s+a[n][m];\nprintf(?°%d?±,s);", "t": "single", "ans": "D", "kp": "数组", "o": [ "66", "22", "24", "23" ], "explanation": "二维数组按行优先初始化，主对角线元素为a[0][0]=1，a[1][1]=7，a[2][2]=15。程序通过双重循环和条件n==m筛选出主对角线元素并累加，结果为1+7+15=23。" }, { "id": 90, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int a[]={2,4,6,8,10,12,14,16};\nint y=1,x, *p;\np=&a[2];\nfor(x=1;x<3;x++)\ny+=* (p+x);\nprintf(\"%d\\n\",y); }", "t": "single", "ans": "C", "kp": "指针", "o": [ "15", "13", "19", "25" ], "explanation": "指针p指向a[2]（值为6）。循环x从1到2，依次执行y+=*(p+1)和y+=*(p+2)。*(p+1)即a[3]值为8，*(p+2)即a[4]值为10。初始y=1，累加后y=1+8+10=19。" }, { "id": 91, "q": "下列程序的运行结果是（　　）。\n#define SQR(x) x*x\nmain()\n{ int a,k=5;\na=++SQR(k+1);\nprintf(\"%d\\n\",a);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "36", "25", "13", "12" ], "explanation": "宏替换为纯文本替换，SQR(k+1)展开为k+1*k+1。语句变为a=++k+1*k+1;。前置自增++k使k变为6，表达式计算为6+1*6+1=13。注意宏定义未加括号导致的运算优先级问题。" }, { "id": 92, "q": "以下叙述中正确的是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "对于逻辑表达式：a++ || b++，设a的值为1，则求解表达式的值后，b的值会发生改变", "对于逻辑表达式：a++ && b++，设a的值为0，则求解表达式的值后，b的值会发生改变", "逻辑运算符的运算结果有两种：0，1", "关系运算符的运算结果有三种：0，1，-1" ], "explanation": "逻辑运算具有短路特性，A和B中由于前半部分已能确定结果，b++均不会执行，b值不变。逻辑和关系运算符的运算结果均只有0（假）和1（真）两种，故C正确，D错误。" }, { "id": 93, "q": "有如下语句int a=10,b=20,*p1,*p2;p1=&a;p2=&b;若要实现p1,p2均指向b，可选用的赋值语句是( )", "t": "single", "ans": "B", "kp": "指针", "o": [ "*p1=*p2;", "p1=p2;", "p1=*p2;", "*p1=p2;." ], "explanation": "指针变量存储的是地址。要使p1和p2都指向变量b，只需将p2中存储的b的地址赋值给p1，即p1=p2;。选项A是修改a的值，C和D类型不匹配。" }, { "id": 94, "q": "下列程序的运行结果是（）。\n#define SQR(x) x*x\nmain()\n{ int a,k=3;\na=++SQR(k+1);\nprintf(\"%d\\n\",a）;\n}", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "16", "9", "8", "17" ], "explanation": "宏替换为直接文本替换，SQR(k+1)展开为k+1*k+1，语句变为a=++k+1*k+1;。前置自增++k使k先变为4，随后计算表达式4+1*4+1，结果为9。注意未加括号引发的优先级变化。" }, { "id": 95, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ "C程序书写格式严格，要求一行内只能写一个语句。", "C程序书写格式自由，一个语句可以写在多行上。", "C程序中的注释只能出现在程序的开始位置和语句的后面。", "用C语言编写的程序只能放在一个程序文件中。" ], "explanation": "C语言书写格式自由，一个语句可以分写在多行，一行也可以写多个语句。注释可以出现在程序的任何位置，且C程序可由多个源文件组成。" }, { "id": 96, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ "C程序中的每一行只能写一条语句", "C语句必须以分号结束", "C语言程序中的注释必须与语句写在同一行", "C语句必须在一行内写完" ], "explanation": "C语言中，分号是语句的结束标志，任何语句都必须以分号结尾。C程序书写格式自由，一行可写多条语句，一条语句也可跨多行，注释位置灵活。" }, { "id": 97, "q": "有以下程序，程序运行后的输出结果是( )。\nmain()\n{ int i=1,sum=0;\nwhile(i<=4)\nsum=sum+i;\ni=i+1;\nprintf(\"%d\\n\",sum);}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "4", "5", "10", "死循环" ], "explanation": "while循环体未使用花括号，因此仅包含sum=sum+i;这一条语句。i=i+1;在循环外部，导致循环条件i<=4永远成立，程序陷入死循环。" }, { "id": 98, "q": "有以下程序段运行后的输出结果是（　　）。\nmain()\n{ int a[10]={1,2,3,4,5,6,7,8,9}, *p=a;\nprintf(\"%d\\n\", *p++); }", "t": "single", "ans": "A", "kp": "指针", "o": [ "1", "2", "3", "4" ], "explanation": "表达式*p++中，后缀自增运算符优先级高于解引用，但后缀自增是先用后加。因此先取p当前指向的值（即a[0]的值1）进行输出，随后指针p向后移动一位。" }, { "id": 99, "q": "C语言目标程序名的后缀是（　　）。", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ ".exe", ".obj", ".c", ".cp" ], "explanation": "C语言源程序文件后缀为.c，经过编译后生成的目标文件后缀通常为.obj（Windows环境）或.o（Linux环境），链接后生成的可执行文件后缀为.exe。" }, { "id": 100, "q": "定义变量是，有关如何选择数据类型的叙述错误的是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "若要保存带有多位小数的数据，可使用双精度类型", "若要处理如\"人员信息\"等含有不同类型的相关数据，应自定义结构体类型", "若只处理\"真\"和\"假\"两种逻辑值，应使用逻辑类型", "整数类型表示的自然数是准确无误差的" ], "explanation": "C语言标准（C89）中没有内置的逻辑类型，通常用整型的0和非0表示真假，直到C99才引入_Bool。因此\"应使用逻辑类型\"在早期C语言中是错误的。双精度型可存多位小数，结构体可处理不同类型数据，整型表示自然数无误差，A、B、D均正确。" }, { "id": 101, "q": "程序的输出结果是()\nint a, b, c;\na=10; b=50; c=30;\nif (a>b) a=b, b=c; c=a;\nprintf(\"a=%d b=%d c=%d\\n\", a, b, c);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "a=10 b=50 c=30", "a=10 b=30 c=10", "a=10 b=50 c=10", "a=50 b=30 c=50" ], "explanation": "if(a>b)条件为假（10>50不成立），因此不执行a=b, b=c;。注意c=a;不在if语句的控制范围内（缺少大括号），所以无论if条件是否成立，c=a;都会执行。最终a=10，b=50，c=10。" }, { "id": 102, "q": "以下程序的运行结果是（　　）\nmain()\n{ int s[12]={1,2,3,4,4,3,2,1,1,1,2,3},c[5]={0},i;\nfor(i=0;i<10;i++) c[s[i]]++;\nfor(i=0;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "04222", "04332", "0422", "0433" ], "explanation": "数组c初始化为全0。循环遍历s的前10个元素，将对应值作为c的下标并使其自增。统计结果：0出现0次，1出现4次，2出现2次，3出现2次，4出现2次。因此c数组元素为0,4,2,2,2，输出04222。" }, { "id": 103, "q": "有以下程序段\nmain()\n{\nint a[] = {6, 7, 8};\nint *p = a;\nprintf(\"%d,\",*p++);\nprintf(\"%d,\", *p);\n} 程序运行后的输出结果是( )", "t": "single", "ans": "B", "kp": "指针", "o": [ "6,6", "6.7", "7,7", "7,8" ], "explanation": "*p++等价于*(p++)，先取p当前指向的值6输出，然后指针p自增指向下一个元素7。第二个printf输出此时p指向的值7。注意选项B中的点号应为逗号排版错误，实际输出为6,7。" }, { "id": 104, "q": "程序定义了N×N的二维数组，并在主函数中自动赋值。请编写函数fun，函数的功能是：使数组右上三角元素中的值乘以m。例如：若m的值为2，a数组中的值为\n| 1 9 7 | | 2 18 14|\na = | 2 3 8 | 则返回主程序后a数组中的值应为 | 2 6 16|\n| 4 5 6 | | 4 5 12|\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容， 仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun( int a[][N], int m)\n{ int i,j; /*定义两个整型变量，用于控制二维数组行、列下标的变化*/\nfor(i=0; i=i; j--) /*内嵌的for()来控制二维数组列的变化*/\na[i][j]*=m; /*对数组上半三角元素中的值全部乘以m*/\n}", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 105, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"12134214241\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "4313", "1111", "4312", "4311" ], "explanation": "程序统计字符串s中字符'1','2','3','4'的出现次数，分别存入v[0]到v[3]。字符串\"12134214241\"中，'1'出现4次，'2'出现3次，'3'出现1次，'4'出现3次。因此v数组元素为4,3,1,3，输出4313。" }, { "id": 106, "q": "'\\n'在内存中占()个字节.", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0", "1", "2", "无法确定" ], "explanation": "'\\n'是转义字符，表示换行符。在C语言中，所有的字符常量（包括转义字符）在内存中均占用1个字节的存储空间。" }, { "id": 107, "q": "有以下程序，在VC平台上编译运行，程序运行后的输出结果是( )。\nint s,t,A=10;\ndouble B=6;\ns=sizeof(A);\nt=sizeof(B);\nprintf(\"%d,%d\\n\",s,t);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2,4", "4,4", "4,8", "10,6" ], "explanation": "在VC平台（32位或64位环境）下，int类型占用4个字节，double类型占用8个字节。sizeof运算符返回数据类型或变量所占的字节数，因此s为4，t为8，输出4,8。" }, { "id": 108, "q": "以下选项中属于 C 语言的数据类型是()", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "复数型", "逻辑型", "双精度型", "集合型" ], "explanation": "C语言的基本数据类型包括整型、字符型、浮点型（单精度float和双精度double）等。复数型、逻辑型（C99前无内置）、集合型不是C语言的标准基本数据类型。双精度型是标准类型。" }, { "id": 109, "q": "以下程序的运行结果是（　　）\nint a=20;\nint f(int c){\nstatic int a=10;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<1;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "34", "35", "36", "33" ], "explanation": "main中全局变量a=20。循环执行1次调用f(3)。f中静态局部变量a初值10，c=4。返回(a++)+c即10+4=14，静态a变为11。k=14。循环结束后k+=a，此处的a是全局变量20，故k=14+20=34。" }, { "id": 110, "q": "以下程序的运行结果是（）。\nmain() { int a=4,b=2,c=3;\nif(a=c) a=a-b;\nif(a>c) c=a+b;\nprintf(\"%d%d%d\\n\",a,b,c);}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "123", "426", "423", "224" ], "explanation": "初始a=4,b=2,c=3。第一个if条件为赋值表达式a=c，将3赋给a，表达式值为真，执行a=a-b，即a=3-2=1。第二个if条件a>c即1>3为假，不执行。最终a=1,b=2,c=3，输出123。" }, { "id": 111, "q": "在执行下述程序段时，若从键盘输入6和8，则结果为（ ）。\nint a,b,s;\nscanf(\"%d%d\",&a,&b）;\ns=a;\nif(a99)\nplace=3;\nelse if(num>9)\nplace=2;\nelse\nplace=1;\ni=num/100;\nj=(num-i*100)/10;\nk=(num-i*100-j*10);\nswitch (place)\n{ case 3: printf(\"%d%d%d\\n\",k,j,i);\nbreak;\ncase 2: printf(\"%d%d\\n\",k,j);\nbreak;\ncase 1: printf(\"%d\\n\",k);\n}\n}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "123", "1,2,3", "321", "3,2,1" ], "explanation": "输入num=123。num>99成立，place=3。计算各位数字：i=123/100=1，j=(123-100)/10=2，k=123-100-20=3。switch匹配case 3，按k,j,i的顺序输出，即321。" }, { "id": 113, "q": "以下程序的运行结果是（　　）。\nmain(){\nint i=0,a=0;\nfor(;i<10;i++)\n{ if(i%10==0) break;\nelse i--;\n}\ni+=11; a+=i;\nprintf(\"%d,%d\\n\",a,i);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "21,11", "11,11", "11,21", "11" ], "explanation": "初始i=0，进入for循环判断i<10成立。循环体内i%10==0成立，执行break跳出循环，此时i未执行自增仍为0。跳出后i+=11使i变为11，a+=i使a变为11。最终输出11,11。" }, { "id": 114, "q": "以下程序的运行结果是（　　）。\nmain(){\nint i=7;\nwhile(i!=0){\nif(i%5==2)\n{ printf(\"#%d\",i); break; }\ni++;\n}\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "#7", "#3#5", "#5", "#2#6" ], "explanation": "初始i=7，满足while条件i!=0。进入循环体，判断i%5==2即7%5==2成立，执行printf输出#7，随后break跳出循环。程序结束，输出结果为#7。" }, { "id": 115, "q": "设int gcd（int x, int y）函数的功能是求两个正整数的最大公约数，则求四个正整数a,b,c,d的最大公约数，下列函数调用不正确的是（）", "t": "single", "ans": "D", "kp": "函数", "o": [ "gcd（gcd（a,b）, gcd( c,d)）", "gcd(gcd(gcd(a,b),c),d）", "gcd(b,gcd(gcd(a,c),d))", "gcd(gcd(a,b,c),d)" ], "explanation": "gcd函数定义为接收两个整型参数。A、B、C选项均通过嵌套调用，每次向gcd传递两个参数，符合语法。D选项中gcd(a,b,c)传递了三个参数，超出了函数定义的参数个数，因此调用不正确。" }, { "id": 116, "q": "有如下程序输出结果是（）\nlong fun( int n)\n{ long s;\nif(n==1 || n==2) s=2;\nelse s=n-fun(n-1);\nreturn s;}\n　main()\n{ printf(\"%ld\\n\", fun(6)); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "4", "6", "5", "3" ], "explanation": "递归推导：fun(2)=2；fun(3)=3-fun(2)=1；fun(4)=4-fun(3)=3；fun(5)=5-fun(4)=2；fun(6)=6-fun(5)=4。最终返回4。" }, { "id": 117, "q": "当a=1，b=3，c=5，d=4时，执行下面一段程序后，x的值为( ).\nif (ab)\nif(b>0) c=0;\nelse c+=1;\nprintf(\"%d\\n\",c) ;", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "考察if-else配对规则。else总是与最近的未配对if结合，即if(b>0)。因a>b成立进入内层，而b>0不成立，故执行else分支c+=1，c由2变为3。" }, { "id": 129, "q": "以下程序的输出结果是( )。\nmain( )\n{ float x=2.0,y;\ndo{y=3.0; } while(x<0.0) ;\ny=1.0;\nprintf(\"%f\",y);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "0.000000", "1.000000", "2.000000", "3.000000" ], "explanation": "考察do-while循环。循环体至少执行一次，y被赋值为3.0。随后判断条件x<0.0为假，退出循环。接着执行y=1.0，最终输出1.000000。" }, { "id": 130, "q": "以下程序的运行结果是（　　）。\nmain(){\nint m=0,f=1,i,n=3;\nfor(i=1; i=0;i--) a[i]=10-i;\nprintf(\"%d%d%d\",a[2],a[6],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "842", "248", "249", "841" ], "explanation": "考察数组逆序赋值。循环中a[i]=10-i，计算得a[2]=8，a[6]=4，a[8]=2。按格式连续输出这三个元素的值，结果为842。" }, { "id": 137, "q": "以下程序段的功能是实现矩阵转置。请选择填空，让程序能正确运行。\n  int a[2][3]={1,2,3,4,5,6};\n   int b[3][2],i,j;\n   for(i=0;i\n   { for(j=0;j\n     {       =a[i][j];\n       printf(\"%5d\",a[i][j]); }\n       printf(\"\\n\") ; }", "t": "single", "ans": "C", "kp": "数组", "o": [ "b[i][j]", "a[j][i]]", "b[j][i]", "a[i][j]" ], "explanation": "考察矩阵转置原理。将2行3列矩阵a转置为3行2列矩阵b，需将a的第i行第j列元素赋值给b的第j行第i列，即b[j][i]=a[i][j]。" }, { "id": 138, "q": "以下程序的运行结果是( )。\nmain()\n{ char p[]={\"how?\"}, q[]={\"abc\"};\nint y;\ny=strcmp(p,q);\nprintf(\"%d\\n\",y;};", "t": "single", "ans": "B", "kp": "字符串", "o": [ "0", "1", "-1", "不确定" ], "explanation": "考察字符串比较函数。strcmp按字符ASCII码比较，'h'大于'a'，故p大于q，返回正数。在部分编译环境（如VC++）中，大于时具体返回值为1。" }, { "id": 139, "q": "程序的输出结果是（）。\nint s=1,t=4,a=2,b=3;\nif (a>b) t=s+t;\nelse if (a==b) t=5;\nelse t=2*s;\nprintf(\"%d\\n\",t);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "2", "5", "4", "6" ], "explanation": "条件a>b为假，继续判断a==b也为假，因此执行最后的else分支。t=2*s=2*1=2，最终输出2。" }, { "id": 140, "q": "若有定义int a[2][3]={2,4,6,8,10,12}; ,则以下描述不正确的是（　）。", "t": "single", "ans": "D", "kp": "指针", "o": [ "*(a+1)为元素a[1][0]的地址", "a[1]+1为元素a[1][1]的地址", "*(a+1)+2为元素a[1][2]的地址", "*a[1]+2的值是12" ], "explanation": "二维数组名a是指向行的指针。`*(a+1)`等价于`a[1]`，代表第二行首元素`a[1][0]`的地址。`*a[1]`取出`a[1][0]`的值8，`*a[1]+2`的值为10；若要表示`a[1][2]`的值12，应写为`*(a[1]+2)`。因此D选项描述错误。" }, { "id": 141, "q": "给定程序MODI1.C中，调用fun函数求出所有满足条件的三位数，存放到形参n所指的数组中，并返回这些数的个数。\n这些三位数等于它各个位上数字的立方和。例如：153=。\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "根据考题可知，本题题面已经给出了三位数的求解方法，即把该三位数的每一个位置上的数分别求出，第一处应改为：a = i / 100，第二处的错误为比较运算符==写成了=，一个=是赋值，==才是比较，所以第二处应为：cube(a)+cube(b)+cube(c)==i，k用来统计符合条件的个数，初始值为0，每求出一个符合条件的数k就做自增运算，所以第三处应为：return k，不需要再减1。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 142, "q": "以下叙述中错误的是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "C程序在运行过程中所有计算都以二进制方式进行。", "所有C程序都需要编译无误后才能运行", "C程序在运行过程中所有计算都以十进制方式进行。", "C程序中字符变量存放的是字符的ASCII值。" ], "explanation": "计算机底层硬件只能识别和处理二进制信号，因此C程序在运行过程中的所有计算和数据存储都是以二进制方式进行的，而不是十进制。十进制只是人类习惯的输入输出表现形式。" }, { "id": 143, "q": "以下程序的运行结果是          。\nint a=5,b=4,c=3,d;\nd=(a>b>c);\nprintf(\"%d\\n\",d);", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1", "True", "0", "False" ], "explanation": "关系运算符`>`的结合性是从左到右。表达式`a>b>c`等价于`(a>b)>c`。首先计算`a>b`即`5>4`，结果为真（1）；接着计算`1>c`即`1>3`，结果为假（0）。因此变量d被赋值为0。" }, { "id": 144, "q": "执行以下程序段时\nx=-1;\nwhile(!x) { x=x*x;}\n则以下选项中描述正确的是（　　）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "循环体将执行1次", "循环体1次也不执行", "循环体将执行无限次", "系统将提示有语法错误" ], "explanation": "在C语言中，非零值被视为逻辑真，零被视为逻辑假。变量x初始值为-1，属于非零值，因此逻辑非运算`!x`的结果为0（假）。由于while循环的条件一开始就不成立，循环体一次也不会执行。" }, { "id": 145, "q": "#define MUL(x,y) x*y\nmain( )\n{ int a=6，b=8，c；\nc=MUL(++a,++b);\nprintf(\"%d \\n\"，c)； }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "63", "48", "6", "8" ], "explanation": "宏替换是简单的文本替换，`MUL(++a,++b)`展开为`++a*++b`。由于未加括号，且涉及同一表达式中多次修改操作数，严格来说属于未定义行为。但在多数传统考试环境的编译器中，会先对a和b进行自增，a变为7，b变为9，最后计算`7*9`得到63。" }, { "id": 146, "q": "以下程序的执行过程中fun（）函数共调用了（）次 。\nlong fun( int n)\n{ long s;\nif(n==1 || n==2) s=2;\nelse s=n-fun(n-2);\nreturn s; }\nmain()\n{ printf(\"%ld\\n\", fun(4)); }", "t": "single", "ans": "B", "kp": "函数", "o": [ "1", "2", "3", "4" ], "explanation": "主函数调用`fun(4)`，这是第1次调用。在`fun(4)`中，由于4不等于1或2，执行`else`分支，计算`4-fun(2)`，从而引发第2次调用`fun(2)`。在`fun(2)`中满足`n==2`，直接返回2，不再递归。因此`fun`函数总共被调用了2次。" }, { "id": 147, "q": "下面选项中合法的字符常量是( )", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "\"h\"", "'ef'", "'X'", "'\\'" ], "explanation": "C语言中字符常量必须用单引号括起来，且通常只能包含一个字符或一个完整的转义序列。A选项是字符串常量；B选项包含多个字符；D选项反斜杠转义了后面的单引号，导致字符常量未闭合；C选项是合法的大写字母字符常量。" }, { "id": 148, "q": "下边程序段输出结果是（ ）。\nint i , a= 0;\nfor ( i = 0; i < 10; i++ )\na++, i++;\nprintf(\"%d\", a);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "10", "9", "6", "5" ], "explanation": "for循环中，每次迭代包含三个部分的执行：判断条件、执行循环体、执行步进表达式。初始i=0，循环体`a++, i++`使a和i均加1，随后for语句的`i++`使i再加1。因此每次循环i实际增加2，a增加1。当i分别为0,2,4,6,8时执行循环体，共执行5次，最终a的值为5。" }, { "id": 149, "q": "以下程序的输出结果是（）\nint a=4;\nint f(int n){\nint t=0;\nstatic int a=7;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<2;i++) s+=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "32", "31", "28", "30" ], "explanation": "全局变量a=4，主函数中s初始为4。第一次调用f(0)走else分支，局部a自增不影响静态a，t为7，返回t+静态a(7)即14，静态a变为8，s变为18。第二次调用f(1)走if分支，t为6，返回t+静态a(8)即14，静态a变为9，s累加后为32。注意局部变量a会屏蔽同名静态和全局变量。" }, { "id": 150, "q": "已知字符'A'的ASCII代码值是65，字符变量c1的值是'A'，c2的值是'D'。则执行语句 printf(\"%d,%d\", c1, c2-2 ); 的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "A,68", "A,B", "65,66", "65,68" ], "explanation": "`printf`中使用`%d`格式控制符会以十进制整数形式输出字符的ASCII码值。字符'A'的ASCII码为65，因此c1输出65；字符'D'的ASCII码为68，`c2-2`即`68-2`等于66。故最终输出结果为65,66。" }, { "id": 151, "q": "下列定义变量的语句中错误的是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "float US$;", "double int_;", "char For;", "int _int;" ], "explanation": "C语言规定标识符只能由字母、数字和下划线组成，且第一个字符必须是字母或下划线。A选项中的标识符`US$`包含了非法字符`$`，因此是错误的变量定义语句。其他选项均符合标识符命名规则且未使用关键字。" }, { "id": 152, "q": "以下程序的运行结果是（　　）\nint k=10;\nint fun(int m)\n{ m+=k; k+=m;\nreturn m;\n}\nmain()\n{ int i=4,s=0;\ns=s+fun(i++); printf(\"%d %d\\n\",i,k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "5 24", "5 14", "4 14", "4 24" ], "explanation": "全局变量k初值为10。main函数中i=4，调用fun(i++)时，传入m=4，随后i自增为5。在fun函数内，m+=k使m变为14，k+=m使全局变量k变为24。函数返回后，输出i和k的值，即5和24。" }, { "id": 153, "q": "程序的输出结果是()\nint a=1,b=2,c=3,d=4, r=0;\nif (a!=1) ;\nelse r=1;\nif (b!=2) r+=2;\nif (c==3); r+=3;\nif (d==4) r+=4;\nprintf(\"%d\\n\", r);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "6", "7", "8", "10" ], "explanation": "a=1，a!=1为假，执行else分支，r=1。b=2，b!=2为假，不执行r+=2。c=3，c==3为真，但if后紧跟分号构成空语句，随后无条件执行r+=3，此时r=4。d=4，d==4为真，执行r+=4，最终r=8。" }, { "id": 154, "q": "以下不构成无限循环的语句或语句组是( ) 。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "n=0;\ndo {++n;}while(n<0);", "n=0;\nwhile(1){n++;}", "n=10;\nwhile(n);{n--;}", "for(n=0,i=1; ;i++) n+=i;" ], "explanation": "A选项中n初值为0，执行++n后n变为1，判断n<0为假，循环结束，不构成无限循环。B选项while(1)条件恒真，是死循环。C选项while(n)后跟分号构成死循环，n--在循环外无法执行。D选项for循环缺少条件判断，默认恒真，也是无限循环。" }, { "id": 155, "q": "以下叙述中不正确的是( ) 。", "t": "single", "ans": "C", "kp": "函数", "o": [ "一个变量的作用域完全取决于变量定义语句的位置", "全局变量可以在函数以外的任何部分进行定义", "局部变量的\"生存期\"只限于本次函数调用，因此不可能将局部变量的运算结果保持至下一次调用", "一个全局变量说明为static存储类是为了限制其他编译单位的引用" ], "explanation": "C选项错误，局部变量可以声明为static静态存储类别，其生存期将延长至整个程序运行期间，能够将运算结果保持至下一次调用。A、B、D选项关于作用域、全局变量定义和static限制外部引用的描述均符合C语言规范。" }, { "id": 156, "q": "下面程序段的输出结果（）\nmain()\n{ int i,a[10 ]={6,2,7,9,8};\nfor(i =1; i <6;i+=2)\nprintf(\"%d\", a[i] ); }", "t": "single", "ans": "B", "kp": "数组", "o": [ "6 7 8", "2 9 0", "2 9", "6 2 7 9" ], "explanation": "数组a初始化后，a[0]=6, a[1]=2, a[2]=7, a[3]=9, a[4]=8，未赋值的a[5]到a[9]自动初始化为0。循环变量i从1开始，每次加2，依次取1、3、5。分别输出a[1]即2，a[3]即9，a[5]即0。因此输出结果为290。" }, { "id": 157, "q": "若有以下说明和语句，其输出结果是()\nchar *s=\"\\t\\v\\\\\\0will\\n\"；\nprintf(\"%d\"，strlen(s))；", "t": "single", "ans": "B", "kp": "字符串", "o": [ "14", "3", "9", "10" ], "explanation": "strlen函数计算字符串长度时，遇到第一个'\\0'即结束，且不包含'\\0'。字符串s的前三个字符分别是转义字符'\\t'、'\\v'和'\\\\'，第四个字符是'\\0'。因此，strlen(s)计算的有效字符个数为3。" }, { "id": 158, "q": "以下叙述中正确的是( )。", "t": "single", "ans": "C", "kp": "综合编程/调试改错", "o": [ "在包含文件中，不得再包含其他文件。", "#include命令行不能出现在程序文件的中间。", "在一个程序中，允许使用任意数量的#include命令行。", "虽然包含文件被修改了，包含该文件的源程序也可以不重新进行编译和连接。" ], "explanation": "C语言中，#include命令行可以出现在程序的任何位置，且数量没有限制，包含文件中也可以再包含其他文件，故A、B错误。若包含文件被修改，源程序必须重新编译和连接才能生效，故D错误。C选项描述正确。" }, { "id": 159, "q": "假定整数数列中的数不重复，并存放在数组中。给定程序modi1.c中函数fun的功能是：删除数列中值为x的元素。n中存放的是数列中元素的个数。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 160, "q": "编写函数fun，它的功能是计算下列级数和，和值由函数值返回。\n例如，当n=10，x=0.3时，函数值为1.349859。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun(double x,int n)\n{ int i;\ndouble f=1.0,h=x;\ndouble s=1;\ns=s+h/f; /*求公式中1、2两项的和(即1+x)*/\nfor (i=2;i<=n;i++)\n{ f=f*i; /*求公式中每一项分母的阶乘值*/\nh=h*x; /*求公式中每一项分子的乘方值*/\ns=s+h/f;\n}\nreturn (s);\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 161, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"12134214241\";\nint v[4]={0,0,1,1},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "4324", "4314", "4313", "2222" ], "explanation": "数组v初值为{0,0,1,1}。遍历字符串s，统计各字符出现次数并累加到v中。'1'出现4次，v[0]加4变为4；'2'出现3次，v[1]加3变为3；'3'出现1次，v[2]加1变为2；'4'出现3次，v[3]加3变为4。最终输出v数组元素：4324。" }, { "id": 162, "q": "设变量均已正确定义，若要通过 scanf(\"%d%c%d%c\",&a1,&c1,&a2,&c2); 语句为变量a1和a2赋数值1和2，为变量c1和c2赋字符A和B。以下所示的输入形式中正确的是()", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "1 A2 B", "1A2 B", "1A 2B", "1 A 2 B" ], "explanation": "scanf格式控制字符串中没有空格，输入时数据间可用空白符分隔。%d读取整数，%c读取单字符。若输入'1A 2B'，a1读取1，c1读取'A'，空格被%d自动跳过，a2读取2，c2读取'B'。若选A，c1会读取空格；若选B，c2会读取空格。" }, { "id": 163, "q": "已知int x=0, y=1;，表达式(!x||y--)计算后，y的值", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "0", "True", "False" ], "explanation": "逻辑或运算符'||'具有短路特性。表达式'!x'中，x为0，'!x'为真。由于'||'左侧已经为真，整个表达式的结果必定为真，因此右侧的'y--'不会被执行。y的值保持不变，仍为1。" }, { "id": 164, "q": "C源程序中不能表示的数制是( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "二进制", "八进制", "十进制", "十六进制" ], "explanation": "在标准C语言中，整型常量只能用十进制、八进制（以0开头）和十六进制（以0x或0X开头）表示，不能直接使用二进制表示。虽然部分现代编译器扩展支持二进制，但在传统C语言考试中，二进制是不能直接表示的数制。" }, { "id": 165, "q": "以下程序段中的变量已定义为int类型\nsum = pad = 5; pAd = sum++, pAd++, ++pAd;\nprintf( \"%d\\n\", pad );\n程序段的输出结果是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "5", "4", "6", "7" ], "explanation": "C语言严格区分大小写，pad、pAd和sum是不同的变量。语句'sum = pad = 5;'将pad和sum赋值为5。随后的逗号表达式'pAd = sum++, pAd++, ++pAd;'仅操作pAd和sum，对pad的值没有任何影响。因此，最后输出pad的值仍为5。" }, { "id": 166, "q": "下列变量定义正确的是", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "int p=q=r=9;", "Double x,y;", "int x,float y;", "char printF='a';" ], "explanation": "A选项连续赋值在定义时不合法；B选项C语言区分大小写，双精度浮点型关键字为double；C选项同一语句定义不同类型变量需用分号隔开，不能用逗号；D选项printF是合法标识符，字符常量赋值正确。" }, { "id": 167, "q": "以下程序的运行结果是（　　）\nint k=10;\nint fun(int m)\n{ m+=k; k+=m;\nreturn m+k;\n}\nmain()\n{ int i=4,s=0;\ns=s+fun(i++); printf(\"%d %d %d\\n\",i,k,s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "5 24 38", "4 24 38", "5 38 24", "4 38 24" ], "explanation": "全局变量k初值为10。main中i=4，调用fun(i++)，传入m=4，随后i自增为5。fun中m+=k即m=14，k+=m即k=24，返回m+k=38。返回后s=0+38=38。最后打印i=5，k=24，s=38。" }, { "id": 168, "q": "以下程序运行后，如果从键盘上输入5，则输出结果是( ) 。\nmain(){ int x;\nscanf(\"%d\",&x);\nif(x--<5) printf(\"%d\",x);\nelse printf(\"%d\",x++);}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "3", "4", "5", "6" ], "explanation": "输入x=5。判断条件x--<5，先使用x的值5进行比较，5<5为假，然后x自减为4。条件为假执行else分支，打印x++，先输出x的当前值4，然后x自增为5。因此输出结果为4。" }, { "id": 169, "q": "在执行以下程序时,为了使输出结果为:t=4 则给a和b输入的值应满足的条件是( )。\nmain( )\n{ int s,t,a,b;\nscanf(\"%d,%d\",&a,&b);\ns=1; t=1;\nif (a<0) s=s+1;\nif (a>b) t=s+t;\nelse if (a==b) t=5;\nelse t=2*s;\nprintf(\"t=%d\\n\",t);\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "a>b", "aa>b", "0b分支，也不能满足a==b，才会执行else分支t=2*s=4。选项B表示ab和a==b均不成立，最终输出t=4。" }, { "id": 170, "q": "以下程序的运行结果是（　　）。\nmain(){\nint n=0;\ndo\n{if(++n%2==0) continue;\n}while(n!=1);\nprintf(\"n=%d\",n);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "n=2", "n=1", "n=3", "死循环" ], "explanation": "n初值为0。进入do-while循环，++n使n变为1，1%2==0为假，不执行continue。判断while条件n!=1，此时n为1，条件为假，退出循环。最后打印n=1。注意continue只跳过本次循环剩余语句，仍会进行条件判断。" }, { "id": 171, "q": "在 C 语言中，do while 语句构成的循环结束时， while 后一对圆括号中表达式的值应该为（）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "1", "True", "非0" ], "explanation": "do-while循环的执行机制是先执行循环体，再判断while后的表达式。当表达式的值为非0（真）时继续循环，当表达式的值为0（假）时结束循环。因此循环结束时，表达式的值必定为0。" }, { "id": 172, "q": "关于以下程序段执行情况的叙述，正确的是(　　)。\nint i, n;\nfor(i=0;i<8;i++)\n{\nn = rand( ) % 5;\nswitch(n)\n{case 1:\ncase 3: printf(\"%d\\n\",n); break;\ncase 2:\ncase 4: printf(\"%d\\n\",n);continue;\ncase 0: exit(0);}\nprintf(\"%d \\n\",n);}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "for循环语句固定执行8次", "当产生的随机数n为4时结束循环操作", "当产生的随机数n为1和2时不做任何操作", "当产生的随机数n为0时结束程序运行" ], "explanation": "rand()%5生成0到4的随机数。当n为1或3时，打印n并break跳出switch；当n为2或4时，打印n并continue跳过for循环剩余语句进入下一次迭代；当n为0时，执行exit(0)直接终止整个程序运行。" }, { "id": 173, "q": "输出结果是( )。\nfor(j=10;j<11;j++)\n{\nfor(i=9;i=j-1)\nprintf(\"%d\",i);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "9", "10", "11", "10 11" ], "explanation": "外层循环只有j=10时满足j<11，执行一次。内层循环从i=9开始，9<10成立；10%9为1，!(j%i)为假，不执行break；随后i>=j-1即9>=9成立，输出i的值9。内层i自增到10后不再满足i0)\n{s+=(j%10)*(j%10)*(j%10)*(j%10);\nj=j/10;}\nif (s==i) result[k++]=i;\n}\nreturn k;\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 185, "q": "有以下程序，程序的运行结果是（　　）。\nmain(){\nint i=1,sum=0;\nwhile(i<=4){\nsum=sum+i;\nsum++;\n}\nprintf(\"%d\\n\",sum);}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "8", "9", "10", "死循环" ], "explanation": "在while循环中，循环变量i的初始值为1，满足条件i<=4。但在循环体内，只有sum的值在不断累加和自增，变量i的值始终为1，从未发生改变。因此循环条件永远成立，导致程序陷入死循环。" }, { "id": 186, "q": "给定程序中，函数fun的功能是：计算形参x所指数组中N个数的平均值（规定所有数均为正数），作为函数值返回；并将大于平均值的数放在形参y所指数组中，在主函数中输出。\n例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000\n主函数中输出：46 32 40 45 48\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "在主函数中随机抽取10个正数，并将值赋给数组x。在fun函数中变量av最后的值就是平均值，所以第一个空填：0；第一个for循环的作用就是计算平均值，所以第二个空填：x[i]/N；第二个for循环的作用是将数组中的数与平均值进行比较，将大于平均值的数存入y数组中，所以第三个空填：j++。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 187, "q": "请编写函数fun，其功能是：给定一个整数n(n<10000)，如果n加上100后是一个完全平方数（所谓“完全平方数”，就是开方后的结果是整数的数），并且n加上268也是一个完全平方数，则函数值返回1，否则返回0。\n注意:部分源程序在文件PROG1.C中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "int fun(long n)\n{\nfloat y1,y2 = 0;//用于计算\ny1 = sqrt(n + 100);//获取n+100后开方的值\ny2 = sqrt(n + 268);//获取n+268后开方的值\nif ((int)y1 == y1 && (int)y2 == y2)//判断y1,y2是否为整数\n{\nreturn 1;\n}\nelse\n{\nreturn 0;\n}\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 188, "q": "若有说明语句int i，j =7，*p=&i；则与i=j等价的语句是()", "t": "single", "ans": "B", "kp": "指针", "o": [ "i=*p;", "*p=*&j;", "i=&j;", "i=**p;" ], "explanation": "指针p指向变量i，因此解引用*p等价于变量i。表达式*&j中，&取地址，*解引用，两者作用抵消，等价于变量j。所以语句*p=*&j;完全等价于i=j;。选项A逻辑错误，选项C类型不匹配，选项D语法错误。" }, { "id": 189, "q": "若要对a进行++运算，则a应具有下面说明()", "t": "single", "ans": "D", "kp": "指针", "o": [ "int a[3][2];", "char *a[80 ] ;", "char (*a)[3];", "int b[10], *a = b;" ], "explanation": "自增运算符++要求其操作数必须是可修改的左值。数组名（如选项A、B）和数组指针（如选项C）本质上都是常量指针，不能作为++的操作数。选项D中a是一个普通的指针变量，可以进行++运算使其指向下一个内存单元。" }, { "id": 190, "q": "下列程序执行后的输出结果是（ ）\nmain()\n{\nint x='f';\nprintf(\"%c\\n\",'A'+(x-'a'+1));\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "G", "H", "I", "J" ], "explanation": "字符在C语言中以ASCII码参与算术运算。表达式x-'a'即'f'-'a'，结果为5。加上1后等于6。'A'的ASCII码加上6，即字母表向后推6个位置，结果为'G'。最后通过%c格式控制符输出字符G。" }, { "id": 191, "q": "int a[5]={2，3，5，7，11}，*p=a+4；下列不能正确引用数组a的元素的表达式是()", "t": "single", "ans": "D", "kp": "指针", "o": [ "*(--p)", "*(p--)", "*(p++)", "*(++p)" ], "explanation": "指针p初始指向a[4]，即数组的最后一个有效元素。选项A、B、C中，p在解引用时或解引用后移动，均能访问到数组内的合法元素。而选项D中，++p先使指针向后移动一位指向a[5]，此时已越界，再解引用会访问非法内存，不能正确引用数组元素。" }, { "id": 192, "q": "编写程序的功能是（　　）。", "t": "single", "ans": "A", "kp": "综合编程/调试改错", "o": [ "建立并修改程序。", "将C源程序编译成目标程序。", "调试程序。", "命令计算机执行指定的操作。" ], "explanation": "编写程序（即编辑阶段）的主要功能是建立和修改C源程序代码。将源程序编译成目标程序是编译器的功能，调试程序是调试工具的功能，命令计算机执行操作则是操作系统的功能。" }, { "id": 193, "q": "以下不能输出字符A的语句是( )。", "t": "single", "ans": "B", "kp": "输入输出", "o": [ "printf(\"%c\\n\",'a'-32) ;", "printf(\"%d\\n\",'A') ;", "printf(\"%c\\n\",65) ;", "printf(\"%c\\n\",'B'-1)" ], "explanation": "选项B使用了%d格式控制符，这会输出字符'A'对应的ASCII码整数值65，而不是字符本身。选项A中'a'-32等于'A'，选项C中65是'A'的ASCII码，选项D中'B'-1等于'A'，且这三项均使用%c格式输出，故都能正确输出字符A。" }, { "id": 194, "q": "以下程序段中，与语句:k＝a>b?(b>c?1:0):0;功能相同的是()。", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "if((a>b)&&(b>c))k=1;\nelse　k=0;", "if((a>b)‖(b>c))k=1;\nelse k=0;", "if(a<=b)k=0;\nelse if(b<=c)k=1;", "if(a>b)k=1;\nelse　if(b>c)　k=1;\nelse　k=0;" ], "explanation": "本题考查条件运算符的嵌套。表达式 `a>b?(b>c?1:0):0` 的逻辑是：首先判断 `a>b`，若为真，则进一步判断 `b>c`，若也为真则结果为1，否则为0；若 `a>b` 为假，则结果直接为0。综合来看，只有当 `a>b` 且 `b>c` 同时成立时，k才被赋值为1，其他情况均为0。选项A使用逻辑与完美等价于该嵌套条件。选项B是逻辑或，选项C和D的逻辑分支与原表达式不符。" }, { "id": 195, "q": "以下程序的运行结果是( ) 。\nmain(){int x=1,y=2,z=3;\nif(x>y)\nif(yy` 为假，因此其后的内层 `if-else` 语句块均不执行。程序直接跳至最后的 `printf(\"%d\\n\", x++);` 语句。此时输出 `x` 的当前值1，随后 `x` 自增为2。因此最终输出结果仅为1。" }, { "id": 196, "q": "下列程序的输出结果是( )。\nmain()\n{\nint x,y=5,d;\nfor(x=10;x>y;x--)\nd++;\nprintf(\"%d \\n\", d);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "输出无确定值", "4", "5", "6" ], "explanation": "本题考查局部变量的初始化。在C语言中，函数内部定义的局部变量（如本题中的 `d`）如果不显式初始化，其初始值是内存中的随机垃圾值。虽然 `for` 循环会执行5次使 `d` 累加，但由于初始值不确定，最终输出的 `d` 的值也是无确定值的。选项B、C、D均假设了 `d` 的初值为0，这是错误的。" }, { "id": 197, "q": "有以下程序段:\nint k,j,s;\nfor(k=2;k<6;k++,k++)\n{s=1;\nfor(j=k;j<6;j++)s+=j;\n}\nprintf(\"%d\\n\",s);\n程序段运行后的输出结果是()", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "6", "40", "24", "10" ], "explanation": "本题考查嵌套循环的执行过程。外层循环变量 `k` 初始为2，每次迭代通过 `k++,k++` 增加2，因此 `k` 依次取2和4。当 `k=2` 时，`s` 被重置为1，内层循环累加2至5，`s` 变为15；当 `k=4` 时，`s` 再次被重置为1，内层循环累加4和5，`s` 变为10。外层循环结束后，输出最后一次计算得到的 `s` 值，即10。" }, { "id": 198, "q": "以下程序的运行结果是( )\nint a=5;\nfun(int b)\n{ int a=10;\na+=b++;\nprintf(\"%d,\",a); }\nmain()\n{ int c=20;\nfun(c);\na+=c++;\nprintf(\"%d\\n\",a); }", "t": "single", "ans": "B", "kp": "函数", "o": [ "31,26", "30,25", "25,25", "30,30" ], "explanation": "本题考查局部变量与全局变量的作用域及自增运算。全局变量 `a` 初值为5。在 `fun` 函数中，定义了同名局部变量 `a=10`，屏蔽了全局变量。执行 `a+=b++` 时，`b` 为20，局部 `a` 变为30并输出。返回 `main` 函数后，操作的是全局变量 `a`，执行 `a+=c++`，此时 `c` 为20，全局 `a` 变为 `5+20=25` 并输出。因此最终输出为30,25。" }, { "id": 199, "q": "以下程序段的输出结果是（ ）。\n#include\nf(int a)\n{ int x=1;\nstatic int y=3;\nx++; y++;\nreturn(a+x+y);}\nmain( )\n{int i;\nfor(i=1;i<3;i++)\nprintf(“°%d”，f(i);}", "t": "single", "ans": "B", "kp": "函数", "o": [ "7,8", "7,9", "7,10", "7,11" ], "explanation": "本题考查静态局部变量的特性。函数 `f` 中的 `y` 是静态变量，只在第一次调用时初始化为3，后续调用保留上一次的值；而 `x` 是自动变量，每次调用都重新初始化为1。第一次调用 `f(1)` 时，`x` 变为2，`y` 变为4，返回 `1+2+4=7`；第二次调用 `f(2)` 时，`x` 重新变为2，`y` 在上次基础上变为5，返回 `2+2+5=9`。因此两次输出结果分别为7和9。" }, { "id": 200, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=1+i;\nprintf(\"%d%d%d\",a[0],a[4],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "159", "951", "259", "952" ], "explanation": "本题考查数组的遍历与赋值。`for` 循环从 `i=9` 递减到 `0`，为数组 `a` 的每个元素赋值，规则为 `a[i]=1+i`。因此，`a[0]` 的值为 `1+0=1`，`a[4]` 的值为 `1+4=5`，`a[8]` 的值为 `1+8=9`。最后 `printf` 语句连续输出这三个元素的值，中间无分隔符，故输出结果为159。" }, { "id": 201, "q": "以下程序的运行结果是（ ）。\nmain( )\n{ char p[20]={'a','b','c','d'},q[]=\"abc\", r[]=\"abcde\";\nstrcat(p,r); strcpy(p+strlen(q),q);\nprintf(\"%d \\n\",sizeof(p)); }", "t": "single", "ans": "C", "kp": "字符串", "o": [ "9", "6", "20", "7" ], "explanation": "本题考查 `sizeof` 运算符与数组。`sizeof` 用于计算数据类型或变量在内存中所占的字节数。题目中数组 `p` 被显式定义为 `char p[20]`，包含20个字符元素，每个字符占1个字节。无论后续使用 `strcat` 或 `strcpy` 对数组内容进行何种修改，数组 `p` 在编译时分配的内存大小已固定为20字节。因此 `sizeof(p)` 的结果始终为20。" }, { "id": 202, "q": "以下函数的功能是（　　）。\nint fun (char *x)\n{ char *y=x;\nwhile(*y++);\nreturn(y-x-1); }", "t": "single", "ans": "A", "kp": "字符串", "o": [ "求字符串的长度", "比较两个字符串的大小", "将字符串x复制到字符串y", "将字符串x连接到字符串y后面" ], "explanation": "本题考查指针操作与字符串处理。函数中指针 `y` 初始指向字符串首地址 `x`。`while(*y++)` 循环会逐个检查字符，直到遇到字符串结束标志 `\\0` 为止，此时 `y` 指向 `\\0` 的下一个内存位置。指针相减 `y-x` 得到的是包含 `\\0` 在内的字符总数，因此 `y-x-1` 恰好排除了结束符，计算出字符串的实际有效长度。" }, { "id": 203, "q": "下列说法正确的是（　　）。", "t": "single", "ans": "C", "kp": "综合编程/调试改错", "o": [ "C程序必须在开头用预处理命令#include", "预处理命令必须位于C源程序的首部", "在C语言中，预处理命令都以\"#\"开头", "C语言的预处理命令只能实现宏定义和条件编译的功能" ], "explanation": "本题考查C语言预处理命令的基本规则。在C语言中，所有的预处理命令（如宏定义、文件包含、条件编译等）都必须以 `#` 开头，故选项C正确。选项A错误，程序并非必须包含 `#include`；选项B错误，预处理命令可以出现在源程序的任何位置，其作用域从定义处开始到文件结束；选项D错误，预处理命令还包括文件包含等功能，不仅限于宏定义和条件编译。" }, { "id": 204, "q": "有以下定义语句，编译时会出现编译错误的是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "char a='\\n';", "char a=\"aa\";", "char a='a';", "char a='\\x2d';" ], "explanation": "本题考查字符变量与字符串常量的区别。`char` 类型的变量只能存储单个字符，必须使用单引号括起来，如选项A、C、D中的 `'\\n'`、`'a'` 和 `'\\x2d'`（十六进制转义字符）均是合法的字符常量。而选项B中的 `\"aa\"` 是字符串常量，在内存中占据多个字节（包含隐含的 `\\0`），其本质是指向字符数组的指针，不能直接赋值给单个 `char` 类型的变量，会导致编译错误。" }, { "id": 205, "q": "执行语句i=4;while(i>0) i--;后,变量i的值是（　　）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "4", "-1", "1" ], "explanation": "本题考查 `while` 循环的执行条件。变量 `i` 初始值为4，满足 `i>0` 的条件，进入循环执行 `i--`。`i` 的值依次变为3、2、1。当 `i` 为1时，条件仍成立，执行 `i--` 后 `i` 变为0。此时再次判断循环条件 `i>0`，由于0不大于0，条件为假，循环终止。因此循环结束后，变量 `i` 的最终值为0。" }, { "id": 206, "q": "若有语句int * p1, a=4;和p1=&a;，下面均代表地址的一组选项是（ ）。", "t": "single", "ans": "D", "kp": "指针", "o": [ "a、p1、*&a", "&*a、&a、*p1", "* &p1、* p1、&a", "&a、&* p1、p1" ], "explanation": "a是变量代表值，p1是指针变量代表地址，*&a即a代表值。&*a语法错误，*p1代表值。&p1是指针的地址。D选项中，&a是a的地址，&*p1即&(*p1)也就是&a代表地址，p1本身存储的是地址。因此D全为地址。" }, { "id": 207, "q": "以下程序的运行结果是（　　）。\n#define N 10\n#define s(x) x*x\n#define f(x) (x*x)\nmain()\n{ int i1,i2;\ni1=1000/s(N); i2=1000/f(N);\nprintf(\"%d %d\\n\",i1,i2);\n}", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ "10 10", "1000 10", "10 1000", "1000 1000" ], "explanation": "宏替换是纯文本替换。s(N)替换为10*10，i1=1000/10*10，从左到右计算得100*10=1000。f(N)替换为(10*10)，i2=1000/(10*10)，计算得10。因此输出1000 10。注意宏定义中括号的重要性。" }, { "id": 208, "q": "给定程序blank1.c中，函数fun的功能是：计算\n直到 。若x=2.5，函数值为：12.182494。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本程序的功能是计算各项表达式之和，直到最后一项的绝对值小于10的-6次方为止。f用来表示各项值累加的和，由于公式中前两项的值没有规律可寻，所以先把f初始化为1.0+x，故第一空填空\"x\"；程序中用while循环用来判断最后一项的绝对值是否大于或等于10的-6次方，如果大于等于，则继续求下一项的值，并进行累加，如果小于，则直接返回累加后的值f。由于除前两项之外的其他各项的值都可以拆分成前一项的值乘以x/n，且程序中用t来记录各项的值，所以第二空填\"n\"；由于t记录的是各项的值，f记录的是各项的和，所以第三空填\"t\"。关于程序各语句的具体分析如下：\n函数double fun(double x)的功能是计算f(x)各项之和。\nf =1.0+x;表示前二项的值。\nt=x;中的t用来存储各项的项值，此处是对t进行初始化，其值为x。\n当n=2时，因为t=x，所以t*= x/n;即t =t*x/n;;等于x*x/2得到结果t=x*x/2。\n当n=3时，因为t=x*x/2，所以 t*=x/n;即t=t*x/n;等于(x*x/2)*x/3，结果t=x*x*x/6。依次类推得出以下项的值。\nf+=t;把每一项得到的值累加起来，得到全部项的和。\nfabs(t)是取绝对值的函数。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 209, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "D", "kp": "综合编程/调试改错", "o": [ "程序必须包含所有三种基本结构才能成为一种算法。", "如果算法非常复杂，则需要使用三种基本结构之外的语句结构，才能准确表达。", "只有简单算法才能在有限的操作步骤之后结束。", "我们所写的每条C语句，经过编译最终将转换成二进制的机器指令。" ], "explanation": "A错误，算法不一定包含所有三种基本结构；B错误，任何复杂算法都可用三种基本结构表达；C错误，算法的有穷性要求所有算法必须在有限步骤内结束；D正确，C语言是编译型语言，每条语句最终都会被编译成二进制的机器指令供计算机执行。" }, { "id": 210, "q": "以下程序运行后的输出结果是(　　)。\nmain( ){　int k=5,n=0;\nwhile(k>0) {\nswitch(k) {\ndefault: break;\ncase 1: n+=k;\ncase 2:\ncase 3: n+=k;}\nk--;}\nprintf(\"%d\\n\",n);}", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "0", "4", "6", "7" ], "explanation": "k=5,4时匹配default，break跳出switch，n不变。k=3匹配case 3，n+=3得3。k=2匹配case 2，穿透至case 3，n+=2得5。k=1匹配case 1，n+=1得6，穿透至case 2和3，n+=1得7。循环结束输出7。" }, { "id": 211, "q": "以下程序的输出结果是().\nint sum = 0, item = 0;\nwhile(item =6)\nbreak;\n}\nprintf(\"%d\\n\", sum) ;", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "10", "15", "6", "7" ], "explanation": "题目代码存在明显缺失与语法错误（如while(item =6)及多余的右括号），无法准确推导。若按常见考题推测，可能考察循环累加及break跳出条件，当累加和或变量达到6时跳出循环。因题面异常，建议人工复核原题代码。" }, { "id": 212, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{1,3,5},{2,3,4},{3,5,7},{3,9}};\nprintf(\"%d%d%d%d\\n\",a[0][1],a[1][1],a[2][1],a[3][1]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "3359", "3333", "3349", "3329" ], "explanation": "二维数组按行优先初始化，未赋值的元素自动补0。a[0]为{1,3,5,0}，a[1]为{2,3,4,0}，a[2]为{3,5,7,0}，a[3]为{3,9,0,0}。题目要求输出a[0][1]、a[1][1]、a[2][1]、a[3][1]，即每行的第二个元素，分别为3、3、5、9。因此输出3359。" }, { "id": 213, "q": "以下程序的运行结果是（ ）。\nmain()\n{ int arr[ ]={6,7,8,9}, *ptr=arr;\n*(ptr+2)+=2;\nprintf(\" %d,%d\\n\", *ptr, *(ptr+2));}", "t": "single", "ans": "D", "kp": "指针", "o": [ "3,7", "4,8", "5,9", "6,10" ], "explanation": "ptr指向数组首元素6。*(ptr+2)即arr[2]，原值为8。*(ptr+2)+=2使其变为10。*ptr仍为首元素6。因此输出6,10。注意指针加法是跨越元素大小的，ptr+2指向第三个元素。" }, { "id": 214, "q": "下列描述正确的是（）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "用C编写的程序可直接运行", "C语言是低级语言", "C语言具有高级语言的特点又有低级语言的特点", "C语言的运行速度比二进制语言快" ], "explanation": "C语言是高级语言，但提供了指针、位运算等直接操作内存和硬件的功能，因此既有高级语言的特点，又有低级语言的特点。A错误，C程序需编译链接后才能运行；B错误，C是高级语言；D错误，机器语言（二进制）运行速度最快。" }, { "id": 215, "q": "关于C语言的符号常量，以下叙述中正确的是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "符号常量的符号名是标识符，但必须大写", "符号常量在整个程序中其值都不能再被重新定义", "符号常量是指在程序中通过宏定义用一个符号名来代表一个常量", "符号常量的符号名必须是常量" ], "explanation": "符号常量是通过#define宏定义定义的，用一个标识符代表一个常量，C正确。A错误，符号名不强制大写，只是习惯大写；B错误，宏定义可以#undef后重新定义；D错误，符号名是标识符，不是常量本身。" }, { "id": 216, "q": "当变量c的值不为2、4、6时，值也为\"真\"的表达式是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "(c==2)‖(c==4)‖(c==6)", "(c>=2&&c<=6)‖(c!=3)‖(c!=5)", "(c>=2&&c<=6)&&!(c%2)", "(c>=2&&c<=6)&&(c%2!=1)" ], "explanation": "A选项当c为2、4、6时为真，不符合。C和D选项表示c在2到6之间且为偶数（即2、4、6）时为真，不符合。B选项中，只要c不等于3或c不等于5，整个表达式就为真。因为c不可能同时等于3和5，所以(c!=3)||(c!=5)恒为真，满足条件。" }, { "id": 217, "q": "以下选项中不合法的标识符是 ( )。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "print", "FOR", "&a", "_00" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头，不能是关键字。A、B、D均符合规则。C选项包含特殊字符&，不符合标识符命名规则，因此不合法。" }, { "id": 218, "q": "以下程序的输出结果是（）\nint a=4;\nint f(int n){\nint t=0;\nstatic int a=6;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<2;i++) s+=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "30", "28", "29", "31" ], "explanation": "全局a=4。i=0时，n%2为0走else，局部a=7，t=7，返回t+静态a(6)=13，静态a变7。i=1时，n%2为1走if，局部a=6，t=6，返回t+静态a(7)=13，静态a变8。s初值为4，最终s=4+13+13=30。" }, { "id": 219, "q": "以下程序输出结果是（ ）\nint fun(int a,int b)\n{ if(b==0) return a;\nelse return(fun(--a,--b)); }\nmain()\n{ printf(\"%d\\n\", fun(6,3));}", "t": "single", "ans": "A", "kp": "函数", "o": [ "3", "2", "4", "5" ], "explanation": "本题考查递归函数调用。fun(6,3)中b不为0，返回fun(5,2)；接着返回fun(4,1)；再返回fun(3,0)。此时b等于0，满足if条件，直接返回a的值3。因此最终输出结果为3。" }, { "id": 220, "q": "给定程序中，函数fun的功能是：调用随机函数产生20个互不相同的整数放在形参a所指数组中（此数组在主函数中已置0）。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "while语句的作用是生成N个数据后停止循环，所以第一处填：N；当出现重复数据的时候终止当前for循环，所以第二处填：break；a数组中有n个有效数据，当i==n时，生成的随机数为有效数据，因此第三处填：n。\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 221, "q": "数组定义char a[ ]=\"HOW ARE YOU?\"; 则数组a所占的空间为( ) 。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "11个字节", "10个字节", "13个字节", "12个字节" ], "explanation": "本题考查字符串数组的内存占用。字符串包含12个可见字符。在C语言中，字符串末尾会自动添加一个结束标志'\\0'，因此数组a实际占用12+1=13个字节的空间。" }, { "id": 222, "q": "下面程序的输出是 正确答案是( )\nmain()\n{\nint k=11;\nprintf(\"k=%d, k=%o, k=%x\\n\", k, k, k) ;\n}", "t": "single", "ans": "D", "kp": "输入输出", "o": [ "k=11, k=12, k=11", "k=11, k=13, k=13", "k=11, k=013, k=0xb", "k=11, k=13, k=b" ], "explanation": "本题考查printf格式控制符。%d以十进制输出11；%o以八进制输出，11转换为八进制是13，且不带前缀0；%x以十六进制小写输出，11转换为十六进制是b，且不带前缀0x。因此输出为k=11, k=13, k=b。" }, { "id": 223, "q": "若有定义语句int a=10;double b=3.14;，则表达式'A'+a+b值的类型是          。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "int", "char", "float", "double" ], "explanation": "本题考查表达式中的类型自动转换。字符'A'和整型变量a在运算时会提升为int型，int与int相加结果仍为int。随后int型结果与double型变量b相加时，int会被自动提升为double型，因此整个表达式的最终类型为double。" }, { "id": 224, "q": "以下选项中不正确的整型常量是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "12L", "-10", "1,900", "257" ], "explanation": "本题考查整型常量的合法表示。C语言中整型常量不能包含逗号等分隔符，因此1,900是不合法的。12L是长整型常量，-10是负整型常量，257是普通的十进制整型常量，均合法。" }, { "id": 225, "q": "C语言中的标识符分为关键字、预定义标识符和用户标识符，以下叙述正确的是（　　）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "关键字可用作用户标识符，但失去原有含义", "在标识符中大写字母和小写字母被认为是相同的字符", "用户标识符可以由字母和数字任意顺序组成", "预定义标识符可用作用户标识符，但失去原有含义" ], "explanation": "本题考查标识符命名规则。关键字不能用作用户标识符；C语言严格区分大小写；用户标识符必须由字母或下划线开头，不能以数字开头。预定义标识符可以用作用户标识符，但会覆盖其原有系统含义。" }, { "id": 226, "q": "若有以下程序\n#include \nmain() {\nint a=0,b=0,c=0,d;\nc= (a+=b, , b+=a); /*第4行*/\nd=c; ; /*第5行*/\n; /*第6行*/\nprintf(\"%d,%d,%d\\n\",a,b,c); /*第7行*/\n}\n编译时出现错误，你认为出错的是", "t": "single", "ans": "A", "kp": "综合编程/调试改错", "o": [ "第4行", "第5行", "第6行", "第7行" ], "explanation": "本题考查语法错误定位。第4行的逗号表达式中出现了连续两个逗号，中间缺少合法的表达式，导致编译时出现语法错误。其他行的空语句或赋值语句在语法上是允许的。" }, { "id": 227, "q": "设y是int型变量，请写出判断y为奇数的C语言表达式是          。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "x%2==0", "x%2==1", "x/2==0", "x/2==1" ], "explanation": "本题考查奇偶数判断表达式。判断一个整数是否为奇数，通常使用取余运算符%，若对2取余结果为1则为奇数。注意题干描述变量为y，但选项均使用变量x，存在变量名不一致的瑕疵，按常规逻辑选择x%2==1。" }, { "id": 228, "q": "设有说明语句：char ch='\\72';则变量ch包含 ( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1个字符", "2个字符", "3个字符", "说明不合法" ], "explanation": "本题考查转义字符。'\\72'是一个八进制转义字符，代表ASCII码值为八进制72的单个字符。虽然由多个数字组成，但在内存中只占1个字节，表示1个字符。" }, { "id": 229, "q": "以下程序的运行结果是（　　）\nint a=1;\nint f(int c){\nstatic int a=3;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "16", "14", "15", "17" ], "explanation": "本题考查变量作用域与静态变量。全局a=1。循环第1次：局部a=3传入f，静态a初值3，c=4，返回3+4=7，静态a变4，k=7。第2次：局部a=3传入f，静态a为4，c=4，返回4+4=8，静态a变5，k=15。循环结束，k加上全局a(1)，最终k=16。" }, { "id": 230, "q": "下列条件语句中，功能与其他语句不同的是( )", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "if(a) printf(\"%d\\n\",x); else printf(\"%d\\n\",y);", "if(a==0) printf(\"%d\\n\",x); else printf(\"%d\\n\",y);", "if(a!=0) printf(\"%d\\n\",x); else printf(\"%d\\n\",y);", "if(!a==0) printf(\"%d\\n\",x); else printf(\"%d\\n\",y);" ], "explanation": "本题考查条件语句的逻辑等价性。A、C、D选项中，当a非0时均输出x，a为0时输出y。而B选项中，当a等于0时输出x，a非0时输出y，其逻辑判断条件与其他三项正好相反，因此功能不同。" }, { "id": 231, "q": "执行下面程序后，x的值为（）。\nint a=0,b=0,c=0,x=3;\nif (a) x=0;\nelse if (!b)x=2;\nelse if (!c) x=1;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "本题考查if-else if级联结构的执行。首先判断if(a)，a为0条件为假；接着判断else if(!b)，b为0，!b为真，条件成立，执行x=2。一旦某个分支条件成立，后续的else if将不再执行，因此x的最终值为2。" }, { "id": 232, "q": "以下不正确的语句是（ ）", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "if(x>y) ;", "if((x=y)&&(x!=0)) x+=y;", "if(x!=y) scanf(\"%d\",&x);", "if(xb）\nif(b>c）\nprintf(\"%d\",d++ +1);\nelse\nprintf(\"%d\",++d +1);\nprintf(\"%d\\n\",d);}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "2", "3", "43", "44" ], "explanation": "本题考查if-else语句的嵌套与配对规则。程序中a=3，b=4，条件a>b为假，因此直接跳过其后的整个if-else嵌套结构，内部的printf语句均不执行。程序直接执行最后的printf(\"%d\\n\",d);，此时变量d的值未被修改，仍为初始值2，故输出结果为2。" }, { "id": 235, "q": "以下程序的运行结果是( )。\nmain(){\nint a=1,b=1;\ndo{\nif(b>=20) break;\nif(b%3==1){ b+=3;continue;}\nb-=5;}while(a<=10);\nprintf(\"%d\",a);}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "7", "8", "9", "1" ], "explanation": "本题考查do-while循环及break、continue语句。循环条件为a<=10，但循环体内并未对变量a进行任何修改，a始终保持为1。循环体内通过修改b的值，最终当b增加到22时满足b>=20，触发break跳出循环。循环结束后执行printf输出a的值，由于a从未改变，故输出结果为1。" }, { "id": 236, "q": "以下程序的运行结果是（　　）。\nmain(){ int i,j,x=0;\nfor(i=1;i<3;i++) {\nx++;\nx++;\n}\nx++;\nprintf(\"x=%d\\n\",x);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "x=3", "x=5", "x=0", "x=7" ], "explanation": "本题考查for循环的执行过程。变量x初始值为0。for循环中i从1递增到2，共执行2次循环体。每次循环体内包含两条x++语句，因此循环执行完毕后x的值增加了4，变为4。循环结束后，再执行一次循环外的x++，x的值变为5。最后输出x=5。变量j在程序中未被使用，不影响结果。" }, { "id": 237, "q": "以下程序运行结果是( )。\nmain()\n{ int a=0,b=0,c=0,d=0;\nwhile(a=1) b=1;c=2;\nprintf(\"%d,%d,%d,%d\\n\",a,b,c,d);\n}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1,0,2,0", "1,1,2,0", "死循环", "编译有错" ], "explanation": "本题考查while循环的条件判断。while语句的条件表达式为a=1，这是一个赋值表达式，其值始终为1（即逻辑真）。由于循环体内只有b=1;，没有任何语句能够改变a的值使其为0，因此该循环条件永远成立，程序将陷入死循环，无法执行后续的c=2;和printf语句。" }, { "id": 238, "q": "下面程序运行后，输出的结果是( )。\nmain()\n{ float a=3,b=5;\nint c=1;\nfor(;a=0;i--) a[i]=10-i;\nprintf(\"%d%d%d\",a[2],a[4],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "862", "852", "268", "258" ], "explanation": "循环将数组a逆序赋值，a[i]=10-i。由此可得a[2]=10-2=8，a[4]=10-4=6，a[8]=10-8=2。printf语句连续输出这三个元素的值，中间无分隔符，因此结果为862。" }, { "id": 248, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int i, x[3][3]={1,2,3,4,5,6,7,8,9};\nfor(i=0;i<3;i++) printf(\"%d,\",x[i][2-i]);}", "t": "single", "ans": "C", "kp": "数组", "o": [ "1,5,9,", "1,4,7,", "3,5,7,", "3,6,9," ], "explanation": "二维数组x按行优先顺序初始化为1至9。循环输出x[i][2-i]，即输出副对角线上的元素。当i=0时输出x[0][2]即3；i=1时输出x[1][1]即5；i=2时输出x[2][0]即7。每次输出后带逗号，结果为3,5,7,。" }, { "id": 249, "q": "以下程序的运行结果是（　　）\nmain( )\n{\nchar b[30];\nstrcpy(&b[0],\"aa\");\nstrcpy(&b[1],\"DEF\");\nstrcpy(&b[2],\"ABC\");\nprintf(\"%s \\n\",b);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "aDABC", "aa", "ABCDE", "aaDABC" ], "explanation": "strcpy函数从指定地址开始覆盖字符串。首先b[0]起存入aa，b为aa；接着从b[1]起存入DEF，覆盖原a及结束符，b变为aDEF；最后从b[2]起存入ABC，覆盖E和F，b变为aDABC。最终输出aDABC。" }, { "id": 250, "q": "以下程序段的输出结果是() 。\nfloat x=3.0,y=0.5;\nif(x=5.0) y=y/x;\nelse y=1.0;\nprintf(\"%f\\n\",y);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0.250000", "0.000000", "1.000000", "0.500000" ], "explanation": "题目中if条件为赋值表达式x=5.0，其值为5.0（真），应执行y=y/x得0.1，但选项无此结果。推测题目本意为关系运算x==5.0，此时条件为假，执行else分支y=1.0，输出1.000000。按给定答案C反推，应以x==5.0理解。" }, { "id": 251, "q": "若有以下定义和语句，则输出结果是（　　）\nint a[10]={2,4,6,8,10,12,14,16,18,20},*p=a;\npritnf(\"%d\",p[3]+a[2]);", "t": "single", "ans": "A", "kp": "指针", "o": [ "14", "10", "8", "12" ], "explanation": "指针p指向数组a的首地址，因此p[i]等价于a[i]。p[3]即a[3]，值为8；a[2]的值为6。两者相加8+6=14。注意题干中printf拼写有误，但不影响逻辑推导。" }, { "id": 252, "q": "以下程序的运行结果是( )\n#define x 6\n#define y (x+1)\n#define z y*x/2\nmain()\n{\nprintf(\"%d\",2*z);\n}", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "16", "15", "21", "42" ], "explanation": "宏替换是纯文本替换。2*z替换为2*y*x/2，进一步替换为2*(x+1)*x/2，最后替换为2*(6+1)*6/2。根据算术运算优先级，计算结果为2*7*6/2=42。注意宏定义y带有括号，保证了x+1优先计算。" }, { "id": 253, "q": "#define f(x) (x)*(x)\nmain( )\n{ int i;\ni=f(5+5)/f(3+3);\nprintf(\"%d\\n\",i);\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "96", "2", "43", "3" ], "explanation": "宏替换为纯文本替换，f(5+5)/f(3+3)替换为(5+5)*(5+5)/(3+3)*(3+3)。由于乘除优先级相同且从左向右结合，计算过程为10*10/6*6。先算100/6整除得16，再乘6得96。注意宏定义外层无括号导致结合顺序改变。" }, { "id": 254, "q": "请编写一个函数fun，它的功能是：计算并输出给定整数n的所有因子（不包括1与n自身）之和。规定n的值不大于1000。\n例如，在主函数中从键盘给n输入的值为856，则输出为：sum=763。\n注意：部分源程序在文件PROG1.C中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "int fun (int n)\n{\nint i,s=0;\nif(n<1000)\n{for (i=2;i\nextern m;\nmain()\n{\nstatic int i=0,m=6;\nfloat j, k=5;\nprintf（\"m=%d\",++m）;\n}\nint m=10;", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "m=7", "m=10", "m=6.000000", "m=6" ], "explanation": "在main函数内部定义了静态局部变量m并初始化为6，它会屏蔽同名的全局变量m。printf语句输出的是局部变量m的值。执行++m后，局部变量m的值变为7，因此输出m=7。" }, { "id": 256, "q": "变量的指针是指变量的（　　）。", "t": "single", "ans": "B", "kp": "指针", "o": [ "值", "地址", "名", "一个标志" ], "explanation": "在C语言中，指针是一种特殊的变量，其值为另一个变量的内存地址。因此，变量的指针就是指该变量在内存中的地址，通过指针可以间接访问该变量的值。" }, { "id": 257, "q": "给定程序MODI1.C中规定输入的字符串全部为字母，fun函数的功能是：统计a所指字符串中每个字母在字符串中出现的次数（统计时不区分大小写），并将出现次数最高的字母输出（如果有多个相同，输出一个即可）。\n例如对于字符串：dadbcdbabdb，对应的输出应为：b或d。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "第一处错误：判断字符数组的长度应该用strlen()函数，所以\"n=sizeof(a);\"应改为\"n=strlen(a);\"。\n第二处错误：根据题意，两个判断条件应该同时存在，而不是只有一个存在即可。所以\"if (a[i] >='a' || a[i]<='z');\"应改为\"if (a[i] >='a' && a[i]<='z');\"。\n第三处错误：此处应将i复制给变量max，所以应将\"i=max;\"改为\"max=i;\"或其等效形式。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 258, "q": "给定程序modi1.c中，fun函数的功能是：先从键盘上输入一个3行3列矩阵的各个元素的值，然后输出主对角线元素之和。\n请改正程序中的错误，或在横线处填上适当的内容并把横线删除，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "由题意可知，程序中通过sum变量累计对角线元素的和，在初始化时需先为sum赋初始值，所以应在横线处填入：\"sum=0;\"。\n根据scanf语句的语法规则\"scanf(\"格式字符串\", 地址，…);\"，地址是指变量在内存中的位置，所以 \"scanf(\"%d\",a[i][j]);\"应改为\"scanf(\"%d\",&a[i][j]);\"或相同作用的语句。\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 259, "q": "已知定义\"int a[ ]={1，2，3，4}，y，*p=&a[1];\"执行y=(*- -p)++后，y的值是()", "t": "single", "ans": "B", "kp": "指针", "o": [ "4", "1", "2", "3" ], "explanation": "p初始指向a[1]（值为2）。--p使p指向a[0]（值为1），*--p取出a[0]的值1。后缀++优先级虽高，但受括号限制，先计算括号内*--p得到1并赋值给y，随后a[0]的值自增为2。因此y的值为1。" }, { "id": 260, "q": "若运行下面程序时, 给变量 a 输入 15, 则输出结果是( ) 。\nint a, b;\nscanf(\"%d\", &a) ;\nb=a>15?a+10: a-10;\nprintf(\"%d\\n\", b) ;", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "5", "10", "15", "25" ], "explanation": "输入a=15。条件表达式a>15判断15是否大于15，结果为假。因此执行冒号后的表达式a-10，即15-10=5。将5赋值给b并输出，结果为5。" }, { "id": 261, "q": "有以下程序段：\nint n=0,p=0;\nwhile(p!=100&&n<3) {scanf(\"%d\",&p);n++;}\n此处while循环的执行条件是（　　）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "p的值不等于100并且n的值小于3", "p的值等于100并且n的值大于等于3", "p的值不等于100或者n的值小于3", "p的值等于100或者n的值大于等于3" ], "explanation": "while循环的条件表达式为p!=100&&n<3。!=表示不等于，&&表示逻辑与（并且），<表示小于。因此该循环的执行条件是p的值不等于100并且n的值小于3。" }, { "id": 262, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{1,3,5},{2,4,6},{3,5,7}};\nprintf(\"%d%d%d%d\\n\",a[0][2],a[1][2],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "5650", "5651", "5655", "5652" ], "explanation": "二维数组a部分初始化，未赋值元素默认为0。a[0]为{1,3,5,0}，a[0][2]是5；a[1]为{2,4,6,0}，a[1][2]是6；a[2]为{3,5,7,0}，a[2][1]是5；a[3]全为0，a[3][0]是0。依次输出5、6、5、0，结果为5650。" }, { "id": 263, "q": "若x,y,z的值分别为2,1,3， 程序的输出结果为（）\nif(y>z)printf(\"%d\\n\",z);\nelse if (zz（1>3）为假；接着判断z= 0)&&(c<= 9)", "(c>= '0')&&(c<= '9')", "0<=c<= 9" ], "explanation": "C语言中判断字符是否为数字字符，需比较其ASCII码值是否在'0'到'9'之间。选项A和D使用了连续比较，在C语言中会被解析为('0'<=c)<='9'，结果恒为真，属于逻辑错误。选项B比较的是整型数值0和9，而非字符。选项C使用逻辑与正确判断了字符范围。" }, { "id": 272, "q": "下列非法的整型常量是          。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "13", "0xabc", "0386", "10101" ], "explanation": "C语言中，以数字0开头的整型常量表示八进制数，其数码范围只能是0到7。选项C中的0386包含了数字8，超出了八进制的有效范围，因此是非法的整型常量。选项A是十进制，选项B是十六进制（0x开头），选项D是十进制，均合法。" }, { "id": 273, "q": "以下选项中不属于C语言标识符的是()", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "用户标识符", "关键字", "常量", "预定义标识符" ], "explanation": "C语言的标识符主要分为三类：关键字（保留字）、预定义标识符（如库函数名）和用户自定义标识符。常量是程序中固定不变的数据值，不属于标识符的范畴。因此选项C正确。" }, { "id": 274, "q": "以下程序运行后的输出结果是( )。\ndouble d=3.2;\nint x,y;\nx=1.2;\ny=(x+3.8)/5.0;\nprintf(\"%d \\n\", d*y);", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "3", "3.2", "0", "3.07" ], "explanation": "首先，x为int类型，赋值1.2时发生截断，x变为1。接着计算y=(1+3.8)/5.0，即4.8/5.0=0.96，赋值给int类型的y时再次截断，y变为0。最后计算d*y，即3.2*0=0.0，使用%d格式输出时，结果为0。" }, { "id": 275, "q": "有以下程序段,则输出结果是（）\nint a=1,b=2,c=3,d=4;\nif((a=2)||(b=1))c=2;\nif((c==3)&&(d=-1))a=5;\nprintf(\"%d,%d,%d,%d\\n\",a,b,c,d);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "5,1,2,-1", "2,2,2,4", "2,1,2,-1", "1,2,3,4" ], "explanation": "第一个if语句中，(a=2)为真，由于逻辑或(||)的短路特性，(b=1)不执行，b保持为2。条件为真，执行c=2。第二个if语句中，此时c为2，(c==3)为假，由于逻辑与(&&)的短路特性，(d=-1)不执行，d保持为4。条件为假，a=5不执行。最终a=2,b=2,c=2,d=4。" }, { "id": 276, "q": "选择出合法的判断a和b是否相等的if语句(设 int x, a, b, c; ) 。", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "if (a=b) x++;", "if (a=b) x++;" ], "explanation": "判断a和b是否相等应使用关系运算符==或!=。选项A是赋值表达式，选项B和D中的运算符=<和=>在C语言中是非法的，正确的应为<=和>=。选项C使用!=判断a和b是否不相等，语法合法且符合逻辑判断要求。" }, { "id": 277, "q": "执行下面程序段后，x的值是（）。\nint a=4,b=5,c=7,d=6,x=-3;\nif(a>=b)\nif(c>d) x=1;\nelse\nif(b=b，即4>=5，结果为假。因此，整个if(a>=b)语句块（包括其内部嵌套的所有if-else）都不会执行。变量x的值保持初始值-3不变。" }, { "id": 278, "q": "以下程序运行后的输出结果是(　　)。\nmain( ){int i,j,m=1;\nfor(i=1;i0;j--){\nif(i*j>3) break;\nm*=i*j;}}\nprintf(\"m=%d\\n\",m);}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "m=4", "m=2", "m=6", "m=5" ], "explanation": "外层循环i=1时，内层循环j从3递减：j=3时，1*3不大于3，m=1*3=3；j=2时，1*2不大于3，m=3*2=6；j=1时，1*1不大于3，m=6*1=6。外层循环i=2时，内层循环j=3，2*3=6>3，触发break跳出内层循环。最终m的值为6。" }, { "id": 279, "q": "以下程序的运行结果是（　　）。\nmain(){\nint y=9 ;\nwhile( y>0){\ny--;\nif(y%3==1 ) printf(\"%d\" , --y) ;\n}\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "630", "963", "852", "875421" ], "explanation": "初始y=9。第一次循环：y--后y=8，8%3!=1。第二次：y--后y=7，7%3==1，输出--y即6，此时y=6。第三次：y--后y=5，5%3!=1。第四次：y--后y=4，4%3==1，输出--y即3，此时y=3。第五次：y--后y=2，2%3!=1。第六次：y--后y=1，1%3==1，输出--y即0，此时y=0。循环结束。输出630。" }, { "id": 280, "q": "C语言中，函数值类型的定义可以缺省，此时函数值的隐含类型是( ) 。", "t": "single", "ans": "B", "kp": "函数", "o": [ "void", "int", "float", "double" ], "explanation": "在早期的C语言标准（如C89）中，如果函数定义时省略了返回值类型，编译器会默认该函数的返回值类型为整型（int）。虽然现代C语言标准不再支持隐式int，但在传统C语言考试中，缺省类型即为int。" }, { "id": 281, "q": "以下程序的输出结果是（）\n#include\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<2;i++)\nprintf(\"%d \",f(i));\n}\nint f(int a)\n{ int b=0; static int c=5;\nb++;c++;\nreturn(a+b+c);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "7 9", "7 8", "7 7", "9 9" ], "explanation": "函数f中，b是局部变量，每次调用初始化为0；c是静态局部变量，只初始化一次。第一次调用f(0)：b=0, c=5，执行b++, c++后b=1, c=6，返回0+1+6=7。第二次调用f(1)：b重新初始化为0，c保留上次值6，执行b++, c++后b=1, c=7，返回1+1+7=9。输出7 9。" }, { "id": 282, "q": "以下程序段输出结果是（ ）。\nint i, a[10]={0};\nfor(i=0;i<10;i++) a[2*i]=2*i;\nprintf(\"%d%d%d%d \",a[1],a[2],a[3],a[4]);}", "t": "single", "ans": "B", "kp": "数组", "o": [ "0246", "0204", "0000", "2468" ], "explanation": "数组a初始全为0。循环中，当i=0时，a[0]=0；i=1时，a[2]=2；i=2时，a[4]=4；i=3时，a[6]=6；i=4时，a[8]=8。其余奇数下标元素未被赋值，保持初始值0。因此a[1]=0，a[2]=2，a[3]=0，a[4]=4。输出结果为0204。" }, { "id": 283, "q": "以下能正确定义一维数组的选项是（　　）。", "t": "single", "ans": "C", "kp": "数组", "o": [ "int a[ ];", "float a[n];", "int a['A'];", "int a(5);" ], "explanation": "C语言定义一维数组时，方括号内必须是常量表达式。A选项未指定大小且未初始化，错误；B选项n若为变量则不合法；C选项'A'是字符常量，其ASCII值为65，属于常量表达式，合法；D选项使用了圆括号，语法错误。" }, { "id": 284, "q": "有以下程序,程序的运行结果是()\nint x=1, y=0, a=0, b=0;\nswitch ( x )\n{\ncase 1: switch(y)\n{\ncase 0: a++;\ncase 1: b++;\n}\ncase 2: a++; b++;\ncase 3: a++; b++;\n}\nprintf(\"a=%d, b=%d\\n\", a, b);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "a=3, b=2", "a=2, b=1", "a=3, b=3", "a=2, b=2" ], "explanation": "x=1进入外层case 1，y=0进入内层case 0，执行a++(a=1)，无break继续执行内层case 1的b++(b=1)。内层结束，无break继续执行外层case 2的a++(a=2)和b++(b=2)，再执行外层case 3的a++(a=3)和b++(b=3)。最终a=3，b=3。" }, { "id": 285, "q": "下面程序运行时，如果从键盘上输入3,5，程序输出的结果是()。\nmain( )\n{\nint a,b,*pa,*pb;\npa=&a; pb=&b;\nscanf(\"%d,%d\",pa,pb);\n*pa=a+b;\n*pb=a+b;\nprintf(\"a=%d,b=%d\\n\",a,b);\n}", "t": "single", "ans": "C", "kp": "指针", "o": [ "a=13,b=13", "a=8,b=8", "a=8,b=13", "出错" ], "explanation": "输入3,5后，a=3，b=5。执行*pa=a+b，即a=3+5=8。接着执行*pb=a+b，此时a已变为8，b仍为5，故b=8+5=13。最终输出a=8,b=13。注意指针pa和pb分别指向a和b，通过指针直接修改了对应变量的值。" }, { "id": 286, "q": "给定程序M0DI1.C中函数fun的功能是：将一个十进制整数转换成r(二～十六）进制形式。\n例如：输入125 16，则输出：7D\n输入9 2，则输出：1001\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得増行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 287, "q": "函数fun的功能是：从三个形参a，b，c中找出中间的那个数，作为函数值返回。\n例如，当a=3，b=5，c=4时，中数为4。\n请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本程序先判断a>b，如果为真，则执行(b>c? b :(a>c?c:___1___))，再看b>c，如果为真，则输出b，说明b就是a,b,c中中间的那个数，如果为假，则说明b是最小的一个数，还需要再比较a,c，如果a>c，说明c是中间的那个数，否则，说明a是中间的那个数，所以第一空填a；如果开始判断的a>b为假的话，则执行的是((a>c)?___2___ : ((b>c)?c:___3___))，此时需判断a>c，若为真，则说明a为中间的那个数，否则，接着判断b>c，为真则输出c，否则输出b。故第二空填a，第三空填b。", "kp": "选择结构", "o": [], "rawType": "operation" }, { "id": 288, "q": "若变量已正确定义为int型，要通过语句 scanf(\"%d,%d,%d\",&a,&b,&c); 给a赋值3、给b赋值4、给 c赋值5，以下输入形式中错误的是()", "t": "single", "ans": "B", "kp": "输入输出", "o": [ "3,4,5", "3 4 5", "3, 4,5", "3,4, 5" ], "explanation": "scanf格式控制字符串中包含非格式字符（如逗号），输入时必须原样输入这些字符。选项A、C、D均包含逗号，且数字间可有任意空白符，能正确匹配。选项B使用空格分隔，缺少必需的逗号，会导致匹配失败，因此错误。" }, { "id": 289, "q": "若变量a、i已正确定义，且i已正确赋值，合法的语句是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "a==1", "++i;", "a=a++=5;", "a=int(i);" ], "explanation": "A选项是关系表达式，缺少分号，不是语句；B选项是自增表达式加分号，构成合法的表达式语句；C选项a++的结果不是左值，不能被赋值，语法错误；D选项C语言中强制类型转换应使用(int)i，而不是int(i)。" }, { "id": 290, "q": "以下选项中可用作C程序合法实数的是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "3.0e0.2", ".1e0", "E9", "9.12E" ], "explanation": "C语言指数形式实数要求：字母e或E之前必须有数字，且e后面的指数必须为整数。A选项指数0.2不是整数；C选项e前无数字；D选项e后无指数。B选项.1e0等价于0.1×10^0，符合规则，是合法的实数。" }, { "id": 291, "q": "下列运算符中， 优先级最高的是()", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "+", "++", "&&", "=" ], "explanation": "选项中++是单目运算符，优先级最高；+是算术运算符，优先级次之；&&是逻辑运算符，优先级较低；=是赋值运算符，优先级最低。因此++的优先级最高。" }, { "id": 292, "q": "阅读以下程序\n#include \nmain() {\nint case ;\nfloat printF;\nprintf(\"请输入2个数：\");\nscanf(\"%d %f\",&case,&printF );\nprintf(\"%d %f\\n\",case,printF ); }\n该程序在编译时产生错误，其出错原因是\n）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "定义语句出错，printF不能用作用户自定义标识符", "定义语句出错，case是关键字，不能用作用户自定义标识符", "定义语句无错，scanf不能作为输入函数使用", "定义语句无错，printf不能输出case的值" ], "explanation": "C语言中，标识符不能与关键字同名。case是C语言的关键字，用于switch语句，不能用作用户自定义标识符，因此定义int case;会导致编译错误。printF不是关键字，C语言区分大小写，它可作合法标识符。" }, { "id": 293, "q": "执行下面程序时,若从键盘输入\"4\"，则程序的运行结果是( )。\nint j,k; char cp;\ncp=getchar( );\nif (cp>='0' && cp<='9')\nk=cp-'0';\nelse if (cp>='a' && cp<='f')\nk=cp-'a'+10;\nelse k=cp-'A'+10;\nprintf(\"%d\\n\",k);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "2", "4", "1", "10" ], "explanation": "输入字符'4'，满足cp>='0' && cp<='9'，因此执行k=cp-'0'。字符'4'与字符'0'的ASCII码差为4，最终输出4。" }, { "id": 294, "q": "以下程序段执行后输出的结果是( )。\nint i=2;\nswitch(i)\n{ case 1: printf(\"%d\",i++);\ncase 2: printf(\"%d\",i++);\ndefault: printf(\"%d\",++i);\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "123", "24", "234", "2" ], "explanation": "i=2，匹配case 2，执行printf输出i++，先输出2，随后i变为3。因无break，穿透到default，执行printf输出++i，i先自增为4再输出4。最终输出24。注意i++是先用后加，++i是先加后用。" }, { "id": 295, "q": "有如下嵌套的if语句 ，以下选项中与上述if语句等价的语句是（）。\nif(ab) t=s+t;\nelse if (a==b) t=5;\nelse t=2*s;\nprintf(\"%d\\n\",t);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "2", "5", "4", "6" ], "explanation": "a=3、b=2，条件a>b成立，因此执行t=s+t，得到t=1+4=5。后面的else if和else分支不再执行，最终输出5。" }, { "id": 316, "q": "以下叙述中正确的是（ ）", "t": "single", "ans": "C", "kp": "指针", "o": [ "如果p是指针变量，则*p表示变量p的地址值", "如果p是指针变量，则&p是不合法的表达式", "在对指针进行加、减算术运算时，数字1表示1个存储单元的长度", "如果p是指针变量，则*p+1和*(p+1)的效果是一样的" ], "explanation": "A错误，*p表示p所指向变量的值，p本身才是地址。B错误，&p表示指针变量p自身的地址，合法。C正确，指针加减整数n时，实际移动的字节数为n乘以该指针基类型的大小，即n个存储单元长度。D错误，*p+1是指针所指的值加1，*(p+1)是下一个单元的值。" }, { "id": 317, "q": "若有以下定义和语句，则数组a的数组元素值是16的表达式是（　　）。\nint a[10]={2,4,6,8,10,12,14,16,18,20},*p=a;", "t": "single", "ans": "D", "kp": "指针", "o": [ "&a[7]", "p+7", "a+7", "*(a+7)" ], "explanation": "数组a中值为16的元素是第8个元素，下标为7，即a[7]。A选项&a[7]是该元素的地址；B选项p+7等价于&a[7]，也是地址；C选项a+7同样是地址；D选项*(a+7)等价于a[7]，表示该元素的值16。" }, { "id": 318, "q": "若程序中有宏定义行： #define N 100 则以下叙述中正确的是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "宏定义行中定义了标识符N的值为整数100。", "上述宏定义行实现将100赋给标示符N。", "在运行时用100替换标识符N。", "在编译程序对C源程序进行预处理时用100替换标识符N。" ], "explanation": "宏定义是C语言的预处理指令，在编译前的预处理阶段进行简单的文本替换，而不是在运行时替换，也不涉及赋值或定义变量类型的操作。因此，D选项正确，A、B、C均错误。" }, { "id": 319, "q": "在一个C程序中( )。", "t": "single", "ans": "B", "kp": "函数", "o": [ "main函数必须出现在所有函数之前", "main函数可以在任何地方出现", "main函数必须出现在所有函数之后", "main函数必须出现在固定位置" ], "explanation": "C语言规定，一个程序必须有且仅有一个main函数作为程序的入口。main函数在源文件中的位置是任意的，可以放在其他函数之前、之后或中间，编译器会自动找到它并从其开始执行。" }, { "id": 320, "q": "以下程序段运行后的输出结果是（ ）。\n{ char s[20]=\"bc123edf456gh\";\nint i,n=0;\nfor(i=0;s[i]!='\\0';i++)\nif(s[i]>='0'&&s[i]<='9' )\nn++;\nprintf(\"%d\",n);\n}", "t": "single", "ans": "C", "kp": "字符串", "o": [ "13", "14", "6", "7" ], "explanation": "程序遍历字符串s，通过条件判断统计其中数字字符的个数。字符串\"bc123edf456gh\"中包含的数字字符有'1','2','3','4','5','6'，共6个。因此n的最终值为6，输出结果为6。" }, { "id": 321, "q": "执行语句printf(\" ___\", 5);将得到出错信息。", "t": "single", "ans": "D", "kp": "输入输出", "o": [ "%d", "%o", "%x", "%f" ], "explanation": "5是整型常量，%d、%o、%x分别用于输出十进制、八进制、十六进制整数，均合法。%f用于输出浮点数，与整型参数类型不匹配，会导致未定义行为或编译警告与出错。" }, { "id": 322, "q": "若有定义语句int a=10;double b=3.14;，则(int)b+'A'+a值的类型是          。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "int", "char", "float", "double" ], "explanation": "C语言中，字符常量参与算术运算时会自动提升为int型。(int)b将double强制转换为int，a本身为int。因此整个表达式均为int型数据进行加法运算，最终结果类型为int。" }, { "id": 323, "q": "以下选项中非法的实型常量是", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "0.0", "0.", ".0", "0" ], "explanation": "实型常量必须包含小数点或指数部分。选项A、B、C均包含小数点，是合法的浮点数表示形式。选项D没有小数点和指数部分，属于合法的整型常量，而非实型常量。" }, { "id": 324, "q": "以下选项中非法的标识符有(　　)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "pet_name", "sex", "E_mail", "QQ number" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头。选项A、B、C均符合命名规则。选项D中包含空格，属于非法字符，因此是非法的标识符。" }, { "id": 325, "q": "设有定义： int x=2; 以下表达式中，x值是6的是", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "2*x, x+=2", "x++,2*x", "x*=2,x+2", "x*=x+1" ], "explanation": "A项执行后x为4；B项逗号表达式值为6，但x自增后值为3；C项执行后x为4；D项等价于x=x*(x+1)，即x=2*(2+1)=6，执行后x的值变为6。" }, { "id": 326, "q": "若有定义语句： int x=12, y=8, z; 在其后执行语句 z= 0.9+x/y; 则z的值为", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "1.9", "1", "2", "2.4" ], "explanation": "x和y均为整型，x/y执行整数除法，12/8结果为1。0.9+1结果为1.9。由于z是整型变量，将浮点数1.9赋值给z时会自动截断小数部分，最终z的值为1。" }, { "id": 327, "q": "max函数的功能是（）\nint max(int a, int b)\n{\nint c;\nc=a>b?a:b\nreturn c;\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "返回两个数的最大值", "返回两个数的最小值", "返回两个数的平均值", "返回两个数的和" ], "explanation": "函数中使用条件运算符a>b?a:b，其含义是如果a大于b，则表达式的值为a，否则为b。因此变量c被赋值为a和b中的较大者，最后返回两个数的最大值。" }, { "id": 328, "q": "if语句的基本形式是：if(表达式)语句，以下关于\"表达式\"值的叙述中正确的是( )。", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "必须是逻辑值", "必须是整数值", "必须是正数", "可以是任意合法的数值" ], "explanation": "C语言中，if语句的条件表达式可以是任意合法的数值类型。系统会自动判断其值，非0值视为真，0值视为假，不局限于逻辑值或整数值。" }, { "id": 329, "q": "以下程序段:\nfloat a,b;\nscanf(\"%f\",&a);\nif(a<0.0) b=0.0;\nelse if((a<0.5)&&(a!=2.0)) b=1.0/(a+2.0);\nelse if(a<10.0) b=1.0/a;\nelse b=10.0;\nprintf(\"%f\\n\",b);\n若运行时输入2.0,则输出结果是()", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "0.000000", "0.500000", "1.000000", "0.250000" ], "explanation": "输入a=2.0。a<0.0为假，(a<0.5)&&(a!=2.0)也为假，继续判断a<10.0为真，因此执行b=1.0/a，得到b=0.5。printf使用%f格式输出6位小数，所以结果为0.500000。" }, { "id": 330, "q": "在执行下述程序段时，若从键盘输入0，则结果为( )\nint x=0,y,z=10;\nscanf(\"%d\",&y);\nif(x=y)\nz=12;\nelse\nz+=z;\nprintf(\"%d\",z);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "10", "12", "编译出错", "20" ], "explanation": "输入0后，y的值为0。if语句的条件是赋值表达式x=y，将y的值0赋给x，表达式的值为0，即条件为假。因此执行else分支z+=z，z初始为10，计算后变为20。" }, { "id": 331, "q": "有如下程序段，其输出结果是 ( )。\nint x=2,a=0,b=0;\nswitch(x){\ncase 0: b++;break;\ndefault: a++;b++;\ncase 1: a++; break;\n}\nprintf(\"a=%d,b=%d\\n\",a,b);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "a=1,b=1", "a=2,b=1", "a=1,b=0", "a=2,b=2" ], "explanation": "x为2，没有匹配的case，执行default分支，a和b均自增变为1。由于default后没有break语句，程序发生穿透，继续执行case 1分支，a再次自增变为2，遇到break跳出。" }, { "id": 332, "q": "有以下程序段\nint x=1, y=0;\nif (!x) y++;\nelse if (x==0)\nif (x) y+=2;\nelse y+=3;\nprintf(\"%d\\n\", y);\n程序运行后的输出结果是()", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "2", "0", "1", "3" ], "explanation": "x初始为1，!x为0即假，不执行y++。接着判断else if(x==0)，由于x为1，条件也为假，其内部的if-else语句均不执行。因此y的值未改变，保持初始值0。" }, { "id": 333, "q": "程序的输出结果是（）\nint a=-2, b=0;\ndo\n{\n++b;\n} while(a++);\nprintf(\"%d %d\\n\",a,b);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1 3", "0 2", "1 2", "2 3" ], "explanation": "do-while循环先执行后判断。第1次：b=1，判断a++，a为-2，判断后a变为-1，条件为真；第2次：b=2，判断a++，a为-1，判断后a变为0，条件为真；第3次：b=3，判断a++，a为0，判断后a变为1，条件为假退出循环。最终a=1，b=3。" }, { "id": 334, "q": "以下程序的运行结果是( ) 。\nint y=9 ;\nfor( ; y>0 ; y--)\nif(y%3==0 ) printf(\"%d\" , --y) ;", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "741", "963", "852", "875421" ], "explanation": "y=9时，y%3==0成立，输出--y即8，此时y=8，循环y--后y=7；y=7不满足条件，y--后为6；y=6满足条件，输出--y即5，y变为5，y--后为4；y=4不满足，y--后为3；y=3满足条件，输出--y即2，y变为2，y--后为1；y=1不满足，y--后为0退出循环。最终输出852。" }, { "id": 335, "q": "由以下while构成的循环，循环体执行的次数是 int k=0; while ( k==0 ) k++;", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "一次也不执行", "执行一次", "无限次", "有语法错，不能执行" ], "explanation": "初始k=0，满足条件k==0，进入循环体执行k++，k变为1。再次判断条件k==0为假，退出循环。因此循环体只执行了一次。" }, { "id": 336, "q": "以下是死循环的程序段是()", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "for(i=1; ; )\nif(++i%2==0) continue;\nif(++i%3==0) break;\n}", "i=-32767;\ndo{if(i<0) break;}while(++i);", "for(i=1; ; ) if(++i<10) continue;", "i=1;\nwhile(i--);" ], "explanation": "选项A中i递增到3的倍数时会执行break退出；选项B中初始i<0直接执行break退出；选项D中i递减到0时条件为假退出循环。选项C中for循环缺少终止条件，且循环体内只有continue没有break，会无限循环下去，是死循环。" }, { "id": 337, "q": "以下程序运行后，如果输入123，则输出结果为（　　）。\nmain(){\nint n1,n2;\nscanf(\"%d\",&n1);\nwhile(n1!=0){\nn2=n1%10;\nn1=n1/10;\nprintf(\"%d\",n2);}}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "123", "32", "3", "321" ], "explanation": "程序通过循环不断对n1取余和整除10，实现将输入的整数逆序输出。输入123，第一次循环n2=3，n1=12，输出3；第二次n2=2，n1=1，输出2；第三次n2=1，n1=0，输出1。n1变为0后退出循环，最终输出321。" }, { "id": 338, "q": "对于无返回的函数f，下面正确的函数原型声明语句是（ ）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "void f(int x,y) ;", "f(int x,int y);", "void f(int x,int y ) ;", "void f( x,y) ;" ], "explanation": "无返回值的函数必须用void声明返回类型。选项A参数y缺少类型声明；选项B缺少返回类型声明；选项D参数x和y均缺少类型声明。只有选项C语法完全正确。" }, { "id": 339, "q": "已定义以下函数 int fun( int *p) { return *p; } fun函数返回值是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "不确定的值", "一个整数", "形参p中存放的值", "形参p的地址值" ], "explanation": "函数fun的返回类型声明为int，因此返回值是一个整数。形参p是一个整型指针，*p表示取指针p所指向的整型变量的值，该值作为int类型返回。" }, { "id": 340, "q": "以下程序的输出结果是（）\nint a=4;\nint f(int n){\nint t=0;\nint a=5;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<3;i++) s+=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "C", "kp": "函数", "o": [ "27", "28", "39", "40" ], "explanation": "全局变量a=4，main中s初始为4。i=0调用f(0)，执行else，局部a=7，t=7，返回t+a++即12，s=16；i=1调用f(1)，执行if，局部a=6，t=6，返回t+a++即11，s=27；i=2调用f(2)，执行else，局部a=7，t=7，返回t+a++即12，s=39。最终输出39。" }, { "id": 341, "q": "对于递归程序，以下不正确的叙述是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "函数的递归调用是指函数直接或间接调用自身", "递归程序容易导致堆栈的溢出", "为了提高程序的执行效率，可采用递归算法", "一般情况下，递归算法可改写成循环算法" ], "explanation": "递归算法虽然代码简洁，但由于每次调用都需要在栈中分配空间保存现场，会导致较大的时间和空间开销，执行效率通常低于等价的循环算法。因此\"为了提高执行效率采用递归\"的叙述是错误的。" }, { "id": 342, "q": "以下程序段运行的结果是（　　）。\nmain()\n{ int p[9]={1,3,5,6,7,8,9,10},i=0,k=0;\nwhile(i<8&&p[i]%2)\n{k=k+p[i];\ni++; }\nprintf(\"%d\\n\",k); }", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "9", "25", "44", "24" ], "explanation": "循环条件是i<8且p[i]为奇数。i=0时p[0]=1，k=1；i=1时p[1]=3，k=4；i=2时p[2]=5，k=9；i=3时p[3]=6，6%2为0，条件为假退出循环。最终k的值为9。" }, { "id": 343, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{2,3,6},{2,7,9},{3,5,10},{1}};\nprintf(\"%d%d%d%d\\n\",a[0][3],a[1][2],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "0951", "0950", "095", "0651" ], "explanation": "二维数组未初始化的元素自动补0。a[0]初始化为{2,3,6,0}，a[0][3]=0；a[1]为{2,7,9,0}，a[1][2]=9；a[2]为{3,5,10,0}，a[2][1]=5；a[3]为{1,0,0,0}，a[3][0]=1。输出拼接为0951。" }, { "id": 344, "q": "若以下说明,则数值为6的表达式是（　　）。\nint a[12]={1,2,3,4,5,6,7,8,9,10};\nchar c='a';", "t": "single", "ans": "C", "kp": "数组", "o": [ "a[6 ]", "a[4]", "a['f '-c]", "a['f'-'c']" ], "explanation": "c='a'，其ASCII码为97，'f'的ASCII码为102。'f'-c等于5。数组a中下标为5的元素a[5]值为6。选项A的a[6]为7，选项B的a[4]为5，选项D中'f'-'c'等于3，a[3]为4。" }, { "id": 345, "q": "当执行下列程序时，如果输入ab，则输出结果是( )。\nmain()\n{\nchar ss[10]=\"12345\";\ngets(ss);strcat(ss,\"6789\");\nprintf(\"%s\\n\",ss);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "ab6789", "123456789", "ab3456789", "ab345" ], "explanation": "gets函数读取字符串\"ab\"并自动添加结束符'\\0'，覆盖原数组前三个字符，此时ss内容为\"ab\"。随后strcat函数将\"6789\"拼接到\"ab\"之后，最终输出\"ab6789\"。" }, { "id": 346, "q": "运行下列程序段时,若输入数据为321,则输出结果是（）。\nint num,i,j,k,s;\nscanf(\"%d\",&num);\nif(num>99) s=3;\nelse if(num>9) s=2;\nelse s=1;\ni=num/100;\nj=(num-i*100)/10;\nk=(num-i*100-j*10);\nswitch(s)\n{case 3:printf(\"%d%d%d\\n\",k,j,i);break;\ncase 2:printf(\"%d%d\\n\",k,j);\ncase 1:printf(\"%d\\n\",k);\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "213", "123", "132", "312" ], "explanation": "输入321，满足num>99，故s=3。计算得i=3，j=2，k=1。switch语句匹配case 3，按格式\"%d%d%d\"依次输出k、j、i的值，即123，随后遇到break跳出。" }, { "id": 347, "q": "下面程序运行时，如果从键盘上输入3,5，程序输出的结果是()\nmain( )\n{\nint a,b,*pa,*pb;\npa=&a; pb=&b;\nscanf(\"%d,%d\",pa,pb);\n*pa=a+b;\n*pb=a+b;\nprintf(\"a=%d,b=%d\\n\",a,b);\n}", "t": "single", "ans": "C", "kp": "指针", "o": [ "a=13,b=13", "a=8,b=8", "a=8,b=13", "出错" ], "explanation": "scanf将3和5分别赋给a和b。执行*pa=a+b时，由于pa指向a，相当于a=a+b，此时a变为8。接着执行*pb=a+b，pb指向b，相当于b=a+b，此时a为8，b变为13。" }, { "id": 348, "q": "若有以下定义和语句，数组元素的值是9的表达式（　　）。\nint a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;", "t": "single", "ans": "D", "kp": "指针", "o": [ "*(p+9)", "a[9]", "&(a+8)", "*(p+8)" ], "explanation": "数组a的第9个元素值为9，其下标为8。指针p指向数组首元素，*(p+8)等价于a[8]，值为9。选项A和B访问的是a[9]值为10，选项C语法错误。" }, { "id": 349, "q": "设有以下定义：\n#define N 3\n#define Y(n) ((N+1) *n)\n则执行语句z=2* (N+Y(5+1));后，z的值为（　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "出错", "42", "48", "54" ], "explanation": "宏替换是纯文本替换。Y(5+1)展开为((3+1)*5+1)，计算得21。原式变为z=2*(3+21)，即2*24，最终结果为48。注意宏定义中参数n未加括号导致的运算优先级问题。" }, { "id": 350, "q": "给定程序MODI1.C中，fun函数的功能是：删除b所指数组中小于10的数据。主函数中输出删除后数组中余下的数据。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "第二处错误：题目要求删除b所指数组中小于10的数据，则要对数组中元素判断是否小于10，如果大于或等于10，则将其放入新的数组t中，数组的下标是从0开始的，num的初始值是0，如果将\"++\"作为num的前缀，则表示数组的下标从1开始，所以错误，应将\"++\"作为num的后缀，所以将\"t[++num]=b[i];\"改为\"t[num++]=b[i];\"。\n第三处错误：变量要先定义后使用，而变量nun未定义，根据上下程序，此处应是num，所以\"for(i=0; i=0&&s[i]<=9", "s[i]>='0'&&s[i]<='9'", "d[i]>=0&&d[i]<=9", "d[i]>='0'&&d[i]<='9'" ], "explanation": "要判断字符是否为数字，需比较其ASCII码值是否在'0'到'9'之间。选项B使用了正确的字符常量进行比较；选项A和C误用整数，选项D判断的是目标数组d且逻辑不符。" }, { "id": 355, "q": "有如下程序段：\nint x=12;\ndouble y=3.141593;\nprintf(\"%d%5.3f\", x, y);\n其输出结果是", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "12 3.141", "12, 3.141", "123.142", "123.141" ], "explanation": "printf中%d输出整数12；%5.3f指定输出浮点数总宽度为5，保留3位小数，3.141593四舍五入为3.142，刚好占5个字符宽度。两者连续输出，中间无空格，结果为123.142。" }, { "id": 356, "q": "若a是数值类型，则逻辑表达式(a==1)||(a!=1)的值是( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "0", "2", "不知道a的值，不能确定" ], "explanation": "逻辑或运算符\"||\"两侧的条件互为对立事件。无论a为何值，a等于1或不等于1必有一个成立，因此该逻辑表达式的结果恒为真，在C语言中真值用1表示。" }, { "id": 357, "q": "以下选项中，能用作用户标识符的是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "_0_", "8_8", "void", "unsigned" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头，也不能是关键字。选项B以数字开头，选项C和D均为C语言保留关键字，只有选项A符合命名规则。" }, { "id": 358, "q": "如果c为字符型变量， 判断c是否为空格(ASCII是32)不能使用()。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "if(c==' 32' )", "if(c==32)", "if(c==' \\40' )", "if(c==' ' )" ], "explanation": "判断字符是否为空格，可直接与空格字符' '比较，或与其ASCII码值32比较，也可用八进制转义字符'\\40'。选项A中的' 32'不是合法的单字符常量表示法，无法正确判断。" }, { "id": 359, "q": "已定义以下函数，该函数的返回值是（ ）。\nfun(int *p)\n{ return *p; }", "t": "single", "ans": "C", "kp": "指针", "o": [ "不确定的值", "形参p中存放的值", "形参p所指存储单元中的值", "形参p的地址值" ], "explanation": "函数形参p是一个整型指针，接收传入的地址。return *p 表示对指针p进行解引用，返回的是p所指向的内存单元中存储的具体数值，而非地址或指针本身的值。" }, { "id": 360, "q": "给定程序MODI1.C中函数fun的功能是：根据以下公式求值，并作为函数值返回。\n例如，给指定精度的变量eps输入0.0005时，应当输出Pi=3.140578。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "本程序的fun函数中定义了 公式中的项变量t与求和变量s。变量t用于存放 公式中各项的值，变量s用于存放 公式中各项值的和。由于 公式的第一项的值为1，且在while循环中，首先做的是求和操作\"s+=t;\"，此时，只有t的值为1，s的值才为第一项的值，下面求t的表达式\"t=t*n/(2*n+1);\"的值才为第二项的值，所以t的初始值应为1，即第一处应改为\"t=1;\"。\n由于s是用于存放 公式中各项值和的变量，且题面要求的是 的值，所以返回函数值时不是返回s，而是返回2*s，即 的值，所以第二处应改为\"return(2*s);\"。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 361, "q": "计算机能直接执行的程序是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "源程序", "目标程序", "编译程序", "可执行程序" ], "explanation": "源程序需经过编译和链接生成可执行程序（如.exe文件）后，才能被计算机硬件直接识别和执行。目标程序是编译后的中间文件，编译程序则是用于翻译源代码的系统软件。" }, { "id": 362, "q": "以下不合法的数值常量是（　　）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "1e1", "011", "0xabcd", "8.0E0.5" ], "explanation": "C语言中科学计数法（指数形式）的E或e后面必须紧跟整数，不能是小数。选项D中E后面是0.5，因此不合法。选项A是合法的科学计数法，B是合法的八进制整数，C是合法的十六进制整数。" }, { "id": 363, "q": "有以下定义语句，编译时会出现编译错误的是()。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "char ch='\\0';", "char ch=65;", "char ch='a';", "char ch='079';" ], "explanation": "C语言中单引号内只能包含一个普通字符或一个转义字符。选项D的'079'包含了三个字符，且若将其视为八进制转义序列，八进制数字中不能包含9，因此会导致编译错误。其余选项均为合法的单字符或转义字符赋值。" }, { "id": 364, "q": "下面程序运行结果为（）。\nint a=2，b=-1, c=2;\nif(ab)\nSWAP(a,b);\nprintf(\"a=%d,b=%d\\n\",a,b);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "a=0,b=5", "a=5,b=6", "a=6,b=5", "a=5,b=0" ], "explanation": "if(a>b)后无大括号，仅控制紧随其后的一条语句。宏SWAP展开为三条语句：t=b;b=a;a=t;。因5>6为假，跳过t=b;，但b=a;和a=t;仍执行。此时t初值为0，故b被赋为5，a被赋为0。这体现了宏定义多条语句不加do-while或大括号的缺陷。" }, { "id": 373, "q": "给定程序modi1.c中，函数fun的功能是：统计字符串中各元音字母（即：A、E、I、O、U）的个数。注意：字母不分大、小写。\n例如：若输入：THIs is a boot，则输出应该是：1、0、2、2、0。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "从本题的要求看，如果某一个元音字母没有在字符串中出现时，程序应返回0。主函数中num[5]代表一块C编译器随机分配的内存地址，在没有对这块内存地址初始化之前，这块内存中存放着随机的数据，也有可能是1，2...等数字，因此在fun函数开始应对num数组进行初始化。fun函数的第一个for循环中，k才是循环变量，而i只是一个常量，因此\"num[i]=0;\"应改为\"num[k]=0;\"或相同作用的语句。\n另外，s代表的只是一个字符串的指针，把它直接当一个数据看待是没有意义的，应该把\"switch( s )\"语句改为\"switch( *s )\"语句。\n本评析仅供参考。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 374, "q": "请编写函数fun，其功能是：计算并输出下列多项式的值：\n例如，在主函数中从键盘给n输入8后，输出为：s=0.662872。\n注意：要求n的值大于1但不大于100。\n部分源程序在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun(int n)\n{ int i;\ndouble sum=0.0; /*定义sum为双精度型变量，并给其赋初值为0.0*/\nif (n>1&&n<=100)\n{for(i=1;i<=n;i++)\nsum+=1.0/(2*i-1)-1.0/(2*i); /*计算出1.0/(2*i-1)-1.0/(2*i)相应的每一个多项式的值，同时累加到变量sum中*/\n}\nreturn sum; /*返回计算结果*/\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 375, "q": "若输入1、2，以下程序的运行结果是（　　）。\n#define SWAP(a,b） t=b;b=a;a=t\nmain()\n{ int a,b,t=0;\nscanf(\"%d,%d\",&a,&b）;\nif (a>b）\nSWAP(a,b）;\nprintf(\"a=%d,b=%d\\n\",a,b）;\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "a=1,b=1", "a=0,b=1", "a=2,b=1", "a=1,b=2" ], "explanation": "宏定义SWAP(a,b)展开后没有大括号，因此if(a>b)仅控制第一条语句t=b;。输入1和2时，a>b为假，t=b不执行。随后顺序执行b=a;（b变为1）和a=t;（t初值为0，a变为0）。最终输出a=0,b=1。" }, { "id": 376, "q": "以下叙述中正确的是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "C语言的源程序不必通过编译就可以直接运行", "C语言中的每条可执行语句最终都将被转换成二进制的机器指令", "C源程序经编译形成的二进制代码可以直接运行", "C语言中的函数不可以单独进行编译" ], "explanation": "C语言源程序必须经过编译和链接才能生成可执行文件，故A、C错误。C语言中的函数可以单独编译为目标文件，故D错误。C语言的可执行语句在编译后最终都会被转换为计算机能直接执行的二进制机器指令，B选项正确。" }, { "id": 377, "q": "下面是对s的初始化，其中不正确的是( )", "t": "single", "ans": "C", "kp": "字符串", "o": [ "char s[5]={“abc”};", "char s[5]={'a','b','c'}", "char s[5]={a,b,c};", "char s[5]=“abc ”;" ], "explanation": "字符数组初始化时，字符常量必须用单引号括起来。选项C中的a,b,c没有加单引号，会被编译器视为未定义的变量名，导致语法错误。其他选项均使用了正确的字符串字面量或字符常量列表进行初始化。" }, { "id": 378, "q": "若有以下定义和语句:\nint a=010, b=0x10, c=10;\nprintf(\"%d, %d, %d\\n\", a, b, c) ;\n则输出结果是( )", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "10, 10, 10", "8, 16, 10", "8, 10, 10", "8, 8, 10" ], "explanation": "C语言中，以0开头的整数常量表示八进制，010转换为十进制为8；以0x或0X开头的表示十六进制，0x10转换为十进制为16；10为普通的十进制数。printf使用%d按十进制输出，因此结果为8, 16, 10。" }, { "id": 379, "q": "若有定义语句int a=3;double b=3.14;，则表达式a+b的类型是          。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "int", "char", "float", "double" ], "explanation": "在C语言表达式中，当不同类型的操作数进行算术运算时，会发生隐式类型转换。int类型的变量a与double类型的变量b相加时，a会被自动提升为double类型，因此表达式a+b的最终结果类型为double。" }, { "id": 380, "q": "以下选项中，合法的一组C语言数值常量是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "12.0 0Xa23 4.5e0", "028 .5e-3 -0xf", "0.177 4e1.5 0abc", "0x8A 10,000 3.e5" ], "explanation": "选项B中028包含非法八进制数字8；选项C中科学计数法4e1.5的指数部分必须为整数，且0abc不是合法常量；选项D中10,000不能包含逗号。选项A中的十进制浮点数、十六进制整数和科学计数法表示均符合C语言语法规则。" }, { "id": 381, "q": "已知a=5,b=3\ny=a>b?a+b:b*a 则y=", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "1", "0", "15", "8" ], "explanation": "条件运算符?:的优先级低于关系运算符>。首先计算a>b，因为5大于3，条件为真。因此表达式取冒号前的值，即计算a+b。将5和3相加得到8，最终变量y的值为8。" }, { "id": 382, "q": "如有int a=3,b=4,c=5,则表达式y=a>b?2*a:3*c的结果是（）", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "6", "9", "12", "15" ], "explanation": "条件表达式a>b?2*a:3*c首先判断条件a>b。已知a=3，b=4，条件为假。因此表达式取冒号后面的部分进行计算，即3*c。已知c=5，计算3*5得到15，故结果为15。" }, { "id": 383, "q": "下列声明变量错误的是（）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "int case=3.5;", "float pi=3;", "char a='V',b,c='C';", "double k=3.5e3;" ], "explanation": "在C语言中，case是用于switch语句的关键字，属于保留字，不能被用作变量名。因此选项A的声明会导致编译错误。其他选项中的变量名均合法，且赋初值时发生了正确的隐式类型转换。" }, { "id": 384, "q": "以下程序的运行结果是（　　）\nint a=30;\nint f(int c){\nstatic int a=1;\nc=c+1;\nreturn (a++)+(c++);\n}\nmain(){\nint i,k=0;\nfor(i=0;i<1;i++) { int a=5; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "37", "38", "36", "35" ], "explanation": "全局变量a初值为30。main函数中循环执行1次，调用f(5)。在f中，静态局部变量a初值为1，参数c变为6。return (a++)+(c++)返回1+6=7，此时k=7。循环结束后，执行k+=a，此处的a为全局变量30，故k=7+30=37。" }, { "id": 385, "q": "下列程序的执行结果是( )。\n#include\nmain( )\n{ int x=0, y=5,z=0;\nif (x=z=y) x=4;\nprintf(\"%d,%d\\n\",x,z); }", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "0,4", "0,0", "4,0", "4,5" ], "explanation": "赋值表达式x=z=y从右向左结合，先将y的值5赋给z，再将z的值5赋给x。整个表达式的值为5，非零即为真，因此执行if分支中的x=4;。最终x的值变为4，z的值保持为5，输出结果为4,5。" }, { "id": 386, "q": "执行下面程序的输出结果是( ) 。\nint a=5, b=0, c=0;\nif (a=a+b) printf(\"****\\n\") ;\nelse printf(\"####\\n\") ;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "有语法错误不能编译", "能通过编译， 但不能通过连接", "输出 ****", "输出 ####" ], "explanation": "if语句的条件是赋值表达式a=a+b。计算该表达式时，将a+b（即5+0=5）的结果赋给a，整个表达式的值为5。在C语言中，非零值被视为逻辑真，因此程序会执行if分支，输出****。" }, { "id": 387, "q": "若a、b、c1、c2、x、y、均是整型变量，正确的switch语句是( ) 。", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "switch(a+b);\n{case 1:y=a+b; break;\ncase 0:y=a-b; break; }", "switch(a*a+b*b)\n{case 3:\ncase 1:y=a+b; break;\ncase 0:y=a-b; break; }\ncase 3:y=b-a;break;}", "switch a\n{case c1:y=a-b; break;\ncase c2: x=a*d; break;\ndefault:x=a+b;}", "switch(a-b)\n{default:y=a*b;break;\ncase 3:case 4:x=a+b;break;\ncase 10:case 11:y=a-b;break;}" ], "explanation": "switch语句的条件表达式必须用括号括起来，且后面不能加分号，排除A；case标签后的值必须是整型常量表达式，不能是变量，排除C；同一个switch语句中case标签的值不能重复，排除B。D选项语法完全正确，default位置灵活。" }, { "id": 388, "q": "以下程序段的运行结果是()\nint a=0,b=1,c=0,d=20;\nif(a) d=d-10;\nelse if(!b)\nif(!c) d=15;\nelse d=25;\nprintf(\"%d\\n\",d);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "10", "15", "25", "20" ], "explanation": "a为0，if(a)为假，执行else if(!b)。b为1，!b为假，因此else if分支不执行，其内部的if(!c)和else语句也被跳过。变量d的值未被修改，保持初始值20。注意else的就近配对原则，此处的else与if(!c)配对，但整体受限于!b为假。" }, { "id": 389, "q": "下面程序段的运行结果是()\nint x,i;\nfor(i=1;i<=100;i++)\n{x=i;\nif(++x%2==0)\nif(++x%3==0)\nif(++x%7==0)\nprintf(\"%3d\",x);\n}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "39 81", "42 84", "26 68", "28 70" ], "explanation": "循环中x初始为i。第一个if使x自增为i+1，需被2整除；第二个if使x自增为i+2，需被3整除；第三个if使x自增为i+3，需被7整除。即寻找满足i+1被2整除、i+2被3整除、i+3被7整除的i。推导可得i为25和67时满足条件，此时输出的x分别为28和70。" }, { "id": 390, "q": "若变量已正确定义，程序结束后，i的值为（）\ni=0;\ndo\n{ printf(\"%d,\",i); }\nwhile( i-- );", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "1", "0", "无限循环", "-1" ], "explanation": "do-while循环先执行循环体再判断条件。首次执行输出0，接着判断while(i--)。由于i初始为0，i--表达式的值为0（逻辑假），循环终止。但在判断后，i会执行自减操作变为-1。因此循环结束后i的值为-1。" }, { "id": 391, "q": "则程序的输出结果是（）\nint a=-2, b=0;\nwhile(a++) ++b ;\nprintf(\"%d,%d\\n\", a, b);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "0,1", "1,2", "2,3", "1,3" ], "explanation": "while(a++)先判断a的值是否为非零，然后再将a加1。初始a=-2，第一次判断为真，a变-1，b变1；第二次判断为真，a变0，b变2；第三次a为0，判断为假，循环结束，但a仍会自增变为1。最终a为1，b为2。" }, { "id": 392, "q": "以下叙述中正确的是( )", "t": "single", "ans": "A", "kp": "函数", "o": [ "函数名代表该函数的入口地址", "所有函数均不能接受函数名作为实参传入", "函数体中的语句不能出现对自己的调用", "如果函数带有参数，就不能调用自己" ], "explanation": "在C语言中，函数名本身代表该函数的入口地址，可用于函数指针赋值或传参，A正确。函数名可以作为实参传递给形参为函数指针的函数，B错误。函数可以调用自身，这称为递归调用，无论是否带有参数均可进行，C和D错误。" }, { "id": 393, "q": "在一个C源程序文件中所定义的全局变量，其作用域为（ ）", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "由具体定义位置和extern说明来决定范围", "所在程序的全部范围", "所在函数的全部范围", "所在文件的全部范围" ], "explanation": "全局变量的有效作用域默认从定义处开始到本源文件结束。若要在定义之前的位置或其他源文件中使用，需通过extern进行声明以扩展其作用域。因此其作用域由具体定义位置和extern说明共同决定。" }, { "id": 394, "q": "以下程序的运行结果是（　　）\nfun(int x)\n{ if(x/2>0) fun(x/2);\nprintf(\"%d \",x);\n}\nmain()\n{ fun(12); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "1 3 6 12", "1 3 6", "1 3", "1" ], "explanation": "本题考查递归函数的执行过程。fun(12)调用fun(6)，fun(6)调用fun(3)，fun(3)调用fun(1)。当x=1时，x/2为0，递归终止，输出1；随后逐层返回，依次输出3、6、12。因此最终输出结果为1 3 6 12。" }, { "id": 395, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int k[10]={1,1,2,2,4,4,2,1,1,1}, x[5]={0},i;\nfor(i=0;i<10;i++) x[k[i]]++;\nfor(i=1;i<5;i++) printf(\"%d\",x[i]);\nprintf(\"\\n\"); }", "t": "single", "ans": "B", "kp": "数组", "o": [ "1 2 3 4", "5 3 0 2", "0 3 5 0", "1 1 2 2\n1 1 2 2" ], "explanation": "程序通过遍历数组k，将k中元素的值作为数组x的下标，并对x中对应元素进行累加，从而统计k中各数字出现的次数。k中1出现5次，2出现3次，3出现0次，4出现2次。最后循环输出x[1]到x[4]的值，即5302，选项B中的空格为排版示意。" }, { "id": 396, "q": "下面程序段是实现字符串拷贝,即把输入s的字符串拷贝给d数组，请选择填空。\nchar   s[100],d[100]; int  j=0, i=0;\npus(s);\nwhile(s[i]){ d[j]=      ; j++;}\nd[j]=0;", "t": "single", "ans": "B", "kp": "字符串", "o": [ "s[i]", "s[i++]", "s[++i]", "s[i+1]" ], "explanation": "实现字符串拷贝需将源字符串s的字符逐个赋给目标数组d，直到遇到结束符'\\0'。在赋值的同时，源字符串的下标i必须自增以读取下一个字符。s[i++]能先取当前字符赋值，再将i加1，符合逻辑。若用s[i]则i不变导致死循环。" }, { "id": 397, "q": "以下程序的运行结果是（　　）\nmain()\n{\nchar s[]=\"abcdef\";\nstrcpy(s,\"abcdefg\");\ns[4]='\\0';\nprintf(\"%s\\n\",s);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "abcd", "abc", "abcde", "abcdef" ], "explanation": "strcpy将\"abcdefg\"复制到数组s中（虽存在数组越界风险，但按题意s内容被覆盖为\"abcdefg\"）。接着将s[4]赋值为'\\0'，即在字符'd'之后截断字符串。使用%s输出时遇到'\\0'即停止，因此只输出前四个字符\"abcd\"。" }, { "id": 398, "q": "若执行程序时， 从键盘上输入 1234,则输出结果是（）。\nchar c1,c2,c3,c4;\nint n;\nint x;\nc1=c2=c3=c4=0;\nscanf(\"%d\",&x);\nif (x>=1000) n=4;\nelse if (x>=100) n=3;\nelse if (x>=10) n=2;\nelse n=1;\nswitch (n)\n{\ncase 4:c4=x%10+'0';x=x/10;\ncase 3:c3=x%10+'0';x=x/10;\ncase 2:c2=x%10+'0';x=x/10;break;\ncase 1:c1=x%10+'0';\n}\nprintf(\"%c%c%c%c\\n\",c4,c3,c2,c1);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "4", "43", "432", "4321" ], "explanation": "输入1234，x>=1000成立，n=4。进入switch的case 4，c4被赋为'4'，x变为123；因无break语句，程序向下穿透执行case 3，c3赋为'3'，x变12；继续穿透至case 2，c2赋为'2'，x变1，遇break跳出。c1未赋值保持为'\\0'。输出时'\\0'不可见，故显示432。" }, { "id": 399, "q": "若有以下语句:\ndouble a,b , *p1,*p2;\np1=&a, p2=&b;\n则下面正确的输入语句是（ ）", "t": "single", "ans": "B", "kp": "指针", "o": [ "scanf(\"%lf%lf\",&p1,&p2);", "scanf(\"%lf%lf\",p1,p2);", "scanf(\"%lf%lf\",a,b);", "scanf(?°%f%f?±,&a,&b);" ], "explanation": "scanf函数需要传入变量的地址。p1和p2已经是指向a和b的指针，即它们存储了a和b的地址，因此直接传入p1和p2即可。A选项传入的是指针的地址，C选项传入的是值，D选项格式错误且double应使用%lf。" }, { "id": 400, "q": "若有如下定义和语句，则输出结果是()\nchar *a=\"ABCD\"；printf(\"%s\"，a)；", "t": "single", "ans": "D", "kp": "指针", "o": [ "A", "AB", "ABC", "ABCD" ], "explanation": "a是一个字符指针，指向字符串常量'ABCD'的首地址。使用%s格式符输出时，会从该地址开始逐个输出字符，直到遇到字符串结束符'\\0'为止，因此输出完整的字符串ABCD。" }, { "id": 401, "q": "以下程序中的for循环执行的次数是（　　）。\n#define N 4\n#define M N+1\n#define NUM 2*(M+1)\n#main()\n{ int i;\nfor(i=1;i<=NUM;i++)\nprintf(\"%d\\n\",i);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "12", "17", "16", "15" ], "explanation": "宏替换是纯文本替换。NUM展开为2*(N+1+1)，进一步展开为2*(4+1+1)，计算结果为12。循环条件为i<=12，i从1递增到12，共执行12次。注意宏定义展开时没有额外的括号保护，但此题中计算结果确为12。" }, { "id": 402, "q": "给定程序modi1.c中，函数fun的功能是：将十进制正整数m转换成k(2≤k≤9)进制数，并按位输出。\n例如，若输入8和2，则应输出1000（即十进制数8转换成二进制表示是1000）。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "k进制数有以下特点：\n1.有0到k-1共k个数码。\n2.逢k进1，借1当k。\nk进制数某一位上的数码实际上代表该数码乘上该位上的权，如十进制数12，1实际代表1*10。原程序给出的fun函数中，第一个for循环用来将十进制的整型数据m转换为k进制数据，并将结果按从低位到高位的顺序保存在数组aa中。在for循环之后，i即为转换成的k进制数的位数，所以根据题义要求，第一处应改为\"aa[i]=m%k;\"或相同作用的语句。\n第二个错误处为：从后往前打印存有i个数的数组中的值，其下标应该为[i-1]到[0]。所以\"printf( \"%d\", aa[i] );\"应当改为\" printf( \"%d\", aa[i-1] );\"。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 403, "q": "请编写函数void fun(int *dp,int n,int upordown)，其功能是，找出dp所指数组中的最小或最大值，并与其第1个元素交换。形参n为元素的个数，形参upordown为查找标志：值为0时找最小值；值为1时找最大值。\n注意：部分源程序在文件PROG1.C中。请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入所编写的若干语句。", "t": "fill", "ans": "void fun (int *dp,int n,int upordown)\n{\nint i,dorx;\ndorx=0;\nif(upordown==0)\n{for(i=1;idp[i]) dorx=i;}\nelse\n{ for(i=1;i0) c=0;\nelse c+=1;\nprintf(\"%d\\n\",c) ;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "题目代码if(a0)存在语法错误，疑似OCR识别遗漏。若按答案C（输出2）反推，c的值未发生改变，说明条件语句未被执行。例如原题可能为嵌套if语句if(aa", "*p>a[0]", "*p>*a[0]", "*p[0]>*a[0]" ], "explanation": "指针p遍历数组a，*p表示当前遍历到的元素。要将最大值放入a[0]，需将当前元素*p与当前最大值a[0]比较。若*p>a[0]，则将*p赋值给a[0]（即*a）。因此条件应为*p>a[0]。选项C和D语法错误，a[0]是整型值不能解引用。" }, { "id": 411, "q": "C语言程序的模块化通过以下（　　）选项来实现。", "t": "single", "ans": "C", "kp": "函数", "o": [ "变量", "程序行", "函数", "语句" ], "explanation": "C语言是结构化程序设计语言，其程序模块化的基本单位是函数。通过将复杂问题分解为多个功能独立的函数，可以实现代码的模块化，提高程序的可读性和可维护性。" }, { "id": 412, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "A", "kp": "输入输出", "o": [ "赋值语句是一种执行语句，必须放在函数的可执行部分。", "scanf和printf是C语言提供的输入和输出语句。", "由printf输出的数据都隐含居中对齐。", "由printf输出的数据的实际精度是由格式控制中的域宽和小数的域宽来完全决定的。" ], "explanation": "在C语言中，赋值表达式加上分号构成赋值语句，属于执行语句，必须放在函数体的可执行部分，A正确。scanf和printf是标准库函数，而非C语言内置语句，B错误。printf输出默认右对齐，C错误。实际精度还受数据类型本身精度的限制，D错误。" }, { "id": 413, "q": "以下程序的运行结果是（　　）\nmain()\n{ char cf[3][5]={\"AAAA\",\"BBB\",\"CC\"};\nprintf(\"\\\"%s\\\"\\n\",cf[2]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "\"CC\"", "\"BBBCC\"", "\"BBCC\"", "\"AAAABBBCC\"" ], "explanation": "cf是二维字符数组，cf[2]表示第三行字符串CC。printf格式控制中的转义字符输出双引号，%s输出字符串内容，因此最终输出带双引号的CC。" }, { "id": 414, "q": "\"\\n\"在内存中占()个字节.", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "0", "1", "2", "无法确定" ], "explanation": "题目中的\"\\n\"是字符串常量，包含换行符和字符串结束标志\\0，共占2个字节。若为字符常量'\\n'则占1个字节。" }, { "id": 415, "q": "若有定义语句int a=10;double b=3.14;，则表达式a='A'+a+b值的类型是          。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "int", "char", "float", "double" ], "explanation": "赋值表达式的类型由左操作数决定。虽然'A'+a+b计算结果为double类型，但赋值给int型变量a时发生隐式转换，整个赋值表达式的值为int类型。" }, { "id": 416, "q": "设有定义： int k=0; 以下选项的四个表达式中与其他三个表达式的值不相同的是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "k++", "k+=1", "++k", "k+1" ], "explanation": "初始k=0。A选项k++是后缀自增，表达式值为自增前的值0；B、C、D选项的表达式值均为1。因此A选项的值与其他三个不同。" }, { "id": 417, "q": "以下程序的运行结果是(小数点后只写一位) （　　）。\ndouble d;\nfloat f;\nlong l;\nint i;\ni=f=l=d=20/3.0;\nprintf(\"%d %ld %f %lf \\n\", i,l,f,d);", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "6 6 6.0 6.0", "6 6 6.7 6.7", "6 6 6.0 6.7", "6 6 6.7 6.0" ], "explanation": "20/3.0结果为6.666...。赋值从右向左，d为6.666...，l截断为6，f为6.0，i截断为6。按选项保留一位小数的简化表示，对应6 6 6.0 6.7。" }, { "id": 418, "q": "若x,y,z的值分别为2,1,3， 程序的输出结果为（）\nif(yn&&m!=0) ;", "if(m>n) m++\nelse n--;", "if(m<0) {;}\nelse n++;" ], "explanation": "C选项中if语句的m++后缺少分号，导致else无法正确匹配，产生语法编译错误。其他选项语法均正确。" }, { "id": 420, "q": "若有定义float x=1.5;int a=1,b=3,c=2;，则正确的switch语句是()。", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "switch(x)\n{\ncase 1.0:printf(\"*\\n\");\ncase 2.0:printf(\"**\\n\");\n}", "switch((int)x);\n{\ncase 1:printf(\"*\\n\");\ncase 2:printf(\"**\\n\");\n}", "switch(a+b)\n{case 1:printf(\"*\\n\");\ncase 2+1:printf(\"**\\n\");\n}", "switch(a+b)\n{case 1:printf(\"*\\n\");\ncase c:printf(\"**\\n\");}" ], "explanation": "switch后的表达式必须是整型或字符型，A错；switch后不能加分号，B错；case后必须是常量表达式，不能是变量，D错。C选项语法正确。" }, { "id": 421, "q": "以下程序运行完后s的值是（ ）。\nmain(){\nint n ;\nfloat s=1.0;\nfor(n=10;n>1;n--)\ns=s+1/ n;\nprintf(\"%6.1f\",s);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1.0", "2.0", "3.0", "10.0" ], "explanation": "循环中1/n为两个整数相除，当n>1时结果恒为0。因此s的值始终为初始值1.0，不会发生改变。" }, { "id": 422, "q": "以下程序段运行后的输出结果是()\nint i,s=1,m=0;\nfor(i=1;i<=2;i++)\n{s=s*11%1000;\ndo {m+=s%10;s=s/10;}while(s);\n}\nprintf(\"m=%d\\n\",m);", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "3", "0", "2", "1" ], "explanation": "i=1时，s=11，内层循环提取个位和十位，m=1+1=2，s变为0。i=2时，s=0*11%1000=0，内层循环m+=0，s=0，m仍为2。最终输出m=2。" }, { "id": 423, "q": "以下程序的运行结果是（　　）。\nmain(){　\nint k=2,n=0;\nwhile(k>0) {\nswitch(k) {\ndefault: break;\ncase 1: n+=k;break;\ncase 0: n--;\n}\nk--;}\nprintf(\"%d\\n\",n);}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "0", "4", "2", "1" ], "explanation": "k=2时，执行default后break跳出switch，k减为1；k=1时，执行case 1，n=n+k=1，break跳出，k减为0；k=0时退出循环。输出1。" }, { "id": 424, "q": "在C语言的函数中，( )", "t": "single", "ans": "C", "kp": "函数", "o": [ "必须有形参", "形参必须是变量名", "可以有也可以没有形参", "数组名不能作形参" ], "explanation": "C语言中，函数的形参是可选的，可以有也可以没有。没有形参的函数在定义和调用时括号内为空或使用void。数组名可以作为形参。" }, { "id": 425, "q": "有以下程序运行后的输出结果是( ) 。\nint fun(int x,int y)\n{ if(x==y) return(x);\nelse return((x+y)/2); }\nmain()\n{ int a=4,b=5,c=6;\nprintf(\"%d\\n\",fun(2*a,fun(b,c）)); }", "t": "single", "ans": "B", "kp": "函数", "o": [ "3", "6", "8", "12" ], "explanation": "先计算内层函数fun(b,c)即fun(5,6)，因5!=6，返回(5+6)/2=5。再计算外层fun(2*a, 5)即fun(8,5)，因8!=5，返回(8+5)/2=6。注意整数除法向下取整。" }, { "id": 426, "q": "如果在同一个源文件中，全局变量与局部变量同名，正确的是（）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "全局变量的作用范围是整个源文件", "全局变量只在main（）范围内有效", "在同名局部变量的作用范围内，全局变量被\"屏蔽\"", "全局变量在同名局部变量的作用范围内仍然起作用" ], "explanation": "在C语言中，如果全局变量与局部变量同名，在局部变量的作用域内，全局变量会被局部变量\"屏蔽\"而不起作用。全局变量的作用域是从定义处到文件末尾，但在同名局部变量作用域内不可见。" }, { "id": 427, "q": "以下只有在使用时才为该类型变量分配内存的存储类说明是( ) 。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "auto和 static", "auto和 register", "register和 static", "extern和 register" ], "explanation": "auto和register变量是局部变量，只有在进入其作用域（如函数调用）时才分配内存，离开时释放。static和extern变量在程序编译或链接时就分配了固定的内存空间，贯穿程序整个运行期。" }, { "id": 428, "q": "以下程序的运行结果是（　　）\nint fun(int a,int b)\n{ if(b==0) return a;\nelse return(fun(--a,--b));\n}\nmain()\n{ printf(\"%d\\n\", fun(4,3));}", "t": "single", "ans": "A", "kp": "函数", "o": [ "1", "2", "3", "4" ], "explanation": "本题考查递归函数。初始调用fun(4,3)，因b不为0，递归调用fun(3,2)；接着调用fun(2,1)，再调用fun(1,0)。当b为0时，满足终止条件，返回a的值1。因此最终输出1。" }, { "id": 429, "q": "以下程序段输出结果是（ ）。\nint i,j;\nint a[4][4]={{2,4,6},{1,3,5},{7,9,11}};\nfor(i=0;i<4;i++)\nprintf(\"%d\",a[i][3-i]);", "t": "single", "ans": "B", "kp": "数组", "o": [ "26511", "0590", "6590", "不能确定" ], "explanation": "二维数组部分初始化时，未赋值的元素自动初始化为0。循环中i从0到3，依次输出a[0][3]、a[1][2]、a[2][1]、a[3][0]。根据初始化列表，a[0][3]为0，a[1][2]为5，a[2][1]为9，a[3][0]为0，故输出0590。" }, { "id": 430, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int b[3][3]={0,1,2,0,1,2,0,1,2},i,j,t=1;\nfor(i=0;i<3;i++)\nfor(j=i;j<=i;j++) t=t+b[i][b[j][j]];\nprintf(\"%d\\n\",t); }", "t": "single", "ans": "D", "kp": "数组", "o": [ "3", "2", "7", "4" ], "explanation": "数组b按行优先初始化。外层循环i从0到2，内层循环j只执行一次（j=i）。当i=0时，t=1+b[0][b[0][0]]=1+b[0][0]=1；当i=1时，t=1+b[1][b[1][1]]=1+b[1][1]=2；当i=2时，t=2+b[2][b[2][2]]=2+b[2][2]=4。最终t为4。" }, { "id": 431, "q": "下面程序的输出结果是()\nint a=2,b=7,c=5;\nswitch(a>0)\n{\ncase 1:switch(b>0)\n{\ncase 1: printf(\"@\"); break;\ncase 0: printf(\"!\"); break;\n}\ncase 0:switch(c==5)\n{\ncase 0: printf(\"*\"); break;\ncase 1: printf(\"#\"); break;\ndefault: printf(\"%%\");break;\n}\ndefault: printf(\"&\");\n}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "@!#%&", "!#&", "@#&", "%%" ], "explanation": "a>0为1，进入外层case 1。b>0为1，内层输出@并break跳出内层switch。由于外层case 1无break，发生穿透，继续执行外层case 0。c==5为1，内层输出#并break跳出。外层case 0无break，继续穿透执行default，输出&。最终结果为@#&。" }, { "id": 432, "q": "有以下程序段运行后的输出结果是( )\nmain()\n{ int a[10]={1,2,3,4,5,6,7,8,9}, *p=a,*q;\np++;\nq=p+2;\nprintf(\"%d\\n\", *p + *q); }", "t": "single", "ans": "D", "kp": "指针", "o": [ "3", "5", "4", "6" ], "explanation": "指针p初始指向数组首元素a[0]。执行p++后，p指向a[1]，其值为2。q=p+2使q指向a[1]之后的第2个元素，即a[3]，其值为4。因此*p + *q的值为2+4=6。" }, { "id": 433, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int a[]={2,4,6,8,10,12,14,16};\nint y=1,x, *p;\np=&a[1];\nfor(x=0;x<4;x++)\ny+=* (p+x);\nprintf(\"%d\\n\",y); }", "t": "single", "ans": "A", "kp": "指针", "o": [ "29", "25", "31", "19" ], "explanation": "指针p指向a[1]（值为4）。循环执行4次，x从0到3，依次将*(p+x)累加到y中。即y = 1 + a[1] + a[2] + a[3] + a[4] = 1 + 4 + 6 + 8 + 10 = 29。" }, { "id": 434, "q": "#define MAX(x,y) (x)>(y)? (x): (y)\nmain()\n{ int a=8,b=7,c=3,d=3,t;\nt=MAX(a+b,c+d) *10;\nprintf(\"%d\\n\",t);\n}", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "6", "60", "150", "15" ], "explanation": "宏替换是纯文本替换。MAX(a+b,c+d)*10展开为(a+b)>(c+d)?(a+b):(c+d)*10。由于条件运算符优先级低于算术运算符，但此处条件15>6为真，直接取问号后的值(a+b)即15。若条件为假，才会计算(c+d)*10。" }, { "id": 435, "q": "给定程序modi1.c中 fun 函数的功能是：求出以下分数序列的前 n 项之和。\n和值通过函数值返回 main ( )函数。\n例如，若 n = 5，则应输出： 8.391667。\n请改正函数 fun 中的错误，使它能得出正确的结果。\n注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "首先，我们必须先读懂题中程序的大致意思，这是发现并改正程序中错误的重要前提。\n程序中的重要思想如下：\n1、函数fun()的作用是得到分数序列的前 n 项之和；\n2、由于公式中运用了除法，所以公式的最终值必须使用double型，以保持最终值的精确性。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 436, "q": "给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位相反的顺序组成一个新的数，并作为函数值返回。\n例如，输入一个整数：27638496，函数返回值为：64862。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 437, "q": "有以下程序段：\nint k=0；\nwhile(k==1) k++;\nwhile 循环执行的次数是（　　）。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "无限次", "有语法错误，不能执行", "1次也不执行", "执行1次" ], "explanation": "while循环的执行条件是括号内的表达式为真（非0）。初始时k=0，判断条件k==1的结果为假（0），因此循环体一次也不会执行，直接跳过循环。" }, { "id": 438, "q": "执行下列程序段后，变量w和*p的值是()\nint b[ ]={2，3，5，9，11，13}，*p=b；\nw=++(*++p)；", "t": "single", "ans": "D", "kp": "指针", "o": [ "3和3", "4和3", "3和4", "4和4" ], "explanation": "p初始指向b[0]。++p使p指向b[1]（原值为3）。*++p取出b[1]的值，外层++将其自增为4，并赋值给w。因此w的值为4，此时p仍指向b[1]，*p的值也为4。注意++和*的结合性从右向左。" }, { "id": 439, "q": "给定程序中，函数fun的功能是：判断形参s所指字符串是否是\"回文\"（Palindrome），若是，函数返回值为1；不是，函数返回值为0。\"回文\"是正读和反读都一样的字符串（不区分大小写字母）。\n例如，LEVEL和Level是\"回文\"，而LEVLEV不是\"回文\"。\n请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本程序将字符串从前向后与从后向前的字母依次比较，在满足各比较字母相等，且比较到或超过字符串长度的二分之一的情况下，说明此字符串是回文。toupper函数的作用是把字符串中所有的小写字母都变成大写字母，而非字母的字符则不改变。\n程序首先通过调用fun函数将指针变量s指向用户输入的字符串的首地址。在fun函数中，用指针变量lp依次取得字符串中从前向后的各字母，所以lp应指向字符串的首地址，故第一空填\"s\"。\n指针变量rp依次取得字符串中从后向前的各字母。当满足lp与rp所指向的存储单元的值相等且指针变量lp小于rp的情况下，lp就继续后移，rp继续前移，所以第二空应填\"--\"。\n如果在lp\nmain()\n{\nint a=2,b=3,c;\nprintf(\" c=%d\\n\",a+b);\n}", "#include\nmain()\n{\nInt a=2,b=3,c\nprintf(\" c=%d\\n\",a+b);\n}", "#include\nmain()\n{\nint a=2,b=3,c;\nprintf(\" c=%d\\n\",a+B);\n}", "#include\nmain()\n{\nint a=2,b=3,c;\nc=a+b;\nprintf(\" c=%d\\n\",d);\n}" ], "explanation": "选项B中Int首字母大写错误，且变量c后缺少分号；选项C中变量B未定义，C语言区分大小写；选项D中变量d未定义。选项A语法正确，包含了头文件、主函数、变量定义及正确的输出语句。" }, { "id": 447, "q": "以下程序的运行结果是（　　）\nint a=30;\nint f(int c){\nstatic int a=1;\nc=c+1;\nreturn (a++)+(c++);\n}\nmain(){\nint i,k=0;\nfor(i=0;i<1;i++) { int a=4; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "D", "kp": "函数", "o": [ "35", "34", "33", "36" ], "explanation": "main函数中，循环执行1次，调用f(4)。在f中，静态局部变量a初值为1，c为4。c=c+1后c为5。返回(a++)+(c++)，即1+5=6，返回后a变为2，c变为6。k累加6。循环结束后，k+=a，此处的a是全局变量30，故k=6+30=36。输出36。" }, { "id": 448, "q": "程序的输出结果是()\nint a, b, c;\na=10; b=50; c=30;\nif (a>b) a=b;b=c;c=a;\nprintf(\"a=%d b=%d c=%d\\n\", a, b, c);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "a=10 b=50 c=30", "a=10 b=30 c=10", "a=10 b=50 c=10", "a=50 b=30 c=50" ], "explanation": "if语句后没有大括号，因此只控制紧随其后的一条语句a=b;。由于a>b(10>50)为假，a=b不执行。接着顺序执行b=c;，b变为30；再执行c=a;，c变为10。最终a=10，b=30，c=10。" }, { "id": 449, "q": "以下程序段的运行结果是()。\nint a=2,b=3,c;\nc=a;\nif(a>b) c=1;\nelse if(a==b) c=0;\nelse c=-1;\nprintf(\"%d\\n\",c);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "2", "1", "-1", "0" ], "explanation": "初始a=2，b=3。判断a>b(2>3)为假，跳过c=1；判断a==b(2==3)为假，跳过c=0；最后执行else分支，c被赋值为-1。因此输出结果为-1。" }, { "id": 450, "q": "若执行下面的程序从键盘上输入6,则输出结果是( )。\nmain( )\n{int x;\nscanf(\"%d\",&x);\nif (x++>5) printf(\"%d\\n\",x);\nelseprintf(\"%d\\n\",x--);}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "7", "6", "5", "4" ], "explanation": "输入x=6。判断条件x++>5，先使用x的值6与5比较，6>5为真，然后x自增变为7。因为条件为真，执行if分支，输出此时x的值，即7。else分支不执行。" }, { "id": 451, "q": "下面程序的输出结果是( ) 。\n#include \nmain( )\n{ int a=2,b=7,c=5;\nswitch(a>0)\n{ case 1:switch(b<0)\n{ case 1: printf(\"@\"); break;\ncase 0: printf(\"!\"); break;\n}\ncase 0:switch(c==5)\n{ case 0: printf(\"*\"); break;\ncase 1: printf(\"#\"); break;\ndefault: printf(\"%%\");break;\n}\ndefault: printf(\"&\");\n} printf(\"\\n\");\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "&", "!#&", "%%", "@*&" ], "explanation": "a>0为真即1，进入外层case 1。内层b<0为假即0，进入内层case 0，输出'!'并break跳出内层switch。由于外层case 1后无break，继续执行外层case 0。c==5为真即1，进入内层case 1，输出'#'并break跳出。外层case 0后无break，继续执行default，输出'&'。最终输出!#&。" }, { "id": 452, "q": "下列程序的执行结果是( )。\nint x=2000,a=15,b=30,c=5,d=0;\nif (a0);\nprintf(\"end\\n\");", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "0 end", "1 end", "3 end", "end" ], "explanation": "i=5时，i%2=1，执行case 1，i减为4并continue跳过if直接判断循环条件；i=4时，i%2=0，执行case 0，i减为3并break跳出switch，满足if(i==3)输出3；后续i变为2、1、0，均不满足i==3，i=0时退出循环输出end。" }, { "id": 454, "q": "有以下程序，执行后输出的结果是( )。\nint i;\nfor(i=0;i<3;i++)\nswitch(i)\n{ case 1: printf(\"%d\",i);\ncase 2: printf(\"%d\",i);\ndefault: printf(\"%d\",i); }", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "011122", "012", "012020", "120" ], "explanation": "switch语句中若没有break，匹配后会穿透执行后续所有case和default。i=0匹配default输出0；i=1匹配case 1，穿透输出111；i=2匹配case 2，穿透输出22。最终结果为011122。" }, { "id": 455, "q": "下面程序段的运行结果是()\nint i;\nfor(i=1;i<=5;i++)\nswitch(i%5)\n{case 0:printf(\"*\");break;\ncase 1:printf(\"#\");break;\ndefault:printf(\",\");break;\ncase 2:printf(\"&\");\n}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "#&,&*", "#&, &,&*", "#, &,&", "#&, ,*" ], "explanation": "i从1到5，i%5分别为1,2,3,4,0。i=1匹配case 1输出#；i=2匹配case 2输出&；i=3和4匹配default输出两个,；i=5时i%5=0匹配case 0输出*。注意default位置不影响匹配规则。结果为#&, ,*。" }, { "id": 456, "q": "程序的输出结果是()\nint i,j;\nfor(i=1;i<3;i++)\n{ for(j=1;j<3;j++)\nprintf(\"%d*%d=%d \",i,j,i*j);}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1*1=1 1*2=2 2*1=2 2*2=4", "1*1=1 1*2=2 2*2=4 2*3=6", "1*1=1 1*2=2 2*2=4", "1*1=1 1*2=2 1*3=3 2*1=2 2*2=4 2*3=6" ], "explanation": "外层循环i从1到2，内层循环j从1到2。i=1时，j依次为1、2，输出1*1=1和1*2=2；i=2时，j依次为1、2，输出2*1=2和2*2=4。各输出项之间有空格，最终结果为1*1=1 1*2=2 2*1=2 2*2=4。" }, { "id": 457, "q": "执行以下程序的输出结果是( )\nmain()\n{\nint n=10;\nwhile(n++<10) printf(\"%d\\n\",n);\nprintf(\"%d\",n--);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "11", "10", "9", "8" ], "explanation": "while条件n++<10中，n++是先取值后自增。初始n=10，10<10为假，循环不执行，此时n自增为11。接着执行printf(\"%d\",n--)，n--是先输出后自减，因此输出11，之后n变为10。" }, { "id": 458, "q": "采用单步调试时，在函数调用时要求跟踪进入函数内部，需要按（）键", "t": "single", "ans": "D", "kp": "综合编程/调试改错", "o": [ "F5", "F10", "F9", "F11" ], "explanation": "在IDE单步调试中，F11（Step Into）用于跟踪进入函数内部执行；F10（Step Over）用于单步跳过函数调用；F5用于继续运行；F9用于设置或取消断点。因此进入函数内部需按F11。" }, { "id": 459, "q": "12．以下程序的运行结果是（ ）。\nfun(int a, int b)\n{ if(a>b) return(a);\nelse return(b); }\nmain()\n{ int x=3, y=8, z=6, r;\nr=fun(fun(x,y), 2*z);\nprintf(\"%d\\n\", r);}", "t": "single", "ans": "D", "kp": "函数", "o": [ "3", "6", "8", "12" ], "explanation": "fun函数的作用是返回两个参数中的较大值。程序先计算内层调用fun(x,y)即fun(3,8)，返回8；再计算2*z即12；最后计算外层调用fun(8,12)，返回较大值12并赋给r，最终输出12。" }, { "id": 460, "q": "a是f函数内定义的静态局部变量，关于a的作用域正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "a的作用域为整个程序", "main( )是a的作用域", "f函数是a的作用域", "ABC都正确" ], "explanation": "静态局部变量（static）的生命周期贯穿整个程序运行期，但其作用域依然局限于定义它的函数内部。函数外部无法直接访问该变量，因此f函数是a的作用域。" }, { "id": 461, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{1,3,6},{2,4,8},{3,5,10}};\nprintf(\"%d%d%d%d\\n\",a[0][3],a[1][2],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "0850", "0650", "0450", "0350" ], "explanation": "二维数组部分初始化时，未显式赋值的元素自动初始化为0。a[0]只有3个元素，a[0][3]为0；a[1][2]为8；a[2][1]为5；a[3]未初始化，a[3][0]为0。按格式输出即为0850。" }, { "id": 462, "q": "若有一维数组int [10]={6,7,8,9,10};则以下描述正确的语句是", "t": "single", "ans": "B", "kp": "数组", "o": [ "将5个初值依次赋给a[1]至a[5 ]", "将5个初值依次赋给a[0]至a[4]", "将5个初值依次赋给a[6]至a[10]", "数组长度与初值的个数不相同,此语句不正确" ], "explanation": "一维数组初始化时，花括号内的初值从下标0开始依次赋给数组元素。提供的5个初值将依次赋给a[0]至a[4]，剩余元素自动初始化为0。数组长度大于初值个数是合法的。" }, { "id": 463, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint i,t[][4]={9,8,7,6,5,4,3,2,1,9};\nfor(i=0;i<3;i++) printf(\"%d\",t[2-i][i]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "147", "148", "149", "146" ], "explanation": "数组t按行优先初始化，共10个元素，推断为3行4列。t[0]为9,8,7,6；t[1]为5,4,3,2；t[2]为1,9,0,0。循环i从0到2，依次输出t[2][0]、t[1][1]、t[0][2]，对应的值分别为1、4、7。" }, { "id": 464, "q": "以下程序的运行结果是（　　）\nmain( )\n{\nchar b[30];\nstrcpy(&b[0],\"BB\");\nstrcpy(&b[1],\"DEF\");\nstrcpy(&b[2],\"ABC\");\nprintf(\"%s \\n\",b);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "BDABC", "BDBB", "BDDEF", "BDAB" ], "explanation": "strcpy函数从指定地址开始覆盖字符串。第一次b变为\"BB\"；第二次从b[1]开始覆盖，b变为\"BDEF\"；第三次从b[2]开始覆盖，b变为\"BDABC\"。最后输出BDABC。" }, { "id": 465, "q": "运行下面程序时， 从键盘输入数据为5,13,2,则输出结果是( )。\nint a,b,c;\nscanf(\"%d,%d,%d\",&a,&b,&c);\nswitch(a)\n{\ncase 1: printf(\"%d\\n\",b+c); break;\ncase 2: printf(\"%d\\n\",b-c); break;\ncase 3: printf(\"%d\\n\",b*c); break;\ncase 4:\n{\nif(c!=0) {printf(\"%d\\n\",b/c);break;}\nelse {printf(\"error\\n\");break;}\n}\ndefualt: break;\n}", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "15", "11", "26", "无输出" ], "explanation": "输入数据后，a的值为5。在switch语句中，没有匹配case 5的分支，且default分支（题目中拼写为defualt，按题意视为default）仅包含break语句，因此程序不执行任何输出操作，直接结束。" }, { "id": 466, "q": "有以下函数\nint fun(char *x, char *y) {\nint n=0;\nwhile ( (*x==*y) && *x!='\\0' ) {\nx++; y++; n++;}\nreturn n ; }\n函数的功能是（ ）", "t": "single", "ans": "B", "kp": "字符串", "o": [ "查找x和y所指字符串中是否有'\\0'", "统计x和y所指字符串中最前面连续相同的字符个数", "将y所指字符串赋给x所指存储空间", "统计x和y所指字符串中相同的字符个数" ], "explanation": "函数通过while循环逐个比较指针x和y所指的字符。当字符相同且未到字符串末尾时，指针后移并累加计数器n。因此，该函数的功能是统计两个字符串从开头起连续相同字符的个数。" }, { "id": 467, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int a[]={2,4,6,8,10,12,14,16};\nint y=1,x, *p;\np=&a[1];\nfor(x=1;x<4;x++)\ny+=* (p+x);\nprintf(\"%d\\n\",y); }", "t": "single", "ans": "A", "kp": "指针", "o": [ "25", "19", "31", "13" ], "explanation": "指针p指向数组a的第2个元素a[1]（值为4）。循环中x从1到3，依次将*(p+1)、*(p+2)、*(p+3)累加到y中，即累加a[2]、a[3]、a[4]的值（6、8、10）。初始y=1，最终y=1+6+8+10=25。" }, { "id": 468, "q": "以下程序段的运行结果是( )\n#define N 9\n#define M1 N+1\n#define M2 M1*2\nmain()\n{ printf(\"%d\\n\",M2); }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "11", "20", "9", "10" ], "explanation": "宏替换是简单的文本替换。M2展开为M1*2，进一步展开为N+1*2，最终替换为9+1*2。根据运算符优先级，先计算乘法1*2=2，再计算加法9+2=11。" }, { "id": 469, "q": "有以下程序\n#include \n#define S(x) 4*(x)*x+1\nvoid main()\n{\nint k=5,j=2;\nprintf(\"%d\\n\",S(k+j));\n}\n程序运行后的输出结果是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "197", "143", "33", "28" ], "explanation": "带参宏替换时，直接将实参文本代入。S(k+j)展开为4*(k+j)*k+j+1。代入k=5, j=2，表达式变为4*(5+2)*5+2+1。计算括号得4*7*5+3，即140+3=143。注意宏定义中第二个x没有括号。" }, { "id": 470, "q": "函数fun的功能是：根据所给的年、月、日，计算出该日是这一年的第几天，并作为函数值返回。其中函数 isleap用来判别某一年是否为闰年。例如，若输入：2008 5 1，则程序输出：2008年5月1日是该年的第122天。\n请在程序的下划线处填入正确的内容，并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "fun函数中调用了isleap函数，而isleap函数是int型函数，返回值应该为leap，这样才能构成fun函数中if语句的判断条件，所以第一空应填leap。计算天数时的方法是，首先计算当前月的前面几个月的天数总和，再计算到当前月的当前天的天数总和，所以第二空应填day。随后进行判断，如果是闰年的话2月总天数为29天，所以当前月大于2月时，总天数需加1，第三空应填1。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 471, "q": "给定程序BLANK1.C中，函数fun的功能是：根据所给的一组学生的成绩，计算出平均成绩，并计算低于平均成绩的学生的平均成绩作为函数值返回。\n例如：如有成绩为：50,60,70,80,90,100,55,65,75,85,95,99，则运行结果应为：62.500000\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "填空1：变量i是循环变量，它的取值范围是所有的数据，目的是求和，然后求平均。变量avg从字面看是平均值，但在下一行中有除以n，因此在这里是求和，故应该填写x[i]。\n填空2：求出平均值，即总和除以个数，故应该填写avg。\n填空3：求小于平均值的数的总和，故应该填写sum。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 472, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"12123234222\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "2621", "2222", "2521", "2721" ], "explanation": "程序遍历字符串s，利用switch语句将字符'1'到'4'分别映射为数组v的下标0到3，并对对应元素进行计数。字符串中'1'有2个，'2'有6个，'3'有2个，'4'有1个，因此数组v的值依次为2、6、2、1，最终输出2621。" }, { "id": 473, "q": "以下程序的运行结果是（　　）\n#include\nint a=9;\nfun(int b)\n{ int a=10;\na+=b++;\nprintf(\"%d \",++a); }\nmain()\n{ int c=23;\nfun(c);\na+=c++;\nprintf(\"%d\\n\",a++);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "34 32", "33 32", "32 32", "34 34" ], "explanation": "调用fun(c)时，传入23。fun内局部变量a初值为10，执行a+=b++后a变为33，输出++a即34。返回main函数后，全局变量a初值为9，执行a+=c++后a变为32，输出a++即32，随后a自增为33。因此输出为34 32。" }, { "id": 474, "q": "已有变量定义和函数调用语句：int a=25; print_value(&a); 下面函数的正确输出结果是()\nvoid print_value(int *x)\n{\nprintf(\"%d\\n\",++*x);\n}", "t": "single", "ans": "D", "kp": "指针", "o": [ "23", "24", "25", "26" ], "explanation": "函数print_value接收变量a的地址。表达式++*x中，解引用运算符*和前置自增运算符++优先级相同且右结合，等价于++(*x)。因此将指针x所指的变量a的值加1，由25变为26并输出。" }, { "id": 475, "q": "给定程序modi1.c中，函数fun的功能是：求三个数的最小公倍数。\n例如，给变量x1、x2、x3分别输入15 11 2，则输出结果应当是：330。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 476, "q": "当执行下列程序时，如果输入abcde，则输出结果是( )。\nmain()\n{\nchar ss[10]=\"12345\";\ngets(ss);strcat(ss,\"6789\");\nprintf(\"%s\\n\",ss);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "abcde6789", "abcde678", "abcde", "6789" ], "explanation": "gets函数读取输入\"abcde\"并覆盖ss原有内容，ss变为\"abcde\"。随后strcat函数将字符串\"6789\"追加到ss末尾，拼接后ss的内容为\"abcde6789\"。数组长度为10，刚好容纳该字符串及结束符，最终输出拼接结果。" }, { "id": 477, "q": "有以下程序\nmain()\n{\nint a=666,b=888;\nprintf(\"%d\\n\",a,b);\n}\n程序运行后的输出结果是（）", "t": "single", "ans": "B", "kp": "输入输出", "o": [ "错误信息", "666", "888", "666,888" ], "explanation": "printf函数的格式控制字符串中只有一个格式说明符\"%d\"，因此只会输出对应的第一个变量a的值666。第二个变量b由于没有对应的格式说明符，会被直接忽略，不会产生错误信息。" }, { "id": 478, "q": "以下选项中合法的实型常量是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0x1.5", "3.1415e3", "35", "'a'" ], "explanation": "实型常量包括十进制小数形式和指数形式。选项B是合法的指数形式实型常量；选项A在早期C标准中不合法；选项C是整型常量；选项D是字符常量。因此选B。" }, { "id": 479, "q": "以下程序段的输出结果是()。\nint a=8,b=6,m=1;\nswitch(a%4)\n{case 0:m++;break;\ncase 1:m++;\nswitch(b%3)\n{default: m++;\ncase 0:m++; break;\n}\n}\nprintf(\"%d\\n\",m);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "1", "5", "2", "3" ], "explanation": "a%4结果为0，匹配case 0，执行m++后m变为2，遇到break跳出switch语句。因此最终输出m的值为2。" }, { "id": 480, "q": "有以下程序段\nmain()\n{\nint x[] = {10, 20, 30};\nint *px = x;\nprintf(\"%d,\",*px ++);\nprintf(\"%d,\", *px);\npx = x;\nprintf(\"%d,\", (*px)++);\nprintf(\"%d,\", *px);\npx = x;\nprintf(\"%d,\", *px++);\nprintf(\"%d,\", *px);\npx = x;\nprintf(\"%d,\", *++px);\nprintf(\"%d\\n\", *px);\n} 程序运行后的输出结果是( )", "t": "single", "ans": "A", "kp": "指针", "o": [ "10,20,10,11,11,20,20,20", "20,10,11,10,11,10,11,10", "11,11,11,12,12,13,20,20", "20,10,11,20,11,12,20,20" ], "explanation": "*px++先取值后指针后移，输出10、20；(*px)++先取值后元素自增，输出10、11；再次*px++输出11、20；*++px先指针后移再取值，输出20、20。需注意指针自增与所指元素自增的优先级和结合性。" }, { "id": 481, "q": "若有定义：\nint a,b;\n通过语句\nscanf(\"%d;%d\",&a,&b);\n能把整数3赋给变量a，5赋给变量b的输入数据是", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "3 5", "3,5", "3;5", "35" ], "explanation": "scanf函数中，格式控制字符串里的普通字符（如分号）必须在输入时原样匹配。因此输入两个整数时，中间必须用分号隔开，即输入\"3;5\"才能正确赋值。" }, { "id": 482, "q": "以下程序段运行后的输出结果是（ ）。\n{ char s[20]=\"BDbc47eDf56Fg89xyw\";\nint i,n=0;\nfor(i=0;s[i]!='\\0';i++)\nif(s[i]>=48&&s[i]<=57 )\nn++;\nprintf(\"°%d\",n);\n}", "t": "single", "ans": "D", "kp": "字符串", "o": [ "2", "4", "8", "6" ], "explanation": "条件s[i]>=48&&s[i]<=57等价于判断字符是否为数字字符'0'到'9'。遍历字符串，其中的数字字符有4、7、5、6、8、9，共计6个，因此n的最终值为6。" }, { "id": 483, "q": "以下不能输出小写字符a的选项是", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "printf(\"%c\\n\",97);", "printf(\"%c\\n\",'a');", "printf(\"%d\\n\",'a');", "printf(\"%c\\n\",'A'+32);" ], "explanation": "选项A、B、D均使用%c格式符，分别通过ASCII码值97、字符常量'a'和大写字母转换输出小写字母a。选项C使用%d格式符，会将字符'a'的ASCII码值97作为整数输出，无法输出字符a。" }, { "id": 484, "q": "下列关系表达式中，结果为\"假\"的是", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "3 <= 4", "(3 < 4) == 1", "(3 + 4) > 6", "(3 != 4) > 2" ], "explanation": "关系表达式结果为真时值为1，假为0。选项A、C显然为真；选项B中3<4为真即1，1==1也为真；选项D中3!=4为真即1，接着判断1>2，结果为假（0）。" }, { "id": 485, "q": "以下选项中合法的常量是（）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "3.5e", "6 6 6", "123E0.2", "0Xa" ], "explanation": "选项A指数部分缺失；选项B包含空格，不是单一常量；选项C科学计数法的指数部分必须为整数，不能是小数；选项D是合法的十六进制整型常量，表示十进制的10。" }, { "id": 486, "q": "下列不合法的标识符是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "scanf", "printf", "67a", "_hy" ], "explanation": "C语言规定标识符只能由字母、数字和下划线组成，且第一个字符必须是字母或下划线。选项C以数字开头，违反了标识符的命名规则，因此是不合法的。" }, { "id": 487, "q": "以下程序的执行后输出a的值为\n#include\nmain()\n{\nint a,b;\na=b+1;\nb=30;\nprintf(“%d”,a);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "31", "30", "随机值", "出错" ], "explanation": "局部变量b在定义后未赋初值就直接参与a=b+1的运算，此时b的值是内存中的随机垃圾值，因此计算得到的a也是随机值。后续对b的赋值不影响已计算的a。" }, { "id": 488, "q": "下列不正确的字符串是", "t": "single", "ans": "C", "kp": "字符串", "o": [ "“中国\"", "\"*****\"", "'how'", "\"how\"" ], "explanation": "C语言中字符串常量必须用双引号括起来。选项C使用了单引号，单引号用于定义字符常量，且标准C中字符常量只能包含单个字符，因此'how'是不正确的字符串表示。" }, { "id": 489, "q": "以下程序的运行结果是（　　）\nint a=21;\nint f(int c){\nstatic int a=4;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "38", "18", "28", "48" ], "explanation": "函数f中的a是静态局部变量，保留上次修改的值。第一次调用f(3)，c为4，返回4+4=8，a变5；第二次调用返回5+4=9，a变6，此时k=17。循环结束后，k+=a中的a是全局变量21，故k=17+21=38。" }, { "id": 490, "q": "程序的输出结果是().\nint a=1,b=2,c=3,d=4;\nif ((a=2)&&(b=1)) c=2;\nif ((c==3) &&(d=-1)) a=5;\nprintf(\"%d,%d,%d,%d\\n\", a,b,c,d);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "2,1,2,4", "2,2,2,4", "5,2,2,-1", "5,1,2,-1" ], "explanation": "第一个if中，a=2和b=1均为赋值表达式且结果非零，条件为真，执行c=2。第二个if中，c==3为假，触发逻辑与的短路特性，d=-1不被执行，a=5也不执行。最终输出2,1,2,4。" }, { "id": 491, "q": "执行下面程序后，x的值为（）。\nint a=0,b=0,c=0,x=3;\nif (a) x=0;\nelse if (b)x=2;\nelse if (!c==1) x=1;", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "考察if-else if结构和逻辑非运算。a和b均为0，条件为假。!c即!0结果为1，1==1为真，故执行x=1。" }, { "id": 492, "q": "在下面的条件语句中（其中S1和S2表示C语言语句），只有一个在功能上与其他三个语句不等价( ) 。", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "if (a) S1; else S2;", "if (a==0) S2; else S1;", "if (a!=0) S1; else S2;", "if(a==0) S1; else S2;" ], "explanation": "考察条件语句的等价性。A、B、C均在a非0时执行S1，a为0时执行S2。D选项在a为0时执行S1，非0时执行S2，逻辑与其他三项相反。" }, { "id": 493, "q": "若 int i=10; 执行下列程序后， 变量 i 的正确结果是() 。\nswitch(i)\n{\ncase 9: i+=1;\ncase 10: i+=1;\ncase 11: i+=1;\ndefault: i+=1;\n}", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "10", "11", "12", "13" ], "explanation": "考察switch语句的穿透特性。i初值为10，匹配case 10，执行i+=1后i变为11。由于没有break语句，程序会继续向下穿透执行case 11和default中的语句，i依次变为12和13。" }, { "id": 494, "q": "以下程序段的运行结果是()\nint a=0,b=1,c=0,d=20;\nif(a==1) d=d-10;\nelse if(b)\nif(!c) d=15;\nelse d=25;\nprintf(\"%d\\n\",d);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "25", "15", "10", "20" ], "explanation": "考察if-else嵌套与悬空else原则。a==1为假，进入else if(b)，b为1条件成立。接着判断内层if(!c)，c为0故!c为真，执行d=15。else d=25与内层if配对，不执行。" }, { "id": 495, "q": "以下程序运行完后的结果是（ ）。\nmain()\n{\nint k;\nfor (k=1;k<5;k++)\n{\nif(k%2!=0)\nprintf(\"#\");\nelse\nprintf(\"*\") ;\n}\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "#*#*", "*#*#", "#*", "#*#*#*" ], "explanation": "考察for循环与条件判断。k从1循环到4。当k为奇数（1和3）时，k%2!=0成立，输出#；当k为偶数（2和4）时，条件不成立，输出*。最终结果为#*#*。" }, { "id": 496, "q": "执行以下程序段时\nx=-1;\ndo\n{ x=x*x; }\nwhile(x--);\n则下面描述正确的是( )", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "循环体将执行两次", "循环体将执行无限次", "循环体将执行一次", "系统将提示有语法错误" ], "explanation": "考察do-while循环与后缀自减运算。首次循环x=-1，执行后x=1；判断条件x--，表达式的值为1（真），x变为0。第二次循环x=0，执行后x=0；判断条件x--，表达式的值为0（假），x变为-1，循环结束。共执行两次。" }, { "id": 497, "q": "下面程序段的运行结果是()\nint i;\nfor(i=1;i<=5;i++)\n{if(i%2) printf(\"*\");\nelse continue;\nprintf(\"#\");\n}\nprintf(\"$\\n\");", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "*#*#*#$", "#*#*#*$", "*#*#$", "#*#*$" ], "explanation": "考察for循环与continue语句。i为奇数时，i%2为真，输出*并继续执行输出#；i为偶数时，i%2为假，执行continue跳过本次循环剩余的#输出。最后循环结束输出$。" }, { "id": 498, "q": "下面程序段的运行结果是()\nint i,j,x=0;\nfor(i=0;i<2;i++)\n{x++;\nfor(j=0;j<=3;j++)\n{if(j%2) continue;\nx++;\n}\nx++;\n}\nprintf(\"x=%d\\n\",x);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "x=4", "x=8", "x=6", "x=12" ], "explanation": "考察嵌套循环与continue。外层循环执行2次。每次外层循环中，第一个x++和最后一个x++各执行1次，共2次，2次循环计4次。内层循环j从0到3，当j为偶数（0和2）时执行x++，每次外层循环内层x++执行2次，2次循环计4次。总计x=8。" }, { "id": 499, "q": "以下程序运行后sum的值是（　　）。\nmain(){\nint i=1 ,sum=0;\nwhile(i<6) {sum+=i;i--;}\nprintf(\"%d\\n\",sum);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "15", "死循环", "不确定", "1" ], "explanation": "考察while循环条件与变量更新。i初值为1，满足i<6。循环体内sum累加i后，i执行自减操作，导致i的值不断减小，永远无法满足i>=6的退出条件，从而形成死循环。" }, { "id": 500, "q": "若已定义的函数有返回值，则以下关于该函数调用的叙述中错误的是( ) 。", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数调用可以作为独立的语句存在", "函数调用可作为一个函数的实参", "函数调用可以出现在表达式中", "函数调用可作为一个函数的形参" ], "explanation": "考察函数调用的语法位置。有返回值的函数调用可作为独立语句、表达式的一部分或作为其他函数的实参。但形参是在函数定义时声明的变量，用于接收实参的值，不能是函数调用。" }, { "id": 501, "q": "以下程序的运行结果是（　　）\nfun(int a, int b){\nif(a>b) return(a);\nelse return(b);\n}\nmain(){\nint x=3, y=18, z=16, r;\nr=fun(fun(x,y), z);\nprintf(\"%d\\n\", r);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "18", "16", "14", "8" ], "explanation": "考察函数嵌套调用。fun函数的功能是返回两个参数中的较大值。首先计算内层调用fun(x,y)即fun(3,18)，返回18；然后计算外层调用fun(18,z)即fun(18,16)，返回18。最终r的值为18。" }, { "id": 502, "q": "以下程序的输出结果是（）\nint a=40;\nint f(int n){\nint t=0;\nint a=7;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<2;i++) s=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "13", "14", "53", "54" ], "explanation": "考察变量作用域与自增运算。f函数内定义了局部变量a=7。当i=0时，n=0，执行else块，块内a=7，t=7，返回t+f内的a++即7+7=14；当i=1时，n=1，执行if块，块内a=6，t=6，返回t+f内的a++即6+7=13。最终s被赋值为13。" }, { "id": 503, "q": "以下程序的执行过程中fun（）函数共调用了（）次 。\nfun(int x)\n{  if(x/3>0) fun(x/3);\n   printf(\"%d*\",x); }\nmain()\n{  fun(9); }", "t": "single", "ans": "B", "kp": "函数", "o": [ "4", "3", "2", "1" ], "explanation": "main函数调用fun(9)为第1次。在fun(9)中，9/3=3>0，调用fun(3)为第2次。在fun(3)中，3/3=1>0，调用fun(1)为第3次。在fun(1)中，1/3=0不大于0，不再递归调用。因此fun函数共被调用了3次。" }, { "id": 504, "q": "有如下程序输出结果是（）\n#include\nlong fib(int n)\n{ if(n>3) return(fib(n-1)+fib(n-2));\nelse return(3); }\nmain()\n{ printf(\"%d\\n\",fib(6)); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "15", "12", "9", "6" ], "explanation": "根据递归函数定义，当n<=3时返回3。计算fib(6)：fib(6)=fib(5)+fib(4)；fib(5)=fib(4)+fib(3)；fib(4)=fib(3)+fib(2)。已知fib(3)=3，fib(2)=3，则fib(4)=3+3=6，fib(5)=6+3=9，最终fib(6)=9+6=15。" }, { "id": 505, "q": "以下程序的运行结果是（　）。\nmain( )\n{ int n[5]={0,0,0},i,k=2;\nfor(i=0;i=0;i--) a[i]=9-i;\nprintf(\"%d%d%d\",a[0],a[1],a[2]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "987", "789", "123", "012" ], "explanation": "循环变量i从9递减到0，依次给数组元素赋值。根据表达式a[i]=9-i，可得a[0]=9-0=9，a[1]=9-1=8，a[2]=9-2=7。printf语句按顺序输出a[0]、a[1]、a[2]的值，结果为987。" }, { "id": 508, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=0;i<2;i++) s+=a[i][0]+a[1][3-i-1];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "16", "15", "17", "18" ], "explanation": "循环变量i从0遍历到1。当i=0时，s累加a[0][0]和a[1][2]，即1+8=9；当i=1时，s累加a[1][0]和a[1][1]，即3+4=7。两次循环结束后，s的总和为9+7=16。" }, { "id": 509, "q": "以下程序的运行结果是（ ）\nvoid f(char p[][10], int n )\n{ char t[10];\nint i,j;\nfor(i=0;i0)\n{strcpy(t,p[i]); strcpy(p[i],p[j]); strcpy(p[j],t); }\n}\nmain( )\n{ char p[5][10]={\"abc\",\"aabdfg\",\"abbd\",\"dcdbe\",\"cd\"};\nf(p,5);\nprintf(\"%d\\n\",strlen(p[0]));}", "t": "single", "ans": "B", "kp": "字符串", "o": [ "2", "6", "4", "3" ], "explanation": "函数f通过双重循环和strcmp对字符串数组进行字典序升序排序。初始字符串中字典序最小的是'aabdfg'，排序后它会被交换到p[0]的位置。strlen函数计算'aabdfg'的长度，结果为6。" }, { "id": 510, "q": "输入一个学生的C语言考试成绩，如果成绩少于60分，则输出failed!；如果成绩大于等于60，且小于80，则输出middle!；如果成绩大于等于80分，则输出excellent!。程序中空格应填的正确表达式是（ ）。\nmain()\n{float cj;scanf(\"%f\",&cj);\nif(cj<60)\nprintf(\"failed!\\n\");\nelse if(_________)\nprintf(\"middle!\\n\");\nelse if (cj>=80)\nprintf(\"excellent!\\n\");}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "cj>='60'&&cj<='80'", "cj>='60'||cj<='80'", "cj>=60&&cj<=80", "cj>=60||cj<=80" ], "explanation": "题目要求成绩大于等于60且小于80时输出middle!。选项A和B使用了字符常量'60'，存在语法错误；选项D使用了逻辑或，不符合区间限制。选项C使用逻辑与正确表达了区间范围，是最符合题意的选项。" }, { "id": 511, "q": "设有如下程序的输出结果是:\n#include\nmain()\n{ int **k, *j, i=100;\nj=&i; k=&j;\nprintf(\"%d\\n\", **k); }", "t": "single", "ans": "B", "kp": "指针", "o": [ "运行错误", "100", "i的地址", "j的地址" ], "explanation": "变量j是指向整型变量i的一级指针，k是指向指针j的二级指针。因此，*k等价于j，**k等价于*j，即解引用后得到变量i的值。由于i被初始化为100，所以输出结果为100。" }, { "id": 512, "q": "若有以下定义和语句，则输出结果是（　　）\nint a[10]={2,4,6,8,10,12,14,16,18,20},*p=a;\npritnf(\"%d\",*(p+5)+a[2]);", "t": "single", "ans": "A", "kp": "指针", "o": [ "18", "16", "14", "12" ], "explanation": "指针p指向数组a的首地址。表达式*(p+5)等价于a[5]，其值为12；a[2]的值为6。两者相加得到12+6=18。题目代码中pritnf为拼写错误，但不影响对表达式结果的逻辑推导。" }, { "id": 513, "q": "以下定义中错误的是( )。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "#define _abc 30", "#define pi 3.1415", "#define num 1000;", "#define name clinton" ], "explanation": "C语言中宏定义#define的语法格式为\"#define 标识符 字符串\"，末尾不需要加分号。如果加上分号，分号会被作为替换文本的一部分，在宏展开时极易引发语法错误。因此选项C的定义是错误的。" }, { "id": 514, "q": "#define MUL(x,y) x*y\nmain( )\n{ int a=8，b=9，c；\nc=MUL(a++,b++);\nprintf(\"%d \\n\"，c)； }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "72", "90", "8", "9" ], "explanation": "宏定义MUL(x,y)展开时直接替换，c=MUL(a++,b++)被替换为c=a++*b++。计算时先取a和b的当前值相乘，即8*9=72，赋值给c，随后a和b再各自自增。因此c的最终值为72。" }, { "id": 515, "q": "给定程序modi1.c中，函数fun的功能是：由形参给定n个实数，输出平均值，并统计在平均值以上（含平均值）的实数个数。\n例如，n=8时，若8个实数为：193.199、195.673、195.757、196.051、196.092、196.596、196.579、196.763\n所得平均值为：195.838750，在平均值以上的实数个数应为：5\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 516, "q": "函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是：将a中的十位和个位数依次放在变量c的百位和个位上，b中的十位和个位数依次放在变量c的千位和十位上。\n例如，当a=45,b=12。调用该函数后，c=1425。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int a, int b, long *c)\n{\nint a_up,a_low,b_up,b_low;\na_up=a/10; /*求正整数a的十位数*/\na_low=a%10; /*求正整数a的个位数*/\nb_up=b/10; /*求正整数b的十位数*/\nb_low=b%10; /*求正整数b的个位数*/\n*c=b_up*1000+a_up*100+b_low*10+a_low; /*将a数的十位和个位数依次放在c数的百位和个位上，b数的十位和个位数依次放在c数的千位和十位上*/\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 517, "q": "用C语言编写的代码程序( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "可立即执行", "是一个源程序", "经过编译即可执行", "经过解释即可执行" ], "explanation": "C语言是编译型语言，编写的代码属于源程序。源程序必须经过编译和链接生成可执行文件后才能运行，不能立即执行，也不通过解释执行。" }, { "id": 518, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"11122233444\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "3323", "3324", "3321", "3320" ], "explanation": "程序遍历字符串，通过switch语句将字符'1'到'4'映射为数组下标0到3，并统计各字符出现次数。字符串中'1'有3个，'2'有3个，'3'有2个，'4'有3个，故数组v的元素依次为3、3、2、3，输出3323。" }, { "id": 519, "q": "ch是一个char型变量,值为'R',则下列表达式的值为().\nch=(ch>='A'&&ch<='N')?ch+32:ch-1", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "R", "Q", "r", "q" ], "explanation": "变量ch初值为'R'。判断条件中'R'的ASCII码大于'N'，导致逻辑与表达式为假。因此执行冒号后的表达式ch-1，即'R'的ASCII码减1，结果为字符'Q'。" }, { "id": 520, "q": "如下程序段执行后，x的值为( )。\nint a=14,b=15,x;\nchar c='A';\nx=(a&&b）&&(c<'B');", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "ture", "false", "0", "1" ], "explanation": "a和b均为非零值，a&&b结果为1。字符'A'的ASCII码小于'B'，c<'B'结果为1。最终1&&1的值为1。C语言中逻辑真用整数1表示，没有布尔关键字。" }, { "id": 521, "q": "以下正确的常量是( )", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "12E5.5", "082", "X56", "'A'" ], "explanation": "A选项科学计数法指数部分必须为整数；B选项八进制数不能包含数字8；C选项十六进制数必须以0x或0X开头；D选项是合法的字符常量。" }, { "id": 522, "q": "下列合法的标识符是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "5type", "-kx", "_arry", "while" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且首字符不能是数字，也不能是关键字。A以数字开头，B包含非法字符减号，D是保留关键字，只有C合法。" }, { "id": 523, "q": "设 ch 是 char 型变量, 值为' B' , 则表达式ch=(ch>=' a' && ch<=' z' ) ?ch-32:ch 的值是()", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "Z", "B", "z", "b" ], "explanation": "变量ch值为'B'，其ASCII码不在小写字母'a'到'z'的范围内，条件表达式判断为假。因此执行冒号后的表达式ch，变量值保持不变，仍为'B'。" }, { "id": 524, "q": "不能正确表示数学式的ab/c表达式是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "a*b/c", "a/c*b", "a/b*c", "a*(b/c)" ], "explanation": "数学式ab/c表示a乘b的积除以c。在C语言中，若变量为整型，a/b*c会先计算a/b导致整除截断丢失精度，无法正确表示原数学式。应先乘后除或使用浮点数。" }, { "id": 525, "q": "以下对变量的定义正确的是（ ）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "int 2c;", "int x=y=z=0;", "int x=0,y=0,z=0;", "int x=0;y=0;z=0;" ], "explanation": "A选项标识符不能以数字开头；B选项连续赋值在变量定义时不合法；D选项使用分号分隔会导致语法错误，应为多条声明语句。C选项使用逗号分隔并分别初始化，语法完全正确。" }, { "id": 526, "q": "以下程序的运行结果是（　　）\nint a=1;\nint f(int c){\nstatic int a=4;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "18", "16", "17", "19" ], "explanation": "全局变量a为1。函数f中静态变量a初值为4。第一次调用f(3)，c为4，返回4+4=8，静态a变为5；第二次调用f(3)，c为4，返回5+4=9，静态a变为6。k累加得17。最后k加上全局变量a的值1，结果为18。" }, { "id": 527, "q": "以下不正确的if语句形式是（）", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "if (x>y&&x!=y);", "if (x==y) x+=y;", "if x!=y\nscanf(\"%d\",&x)\nelse\nscanf(\"%d\",&y);", "if(xb) t=s+t;\nelse if(a==b) t=5;\nelse t=2*s;\nprintf(\"%d,%d\",s,t);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "1,2", "2,1", "1,1", "2,2" ], "explanation": "已知a=5，b=2。判断条件a>b成立，执行t=s+t，即t=1+1=2。变量s未被修改，保持初值1。最终输出s和t的值，结果为1,2。" }, { "id": 529, "q": "若执行以下程序段时从键盘上输入10，则输出结果是( ) 。\nint n;\nscanf(\"%d\",&n);\nif(++n <10)\nprintf(\"%d\\n\",--n);\nelse\nprintf(\"%d\\n\", n--);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "11", "10", "9", "8" ], "explanation": "输入10赋给n。if条件中++n使n变为11，11<10为假，执行else分支。printf中n--为后缀自减，先使用n的当前值11进行输出，之后n再减1变为10。因此输出结果为11。" }, { "id": 530, "q": "以下选项中与 if(a==1)a=b; else a++; 语句功能不同的switch语句是()", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "switch(a= =1) {case 0:a=b;break; case 1:a++; }", "switch(a) {case 1:a=b;break; default : a++; }", "switch(a) {default:a++;break; case 1:a=b; }", "switch(a= =1) {case 1:a=b;break; case 0:a++; }" ], "explanation": "原语句表示当a等于1时执行a=b，否则执行a++。选项A中switch的条件表达式为a==1，当a等于1时表达式值为1，会执行case 1分支即a++，与原语句逻辑正好相反。其他选项均能实现原语句功能。" }, { "id": 531, "q": "以下程序的结果是（）。\nint a=1,b=2,c=3;\nif(ab;) a=b; b=c; c=a;\nprintf(\"a=%d b=%d c=%d\",a,b,c);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "a=50 b=30 c=50", "a=10 b=50 c=30", "a=60 b=30 c=10", "a=50 b=30 c=60" ], "explanation": "for循环若未使用花括号，其循环体仅为紧随其后的一条语句。本题中循环体只有a=b;。因初始a=50，b=60，条件a>b为假，循环不执行。随后顺序执行b=c;使b变为30，c=a;使c变为50。最终输出a=50 b=30 c=50。" }, { "id": 534, "q": "若i为整型变量，则以下循环执行的次数是（　　）。\ni=1;\nwhile(i=0) printf(\"%d\",i--);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "无限次", "0次", "1次", "2次" ], "explanation": "while循环的条件表达式为赋值表达式i=0，而非关系表达式i==0。执行该表达式会将0赋给i，且整个表达式的值为0，即逻辑假。因此循环条件一开始就不成立，循环体执行0次。" }, { "id": 535, "q": "下面程序段()\nfor(t=1;t<=100;t++)\n{ scanf(\"%d\",&x);\nif(x<0) continue;\nprintf(\"%3d\",t);\n}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "当x<0时整个循环结束", "x>=0时什么也不输出", "printf函数永远也不执行", "最多允许输出100个非负整数" ], "explanation": "当输入x<0时，continue语句会跳过本次循环中剩余的printf语句，直接进入下一次循环，因此不会输出。只有当x>=0时才会执行printf输出t的值。循环总共执行100次，故最多允许输出100个非负整数对应的序号。" }, { "id": 536, "q": "有以下程序段:\nint i,j;\nfor(i=1;i<4;i++)\n{\nfor(j=i;j<4;j++) printf(\"%d*%d=%d \",i,j,i*j);\nprintf(\"\\n\");\n}\n程序运行后的输出结果是 ()", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1*1=1 1*2=2 1*3=3\n2*2=4 2*3=6\n3*3=9", "1*1=1 1*2=2 1*3=3\n2*1=2 2*2=4\n3*1=3", "1*1=1\n1*2=2 2*2=4\n1*3=3 2*3=6 3*3=9", "1*1=1\n2*1=2 2*2=4\n3*1=3 3*2=6 3*3=9" ], "explanation": "外层循环i从1到3，内层循环j从i到3。当i=1时，j依次为1、2、3，输出1*1=1 1*2=2 1*3=3并换行；i=2时，j为2、3，输出2*2=4 2*3=6并换行；i=3时，j为3，输出3*3=9并换行。选项A的输出顺序与程序逻辑完全一致。" }, { "id": 537, "q": "以下程序的输出结果是( )。\nmain( )\n{ int a=-1,b=1;\nwhile((++a<0)&&!(b--<=0))\nprintf(\"%d %d \",a,b);\nprintf(\"%d %d \",a,b);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "-1 1", "0 1", "1 0", "0 1 0 1" ], "explanation": "初始a=-1，b=1。while条件中先计算++a，a变为0，0<0为假。由于逻辑与&&的短路特性，右侧的!(b--<=0)不再执行，b的值保持为1不变。循环条件为假，直接跳出循环，执行循环外的printf，输出0 1。" }, { "id": 538, "q": "有关函数名的叙述正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "可以不符合标识符的命名规则", "可以与关键字相同", "函数名应符合标识符的命名规则", "函数名必须是小写" ], "explanation": "在C语言中，函数名属于用户自定义标识符，必须严格遵守标识符的命名规则，即由字母、数字和下划线组成，且不能以数字开头，也不能与C语言的关键字同名。函数名并非必须全小写，可包含大写字母。" }, { "id": 539, "q": "以下程序的运行结果是（　　）\nfun(int a, int b){\na=b;\nb=a;\nreturn a;\n}\nmain(){\nint x=23, y=18, z=16, r;\nr=fun(fun(x,y), z);\nprintf(\"%d\\n\", r);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "16", "18", "23", "61" ], "explanation": "函数fun的功能是将形参b的值赋给a，然后返回a的值，即返回第二个参数的值。第一次调用fun(x,y)即fun(23,18)，返回18；第二次调用fun(18,z)即fun(18,16)，返回16。最终r被赋值为16并输出。" }, { "id": 540, "q": "在C语言中，只有在使用时才占用内存单元的变量，其存储类型是( )", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "extern和register", "auto和static", "static和register", "auto和register" ], "explanation": "auto（自动变量）和register（寄存器变量）属于局部变量，只有在程序执行到其定义的作用域时才分配内存或寄存器单元，离开作用域即释放。而static和extern变量在程序编译或链接时就分配固定的内存单元，贯穿整个运行过程。" }, { "id": 541, "q": "有关静态变量的说法，正确的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "静态变量前面不能有static", "静态变量存放在自由空间区", "静态变量不能与动态变量同名", "静态变量是在编译时分配内存空间的" ], "explanation": "静态变量使用static关键字声明，故A错。静态变量存储在全局或静态存储区，而非自由空间（堆区），故B错。局部静态变量与动态变量作用域不同，可以同名，故C错。静态变量在编译阶段分配内存，并在程序运行期间一直存在，D正确。" }, { "id": 542, "q": "若有以下程序\nvoid f(int x)\n{\nif (x >= 10)\n{\nprintf(\"%d-\", x%10);\nf(x/10); }\nelse printf(\"%d\", x); }\nmain() {\nint z = 123456;\nf(z); }\n则程序的输出结果是( )", "t": "single", "ans": "A", "kp": "函数", "o": [ "6-5-4-3-2-1", "6-5-4-3-2-1-", "1-2-3-4-5-6", "1-2-3-4-5-6-" ], "explanation": "函数f先判断x>=10，若成立则打印x%10并带连字符，然后递归调用f(x/10)。对于123456，依次打印6-、5-、4-、3-、2-，最后x=1时不满足条件，执行else打印1。因此输出为6-5-4-3-2-1。选项A正确。" }, { "id": 543, "q": "以下程序段的输出结果是（ ）\nint add(int a[ ])\n{ int s;\na[1]=a[1]+1; a[3]=a[3]+2; s=a[1]+a[3];\nreturn s;}\nmain( )\n{ int s1,s2, a[6]={1,2,3,5,7,8};\ns1=add(a);\ns2=a[1]+a[3];\nprintf(“%d,%d,%d”,a[1],s2,s1);}", "t": "single", "ans": "D", "kp": "数组", "o": [ "2,510", "2,7,10", "2,5,7", "3,10,10" ], "explanation": "数组名作函数参数传递的是地址，函数内对数组元素的修改会影响原数组。初始a[1]=2，a[3]=5。调用add(a)后，a[1]变为3，a[3]变为7，返回值s1为10。回到main函数，s2=a[1]+a[3]即3+7=10。最后打印a[1]、s2、s1，结果为3,10,10。选项D正确。" }, { "id": 544, "q": "若有定义int x[3][4];，以下选项中对数组a的数组元素正确引用的是（　　）。", "t": "single", "ans": "D", "kp": "数组", "o": [ "x[0][4]", "x[3][4]", "x[3][1]", "x[1==2][1<3]" ], "explanation": "二维数组x[3][4]的行下标范围是0~2，列下标范围是0~3。A选项列下标4越界；B选项行、列下标均越界；C选项行下标3越界。D选项中，关系表达式1==2值为0，1<3值为1，等价于引用x[0][1]，在合法范围内，故D正确。" }, { "id": 545, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=1+i;\nprintf(\"%d%d%d\",a[0],a[4],a[6]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "157", "751", "257", "752" ], "explanation": "循环从i=9递减到0，每次执行a[i]=1+i。因此a[0]=1，a[4]=5，a[6]=7。printf按顺序输出a[0]、a[4]、a[6]的值，中间无分隔符，结果为157。选项A正确。" }, { "id": 546, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int s[ ]={0,1,2,0,0,1,2,1,1,2,1,2},c[3]={0},i;\nfor(i=0;i<12;i++) c[s[i]]++;\nfor(i=0;i<3;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\"); }", "t": "single", "ans": "B", "kp": "数组", "o": [ "5 4 3", "3 5 4", "3 4 5", "4 3 5" ], "explanation": "数组s中包含3个0，5个1，4个2。循环c[s[i]]++的作用是统计s中各数字出现的次数，并存入数组c对应下标中。因此c[0]=3，c[1]=5，c[2]=4。最后循环打印c[0]到c[2]，输出3 5 4。选项B正确。" }, { "id": 547, "q": "当执行下列程序时，如果输入123，则输出结果是( )。\nmain()\n{\nchar ss[10]=\"12345\";\ngets(ss);strcat(ss,\"6789\");\nprintf(\"%s\\n\",ss);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "1236789", "1234567", "123456789", "126789" ], "explanation": "gets(ss)读取输入的123并覆盖原字符串，此时ss内容为123。strcat函数将6789追加到ss末尾，拼接后ss变为1236789。最后通过printf输出该字符串。选项A正确。" }, { "id": 548, "q": "上面程序片段的输出结果是().\nk=-3;\nif k<=0 printf(\"####\");\nelseprintf(\"&&&&\");", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "####", "&&&&", "####&&&&", "有语法错误，无输出结果" ], "explanation": "C语言中if语句的条件表达式必须用圆括号括起来。题目中if k<=0缺少括号，正确写法应为if (k<=0)。此外，else和printf之间应有空格。因此该程序片段存在语法错误，无法编译运行，无输出结果。选项D正确。" }, { "id": 549, "q": "有以下程序\n#include\nmain( )\n{ int n,*p=NULL;\n*p=&n;\nprintf(\"Input n:\"); scanf(\"%d\",&p); printf(\"output n：\");\nprintf(\"%d\\n\",p);\n}\n该程序试图通过指针p为变量n读入数据并输出，但程序有多处错误，以下语句正确的是（ ）", "t": "single", "ans": "A", "kp": "指针", "o": [ "int n,*p=NULL;", "*p=&n;", "scanf(\"%d\",&p)", "printf(\"%d\\n\",p);" ], "explanation": "A选项定义整型变量n和空指针p，语法正确。B选项*p=&n错误，应将n的地址赋给指针p，即p=&n。C选项scanf(\"%d\",&p)错误，p本身是指针，应写为scanf(\"%d\",p)。D选项应输出p指向的值即*p。故只有A正确。" }, { "id": 550, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int a[]={2,4,6,8,10,12,14,16};\nint y=1,x, *p;\np=a;\nfor(x=0;x<4;x++)\ny+=* (p+x);\nprintf(\"%d\\n\",y); }", "t": "single", "ans": "D", "kp": "指针", "o": [ "19", "15", "13", "21" ], "explanation": "指针p指向数组a首地址。循环执行4次，x从0到3，依次将a[0]到a[3]的值累加到y中。即y = 1 + a[0] + a[1] + a[2] + a[3] = 1 + 2 + 4 + 6 + 8 = 21。最后输出y的值21。选项D正确。" }, { "id": 551, "q": "以下叙述中错误的是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "预处理命令行的最后不能以分号表示结束。", "C程序对预处理命令行的处理是在程序执行的过程中进行的。", "#define MAX 100 是合法的宏定义命令行", "在程序中凡是以“#”开始的语句行都是预处理命令行。" ], "explanation": "C语言的预处理命令是在编译之前的预处理阶段进行处理的，而不是在程序执行过程中进行，故B选项错误。预处理命令行不以分号结尾，A正确；#define是合法的宏定义，C正确；以#开头的行均为预处理命令，D正确。" }, { "id": 552, "q": "有以下程序\n#include \n#define SUB( X, Y ) (X+1)*Y\nmain()\n{\nint a=3, b=4;\nprintf(\"%d\\n\",SUB(a++ ,b++ ));\n}\n程序运行后的输出结果是( )。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "20", "12", "16", "25" ], "explanation": "宏替换是纯文本替换。SUB(a++, b++)展开为(a+++1)*b++。计算时，先计算括号内a+++1，此时a为3，表达式值为4，随后a自增为4；接着计算4 * b++，此时b为4，乘积为16，随后b自增为5。因此输出结果为16。选项C正确。" }, { "id": 553, "q": "给定程序MODI1.C中，函数fun的功能是：判断输入的任何一个正整数n，是否等于某个连续正整数序列之和。若是，则输出所有可能的序列。否则输出\"不能分解\"。\n例如：当输入100时，输出：100=9+10+11+12+13+14+15+16\n100=18+19+20+21+22\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "第一处错误：n是输入的整数，m是fun函数中定义的变量，所以进行赋值操作时，应将n的值赋给m，所以\"n = m;\"应改为\"m = n;\"\n第二处错误：C程序中每一条执行语句都必须用分号结束，所以\"c++\"语句末尾应该加上\";\"。\n第三处错误：if语句中对m的值进行判断，当m为0时，即等于某个连续正整数序列之和，则输出所有可能的序列。所以\"if ( m!=0)\"应改为\"if ( m==0)\"。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 554, "q": "给定程序blank1.c中，函数fun的功能是：计算\n的前n项之和。若x=2.5，n=15时，函数值为：1.917914。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "for (i=1;id) x=2;\nelse x=3;\nelse x=6;\nelse x=7;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "1", "2", "3", "6" ], "explanation": "C语言中else总是与最近的未配对if配对。ad为假，因此执行else x=3。最终x的值为3。" }, { "id": 559, "q": "以下叙述中正确的是（ ）", "t": "single", "ans": "C", "kp": "指针", "o": [ "指针变量只能通过求地址运算符（&) 来获得地址值", "语句p=NULL;与p=\\0;是等价的语句", "int* p1; int ** p2; int *p3;都是合法的定义指针变量的语句", "语句p=NULL;执行后，指针p指向地址为0的存储单元" ], "explanation": "指针变量可通过取地址、赋值或函数返回值获取地址，A错；p='\\0'将字符赋给指针，类型不匹配，B错；p=NULL表示指针为空，不指向任何有效存储单元，D错。选项C分别定义了整型指针、二级指针和整型指针，语法均合法，为正确选项。" }, { "id": 560, "q": "以下函数的功能是（）\n#include\nfloat jc(int);//jc函数的功能是计算阶乘\nmain()\n{\nint j,k; float rt;\nscanf(\"%d,%d\",&j,&k);\nrt=( jc(j)- jc(k) )/ jc( k );\nprintf(\"rt=%f\\n\", rt);\n}", "t": "single", "ans": "D", "kp": "函数", "o": [ "求排列数", "求最大公约数", "求最小公倍数", "求组合数" ], "explanation": "本题题面代码公式存在明显错误，无法得出组合数。正确的组合数计算公式应为jc(j)/(jc(k)*jc(j-k))。结合选项与答案，本题考查的是利用阶乘函数计算组合数的逻辑，题面代码疑似录入或识别错误，建议人工复核。" }, { "id": 561, "q": "请编一个函数fun，函数的功能是使实型数保留2位小数，并对第三位进行四舍五入（规定实型数为正数）。\n例如：实型数为1234.567，则函数返回1234.570000；\n实型数为1234.564，则函数返回1234.560000。\n注意: 部分源程序存在文件PROG1.C文件中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "float fun ( float h )\n{\nreturn (int)(h*100+0.5)/100.0; /*将该数乘以10的n次方，然后将该数加上0.5，对其取整，然后再除以10的n次方*/\n}", "kp": "数据类型与表达式", "o": [], "rawType": "operation" }, { "id": 562, "q": "C语言源程序名的后缀是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ ".exe", ".obj", ".c", ".cp" ], "explanation": "C语言源程序文件的标准扩展名是.c。编译后生成的目标文件后缀通常为.obj或.o，链接后生成的可执行文件后缀为.exe或无后缀。因此正确选项为C。" }, { "id": 563, "q": "以下程序段运行后的输出结果是（ ）。\n{ char s[20]=\"ASbc7eDf56Fg89hqw\";\nint i,n=0;\nfor(i=0;s[i]!='\\0';i++)\nif(s[i]>='A'&&s[i]<='Z' )\nn++;\nprintf(\"%d\",n);\n}", "t": "single", "ans": "B", "kp": "字符串", "o": [ "17", "4", "5", "8" ], "explanation": "程序通过for循环遍历字符数组s，利用条件判断字符是否为大写英文字母。字符串ASbc7eDf56Fg89hqw中，大写字母仅有A、S、D、F共4个，其余为小写字母或数字。因此变量n最终累加结果为4，输出4。" }, { "id": 564, "q": "有以下程序\nchar c1='A',c2='Y';\nprintf(\"%d,%d\\n\",c1,c2);\n程序的输出结果是", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "输出格式不合法，输出出错信息（　　）。", "65,90", "65,89", "A,Y" ], "explanation": "printf函数使用%d格式控制符输出字符变量时，会输出其对应的ASCII码值。字符A的ASCII码值为65，字符Y在字母表中位于A之后第24位，其ASCII码值为65+24=89。因此程序输出结果为65,89。" }, { "id": 565, "q": "表示关系式x≤y≤z的C语言表达式的是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "(x<=y)||(y<=x)", "(x<=y<=z)", "(x<=y)&&(y<=z)", "(x≤y y)&&(y≤x)" ], "explanation": "C语言中不支持数学中的连续不等式写法，若直接书写会被解析为(x<=y)<=z，导致逻辑错误。必须将其拆分为两个独立的关系表达式，并使用逻辑与运算符&&连接，即(x<=y)&&(y<=z)，表示y同时大于等于x且小于等于z。" }, { "id": 566, "q": "以下选项中合法的实型常量是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "3.1415926", "3.13e-2.1", "0", "2.0*10" ], "explanation": "实型常量分为十进制小数形式和指数形式。选项A是合法的小数形式；选项B的指数部分必须为整数，-2.1不合法；选项C的0默认为整型常量；选项D包含乘法运算符，属于算术表达式而非单一常量。因此只有A是合法的实型常量。" }, { "id": 567, "q": "有以下程序，程序运行后的输出结果是（　　）。\nchar a='H';\na=(a>='A'&&a<='Z')?(a+32):a;\nprintf(\"%c\\n\",a);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "H", "A", "h", "a" ], "explanation": "程序首先判断字符a是否在大写字母A到Z范围内。H满足条件，因此执行条件表达式的真值分支a+32。在ASCII码中，大写字母加上32即可转换为对应的小写字母，H加32后变为h。最后通过%c格式输出字符h。" }, { "id": 568, "q": "以下程序的运行结果是          。\nchar c;\nint n=100;\nfloat f=10;\ndouble x;\nx=f*=n/=(c=50);\nprintf(\"%d,%f\\n\",n,x);", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2,20", "2,20.0", "2,20.000000", "2 20.000000" ], "explanation": "赋值运算符结合性为从右向左。首先执行c=50；接着n/=50，即n=100/50=2；然后f*=2，即f=10.0*2=20.0；最后x=20.0。printf中%d输出整型n的值2，%f默认输出6位小数的双精度浮点数x，即20.000000。两者以逗号分隔，故选C。" }, { "id": 569, "q": "以下定义语句中正确的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "char A=98+1,c='c';", "int a=b=0;", "float a=1,2=b;", "double a; b;" ], "explanation": "A选项正确，定义了两个字符变量并赋初值，98+1结果为99，可隐式转换为字符。B选项错误，连续赋值在定义时非法，应写为int a=0, b=0;。C选项错误，变量名不能以数字开头。D选项错误，定义多个变量应用逗号分隔，不能用分号。" }, { "id": 570, "q": "以下程序的功能是（）\n#include\nmain()\n{\nint a[50], i,n,j,t;\nprintf(\"请输入n的个数\\n\");\nscanf(\"%d\",&n);\nprintf(\"请输入%d个数\\n\",n);\nfor(i=0;ib) x++;" ], "explanation": "C语言中判断相等使用\"==\"，判断不相等使用\"!=\"。A选项\"a=b\"是赋值表达式，非判断；B选项\"=<\"语法错误，应为\"<=\"；D选项\"=>\"语法错误，应为\">=\"。C选项\"a!=b\"合法，用于判断a和b是否不相等，符合题意。" }, { "id": 572, "q": "执行下面程序的正确结果是 ( )。\ndouble x, y;\nprintf(\"Enter x: \") ;\nx=-3;\nif (x < 0) {\ny = 0; }\nelse if (x <= 15) {\ny = 4 * x / 3; }\nelse{\ny = 2. 5 * x - 10. 5; }\nprintf(\"f(%. 2f) =%. 2f\\n\", x, y) ;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0", "0. 0", "0. 00", "0. 0000" ], "explanation": "x被赋值为-3，满足条件x<0，因此执行y=0;。随后执行printf语句，格式控制符为\"%.2f\"，表示保留两位小数。y的值为0，按此格式输出即为0.00。故选C。" }, { "id": 573, "q": "对下面的while语句，循环体结束后a的值是（ ）。\na=30;\ndo{;}while ( a--) ;", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "-1", "1", "0", "30" ], "explanation": "do-while循环先执行循环体，再判断条件。a--是后缀自减，先使用a的值作为条件判断，再将a减1。当a减到0时，条件判断为假（0），循环结束，但此时仍会执行一次自减操作，使a变为-1。因此循环结束后a的值为-1。" }, { "id": 574, "q": "下列程序的输出结果是().\nint i;\nfor(i=1;i<10;i++)\n{\nif(i%5==0)continue;\nprintf(\"%d \",i);\n}\nprintf(\"end\\n\");", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1 2 3 4 end", "5 6 7 8 end", "1 2 3 4 6 7 8 9 end", "end" ], "explanation": "循环变量i从1递增到9。当i=5时，i%5==0成立，执行continue跳过本次循环的printf，直接进入下一次循环。因此5不会被输出，其余数字1、2、3、4、6、7、8、9均正常输出。最后输出end。故选C。" }, { "id": 575, "q": "则以下程序段中内循环体的总执行次数是( ) 。\nfor(i=3; i; i--)\nfor(j=0; j<=2; j++)\nfor(k=0; k<=2; k++)", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "12", "18", "24", "27" ], "explanation": "外层循环for(i=3; i; i--)，i从3递减到1，执行3次。中层循环for(j=0; j<=2; j++)，j从0到2，执行3次。内层循环for(k=0; k<=2; k++)，k从0到2，执行3次。总执行次数为3×3×3=27次。故选D。" }, { "id": 576, "q": "有以下程序，程序运行后的输出结果是( )。\nmain( )\n{int i=1,sum=0;\nwhile(i<=4)\n{ sum=sum+i;\ni=i+1;}\nprintf(\"%d\\n\",sum);}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "4", "5", "10", "死循环" ], "explanation": "初始i=1，sum=0。循环条件为i<=4。第1次：sum=1，i=2；第2次：sum=3，i=3；第3次：sum=6，i=4；第4次：sum=10，i=5。此时i<=4不成立，退出循环。最终输出sum的值为10。故选C。" }, { "id": 577, "q": "C语言中规定，简单变量做实参时，它和对应形参之间的数据传递方式是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "地址传递", "单向值传递", "由实参传给形参，再由形参传给实参", "由用户指定传递方式" ], "explanation": "在C语言中，当简单变量作为函数实参时，数据传递方式是单向值传递。即实参的值被复制给形参，形参的改变不会影响实参的值。地址传递通常用于数组或指针作实参的情况。故选B。" }, { "id": 578, "q": "外部变量前面加上static后，下列说法正确的是（）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "限于本文件使用", "作用域没有变化", "扩大了作用域", "生存期得以延长" ], "explanation": "在C语言中，外部变量（全局变量）默认具有外部链接属性，可被其他文件引用。若在其前面加上static关键字，则将其作用域限制在定义它的本文件内，其他文件无法访问，这称为内部链接属性。故选A。" }, { "id": 579, "q": "有以下程序\n#include \nfunc(int n)\n{ static int num=1;\nnum=num+n;printf(\"%d\",num);\n}\nvoid main()\n{ func(3);func(4);printf(\"\\n\"); }\n程序运行后的输出是 ( )", "t": "single", "ans": "C", "kp": "函数", "o": [ "4 5", "3 5", "4 8", "3 4" ], "explanation": "func函数中num为静态局部变量，只初始化一次。首次调用func(3)时，num=1+3=4，输出4。第二次调用func(4)时，num保留上次结果4，num=4+4=8，输出8。因此程序输出为4 8。故选C。" }, { "id": 580, "q": "以下程序的运行结果是（　　）\nfun(int x)\n{ if(x/2>0) fun(x/2);\nprintf(\"%d \",x);\n}\nmain()\n{ fun(14); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "1 3 7 14", "1 3 6 12", "14", "1 3 14" ], "explanation": "fun(14)中，14/2=7>0，调用fun(7)；fun(7)中，7/2=3>0，调用fun(3)；fun(3)中，3/2=1>0，调用fun(1)；fun(1)中，1/2=0，不满足条件，输出1并返回。随后逐层返回，分别输出3、7、14。最终输出结果为1 3 7 14。故选A。" }, { "id": 581, "q": "以下程序运行的结果是（　　）。\nmain()\n{ int p[10]={0,3,4,5,6,7,8,9},i=7,k=0;\nwhile(i>=0&&p[i]%2)\n{k=k+p[i];\ni--; }\nprintf(\"%d\\n\",k); }", "t": "single", "ans": "A", "kp": "数组", "o": [ "9", "42", "33", "39" ], "explanation": "初始i=7，p[7]为9，9%2为真，k累加9得9，i减为6。接着判断p[6]为8，8%2为假，循环结束。最终输出k的值9。" }, { "id": 582, "q": "若有定义int a[2][3];，以下选项中对数组a的数组元素正确引用的是（ ）。", "t": "single", "ans": "D", "kp": "数组", "o": [ "a[2][!1]", "a[2][3]", "a[0][3]", "a[1>2][!1]" ], "explanation": "数组a的行下标范围是0到1，列下标范围是0到2。选项A、B的行下标2越界；选项C的列下标3越界。选项D中，1>2结果为0，!1结果也为0，等价于引用a[0][0]，未越界且合法。" }, { "id": 583, "q": "以下程序的运行结果是（　　）\nvoid f(char p[][10], int n )\n{\nchar t[10]; int i,j;\nfor(i=0;i0) {strcpy(t,p[i]); strcpy(p[i],p[j]); strcpy(p[j],t); }\n}\nmain()\n{\nchar p[5][10]={\"abc\",\"aabbdfg\",\"abbd\",\"dcdbe\",\"cd\"};\nf(p,5);\nprintf(\"%d\\n\",strlen(p[0]));\n}", "t": "single", "ans": "B", "kp": "字符串", "o": [ "6", "7", "5", "1" ], "explanation": "函数f通过双重循环和strcmp比较，将字符串数组按字典序升序排列。原数组中最小的字符串是\"aabbdfg\"，排序后它被交换到p[0]的位置。strlen(p[0])计算其长度，不包含结束符，结果为7。题目代码虽有部分缺失，但不影响逻辑推断。" }, { "id": 584, "q": "若有定义语句： double a, *p=&a; 以下叙述中错误的是（ ）", "t": "single", "ans": "D", "kp": "指针", "o": [ "定义语句中的 * 号是一个说明符", "定义语句中的p只能存放double类型变量的地址", "定义语句中 *p=&a 把变量a的地址作为初值赋给指针变量p", "定义语句中的 * 号是一个间址运算符" ], "explanation": "在变量定义语句中，星号（*）是指针类型说明符，用于声明p是一个指针变量，而不是间址（解引用）运算符。间址运算符只在表达式中使用，用于获取指针所指向的内存单元的值。" }, { "id": 585, "q": "若有说明语句\"int a[10]，*p=a；\"，对数组元素的正确引用是()", "t": "single", "ans": "C", "kp": "指针", "o": [ "a[p]", "p[a]", "*(p+2)", "p+2" ], "explanation": "p是指向数组首元素的指针。选项A和B中数组下标必须为整数，不能是指针或数组名；选项D的p+2表示的是数组第3个元素的地址，而非元素本身；选项C中*(p+2)通过指针偏移并解引用，正确引用了数组的第3个元素，等价于a[2]。" }, { "id": 586, "q": "若输入1、2，以下程序的运行结果是（　　）\n#define SWAP(a,b) { t=b;b=a;a=t }\nmain()\n{ int a,b,t=0;\nscanf(\"%d,%d\",&a,&b);\nif (a>b)\nSWAP(a,b);\nprintf(\"a=%d,b=%d\\n\",a,b);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "a=1,b=2", "a=2,b=1", "a=0,b=1", "a=1,b=1" ], "explanation": "输入1和2后，a=1，b=2。判断条件a>b（即1>2）为假，因此不执行SWAP宏进行交换。程序直接执行输出语句，打印a和b的初始值，结果为a=1,b=2。" }, { "id": 587, "q": "已知一个数列的前三项分别为0，0，1，以后的各项都是其相邻的前三项之和。给定程序modi1.c中函数fun的功能是：计算并输出该数列前n项的平方根之和sum。n的值通过形参传入。\n例如，当n＝10时，程序的输出结果应为：23.197745。\n请改正函数fun中的错误，使程序能输出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "C语言规定，凡不加类型说明的函数，一律自动按整型处理。如果函数有返回值，这个值当然应属于某一个确定的类型，应当在定义函数时指定函数值的类型。根据题意，函数返回值为实型，所以第一处错误\"fun(int n)\"应改为\"float fun (int n)\"或具有相同作用的句子。\n函数的返回值是通过函数中的return语句获得的。return语句后面的括弧可以不要，但分号不能少，必须加分号。所以，第二处错误应改为\"return sum;\"或相同作用的句子。\n如果函数值的类型和return语句中表达式的值不一致，则以函数类型为准。对数值型数据，可以自动进行类型转换。即函数类型决定返回值的类型。\n本评析仅作参考。", "kp": "函数", "o": [], "rawType": "operation" }, { "id": 588, "q": "函数fun的功能是：逆置数组元素中的值。例如：若a所指数组中的数据依次为：1、2、3、4、5、6、7、8、9，则逆置后依次为：9、8、7、6、5、4、3、2、1。形参n给出数组中数据的个数。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "要逆置一个含有n个元素的数组a，只要依次做下列操作：将a[0]与a[n-1]交换，将a[1]与a[n-2]交换，……，这样一共要交换n/2对元素，故第一空应填n/2；对于第i(i<=n/2)个元素，它应与a[n-1-i]交换，故第二空应填i；在本题中，交换两个数是通过中间变量来实现的，假设要交换的数据为a,b，我们可以利用中间变量t来完成交换，执行语句如下：t=a;a=b;b=t;，根据该思想，第三处应填入的语句为a[n-1-i]或其等效形式。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 589, "q": "编写程序，实现矩阵（3行3列）的转置（即行列互换）。\n例如，输入下面的矩阵：\n100 200 300\n400 500 600\n700 800 900\n程序输出：\n100 400 700\n200 500 800\n300 600 900\n注意： 部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int array[3][3])\n{ int i,j;int b[3][3];\nfor (i=0;i<3;i++)\nfor (j=0;j<3;j++)\nb[j][i]=array[i][j];/*将矩阵行列互换*/\nfor (i=0;i<3;i++)\nfor (j=0;j<3;j++)\narray[i][j]=b[i][j];/*将b数组中的数据原封不动的保存在array数组中*/\n}", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 590, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[10]=\"12341233\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "2231", "2222", "2232", "2242" ], "explanation": "程序遍历字符串s，利用switch语句将字符'1'到'4'分别映射为索引0到3，并对数组v中对应元素进行计数。字符串中'1'、'2'、'3'、'4'分别出现了2、2、3、1次，因此v数组最终值为2、2、3、1，循环输出结果为2231。" }, { "id": 591, "q": "以下程序的运行结果是          。\nchar ch;\nch='B'+32;\nprintf(\"%c\\n\",ch);", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "'B'", "'b'", "98", "b" ], "explanation": "大写字母与小写字母的ASCII码值相差32。'B'的ASCII码加上32后等于小写字母'b'的ASCII码。printf函数使用%c格式控制符输出字符本身，不带单引号，因此屏幕上显示b。" }, { "id": 592, "q": "按照C语言规定的用户标识符命名规则，不能出现在标识符中的是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "连接符", "大写字母", "数字字符", "下划线" ], "explanation": "C语言规定，用户标识符只能由字母、数字和下划线三种字符组成，且第一个字符必须是字母或下划线。连接符（如减号）不属于合法字符，不能出现在标识符中。" }, { "id": 593, "q": "以下程序的运行结果是          。\nint a=0;\na+=(a=8);\nprintf(\"%d\\n\",a);", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "8", "0", "16", "出错" ], "explanation": "表达式a+=(a=8)中，先计算括号内的赋值表达式a=8，此时a的值变为8，该表达式的值也为8。接着计算a+=8，即a=a+8，最终a的值为16。" }, { "id": 594, "q": "有以下程序段运行时，输入的值在哪个范围才会有输出结果( ) 。\nint x;\nscanf(\"%d\",&x);\nif(x<=3) ;\nelse\nif(x!=10) printf(\"%d\\n\",x);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "不等于10的整数", "大于3且不等于10的整数", "大于3或等于10的整数", "小于3的整数" ], "explanation": "程序首先判断x<=3，若成立则执行空语句，无输出；若不成立（即x>3），则进入else分支，继续判断x!=10。只有当x大于3且不等于10时，才会执行printf语句产生输出结果。" }, { "id": 595, "q": "以下程序的运行结果是（　　）。\nmain(){ int i;\nfloat x=2,y=3,z;\nfor(i=1, z=x; i100) break;\n}", "for( ; ; );", "int k=1000;\ndo {--k;} while (k>=1000);", "int s=36;\nwhile (s) ++s;" ], "explanation": "A选项中i=i%100+1的结果最大为100，if(i>100)永远不成立，是死循环；B选项for(;;)缺少条件判断，是死循环；D选项s初始为36，++s使其不断增大，永远不为0，是死循环。C选项中k初始为1000，执行--k后k变为999，判断条件k>=1000为假，循环仅执行一次即结束，未构成死循环。" }, { "id": 597, "q": "程序的输出结果是()\nint sum = 0, item = 0;\nwhile(item < 5)\n{\nitem++;\nsum += item;\nif(sum==5)\nbreak;\n}\nprintf(\"%d\\n\", sum) ;", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "10", "15", "5", "6" ], "explanation": "程序通过while循环累加item的值到sum中。循环过程如下：第1次item变为1，sum为1；第2次item变为2，sum为3；第3次item变为3，sum为6；第4次item变为4，sum为10；第5次item变为5，sum为15。由于sum的值依次为1、3、6、10、15，始终不等于5，因此if(sum==5)条件不成立，不会触发break。当item等于5时，不满足item<5，循环正常结束，最终输出sum的值15。" }, { "id": 598, "q": "以下叙述中正确的是( )", "t": "single", "ans": "A", "kp": "函数", "o": [ "函数既可以直接调用自己，也可以间接调用自己", "任何情况下都不能用函数名作为实参", "函数的递归调用不需要额外开销，所以效率很高", "简单递归不需要明确的结束递归的条件" ], "explanation": "A选项正确，函数直接调用自身称为直接递归，通过其他函数调用自身称为间接递归。B选项错误，函数名代表函数入口地址，可作为实参传递给函数指针形参。C选项错误，递归调用需要分配栈空间保存现场，存在额外的时间和空间开销。D选项错误，任何递归都必须有明确的结束条件，否则会导致无限递归和栈溢出。" }, { "id": 599, "q": "以下关于语句extern k; 的描述，不正确的是（）\n#include\nextern k;\nmain()\n{\nstatic int i=0,m;\nfloat j,k;\n}\nfloat k;", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "不是变量定义", "不可省略extern", "外部变量k的申明", "可省略extern" ], "explanation": "extern k;是对外部变量的声明而非定义，因此A和C描述正确。在C语言中，声明外部变量时若省略extern关键字，编译器会将其视为变量定义或报语法错误，且此处外部变量k最终定义为float类型，省略extern会导致类型冲突或语法错误，因此extern不可省略，B描述正确，D描述错误。" }, { "id": 600, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint p[8]={11,12,13,14,15,16,17,18},i=0,j=0;\nwhile(i++<5) if(p[i]%2) j+=p[i];\nprintf(\"%d\\n\",j);\n}", "t": "single", "ans": "B", "kp": "数组", "o": [ "13", "28", "15", "14" ], "explanation": "本题考查后置自增与数组遍历。while(i++<5)先判断i<5再将i加1。当i为0时，判断后i变1，p[1]为12(偶数)；i为1时，判断后i变2，p[2]为13(奇数)，j累加13；i为2时，判断后i变3，p[3]为14(偶数)；i为3时，判断后i变4，p[4]为15(奇数)，j累加15，此时j为28；i为4时，判断后i变5，p[5]为16(偶数)；i为5时条件不成立，循环结束。最终j为28。" }, { "id": 601, "q": "若有一维数组int m[8]={1,2,3,4,5,6};则以下描述正确的语句是:", "t": "single", "ans": "A", "kp": "数组", "o": [ "将6个初值依次赋给a[0]至a[5]", "将6个初值依次赋给a[0]至a[4]", "将6个初值依次赋给a[1]至a[6]", "数组长度与初值的个数不相同,此语句不正确" ], "explanation": "在C语言中，定义数组时若提供的初值个数少于数组长度，系统会自动将剩余元素初始化为0。本题中数组长度为8，提供了6个初值，这6个初值会依次赋给数组的前6个元素（即下标0至5的元素），剩余的2个元素自动赋值为0。选项A正确描述了初值的赋值范围，选项D认为语句不正确是错误的。注意选项中的a应为题目笔误，实指数组m。" }, { "id": 602, "q": "有以下程序\nmain() {\nint m=1,n=2,*p=&m,*q=&n,*r;\nr=p; p=q; q=r;\nprintf(\"%d,%d,%d,%d\\n\",m,n,*p,*q); }\n程序运行后的输出结果是（ ）", "t": "single", "ans": "B", "kp": "指针", "o": [ "1,2,1,2", "1,2,2,1", "2,1,2,1", "2,1,1,2" ], "explanation": "本题考查指针变量的交换。初始时p指向m（值为1），q指向n（值为2）。通过中间指针r交换了p和q的指向，交换后p指向n，q指向m。此过程仅改变了指针的指向，并未改变m和n本身的值。因此，m和n仍为1和2，*p的值为2，*q的值为1，最终输出结果为1,2,2,1。" }, { "id": 603, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ "预处理命令行必须位于C源程序的起始位置", "在C语言中，预处理命令行都以\"#\"开头", "每个C程序必须在开头包括预处理命令行#include", "C语言的预处理不能实现宏定义和条件编译的功能" ], "explanation": "C语言的预处理命令必须以#开头，且末尾不加分号，因此B选项正确。预处理命令可以出现在源程序的任何位置，其作用范围从出现位置到文件末尾，并非必须在起始位置，A错误。并非每个程序都必须包含#include，C错误。预处理功能包括宏定义、文件包含和条件编译等，D错误。" }, { "id": 604, "q": "程序定义了N×N的二维数组，并在主函数中赋值。请编写函数fun，函数的功能是：求出数组周边元素的平均值并作为函数值返回给主函数中的s。\n例如：a数组中的值为\n|0 1 2 7 9|\n|1 9 7 4 5|\na= |2 3 8 3 1|\n|4 5 6 8 2|\n|5 9 1 4 1|\n则返回主程序后s的输出结果为：3.375000。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun ( int w[][N] )\n{ int i,j,n=0;double sum=0;\nfor(i = 0 ; i < 5 ; i++)\nfor(j = 0 ; j < 5 ; j++)\nif(i==0||j==0||i==N-1||j==N-1) {sum+=w[i][j];n++;}/*判断是否为第一行或最后一行的元素*/\nreturn sum/n;\n}", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 605, "q": "有以下程序段\nint k=0；\nwhile(k=1) k++;\nwhile 循环执行的次数是( ) 。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "无限次", "有语法错，不能执行", "一次也不执行", "执行1次" ], "explanation": "本题考查while循环的条件判断。循环条件k=1是赋值表达式，而非关系表达式k==1。每次判断时，都会将1赋值给k，该赋值表达式的值恒为1（即逻辑真）。因此，循环条件永远成立，k++会不断执行，导致该while循环执行无限次。" }, { "id": 606, "q": "以下定义正确的是（ ）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "int b1[10],b1;", "float b1[ ],b2;", "int 1a[10],a;", "float b1[10],b2;" ], "explanation": "本题考查变量与数组的合法定义。A选项中数组名b1与变量名b1重复，不合法；B选项中定义数组b1时未指定长度且未进行初始化，不合法；C选项中变量名1a以数字开头，违反了C语言标识符必须以字母或下划线开头的规则；D选项正确定义了一个包含10个元素的浮点型数组b1和一个浮点型变量b2，语法完全正确。" }, { "id": 607, "q": "若有一维数组int n[10]={1,2,3,4,5,6};则以下能正确引用数组元素是（ ）。", "t": "single", "ans": "A", "kp": "数组", "o": [ "n[3>1]", "n[10]", "n[n]", "n[ ]" ], "explanation": "本题考查数组元素的合法引用。数组n的长度为10，合法下标范围是0到9。A选项中3>1是关系表达式，结果为1，n[1]是合法的数组元素引用；B选项下标10超出了最大下标9，导致越界；C选项数组名n代表数组首地址，不能作为下标使用；D选项方括号内缺少下标表达式，存在语法错误。因此只有A选项正确。" }, { "id": 608, "q": "下列定义变量的语句中错误的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "float float;", "double int_;", "char fo;", "int _int;" ], "explanation": "本题考查C语言标识符的命名规则。C语言规定，标识符不能与系统关键字同名。A选项中使用了关键字float作为变量名，这是非法的，会导致编译错误。B、C、D选项中的int_、fo和_int均符合标识符由字母、数字和下划线组成且不以数字开头的规则，且未使用关键字，属于合法的变量定义。" }, { "id": 609, "q": "以下程序段，与语句k=a>b?(b>c?1:0):0;功能相同的是( ) 。", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "if((a>b)&&(b>c)) k=1;\nelse k=0;", "if((a>b）||(b>c）) k=1;\nelse k=0;", "if(a<=b）k=0;\nelse if (b<=c) k=1;", "if(a>b）k=1;\nelse if(b>c） k=1;\nelse k=0;" ], "explanation": "条件运算符嵌套等价于逻辑与判断。仅当a>b且b>c同时成立时，内层表达式返回1，否则返回0。选项A的逻辑判断与赋值结果完全一致。B使用逻辑或，C和D的分支逻辑与嵌套条件不符。" }, { "id": 610, "q": "下面程序段的运行结果是()\nint n=0;\nwhile(n++<=2);\nprintf(\"%d\",n);", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "2", "3", "4", "语法错误" ], "explanation": "while循环体为空语句，仅执行条件判断。n++为后置自增，先比较后加1。循环依次判断0、1、2均满足条件，n分别变为1、2、3；当n为3时判断3<=2为假，循环结束，此时n自增为4。最终输出4。" }, { "id": 611, "q": "以下程序运行后,a的值是()\nfor(a=1, b=1; a<=10; a++)\n{\nif(b>=10) break;\nif (b%3==1)\n{\nb+=3;\ncontinue;\n}\n}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "6", "5", "4", "101" ], "explanation": "初始a=1、b=1。前三次循环中b%3==1均成立，b依次变为4、7、10，同时每轮结束a自增。下一轮开始时a为4，b>=10成立，执行break退出循环，因此a的值为4。" }, { "id": 612, "q": "在C程序中，与while(m)中表达式m完全等价的是 ( )", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "m==0", "m!=0", "m==1", "m!=1" ], "explanation": "C语言中条件表达式以非零为真、零为假。while(m)即判断m是否为真，等价于显式判断m!=0。m==0表示假，m==1仅覆盖部分真值情况，m!=1逻辑不符。" }, { "id": 613, "q": "有以下程序\nvoid fun2(char a, char b )\n{ printf(\"%c%c\",a,b ); }\nchar a='A',b='B';\nvoid fun1( )\n{a='C'; b='D' ; }\nmain( )\n{ fun1( );\nprintf(\"%c%c\",a,b );\nfun2('E','F');\n}\n程序的运行结果是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "ABEF", "CDEF", "ABCD", "CDAB" ], "explanation": "a和b为全局变量。fun1()直接修改全局变量值为C和D。main中先调用fun1()，随后打印全局变量输出CD；再调用fun2('E','F')输出EF。拼接结果为CDEF。" }, { "id": 614, "q": "若有说明语句\n\"char s[ ]={'A'，'B'，'C'，'D'}，*p=s，c；\"，则执行语句c=++*++p；后，变量c的值()", "t": "single", "ans": "C", "kp": "指针", "o": [ "'A'", "'B'", "'C'", "'D'" ], "explanation": "运算符优先级与结合性：++p先使指针后移指向B；*解引用取得字符B；前置++将该字符值加1变为C，并赋给c。故c的值为C。" }, { "id": 615, "q": "若有以下定义和语句，则数组a的数组元素值是9的表达式是（　　）。\nint a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;", "t": "single", "ans": "A", "kp": "指针", "o": [ "p[8]", "a[7]", "p+8", "a+8" ], "explanation": "数组下标从0开始，值为9的元素是a[8]。指针p指向数组首地址，p[8]等价于*(p+8)，即访问第9个元素，值为9。B选项为8，C和D均为地址而非元素值。" }, { "id": 616, "q": "以下叙述中错误的是（　　）。", "t": "single", "ans": "C", "kp": "综合编程/调试改错", "o": [ "结构化程序由顺序、分支、循环三种基本结构组成", "C语言是一种结构化程序设计语言", "使用三种基本结构构成的程序只能解决简单问题", "结构化程序设计提倡模块化的设计方法" ], "explanation": "结构化程序设计由顺序、分支、循环三种基本结构组成，通过模块化设计可解决任意复杂问题。C选项只能解决简单问题违背了结构化程序设计的核心思想与能力，故错误。" }, { "id": 617, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"12123234222\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=1;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "621", "1621", "2621", "3621" ], "explanation": "程序统计字符串中1~4的出现次数并存入v[0]~v[3]。字符串中2出现6次，3出现2次，4出现1次。循环从k=1开始输出v[1]、v[2]、v[3]，即6、2、1，结果为621。" }, { "id": 618, "q": "有以下程序\nint a=0, b=0;\n/* 给a赋值 a=10; b=20; 给b赋值 */\nprintf(\"a+b=%d\\n\",a+b);\n程序运行后的输出结果是( )", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "a+b=0", "出错", "a+b=30", "a+b=10" ], "explanation": "/* */为块注释，其中的赋值语句a=10; b=20;不会被编译器执行。变量a和b保持初始值0，相加结果为0，按格式输出为a+b=0。" }, { "id": 619, "q": "设 int x=1, y=1; 表达式(!x||y--)的值是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0", "1", "2", "-1" ], "explanation": "逻辑或||具有短路特性，但左侧!x为假（0），需计算右侧。y--为后置自减，先返回原值1作为表达式结果，再将y减为0。逻辑表达式结果为真，即1。" }, { "id": 620, "q": "以下选项中不能用作C程序合法常量的是（）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "'\\076'", "5,678", "789", "\"\\x7D\"" ], "explanation": "C语言整型常量中不能包含逗号分隔符，5,678会被解析为逗号表达式而非单一常量。A为八进制转义字符，C为十进制整数，D为含十六进制转义的字符串，均合法。" }, { "id": 621, "q": "以下选项中，能用作用户标识符的是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "for", "1ch", "_ch1", "int" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且首字符不能为数字，同时不能是关键字。选项A和D是关键字，选项B以数字开头，均不合法。选项C符合规则。" }, { "id": 622, "q": "以下程序运行后的输出结果是( )。\nint x,y,z;\nx=y=1;\nz=x++,y++,++y;\nprintf(\"%d,%d,%d\\n\",x,y,z);", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2,3,3", "2,3,2", "2,3,1", "2,2,1" ], "explanation": "逗号运算符优先级低于赋值运算符。表达式z=x++,y++,++y等价于(z=x++),(y++),(++y)。首先执行z=x++，z被赋值为1，x自增为2；接着执行y++，y变为2；最后执行++y，y变为3。因此输出2,3,1。" }, { "id": 623, "q": "若有定义：double a=22;int i=0,k=18;，则不符合C语言规定的赋值语句是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "i+j=a;", "i=(a+k)<=(i+k);", "i=a;", "i=!a;" ], "explanation": "赋值运算符的左侧必须是左值（即可以被赋值的内存空间，如变量）。选项A中i+j是算术表达式，不能作为左值接收赋值，因此不符合C语言规定。其他选项左侧均为变量i，合法。" }, { "id": 624, "q": "C语言中double 类型数据占字节数为（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "4", "12", "8", "16" ], "explanation": "在C语言标准中，单精度浮点型（float）通常占4个字节，而双精度浮点型（double）通常占8个字节（64位），以提供更高的精度和更大的表示范围。" }, { "id": 625, "q": "以下程序的运行结果是（　　）\nint a=20;\nint f(int c){\nstatic int a=20;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<1;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "44", "34", "33", "45" ], "explanation": "函数f内的a是静态局部变量，初始为20。main中循环1次，调用f(3)，c变为4，返回20+4=24，静态a变为21，此时k=24。循环结束后，执行k+=a，此处的a是全局变量（值为20），故k=24+20=44。" }, { "id": 626, "q": "程序的输出结果是().\nint a=1,b=2,c=3,d=4;\nif ((a=2) || (b=1)) c=2;\nif ((c==3) && (d=-1)) a=5;\nprintf(\"%d,%d,%d,%d\\n\", a,b,c,d);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "2,1,2,4", "2,2,2,4", "5,2,2,-1", "5,1,5,-1" ], "explanation": "逻辑或||具有短路特性。(a=2)为真，(b=1)不执行，b保持2，c被赋为2。逻辑与&&也有短路特性，(c==3)为假，(d=-1)不执行，d保持4。最终a=2，b=2，c=2，d=4。" }, { "id": 627, "q": "若x,y,z的值分别为2,1,3， 程序的输出结果为（）\nif(y>z)printf(\"%d\\n\",z);\nelse if (zy)printf(\"%d\\n\",y);\nelse printf(\"%d\\n\",0);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "y>z即1>3为假，继续判断zy即2>1为真，因此执行printf输出y的值1。" }, { "id": 628, "q": "有程序:\nmain()\n{int a=5,b=1,c=0;\nif(a=b+c)\nprintf(\"***\\n\");\nelse\nprintf(\"$$$\\n\");}\n该程序()", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "有语法错误不能通过编译", "可以通过编译,但不能通过连接", "输出:***", "输出:$$$" ], "explanation": "在if语句的条件判断中，a=b+c是赋值表达式。将b+c（即1+0=1）赋值给a，表达式的值为1。在C语言中，非0值即为真，因此条件成立，执行if分支，输出***。" }, { "id": 629, "q": "若有定义: float x=1.5; int a =1,b=3,c=2;则正确的switch语句是( ) 。", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "switch(a+b)\n{case 1: printf(\"*\\n\");\ncase 2+1 : printf(\"**\\n\");}", "switch( (int)x );\n{ case 1: printf(\"*\\n\");\ncase 2 : printf(\"**\\n\");}", "switch( x );\n{ case 1.0: printf(\"*\\n\");\ncase 2.0 : printf(\"**\\n\");}", "switch(a+b )\n{ case 1: printf(\"*\\n\");\ncase c: printf(\"**\\n\");}" ], "explanation": "switch后的控制表达式必须是整型或字符型，case后必须是常量表达式。B选项switch后多了分号；C选项控制表达式为float型且case后为浮点常量；D选项case后为变量。仅A选项完全符合语法。" }, { "id": 630, "q": "以下程序段的运行结果是()\nint a=-1,b=3,c=3 ,s=0,w=0,t=0;\nif(c>0) s=a+b;\nif(a<=0)\n{if(b>0)\nif(c<=0) w=a-b;\n}\nelse if(c>0) w=a-b;\nelse t=c;\nprintf(\"%d,%d,%d\",s,w,t);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "2,0,0", "0,0,0", "0,2,1", "2,1,1" ], "explanation": "先执行if(c>0)，因为c=3成立，所以s=a+b=-1+3=2。接着a<=0成立，进入内层判断；b>0成立，但c<=0不成立，所以w不变仍为0。外层if已经匹配，不执行后面的else if和else，t仍为0，最终输出2,0,0。" }, { "id": 631, "q": "以下程序运行后的输出结果是( )。\nint i=10,j=0;\ndo\n{ j=j+1; i--; }\nwhile(i>=2);\nprintf(\"%d\\n\",j);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "8", "9", "50", "51" ], "explanation": "do-while循环先执行循环体再判断条件。初始i=10，每次循环i减1，j加1。当i从10递减到2时，条件i>=2成立，共执行9次循环。当i减为1时条件不成立退出循环，此时j的值为9。" }, { "id": 632, "q": "以下程序的运行结果是（　　）。\nmain(){\nint i,m=54;\nfor(i=1;i<=3;i++)\nm=m%i;\nprintf(\"%d\\n\",m);}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "1", "2", "3" ], "explanation": "循环变量i从1递增到3。第一次循环i=1，m=54%1结果为0；第二次循环i=2，m=0%2结果为0；第三次循环i=3，m=0%3结果仍为0。循环结束后m的值为0。" }, { "id": 633, "q": "下面程序的结果是（）\nint i=1;\nwhile(i<=3)\n{ printf(\"%d \", i);\ni++;\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "1 2 3", "1 2", "2 3", "1 2 3 4" ], "explanation": "初始i=1，满足i<=3，输出1，i变为2；满足条件，输出2，i变为3；满足条件，输出3，i变为4；不满足条件退出循环。因此输出1 2 3。" }, { "id": 634, "q": "有以下程序,程序运行后的输出结果是 （）\nint i;\nfor(i=0;i<3;i++)\nswitch(i)\n{\ncase 0:printf(\"%d\",i);break;\ncase 2:printf(\"%d\",i);break;\ndefault:printf(\"%d\",i);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "022111", "012", "0012", "000122" ], "explanation": "i=0时，匹配case 0，输出0并break；i=1时，无匹配，执行default，输出1；i=2时，匹配case 2，输出2并break。循环结束，最终输出012。" }, { "id": 635, "q": "下边循环执行完后，s为（ ）。\nfor ( a= 1; a< 5; a++ )\nfor ( b= s = 0; b< a; b++, s = s +a)\n;", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "10", "16", "4", "无答案" ], "explanation": "外层a从1到4。每次外层循环开始时，内层初始化b=0，s=0。内层循环执行a次，每次s增加a，故内层结束时s=a*a。当a=4时，内层循环执行4次，s累加4次4，最终s=16。循环结束后s保持最后一次结果16。" }, { "id": 636, "q": "程序运行后输出结果是()\nint a = -1, b = 0;\nwhile (a++ && b++) ;\nprintf(\"%d,%d\\n\", a, b );", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0,1", "1,0", "1,1", "0,0" ], "explanation": "初始a=-1，b=0。第一次判断：a++值为-1（真），a变为0；由于是&&运算，继续判断b++值为0（假），b变为1。整体条件为假，退出循环。此时a=0，b=1，输出0,1。" }, { "id": 637, "q": "return X; 语句中的X不能是（）", "t": "single", "ans": "B", "kp": "函数", "o": [ "变量", ".运算符", "常量", "表达式" ], "explanation": "return语句后的表达式X可以是常量、变量或合法的表达式，其值将作为函数返回值。选项B中的\".\"是结构体成员访问运算符，不能单独作为表达式或返回值使用，会导致语法错误。" }, { "id": 638, "q": "以下程序的运行结果是（　　）\nfun(int a, int b){\nif(a>b) return(a);\nelse return(b);\n}\nmain(){\nint x=23, y=18, z=16, r;\nr=fun(fun(x,y), z);\nprintf(\"%d\\n\", r);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "23", "18", "16", "32" ], "explanation": "fun函数用于返回两个参数中的较大值。首先计算内层函数调用fun(23,18)，返回较大值23；然后计算外层调用fun(23,16)，返回较大值23。最终r的值为23并输出。" }, { "id": 639, "q": "下列说法中，正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "局部变量的作用范围一定小于全局变量", "全局变量可定义在函数内部", "全局变量的作用范围可能小于局部变量", "全局变量可定义在复合语句内部" ], "explanation": "全局变量作用域从定义处到文件末尾，若定义在文件靠后位置，其作用域可能极小。局部变量作用域在其所在的函数或复合语句内。因此全局变量的作用范围可能小于局部变量。全局变量不能定义在函数或复合语句内部。" }, { "id": 640, "q": "以下叙述中正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "全局变量的作用域一定比局部变量的作用域大", "函数的形参属于全局变量", "未在定义语句中赋初值的静态变量的初值是0", "未在定义语句中赋初值的auto变量的初值是0" ], "explanation": "静态变量（static）若未显式初始化，系统会自动将其初始化为0。auto变量未初始化时值为随机垃圾值。全局变量作用域不一定比局部变量大。函数的形参属于局部变量，而非全局变量。" }, { "id": 641, "q": "25．有以下程序运行结果是（）。\nint fun(int a,int b)\n{ if(b==0) return a;\nelse return(fun(--a,--b)); }\nmain()\n{ printf(\"%d\\n\", fun(4,2));}", "t": "single", "ans": "B", "kp": "函数", "o": [ "1", "2", "3", "4" ], "explanation": "第一次调用fun(4,2)，b不为0，返回fun(--a,--b)即fun(3,1)；第二次调用fun(3,1)，b不为0，返回fun(--a,--b)即fun(2,0)；第三次调用fun(2,0)，b为0，直接返回a的值2。最终输出2。" }, { "id": 642, "q": "以下程序的输出结果是（　　）。\nmain()\n{ int i, a[10]={0,0,0,0};\nfor(i=9;i>=0;i=i-2) a[i]=10-i;\nprintf(\"%d %d %d\",a[2],a[4],a[8]);}", "t": "single", "ans": "C", "kp": "数组", "o": [ "1 3 5", "5 3 1", "0 0 0", "0 5 3" ], "explanation": "数组a初始部分元素为0，其余自动补0。循环中i从9递减2（9,7,5,3,1），仅对奇数下标元素赋值。a[2]、a[4]、a[8]均为偶数下标，未被循环修改，保持初始值0。因此输出0 0 0。" }, { "id": 643, "q": "若有定义int a[3][4];，以下选项中对数组a的数组元素正确引用的是（ ）。", "t": "single", "ans": "B", "kp": "数组", "o": [ "a[3][0]", "a[!1][1>2]", "a[0][4]", "a[3][4]" ], "explanation": "数组a的行下标范围是0~2，列下标范围是0~3。A项行下标3越界；C项列下标4越界；D项行列均越界。B项中!1结果为0，1>2结果为0，即引用a[0][0]，在合法范围内，引用正确。" }, { "id": 644, "q": "以下能正确定义一维数组的选项是（　　）。", "t": "single", "ans": "B", "kp": "数组", "o": [ "int 1b[6 ];", "float b1[6];", "float char[6];", "int x=100;\nint b1[x];" ], "explanation": "A项标识符不能以数字开头；C项char是关键字，不能作为数组名；D项在传统C语言标准中数组长度必须是常量表达式，不能用变量x。B项符合标识符命名规则且长度为常量，定义正确。" }, { "id": 645, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint m[][3]={1,4,7,2,5,8,3,6,9};\nint i,j,k=2;\nfor(i=1;i<3;i++)\nprintf(\"%d \",m[k][i]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "6 9", "3 6 9", "6", "9" ], "explanation": "二维数组按行优先初始化，3列表示每行3个元素。因此m[2]对应第三行{3,6,9}。循环变量i从1到2，依次输出m[2][1]和m[2][2]，即6和9，中间有空格。" }, { "id": 646, "q": "运行下列程序后的输出结果是（ ）\n{ char str1[10]= \"nan\",str2[10]=“chang”;\nstrcat(str1,str2);\nprintf(\"%s\\n\",str1); }", "t": "single", "ans": "B", "kp": "字符串", "o": [ "nan", "nanchang", "chang", "changnan" ], "explanation": "strcat函数用于将第二个字符串拼接到第一个字符串的末尾，并覆盖第一个字符串原有的结束符'\\0'。str1初始为\"nan\"，拼接\"chang\"后变为\"nanchang\"，最后通过%s输出该结果。" }, { "id": 647, "q": "以下程序是从键盘输入14,9,5三个数，输出结果是( )。\n#include\nmain()\n{\nint a,b,c,max;\nscanf(\"%d,%d,%d\",&a,&b,&c);\nif(a>b)\nmax=a;\nelse\nmax=b;\nif(c>max) max=c;\nprintf(\" %d\",max);\n}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "14", "9", "5", "无答案" ], "explanation": "程序通过两次if判断求三个数中的最大值。首先比较a和b，将较大者赋给max；接着比较c和max，若c更大则更新max。输入14,9,5时，a>b成立使max为14，c>max不成立，最终输出14。" }, { "id": 648, "q": "以下程序的运行结果是（）。\nmain()\n{ char a[ ]=\"programming\", b[ ]=\"language\";\nchar *p1, *p2;\nint i;\np1=a;\np2=b;\nfor(i=0;i<7;i++)\nif(* (p1+i)== * (p2+i))\nprintf(\"%c\",* (p1+i)); }", "t": "single", "ans": "D", "kp": "指针", "o": [ "gm", "rg", "or", "ga" ], "explanation": "程序通过指针遍历两个字符串的前7个字符，逐个比较对应位置的字符是否相同。a和b在索引3处同为'g'，在索引5处同为'a'，其余位置字符均不相同，因此依次输出g和a。" }, { "id": 649, "q": "若有以下说明和语句，且0≤i＜5，则下面哪个答案( )是对数组元素地址的正确表示？\nfloat a[]={1.6,3.0,-5.4,7.8,94.0},*p,i;\np=a;", "t": "single", "ans": "D", "kp": "指针", "o": [ "&(p+i)", "a++", "&p", "&p[i]" ], "explanation": "数组名a是地址常量，不能进行a++运算，排除B。p是指针变量，&p和&(p+i)获取的是指针变量自身的地址，而非数组元素地址，排除A和C。p[i]等价于*(p+i)，对其取地址&p[i]即为p+i，正确表示数组第i个元素的地址。" }, { "id": 650, "q": "在程序中要使用语句：printf（\"%s\",STRING）;输出一个长度为5的提示信息\"OK!\"(注意包含双引号)，则应该使用的宏定义语句是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "#define STRING \"OK!\"", "#define STRING \"\"OK!\"\"", "#define STRING \\\"OK!\\?\"", "#define STRING \"\\\"OK!\\\"\"" ], "explanation": "要在C语言中输出双引号，必须在字符串中使用转义字符\\\"。因此表示带双引号的\"OK!\"的字符串字面量应为\"\\\"OK!\\\"\"。宏定义进行简单的文本替换，选项D正确定义了该字符串，替换后printf可正常输出带双引号的内容。" }, { "id": 651, "q": "下列程序的运行结果是（　　）。\n#define SQR(x) x*x\nmain()\n{ int a,k=7;\na=++SQR(k+1);\nprintf(\"%d\\n\",a);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "15", "16", "17", "64" ], "explanation": "宏替换是纯文本替换，SQR(k+1)展开为k+1*k+1。前置自增++作用于第一个k，使k变为8。表达式变为8+1*8+1，根据运算优先级先算乘法1*8=8，再算加法8+8+1=17。注意宏定义未加括号导致的优先级问题。" }, { "id": 652, "q": "给定程序modi1.c中函数fun的功能是：为一个偶数寻找两个素数，这两个素数之和等于该偶数，并将这两个素数通过形参指针传回主函数。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 653, "q": "给定程序中，函数fun的功能是计算下式\n直到 ，并把计算结果作为函数值返回。\n例如：若形参e的值为1e-3，函数的返回值为0.551690。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "变量x用来存放各项的值，根据题面中的公式得知第一处填：3.0，第三处答案填：(2*i+1)；while语句的作用是条件表达式成立时，重复执行循环体，所以第二处答案填：>。\n本评析仅作参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 654, "q": "函数fun的功能是：将a、b中的两个两位正整数合并形成一个新的整数放在c中。合并的方式是：将a中的十位和个位数依次放在变量c的十位和千位上，b中的十位和个位数依次放在变量c的个位和百位上。\n例如，当a=45,b=12。调用该函数后，c=5241。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int a, int b, long *c)\n{\nint a_up,a_low,b_up,b_low;\na_up=a/10; /*求正整数a的十位数*/\na_low=a%10; /*求正整数a的个位数*/\nb_up=b/10; /*求正整数b的十位数*/\nb_low=b%10; /*求正整数b的个位数*/\n*c=a_low*1000+b_low*100+a_up*10+b_up; /*将a数的十位和个位数依次放在c数的十位和千位上，b数的十位和个位数依次放在c数的个位和百位上*/\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 655, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ "在C语言程序设计中，所有函数必须保存在一个源文件中。", "在算法设计时，可以把复杂任务分解成一些简单的子任务。", "包含了三种基本结构的算法可以解决一切问题。", "结构化程序必须包含所有的三种基本结构，缺一不可。" ], "explanation": "C语言程序可由多个源文件组成，A错误。结构化程序设计支持将复杂问题分解为简单子任务，B正确。三种基本结构不能解决所有不可计算问题，C错误。程序可根据需要只使用部分基本结构，不必三者俱全，D错误。" }, { "id": 656, "q": "以下程序执行的结果是（）\nint sum( int n)\n{\nint k, s=0;\nfor(k=1;k<=n;k++)\ns=s+k;\nreturn s;\n}\nmain()\n{\nprintf(\"%d\\n\",sum(100));\n}", "t": "single", "ans": "B", "kp": "函数", "o": [ "1000", "5050", "6060", "7070" ], "explanation": "函数sum通过for循环计算从1累加到n的和。当传入参数为100时，循环执行100次，计算1+2+...+100的结果。根据等差数列求和公式，结果为100×101/2=5050，最终由main函数输出。" }, { "id": 657, "q": "有如下程序，该程序的输出结果是 ( )。\nmain( )\n{ int x=1,a=0,b=0;\nswitch(x)\n{ case 0: b++;\ncase 1: a++; break;\ncase 2: a++;b++; }\nprintf(\"a=%d,b=%d\\n\",a,b); }", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "a=2,b=1", "a=1,b=1", "a=1,b=0", "a=2,b=2" ], "explanation": "switch语句根据x的值匹配case标签。x为1，直接跳转到case 1执行a++，使a变为1。随后遇到break语句跳出switch结构，不会执行case 2。变量b保持初始值0，因此输出a=1,b=0。" }, { "id": 658, "q": "以下叙述中正确的是( )。", "t": "single", "ans": "A", "kp": "综合编程/调试改错", "o": [ "C程序中注释部分可以出现在程序中任意合适的地方", "花括号\"{\"和\"}\"只能作为函数体的定界符", "构成C程序的基本单位是函数，所有函数名都可以由用户命名", "分号是C语句之间的分隔符，不是语句的一部分" ], "explanation": "C语言注释可出现在任何允许空白符的地方，A正确。花括号还用于复合语句和数组初始化等，B错误。main函数名固定，且函数名不能是关键字，C错误。分号是语句的结束标志，属于语句的一部分，D错误。" }, { "id": 659, "q": "下面不正确的字符串常量是______。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "'abc'", "\"1212\"", "\"0\"", "\" \"" ], "explanation": "在C语言中，字符串常量必须用双引号括起来。单引号用于表示字符常量，如'a'。虽然部分编译器允许单引号包含多个字符，但它属于多字符字符常量，并非标准的字符串常量，因此A选项的'abc'不正确。" }, { "id": 660, "q": "以下选项中合法的标识符有(　　)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "_123", "do", "-abc", "2a" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头，也不能是关键字。A选项以下划线开头，合法；B选项do是关键字；C选项包含非法字符减号；D选项以数字开头，均不合法。" }, { "id": 661, "q": "以下程序的功能是：输出a、b、c3个变量中的最小值。请填空。\nint a,b,c,t1,t2;\nscanf(\"%d%d%d\",&a,&b,&c);\nt1=a\nint a=9;\nfun(int b)\n{ int a=10;\na+=b++;\nprintf(\"%d，\",a); }\nmain()\n{ int c=23;\nfun(c);\na+=c++;\nprintf(“%d\\n”,a);}", "t": "single", "ans": "D", "kp": "函数", "o": [ "32,31", "35,34", "34,33", "33,32" ], "explanation": "fun函数中定义了局部变量a，屏蔽了全局变量a。调用fun(23)时，局部a=10，执行a+=b++后a变为33，输出33。返回main函数后，a指全局变量a（初值9），执行a+=c++后a变为9+23=32，输出32。" }, { "id": 664, "q": "运行下面程序时，从键盘输入数据为\"1,13,5\"，\n则输出结果是( )。\n#include \nmain( )\n{ inta,b,c;\nscanf(\"%d,%d,%d\",&a,&b,&c);\nswitch(a)\n{ case 1: printf(\"%d\\n\",b+c); break;\ncase 2: printf(\"%d\\n\",b-c); break;\ncase 3: printf(\"%d\\n\",b*c); break;\ncase 4: { if(c!=0) {printf(\"%d\\n\",b/c);break;}\nelse {printf(\"error\\n\");break;}\n}\ndefault: break;\n}\n}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "18", "8", "65", "error" ], "explanation": "输入数据后，a=1，b=13，c=5。switch语句根据a的值匹配到case 1，执行printf输出b+c的结果，即13+5=18，随后遇到break跳出switch语句，最终输出18。" }, { "id": 665, "q": "以下能正确计算10!的程序段是()。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "do {i=1;s=1;\ns=s*i;\ni++;\n}while(i<=10);", "do{i=1;s=0;\ns=s*i;\ni++;\n}while(i<=10);", "i=1;s=1;\ndo{s=s*i;\ni++;\n}while(i<=10);", "i=1;s=0;\ndo{s=s*i;\ni++;\n}while(i<=10);" ], "explanation": "计算阶乘需将累乘变量s初始化为1，循环变量i初始化为1。A和B选项在循环体内初始化i和s，会导致每次循环都重置；D选项s初始化为0导致乘积始终为0。只有C选项在循环外正确初始化，能正确计算10!。" }, { "id": 666, "q": "执行语句i=2; while (i++<3);后,变量i的值是( ) 。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "3", "4", "5", "不定" ], "explanation": "初始i=2。第一次判断i++<3，使用i的原值2进行比较，2<3为真，判断后i自增为3；第二次判断，使用3进行比较，3<3为假，判断后i自增为4，循环结束。因此最终i的值为4。" }, { "id": 667, "q": "则程序的输出结果是（）\nint a=-2, b=0;\nwhile(++a) b++ ;\nprintf(\"%d,%d\\n\", a, b);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0,1", "1,2", "1,3", "2,3" ], "explanation": "初始a=-2，b=0。第一次循环条件++a使a变为-1，非零为真，执行b++使b变为1；第二次判断++a使a变为0，条件为假，循环结束。最终输出a和b的值分别为0和1。" }, { "id": 668, "q": "有以下程序段的输出结果是( )\n{ char s[ ]＝\"012xy\\08s34f4w2\"；\n　　int i， n＝0；\n　　for ( i＝0；s[i]！＝0； i＋＋ )\n　　　 if(s[i] >＝ '0' && s[i] <＝ '9')\nn＋＋；\n　　printf(\"%d\\n\"，n)；}", "t": "single", "ans": "B", "kp": "字符串", "o": [ "0", "3", "7", "8" ], "explanation": "字符串中的\\0是转义字符，代表字符串结束标志。因此数组s实际存储的有效字符为012xy。for循环遍历这5个字符，其中0、1、2满足大于等于'0'且小于等于'9'的条件，计数器n加1，最终输出3。" }, { "id": 669, "q": "有以下程段序运行后的输出结果是\nmain( )\n{ char s[ ]=\"246\",*p;\np=s;\npintf(\"%c\", *p++);\nprintf(\"%c\",*p++);\n}", "t": "single", "ans": "A", "kp": "指针", "o": [ "24", "46", "26", "输出错误" ], "explanation": "指针p初始指向字符串首字符'2'。第一条输出语句中，*p++先取p所指内容'2'输出，然后p自增指向'4'；第二条输出语句同理，输出'4'后p指向'6'。因此最终输出24。" }, { "id": 670, "q": "下列程序的运行结果是（　　）。\n#define SQR(x) x*x\nmain()\n{ int a,k=5;\na=++SQR(k+1);\nprintf(\"%d\\n\",a);\n}", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "36", "11", "12", "13" ], "explanation": "宏替换是简单的文本替换，SQR(k+1)被替换为k+1*k+1。因此a=++SQR(k+1)展开为a=++k+1*k+1。由于++优先级高，先执行++k使k变为6，接着计算表达式6+1*6+1，结果为13。" }, { "id": 671, "q": "函数fun的功能是：统计所有小于等于n(n>2)的素数的个数，素数的个数作为函数值返回。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "素数是指除了1和它本身，不能被任何其它介于1和它本身之间的数整除的数。本题通过双重for循环来实现求素数，第二层for循环用于判断数i是否是素数，从2开始被整除，故第一空填j=2；\nif语句用于判断数i是否能被j整除，如果能整除，说明i并不是素数，则跳出内层for循环，故第二空填i；\n如果i被所有的j整除运算，但其余数均不为0，则i为素数，此种思想通过if(j>=i)来实现，故第三空填j。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 672, "q": "函数fun的功能是：将s所指字符串中下标为偶数同时ASCII值为奇数的字符删除，s所指串中剩余的字符形成的新串放在t所指的数组中。\n例如，若s所指字符串中的内容为\"ABCDEFG12345\"，其中字符C的ASCII码值为奇数，在数组中的下标为偶数，因此必须删除；而字符1的ASCII码值为奇数，在数组中的下标也为奇数，因此不应当删除，其它依次类推。最后t所指的数组中的内容应是\"BDF12345\"。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(char *s, char t[])\n{\nint i,slenth,n=0;\nslenth=strlen(s); /*统计字符串s中字符的个数*/\n/*判断字符s[i]的下标是否为偶数且其值的ASCII码值是否为奇数，如果是，则继续下一个字符的判断，否则将字符s[i]复制到t数组中*/\nfor(i=0;ib) t=s+t;\nelse if (a==b) t=5;\nelse t=2*s;\nprintf(\"%d\\n\",t);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "2", "4", "5", "6" ], "explanation": "初始s=1，t=4，a=-2，b=3。a<0成立，所以s变为2。接着判断a>b，-2>3为假；a==b也为假，因此执行else分支t=2*s=4。最后输出t，结果为4。" }, { "id": 676, "q": "下列程序的运行结果是 ()\nmain()\n{\nint a=3,c=7;\nprintf(\"a=%d,b=%d\\n\",a,c);\n}", "t": "single", "ans": "B", "kp": "输入输出", "o": [ "a=%3,b=%7", "a=3,b=7", "a=d, b=d", "a=%d,b=%d" ], "explanation": "printf函数按格式字符串原样输出非格式控制字符，%d依次被变量a和c的值替换。因此输出a=3,b=7。注意格式串中的b只是普通字符，与变量名无关。" }, { "id": 677, "q": "以下程序的输出结果是（）\nint a=4;\nint f(int n){\nint t=0;\nint a=7;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<3;i++) s=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "14", "41", "39", "15" ], "explanation": "全局变量a=4，函数f内定义局部变量a=7，屏蔽全局变量。i=0时，n%2为假，t=7，返回t+a++即14，s=14；i=1时，n%2为真，t=6，返回t+a++即13，s=13；i=2时，n%2为假，t=7，返回14，s=14。循环结束输出s的值14。" }, { "id": 678, "q": "以下程序的运行结果是（　　）\nint f(int x) {\nint y;\nif(x==0||x==1) return (3);\ny=x*x-f(x-2);\nreturn y;\n}\nmain(){\nint z;\nz=f(4);\nprintf(\"%d\\n\",z);\n}", "t": "single", "ans": "D", "kp": "函数", "o": [ "12", "13", "14", "15" ], "explanation": "递归函数f(x)的终止条件为x=0或1时返回3。计算f(4)时，f(4)=4*4-f(2)=16-f(2)；f(2)=2*2-f(0)=4-3=1；因此f(4)=16-1=15。" }, { "id": 679, "q": "给定程序MODI1.C中函数fun的功能是：交换主函数中两个变量的值。例如：若变量a中的值原为8，b中的原值为3。程序运行后a中的值为3，b中的值为8。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本程序主要是通过子函数中的指针变量值的改变，从而达到交换主函数中a，b两个变量值的目的。\n本评析仅作参考。", "kp": "指针", "o": [], "rawType": "operation" }, { "id": 680, "q": "函数fun的功能是：统计长整数n的各个位上出现数字1、2、3的次数，并通过外部（全局）变量c1、c2、c3返回主函数。例如，当n=123114350时，结果应该为：c1=3 c2=1 c3=2。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "通过while循环，检验长整数n中的每一个字符，再使用switch分支判断语句，累加计算出各个数字的个数。\n第一处填空，将n对10取余，得到的数字即为个位上的数字，对个位上的数字进行判断之后，将n除以10，得到的整数n再次进入循环，从而得到n每一位上的数字，所以这里应填\"n%10\"。\n第二处填空，由题面可知，出现数字1时，变量c1增1，此时跳出循环，进入下一步，所以这里应填\"break\"。\n第三处填空，同上可知，这里应填\"break\"。\n本评析仅供参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 681, "q": "在C语言中，每个语句和数据定义是用（　　）结束。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "分号", "逗号", "句号", "括号" ], "explanation": "C语言语法规定，每个语句和数据定义都必须以分号作为结束标志，分号是语句的组成部分，而不是分隔符。" }, { "id": 682, "q": "以下正确的常量是( )", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "3.141", "\\101", "087", "X97" ], "explanation": "A为合法的浮点型常量；B缺少单引号，不是合法的字符常量；C以0开头表示八进制，但包含非法数字8；D十六进制常量应以0x或0X开头，X97格式错误。" }, { "id": 683, "q": "以下程序的运行结果是（　　）\nint a=10;\nint f(int c){\nstatic int a=1;\nc=c+1;\nreturn (a++)+(c++);\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=7; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "29", "28", "27", "30" ], "explanation": "函数f中a为静态局部变量，初始为1，每次调用后自增。第一次调用f(7)，c变为8，返回1+8=9，静态a变为2，k=9；第二次调用f(7)，c变为8，返回2+8=10，静态a变为3，k=19。循环结束后，k加上全局变量a的值10，最终k=29。" }, { "id": 684, "q": "给定程序中，函数fun的功能是根据形参i的值返回某个函数的值。当调用正确时，程序输出：\nx1=5.000000, x2=3.000000, x1*x1+x1*x2=40.000000\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "函数", "o": [], "rawType": "operation" }, { "id": 685, "q": "要把高级语言编写的源程序转换为目标程序,需要进行( )。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "编辑", "解释", "编译", "连接" ], "explanation": "将高级语言编写的源程序翻译成等价的机器语言目标程序的过程称为编译。编辑是编写代码，解释是边翻译边执行不生成目标程序，连接是将目标程序与库函数等组合成可执行文件。" }, { "id": 686, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[10]=\"12342233\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "1331", "2331", "3331", "1111" ], "explanation": "程序通过switch语句统计字符串中字符'1'到'4'的出现次数，分别存入数组v的v[0]到v[3]中。字符串中'1'出现1次，'2'出现3次，'3'出现3次，'4'出现1次，因此v数组元素依次为1、3、3、1，输出1331。" }, { "id": 687, "q": "若变量 c 为 char 类型则能正确判断出 c 为小写字母的表达式是()。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "'a'<=c<= 'z'", "(c>= 'a')||(c<= 'z')", "('a'=c)", "(c>= 'a')&&(c<= 'z')" ], "explanation": "C语言中不能像数学中那样使用连续不等式（如'a'<=c<='z'），必须用逻辑与运算符&&将两个条件连接起来，即c大于等于'a'并且c小于等于'z'。" }, { "id": 688, "q": "表达式5/2+(float)5/2 的值是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "5", "4", "4.5", "5.0" ], "explanation": "表达式中5/2为整数除法，结果为2；(float)5将5强制转换为浮点数，再除以2进行浮点除法，结果为2.5。两者相加时，整数2自动转换为浮点数，最终结果为4.5。" }, { "id": 689, "q": "下面四个选项中，均是合法浮点数的选项是 ______。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "1e1 5e-9.4 03e2", "-0.6 12e-4 -8e5", "123e 1.2e-0.4 2e-1", "-e3 .8 e-4 5.e-0" ], "explanation": "科学计数法表示浮点数时，e或E之前必须有数字，且e后面的指数必须为整数。选项A中5e-9.4指数非整数；选项C中123e缺少指数，1.2e-0.4指数非整数；选项D中-e3和e-4缺少尾数。只有B选项均符合浮点数语法规则。" }, { "id": 690, "q": "设变量a是整型，f为单精度型，i 是双精度型，则表达式 10+'\\025'+i*f 值的数据类型为()", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "int", "float", "double", "不确定" ], "explanation": "C语言中，表达式计算时会进行隐式类型转换，向精度高的类型对齐。字符常量'\\025'和整型常量10参与运算时视为int型；单精度f与双精度i相乘时，f自动转换为double型，i*f结果为double型；最后int型结果与double型相加，整体转换为double型。" }, { "id": 691, "q": "以下程序的输出结果是()\nmain()\n{\nint a=12, b=12;\nprintf(\"%d, %d\\n\", --a, b++) ;\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "11,12", "12,12", "12,13", "11,13" ], "explanation": "本题考查自增自减运算符的前缀与后缀区别。--a为前缀递减，先使a减1变为11，再输出11；b++为后缀递增，先输出b的当前值12，然后b再加1。因此输出结果为11,12。" }, { "id": 692, "q": "有以下定义，则以下选项中正确的表达式是（　　）。\nint a;\nlong b;\ndouble x,y;", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "a%(int)(x-y)", "a=x<>y", "(a*y)%b", "y=x+y=x" ], "explanation": "取余运算符%要求两侧操作数必须均为整型。选项A通过(int)将双精度表达式(x-y)强制转换为整型，符合语法；选项B中C语言无<>运算符；选项C中a*y结果为double型，不能直接用于%运算；选项D中x+y不是左值，不能被赋值。" }, { "id": 693, "q": "下列定义变量的语句中错误的是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "bool a;", "double int_;", "char For;", "int _int;" ], "explanation": "传统C语言（C89/C90标准）的基本数据类型中不包含bool类型，若要使用需引入C99标准的头文件。而int_、For（区分大小写，非关键字for）和_int均符合标识符命名规则，定义合法。" }, { "id": 694, "q": "以下程序的运行结果是（　　）\n#include\nint a=7;\nfun(int b)\n{ int a=10;\na+=b++;\nprintf(\"%d，\",a); }\nmain()\n{ int c=31;\nfun(c);\na+=c++;\nprintf(\"%d\\n\",a);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "41,38", "42,39", "43,40", "40,37" ], "explanation": "函数fun中定义了局部变量a，屏蔽了全局变量a。调用fun(c)时，局部a初值为10，执行a+=b++后a变为41并输出，形参b的改变不影响实参c。返回main函数后，a指代全局变量（初值7），执行a+=c++，即a=7+31=38并输出。" }, { "id": 695, "q": "已知int x=7,y=8,z=9,则执行\nif (x>y)\nz=x;x=y;y=z;\n语句后，x、y、z 的值是( )。", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "x=7,y=8,z=9", "x=8,y=9,z=9", "x=8,y=9,z=7", "x=8,y=9,z=8" ], "explanation": "C语言中，if语句若未使用花括号，则只控制其后紧跟的第一条语句。由于x>y（7>8）为假，z=x不执行。随后的x=y;和y=z;不受if控制，顺序执行。因此x被赋值为8，y被赋值为9，z保持原值9不变。" }, { "id": 696, "q": "运行下面程序时， 若从键盘输入数据为\"86\"，则输出结果是( )。\nint t;\nscanf(\"%d\",&t);\nif (t>=90) printf(\"A\\n\");\nelse if (t>=80) printf(\"B\\n\");\nelse if (t>=70) printf(\"C\\n\");\nelse if (t>=60) printf(\"D\\n\");\nelse printf(\"E\\n\");\nprintf(\"OK\\n\");", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "B", "B OK", "B\nOK", "B\nC\nD\nE\nOK" ], "explanation": "程序使用if-else if多分支结构，输入86满足t>=80条件，执行printf(\"B\\n\")后跳出整个if-else语句块。随后顺序执行if结构外的printf(\"OK\\n\")。因此输出B和OK，且各占一行。" }, { "id": 697, "q": "以下if语句语法正确的是（）", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "if (x>0) printf(\"%f\",x) else printf(\"%f\",-x);", "if(x>0) { x=x+y;printf(\"%f\",x);} else printf(\"%f\",-x);", "if(x>0) x=x+y;printf(\"%f\",x); else printf(\"%f\",-x);", "if(x>0) { x=x+y;printf(\"%f\",x) } else printf(\"%f\",-x)" ], "explanation": "if语句的分支若包含多条语句，必须用花括号{}括起来构成复合语句，且每条语句末尾需有分号。选项A和D在printf后缺少分号；选项C中if后跟了两条独立语句且未加花括号，导致else无法与if正确匹配；只有选项B语法完全正确。" }, { "id": 698, "q": "以下程序执行后输出的结果是( )。\nmain()\n{ int i=1;\nswitch(i)\n{ case 1: printf(\"%d\",i++);\ncase 2: printf(\"%d\",i++);\ndefault: printf(\"%d\",i++);\n}}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "123", "1", "234", "2" ], "explanation": "switch语句中，若case分支后没有break语句，程序会发生\"穿透\"现象，继续执行后续case或default中的语句。i初值为1，匹配case 1，输出1后i自增为2；因无break，继续执行case 2输出2，i变为3；再穿透至default输出3，i变为4。最终输出123。" }, { "id": 699, "q": "以下程序段的运行结果是( ) 。\nint x=3,y=4,z=5;\nif(x0) ;", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "45", "54", "4", "5" ], "explanation": "该程序段通过do-while循环实现整数各位数字的逆序输出。每次循环中，利用num%10取出当前个位数字并输出，然后通过num/10去掉个位。输入45时，第一次循环输出5，num变为4；第二次循环输出4，num变为0，循环结束。最终输出54。" }, { "id": 701, "q": "下列程序的输出结果是( )。\nmain()\n{\nint f,d;\nfor(f=1;f<100;f++)\nd=20/3;\nprintf(\"%d,%d \", f,d);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "100,6", "101,6", "100,6.6", "101,6.6" ], "explanation": "for循环后未加大括号，循环体仅为d=20/3;。循环条件f<100，f从1递增，当f=100时退出循环。整型除法20/3结果为6。因此最终f为100，d为6。" }, { "id": 702, "q": "有以下程序段其输出结果是( ) 。\nint x=3;\ndo\n{ printf(\"%d\",x-=2); }\nwhile (!(--x));", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1", "3 0", "1 -２", "死循环" ], "explanation": "初始x=3。首次执行循环体，x-=2使x变为1并输出1；接着判断条件，--x使x变为0，!0为真，继续循环。第二次执行循环体，x-=2使x变为-2并输出-2；判断条件时--x使x变为-3，!(-3)为假，退出循环。最终输出1和-2。" }, { "id": 703, "q": "以下程序的运行结果是( )。\nint x;\nfor(x=3;x<6;x++){\nprintf(\"%d\",x);\ncontinue;\nprintf(\"%d\",x);\n}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "33445", "33", "3", "345" ], "explanation": "for循环中x依次取3、4、5。每次循环先执行第一个printf输出当前的x值，随后遇到continue语句，直接跳过本次循环剩余的代码（即第二个printf），进入下一次循环的条件判断与更新。因此只输出3、4、5。" }, { "id": 704, "q": "输出结果是( )。\nfor(j=10;j<11;j++)\n{\nfor(i=9;i=j-1) printf(\"%d\",j);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "9", "10", "11", "10 11" ], "explanation": "外层循环j从10开始，条件j<11，只会执行一次。内层循环i从9开始且i=j-1成立，输出j的值10。" }, { "id": 705, "q": "下面程序的结果是()\nint sum=0;\nint i=2;\nwhile (i<=9)\nif (10%i==0)\nsum=sum+i++;\nprintf(\"%d\\n\", sum);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "死循环", "7", "0", "13" ], "explanation": "while循环体仅包含if语句。当i=2时，10%2==0成立，sum累加且i自增为3。当i=3时，10%3==0不成立，if内的i++不执行，导致i的值始终为3，无法满足i>9的退出条件，从而陷入死循环。" }, { "id": 706, "q": "以下正确的函数定义形式是 ( ) 。", "t": "single", "ans": "A", "kp": "函数", "o": [ "double fun(int x,int y) { }", "double fun(int x;int y) { }", "double fun(int x, int y);", "double fun(int x,y);" ], "explanation": "C语言中函数定义需包含返回类型、函数名、参数列表和函数体。参数列表中每个参数必须独立声明类型并用逗号分隔。选项B误用分号，选项C和D缺少函数体仅为函数声明，且D中参数类型声明不规范。因此A为正确的定义形式。" }, { "id": 707, "q": "以下程序的运行结果是（　　）\nfun(int a, int b){\nif(a>b) return(a);\nelse return(b);\n}\nmain(){\nint x=3, y=8, z=16, r;\nr=fun(fun(x,y), 2*z);\nprintf(\"%d\\n\", r);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "32", "12", "30", "28" ], "explanation": "函数fun的功能是返回两个参数中的较大值。首先计算内层函数调用fun(x,y)，即fun(3,8)，返回8。接着计算外层调用fun(8, 2*z)，其中2*z为32，比较8和32，返回较大值32。最终r的值为32并输出。" }, { "id": 708, "q": "有以下程序运行后的输出结果是( ) 。\nint a=4;\nint f(int n)\n{ int t=0;\nstatic int a=5;\nif(n%2) { int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++; }\nmain()\n{ int s=a,i=0;\nfor(;i<2;i++) s+=f(i);\nprintf (\"%d\\n\",s); }", "t": "single", "ans": "B", "kp": "函数", "o": [ "24", "28", "32", "36" ], "explanation": "全局变量a=4，main中s初始为4。函数f中static a初始为5。第一次调用f(0)，走else分支，局部a=7使t=7，返回t+static a++即7+5=12，static a变为6，s变为16。第二次调用f(1)，走if分支，局部a=6使t=6，返回6+6=12，static a变为7，s累加为28。" }, { "id": 709, "q": "以下程序的运行结果是（　　）。\nlong fun( int n)\n{\nlong s;\nif(n==1 || n==2) s=2;\nelse s=n-fun(n-2);\nreturn s;\n}\nmain()\n{ printf(\"%ld\\n\", fun(4)); }", "t": "single", "ans": "B", "kp": "函数", "o": [ "1", "2", "3", "4" ], "explanation": "本题考查递归函数。调用fun(4)时，n=4不满足基准条件，执行s = 4 - fun(2)。接着调用fun(2)，满足n==2，返回2。因此fun(4)的计算过程为4 - 2 = 2，最终输出结果为2。" }, { "id": 710, "q": "15．以下程序的运行结果是（　　）。\nlong fun( int n)\n{ long s;\nif(n==1 || n==2) s=2;\nelse s=n-fun(n-1);\nreturn s; }\nmain()\n{ printf(\"%ld\\n\", fun(3)); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "1", "2", "3", "4" ], "explanation": "本题考查递归函数。调用fun(3)时，n=3不满足基准条件，执行s = 3 - fun(2)。接着调用fun(2)，满足n==2的条件，直接返回2。因此fun(3)的计算过程为3 - 2 = 1，最终输出结果为1。" }, { "id": 711, "q": "以下程序的运行结果是（　　）\nmain()\n{ int s[12]={1,2,3,4,4,3,2,1,1,1,2,3},c[5]={0},i;\nfor(i=0;i<10;i++) c[s[i]]++;\nfor(i=1;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "4222", "0422", "04222", "0432" ], "explanation": "数组s的前10个元素为1,2,3,4,4,3,2,1,1,1。第一个for循环统计这10个数字出现的次数并存入数组c对应下标中。统计结果为：1出现4次，2出现2次，3出现2次，4出现2次，即c[1]到c[4]分别为4,2,2,2。第二个循环输出c[1]至c[4]，结果为4222。" }, { "id": 712, "q": "以下对二维数组正确的定义语句是（　　）。", "t": "single", "ans": "B", "kp": "数组", "o": [ "int y[ ][3]={{0,1,2},{1,2},{1,2,3,4}};", "int y[4][3]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};", "int y[3][ ]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};", "int x[3][4]={{1},{2},{3,4},{5,6,7}};" ], "explanation": "C语言定义二维数组时，若提供完整初始化，行号可省略但列号不可省略。选项A中第三组初始化数据超出列数3；选项C省略了列号且初始化行数超出定义；选项D初始化提供了4行数据但数组仅定义为3行。选项B行列数与初始化数据完全匹配，为正确定义。" }, { "id": 713, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=11-i;\nprintf(\"%d%d%d\",a[2],a[6],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "953", "359", "731", "137" ], "explanation": "循环从i=9递减到0，依次给数组赋值a[i]=11-i。计算可得a[2]=11-2=9，a[6]=11-6=5，a[8]=11-8=3。printf连续输出这三个元素，中间无空格，因此结果为953。" }, { "id": 714, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int m[][3]={1,4,7,2,5,8,3,6,9};\nint i,j,k=2;\nfor(i=0;i<3;i++)\nprintf(\"%d \",m[k][i]); }", "t": "single", "ans": "C", "kp": "数组", "o": [ "4 5 6", "2 5 8", "3 6 9", "7 8 9" ], "explanation": "二维数组m按行优先顺序初始化，每行3个元素。m[0]为{1,4,7}，m[1]为{2,5,8}，m[2]为{3,6,9}。变量k=2，循环输出m[2][0]、m[2][1]和m[2][2]，即第三行的元素3、6、9。" }, { "id": 715, "q": "有以下程序段叙述中正确的是（）\n{ char p[ ]={′a′, ′b′, ′c′},q[10]={ ′a′, ′b′, ′c′};\nprintf(\"%d%d\\n\",strlen(p),strlen(q));\n}", "t": "single", "ans": "B", "kp": "字符串", "o": [ "在给p和q数组置初值时,系统会自动添加字符串结束符,故输出的长度都为3", "由于p数组中没有字符串结束符,长度不能确定,但q数组中字符串长度为3", "由于q数组中没有字符串结束符,长度不能确定,但p数组中字符串长度为3", "由于p和q数组中都没有字符串结束符,故长度都不能确定" ], "explanation": "strlen计算字符串长度时以'\\0'为结束标志。数组p未指定大小且初始化未包含'\\0'，导致strlen(p)结果不确定；数组q大小为10，部分初始化时剩余元素自动补'\\0'，因此strlen(q)能正确计算出长度为3。" }, { "id": 716, "q": "有函数关系如下，\n能正确表示该关系的程序段是()", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "y=x+1;\nif(x>=0)\nif(x==0) y=x;\nelse y=x-1;", "y=x-1;\nif(x!=0)\nif(x>0) y=x+1;\nelse y=x;", "if(x<=0)\nif(x<0) y=x-1;\nelse y=x;\nelse y=x+1;", "y=x;\nif(x<=0)\nif(x<0) y=x-1;\nelse y=x+1;" ], "explanation": "题目缺失具体的函数关系表达式或图像。根据选项C的逻辑结构，当x<0时y=x-1，x=0时y=x（即0），x>0时y=x+1，这符合常见的分段函数考题设定。因题干信息不全，建议结合原题图像确认。" }, { "id": 717, "q": ".若有定义int a[]={10,20,30}, *p=&a;，当执行p++;后，下列说法错误的是（ ）", "t": "single", "ans": "A", "kp": "指针", "o": [ "p向高地址移了一个字节", "p向高地址移了一个存储单元", "p向高地址移了四个字节", "p与a+1等价" ], "explanation": "指针p指向整型数组a，执行p++时，指针向高地址移动一个整型存储单元（通常为4个字节），而不是一个字节。因此选项A描述错误。p++后指向a[1]，与a+1等价，B、C、D均正确。" }, { "id": 718, "q": "若有以下定义和语句，则输出结果是（　　）\nint a[10]={2,4,6,8,10,12,14,16,18,20},*p=&a[2];\npritnf(\"%d\",*(p+2)+a[2]);", "t": "single", "ans": "A", "kp": "指针", "o": [ "16", "18", "14", "12" ], "explanation": "指针p指向a[2]（值为6）。表达式*(p+2)等价于a[4]，其值为10。a[2]的值为6。两者相加10+6=16。注意题干中printf拼写有误，但不影响逻辑推导，最终输出结果为16。" }, { "id": 719, "q": "下面选项中关于编译预处理的叙述正确的是( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "凡是以#号开头的行，都被称为编译预处理命令行。", "预处理命令行必须使用分号结尾。", "预处理命令行不能出现在程序的最后一行。", "预处理命令行的作用域是到最近的函数结束处。" ], "explanation": "C语言中，凡是以#号开头的行都是编译预处理命令行。预处理命令不需要以分号结尾，可以出现在程序的任何位置（包括最后一行），且其作用域是从定义处开始直到源文件结束，而非到函数结束。" }, { "id": 720, "q": "设有宏定义 #define IsDIV(k,n) ((k%n==1)?1:0)，且变量m已正确定义并赋值，则宏调用IsDIV(m,5)&&IsDIV(m,7) 为真时所要表达的是（　　）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "判断m是否能被5或者7整除", "判断m是否能被5和7整除", "判断m被5或者7整除是否余1", "判断m被5和7整除是否都余1" ], "explanation": "宏替换后，表达式变为((m%5==1)?1:0) && ((m%7==1)?1:0)。当且仅当m除以5余1且m除以7余1时，两个条件表达式的值均为1，逻辑与的结果才为真。因此该宏调用用于判断m被5和7整除是否都余1。" }, { "id": 721, "q": "给定程序modi1.c中，函数insert的功能是：利用插入排序法对字符串中的字符按从小到大的顺序进行排序。插入法的基本算法是：先对字符串中的头两个元素进行排序。然后把第三个字符插入到前两个字符中，插入后前三个字符依然有序；再把第四个字符插入到前三个字符中，……。待排序的字符串已在主函数中赋予。\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "由题意可知，需通过字符串函数求出字符串aa的长度，求字符串的函数为strlen。应将\"n=strlen[ aa ];\"改为\"n=strlen(aa);\"。\nC语言中规定，使用变量之前应先对变量进行定义。程序中变量c未定义，不可在程序中使用。由题意可知，这里应为变量ch，故\"c=aa[i];\"应改为\"ch=aa[i];\"或相同作用的语句。\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 722, "q": "函数fun的功能是进行数字字符转换。若形参ch中是数字字符'0'～'9'，则'0'转换成'9'，'1'转换成'8'，'2'转换成'7'，……，'9'转换成'0'；若是其它字符则保持不变；并将转换后的结果作为函数值返回。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "由主函数中的语句\"c2=fun(c1);\"知：函数fun的返回类型为字符，故第一空应填char；在题面中要求对数字字符进行转换，故第二空的目的是判断字符ch是否为一数字字符，即ch是否在'0'～'9'之间故第二空应填ch<='9'或其等效形式；第三空处语句的目的是返回转换后的结果，即返回一字符，其所对应的数字与转换前字符所对应的数字的和为9，故第三空应填'0'或其等效形式。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 723, "q": "请编写函数fun，其功能是：将一组得分中，去掉一个最高分和一个最低分，然后求平均值，并通过函数返回。函数形参a指向存放得分的数组，形参n中存放得分个数（n>2）。\n例如，若输入9.9 8.5 7.6 8.5 9.3 9.5 8.9 7.8 8.6 8.4十个得分，则输出结果为：8.687500。\n注意：部分源程序存在PROG1.C中，请勿改动主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入所编写的若干语句。", "t": "fill", "ans": "double fun(double a[ ] , int n)\n{\ndouble min,max,s,avg;\nint i;\nmin=a[0];\nmax=a[0];\ns=0.0;\navg=0.0;\nfor(i=0;ia[i])\nmin=a[i];\nif(max10?x-12: x/12) ;\nprintf(\"%d \", w++||z++) ;\nprintf(\"%d \", w>z) ;\nprintf(\"%d \", w&&z) ;", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "0 1 0 1", "1 1 1 1", "1 0 1 0", "0 1 1 1" ], "explanation": "首先x>10为真，输出x-12即0。接着w++值为5（真），触发逻辑或短路，z++不执行，输出1，此时w=6，z=9。然后w>z即6>9为假，输出0。最后w&&z即6&&9为真，输出1。结果为0 1 0 1。" }, { "id": 726, "q": "设int gcd（int x, int y）函数的功能是求两个正整数的最大公约数，则求三个正整数a,b,c的最大公约数，下列函数调用正确的是（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "gcd（gcd（a,b）,c）", "gcd(a,b,c)", "gcd(b,c,a)", "gcd(gcd(a,b,c))\ngcd(gcd(a,b,c))" ], "explanation": "函数gcd用于求两个数的最大公约数。要求三个数a、b、c的最大公约数，可以先求a和b的最大公约数，再将结果与c求最大公约数。因此正确的嵌套调用方式为gcd(gcd(a,b), c)。" }, { "id": 727, "q": "以下程序段的运行结果是（　　）\n{ char str1[10]= \"bei\",str2[10]=\"jing\";\nchar str3[10]= \"shang\",str4[10]=\"hai\";\nstrcpy(st1,str2);\nstrcpy(&str3[1],&str4[1]);\nprintf(\"%s,%s\\n\",str1,str3); }", "t": "single", "ans": "A", "kp": "字符串", "o": [ "jing, sai", "jingbei, shanghai", "beijing, shanghai", "jingbei, hangai" ], "explanation": "strcpy(str1, str2)将'jing'复制到str1。strcpy(&str3[1], &str4[1])将str4从索引1开始的'ai'复制到str3索引1处，覆盖原有字符并补'\\0'，使str3变为'sai'。题干中st1为str1的笔误。" }, { "id": 728, "q": "设有定义： int x=0, *p; 紧接着的赋值语句正确的是（ ）", "t": "single", "ans": "B", "kp": "指针", "o": [ "*p=NULL;", "p=NULL;", "p=x;", "*p=x;" ], "explanation": "指针p未初始化时不能解引用，因此A和D错误。p是指针变量，x是整型变量，类型不匹配，C错误。将空指针常量NULL赋值给指针变量p是合法的，用于初始化指针，故选B。" }, { "id": 729, "q": "甲乙丙丁四人同时开始放鞭炮，甲每隔t1秒放一次，乙每隔t2秒放一次，丙每隔t3秒放一次，丁每隔t4秒放一次，每人各放n次。函数fun的功能是根据形参提供的值，求出总共听到多少次鞭炮声作为函数值返回。注意，当几个鞭炮同时炸响，只算一次响声，第一次响声是在第0秒。\n例如，若t1=7，t2=5，t3=6，t4=4，n=10，则总共可听到28次鞭炮声。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "宏定义函数OK的作用是判断在某个时间i时是否有鞭炮响声，故第一空应填i；\n函数fun首先找出四个人中所用时间最长的一个人，并把他每次放鞭炮所隔的时间赋给maxt，那么表达式maxt*(n-1)表示四个放完n次鞭炮所用的时间。fun函数中的第一个循环用于确定每隔1秒的时间，是否有鞭炮声，如果有，则使得记录鞭炮响声次数的变量count加1，所以第二空应填t++；\n最后返回鞭炮炸响的次数，即第三空填count。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 730, "q": "有如下程序\n#include \nmain()\n{\nint i;\nfor (i=0; i<5; i++)\nputchar('9' - i);\n}\n程序运行后的输出结果是", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "98765", "54321", "'9''8''7''6''5'", "'43210'" ], "explanation": "循环变量i从0递增到4。putchar输出字符，'9'-0为'9'，'9'-1为'8'，依此类推，'9'-4为'5'。因此依次输出字符9、8、7、6、5，结果为98765。" }, { "id": 731, "q": "已知：char a;int b;float c;double d;则执行语句c=a+b+c+d;后，变量c的数据类型是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "char", "int", "float", "double" ], "explanation": "表达式a+b+c+d在计算时，由于存在double类型变量d，其他变量会隐式转换为double，表达式结果为double型。但赋值给变量c时，c在定义时已确定为float类型，变量的数据类型不会因赋值而改变。" }, { "id": 732, "q": "以下程序段中的变量已定义为int类型\nsum = pad = 5; pAd = sum++, pAd++, ++pAd;\nprintf( \"%d\\n\", sum );\n程序段的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "5", "4", "6", "7" ], "explanation": "C语言区分大小写，pAd和pad是不同变量。逗号表达式从左向右执行：先执行pAd=sum++，sum自增为6，pAd被赋值为5；接着pAd++使pAd变为6；最后++pAd使pAd变为7。printf输出sum的值，即6。" }, { "id": 733, "q": "关于C语言的变量，以下叙述中错误的是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "所谓变量是指在程序运行过程中其值可以被改变的量", "变量所占的存储单元地址可以随时改变", "程序中用到的所有变量都必须先定义后才能使用", "由三条下划线构成的符号名是合法的变量名" ], "explanation": "变量在程序运行期间，其值可以改变，但其所占用的内存存储单元地址是固定不变的，不能随时改变，故B选项叙述错误。其他选项均符合C语言变量的基本规则。" }, { "id": 734, "q": "以下叙述中正确的是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数调用时，不必区分函数名称的大小写", "调用函数时，函数名必须与被调用的函数名完全一致", "函数名允许用数字开头", "在函数体中只能出现一次return语句" ], "explanation": "C语言严格区分大小写，函数调用时名称必须完全一致，A错B对。标识符不能以数字开头，C错。函数体中可以根据逻辑需要出现多次return语句，D错。" }, { "id": 735, "q": "当执行下列程序时，如果输入abcd，则输出结果是( )。\nmain()\n{\nchar ss[10]=\"12345\";\ngets(ss);strcat(ss,\"6789\");\nprintf(\"%s\\n\",ss);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "abcd6789", "abc6789", "6789", "abcd" ], "explanation": "数组ss初始化为\"12345\"。gets(ss)读取输入\"abcd\"并覆盖原内容，ss变为\"abcd\"。strcat将\"6789\"拼接到ss末尾，最终ss的内容为\"abcd6789\"，printf输出该字符串。" }, { "id": 736, "q": "给定程序modi1.c中函数fun的功能是：依次取出字符串中所有数字字符，形成新的字符串，并取代原字符串。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "程序中的第一个错误：s[j]=s[i];只是对s[0]循环赋值，其值为最后一个数字字符，其余的数字字符并没有保存下来，此处给s[0]赋值后，下一个数字字符应该是赋给s[1]，依次类推，所以，给s[j]赋值后j应当加1，即：j++，或者++j也可以写在一起为：s[j++]=s[i];。\n程序中的第二个错误：s[j]=\"\\0\";是想给数组加上空字符作为字符串的结束标志，但是在C语言中，字符应当用单引号引起来，双引号表示字符串。所以这里应该修改为\"s[j]='\\0';\"。\n本评析仅供参考。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 737, "q": "编写函数fun，它的功能是：计算并输出下列级数和：\n例如，当n=10时，函数值为：0.909091。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun(int n)\n{ int i;\ndouble s=0;\nfor (i=1;i<=n;i++)\ns=s+1.0/(i*(i+1)); /*累加各分式的值*/\nreturn(s);\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 738, "q": "若有定义语句：char a='\\82'; 则变量a", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "包含1个字符", "说明不合法", "包含2个字符", "包含3个字符" ], "explanation": "C语言中八进制转义字符的形式为\\ddd，其中d必须是0到7之间的数字。'\\82'中包含了数字8，不符合八进制规则，因此该字符常量说明不合法。" }, { "id": 739, "q": "已知a=5,b=6,c=7,d=8,m=2,n=2，执行(m=a>b)&&(n=cb，即5>6为假，m被赋值为0。由于左侧为0，整个表达式必为假，右侧n=c\nfloat k;\nmain()\n{\nstatic int i=0,m;\nfloat j,k;\n…\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1", "2", "3", "4" ], "explanation": "C语言中，全局变量具有静态存储期，因此全局变量k是一个静态变量。在main函数中，使用static关键字声明的局部变量i和m也是静态变量。局部变量j和k是自动变量。因此程序中共有3个静态变量。" }, { "id": 745, "q": "以下程序段的运行结果是（　　）。\n{\nint s[12]={1,2,3,4,4,3,2,1,1,1,2,3},c[5]={0},i;\nfor(i=0;i<12;i++) c[s[i]]++;\nfor(i=1;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "C", "kp": "数组", "o": [ "1 2 3 4", "2 3 4 4", "4 3 3 2", "1 1 2 3" ], "explanation": "数组c用于统计数组s中各元素出现的次数。遍历s数组，c[s[i]]++使得c[1]到c[4]分别记录1到4出现的频次。在s中，1出现4次，2出现3次，3出现3次，4出现2次。因此c[1]至c[4]的值分别为4、3、3、2，循环输出结果为4332。" }, { "id": 746, "q": "以下程序的功能实现大小写字母之间的转换。若ch是小写字母，则转换成大写字母，若ch是大写字母，则转换成小写字母，若是其他字符则保持不变。程序中空格应填的正确表达式是（ ）。\nmain()\n{char ch;\nscanf(\"%c\",&ch);\nif (________)\nch= ch -'a' + 'A';\nif ((ch>='A')&&(ch<='Z') )\nch= ch +'a'-'A' ;}", "t": "single", "ans": "B", "kp": "字符串", "o": [ "ch>=a&&ch<=z", "ch>='a'&&ch<='z'", "ch>=97||ch<=122", "ch>='a'||ch<='z'" ], "explanation": "题目要求判断字符ch是否为小写字母，若是则转换为大写。小写字母的ASCII码范围是'a'到'z'，因此条件表达式应为ch>='a'&&ch<='z'。选项A缺少单引号，选项C和D的逻辑运算符或范围表示不正确。" }, { "id": 747, "q": "以下叙述中错误的是（ ）", "t": "single", "ans": "D", "kp": "指针", "o": [ "函数可以返回地址值", "改变函数形参的值，不会改变对应实参的值", "当在程序的开头包含头文件stdio.h时，可以给指针变量赋NULL", "可以给指针变量赋一个整数作为地址值" ], "explanation": "指针变量用于存储地址，不能直接将一个普通整数赋值给指针变量，必须进行强制类型转换，或赋值为0表示空指针。选项A、B、C均符合C语言规范：函数可返回指针，值传递不改变实参，stdio.h中定义了NULL宏。" }, { "id": 748, "q": "以下是if语句的基本形式：\nif(表达式) 语句\n其中\"表达式\"( ) 。", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "必须是逻辑表达式", "必须是关系表达式", "必须是逻辑表达式或关系表达式", "可以是任意合法的表达式" ], "explanation": "在C语言中，if语句后的表达式可以是任意合法的表达式，包括算术表达式、关系表达式、逻辑表达式、赋值表达式等。系统会自动计算表达式的值，若结果非0则视为\"真\"，执行对应语句；若为0则视为\"假\"。" }, { "id": 749, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=1+i;\nprintf(\"%d%d%d\",a[2],a[4],a[6]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "357", "752", "753", "157" ], "explanation": "循环语句for(i=9;i>=0;i--) a[i]=1+i;将数组a的每个元素赋值为其下标加1。因此，a[2]的值为3，a[4]的值为5，a[6]的值为7。printf语句连续输出这三个元素的值，中间无分隔符，故结果为357。" }, { "id": 750, "q": "以下程序段的运行结果是( )\n#define N 10\n#define M1 N+1\n#define M2 M1*2\nmain()\n{ printf(\"%d\\n\",M2); }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "12", "22", "20", "11" ], "explanation": "宏替换是简单的文本替换，不进行计算。M2被替换为M1*2，进一步替换为N+1*2，最终替换为10+1*2。根据运算符优先级，先计算乘法1*2，再计算加法10+2，结果为12。注意宏定义中未加括号导致的优先级问题。" }, { "id": 751, "q": "以下叙述中错误的是（　　）。", "t": "single", "ans": "C", "kp": "综合编程/调试改错", "o": [ "C程序经过编译、连接步骤之后才能形成一个真正可执行的二进制机器指令文件", "用C语言编写的程序称为源程序，它以ASCII代码形式存放在一个文本文件中", "C语言中的每条可执行语句和非执行语句最终都将被转换成二进制的机器指令", "C语言源程序经编译后生成后缀为.obj的目标程序" ], "explanation": "C语言源程序中的非执行语句（如注释、预处理命令、变量声明等）在编译过程中会被处理或忽略，不会被转换成二进制的机器指令。只有可执行语句才会被编译成机器指令。选项A、B、D的描述均正确。" }, { "id": 752, "q": "与数学表达式x≥y≥z对应的C语言表达式是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "(x>=y>=z)", "(x>=y)&&(y>=z)", "(x>=y)!(y>=z)", "(x>=y)||(y>=x)" ], "explanation": "C语言不支持数学中的连续不等式写法。若写成x>=y>=z，会先计算x>=y得到0或1，再将其与z比较，逻辑错误。正确的做法是将其拆分为两个独立的关系表达式，并用逻辑与运算符&&连接，即(x>=y)&&(y>=z)。" }, { "id": 753, "q": "下面选项中的程序段，没有编译错误的是（ ）", "t": "single", "ans": "A", "kp": "指针", "o": [ "char* sp, s[10]; sp = \"Hello\";", "char* sp, s[10]; s = \"Hello\";", "char str1[10] = \"computer\", str2[10]; str2 = str1;", "char mark[]; mark = \"PROGRAM\";" ], "explanation": "在C语言中，数组名代表数组首地址，是一个地址常量，不能对其进行赋值操作，因此选项B、C、D中对数组名s、str2、mark的赋值均非法。选项A中，sp是字符指针变量，可以指向字符串常量\"Hello\"的首地址，语法正确。" }, { "id": 754, "q": "下列程序的执行结果是( )。\nint x=2000,a=15,b=30,c=5,d=0;\nif (a\nmain(){\nint x=1,y=1;\nif ( !x ) y++;\nelse if (x==0)\nif(x) y+=2;\nelse y+=3;\nprintf(\"%d\\n\",y);\n}\n程序运行后的输出结果是（）。", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "3", "2", "1", "0" ], "explanation": "初始x=1，y=1。第一个条件if(!x)即if(0)为假；接着判断else if(x==0)即else if(0)也为假。由于所有条件判断均不成立，程序不会执行任何if或else分支内的语句，y的值保持初始值1不变，最终输出1。" }, { "id": 767, "q": "下面的程序片段所表示的数学函数关系是( )。\nif (x>0) y=1;\nelse y=0;\nif (x==0) y=-1;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "┌ -1(x<0)\n│\ny=┤ 0 (x=0)\n│\n└ 1 (x>0)", "┌ 1 (x<0)\n│\ny= ┤-1 (x=0)\n│\n└ 0 (x>0)", "┌ 0 (x<0)\n│\ny= ┤-1 (x=0)\n│\n└ 1 (x>0)", "┌ -1(x<0)\n│\ny= ┤ 1 (x=0)\n│\n└ 0 (x>0)" ], "explanation": "程序先判断x>0，成立则y=1，否则y=0。接着判断x==0，成立则y=-1。综合来看，当x>0时y=1；当x=0时，先被赋0后被赋-1，最终y=-1；当x<0时，两次判断均不满足后续赋值，y保持0。因此表示的数学函数关系为x>0时y=1，x=0时y=-1，x<0时y=0。" }, { "id": 768, "q": "以下叙述中正确的是（）", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "if语句只能嵌套一层", "不能在else子句中再嵌套if语句", "if子句和else子句中可以是任意的合法的C语句", "改变if-else语句的缩进格式，会改变程序的执行流程" ], "explanation": "C语言中，if和else子句后可以跟任何合法的C语句，包括单条语句、复合语句或空语句。if语句支持多层嵌套，else子句中也可以嵌套if语句。此外，C语言通过大括号和语法结构控制执行流程，改变代码缩进格式不会影响程序的实际执行逻辑。" }, { "id": 769, "q": "下面程序的运行结果是( )。\nint a,b;\na=-1;\nb=0;\ndo\n{\n++a;\n++a;\nb+=a;\n} while(a<=9);\nprintf(\"%d\\n\",b);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "36", "24", "25", "26" ], "explanation": "初始a=-1，b=0。每次循环a自增两次（即加2），然后b累加a的值。循环过程如下：第1次a=1，b=1；第2次a=3，b=4；第3次a=5，b=9；第4次a=7，b=16；第5次a=9，b=25；第6次a=11，b=36。此时a=11不满足a<=9的条件，循环结束，最终输出b的值为36。" }, { "id": 770, "q": "有以下程序段\nint k=1；\nwhile(k=0) k++;\nwhile 循环执行的次数是( ) 。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "无限次", "有语法错，不能执行", "一次也不执行", "执行1次" ], "explanation": "本题考查while循环的条件判断。循环条件为赋值表达式\"k=0\"，该表达式的值为赋值后的结果，即0。在C语言中，0代表逻辑假，因此循环条件一开始就不成立，循环体一次也不会执行。注意区分赋值运算符\"=\"与关系运算符\"==\"。" }, { "id": 771, "q": "有以下程序，执行后输出的结果是（　　）。\nmain(){\nint i;\nfor(i=0;i<3;i++){\nif(i==2) continue;\nswitch(i)\n{ case 1: printf(\"%d\",i);\ncase 2: printf(\"%d\",i);\ndefault: printf(\"%d\",i); }\n}\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "011122", "0111", "012020", "012" ], "explanation": "当i=0时，执行default分支输出0；当i=1时，匹配case 1输出1，由于没有break语句，发生穿透，继续执行case 2和default，各输出一个1，共输出111；当i=2时，满足if条件执行continue，直接跳过本次循环剩余部分。因此最终输出结果为0111。注意switch-case的穿透特性及continue的作用。" }, { "id": 772, "q": "下面程序段的运行结果是()\nint i,j,a=0;\nfor(i=0;i<2;i++)\n{for(j=0;j<4;j++)\n{if(j%2) break;\na++;\n}\na++;\n}\nprintf(\"%d\\n\",a);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "4", "5", "6", "7" ], "explanation": "外层循环执行2次（i=0和1）。每次内层循环中，当j=0时，j%2为0，不执行break，a自增1；当j=1时，j%2为1，执行break跳出内层循环。因此每次外层循环中，内层循环使a加1，跳出后外层循环的a++再使a加1，即每次外层循环a共增加2。外层循环执行2次，最终a的值为4。" }, { "id": 773, "q": "有如下程序\nmain()\n{ int n=9;\nwhile(n>6)\n{n--;printf(\"%d\",n);}}\n该程序段的输出结果是( )", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "987", "876", "8765", "9876" ], "explanation": "初始n=9，满足n>6进入循环。第一次循环n自减为8，输出8；第二次循环n自减为7，输出7；第三次循环n自减为6，输出6；此时n=6，不再满足n>6的条件，循环结束。因此程序最终输出的结果是876。注意先自减再输出的顺序。" }, { "id": 774, "q": "对于无返回值的函数h，下面不正确的函数原型声明语句是（　　）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "void h(x,int y) ;", "void h(int a, int b);", "void h(int x, int y) ;", "void h( int, int) ;" ], "explanation": "在C语言中，函数声明时必须明确指定每个形参的数据类型。选项A中，第一个形参x缺少数据类型说明，属于语法错误。选项B、C提供了完整的类型和参数名，选项D提供了完整的类型而省略了参数名，这三种形式在函数原型声明中都是合法的。" }, { "id": 775, "q": "以下程序的输出结果是（）\nint a=4;\nint f(int n){\nint t=0;\nint a=7;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<3;i++) s+=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "45", "44", "42", "43" ], "explanation": "全局变量a=4，main中s初始为4。函数f内定义局部变量a=7。当i=0时，执行else分支，块内局部a=7，t=7，返回t+f内局部a++（即7+7=14），s变为18；当i=1时，执行if分支，块内局部a=6，t=6，返回6+7=13，s变为31；当i=2时，同i=0，返回14，s变为45。最终输出45。注意变量遮蔽与自增运算顺序。" }, { "id": 776, "q": "以下叙述中正确的是（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "外部变量可以没有作用域", "main（）函数中定义的局部变量的作用域可扩展到其它自定义函数", "局部变量存放在静态存储区", "全局变量可在函数内部定义" ], "explanation": "B项main函数的局部变量作用域仅限main内；D项全局变量必须在函数外部定义；C项普通局部变量存放在动态存储区，仅静态局部变量存放在静态存储区；A项任何变量都有作用域，外部变量作用域通常到文件末尾或通过extern扩展。各选项表述均有明显瑕疵，疑似题目选项文字有遗漏（如C项漏掉\"静态\"二字）。" }, { "id": 777, "q": "以下正确的定义语句是（ ）", "t": "single", "ans": "A", "kp": "数组", "o": [ "int a[ ][3]={{ 0 },{1},{1,2,3}};", "int a[3][3]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};", "int a[3][ ]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};", "int a[ ][3]={1;2;3;4};" ], "explanation": "二维数组初始化时，可以省略第一维（行数）的大小，系统会根据初始化数据的行数自动推断，但第二维（列数）的大小必须明确指定。选项A省略了第一维，列数为3，初始化数据分为3行，合法；选项B和C的初始化行数超过了定义的行数，且C省略了第二维大小；选项D使用了分号而非逗号分隔元素，存在语法错误。" }, { "id": 778, "q": "以下对一维数组arry进行正确初始化的语句是（　　）。", "t": "single", "ans": "A", "kp": "数组", "o": [ "int arry[ ]={0,11,12,13,14,15};", "int arry[5]={ };", "int arry[5]={2,4,6,8,10,12 };", "int arry[5]={3:6:9:12};" ], "explanation": "选项A省略了数组长度，编译器会根据大括号内元素的个数自动确定数组长度为6，语法正确。选项B的初始化列表为空，不符合C语言标准语法；选项C提供的初始值个数（6个）超过了数组定义的长度（5），会导致编译错误；选项D使用了冒号而不是逗号来分隔初始值，存在语法错误。" }, { "id": 779, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=0;i<3;i++) s+=a[i][0]+a[1][2-i];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "C", "kp": "数组", "o": [ "26", "25", "24", "27" ], "explanation": "循环执行3次。i=0时，s累加a[0][0]和a[1][2]即1+8=9；i=1时，累加a[1][0]和a[1][1]即3+4=7，s变为16；i=2时，累加a[2][0]和a[1][0]即5+3=8，s最终为24。" }, { "id": 780, "q": "以下程序的运行结果是（　　）\nmain()\n{\nchar arr[2][4];\nstrcpy(arr[0],\"you\");\nstrcpy(arr[1],\"me\");\nprintf(\"%s\\n\",arr);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "you", "me", "youme", "youm" ], "explanation": "二维数组名arr作为printf的%s参数时，会退化为指向首行首元素的指针，即arr[0]的地址。因此从arr[0]开始输出字符串，遇到arr[0]末尾的'\\0'停止，故只输出you。" }, { "id": 781, "q": "下面程序的输出结果是( ).\nmain( )\n{int x=100,a=10,b=20,ok1=5,ok2=10;\nif (a\n#define SUB(a) (a)-(a)\nmain()\n{\nint a=2,b=3,c=5,d;\nd=SUB(a+b)*c;\nprintf(\"%d\\n\",d);\n}\n程序运行后的输出结果是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "-12", "0", "10", "-20" ], "explanation": "宏替换为文本替换，d=SUB(a+b)*c被替换为d=(a+b)-(a+b)*c。代入a=2,b=3,c=5，表达式为(2+3)-(2+3)*5。根据运算符优先级，先算乘法再算减法，即5 - 5*5 = -20。" }, { "id": 786, "q": "给定程序modi1.c中，函数fun的功能是：找出一个大于形参m且紧随m的素数，并作为函数值返回。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "首先，我们必须先读懂题中程序的大致意思，这是发现并改正程序中错误的重要前提。\n程序中的重要思想如下：\n1、首先，要了解素数的意思，素数是指只能被1和它自身整除的数；\n2、题目中要求找出一个大于给定整数 m 且紧随 m 的素数。\n本评析仅作参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 787, "q": "给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。\n例如，当形参n的值为10时，函数返回：-0.204491。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "变量k用来决定符号位，所以第一处填：1，第三处填：-1；根据题目中的公式可以得出每项的分母是该数值的倍数的平方，程序中用变量t来表示，所以第二处答案为：2*i或2.0*i或i*2或i*2.0。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 788, "q": "m个人的成绩存放在score数组中，请编写函数fun，它的功能是：将低于平均分的人数作为函数值返回，将低于平均分的分数放在below所指的数组中。\n例如，当score数组中的数据为：10、20、30、40、50、60、70、80、90时，函数返回的人数应该是4，below中的数据应为：10 20 30 40。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "int fun(int score[], int m, int below[])\n{\nint total=0;/*用于计算m个学生的成绩之和*/\nint average=0;\nint *p_below=below;/*用于存放成绩低于平均分的学生的成绩*/\nint i=0;\nint j=0;/*用于计算成绩低于平均分的学生的人数*/\nfor(i=0;i=65&&s[i]<=90 )\nn++;\nprintf(\"%d\",n);\n}", "t": "single", "ans": "C", "kp": "字符串", "o": [ "17", "4", "5", "8" ], "explanation": "程序遍历字符串s，通过条件s[i]>=65&&s[i]<=90判断字符是否为大写字母（ASCII码65~90）。字符串中B、S、D、F、Y共5个大写字母，因此n最终累加为5。" }, { "id": 791, "q": "若有定义： int a,b; 通过语句 scanf(\"%d;%d\",&a,&b); 能把整数1赋给变量a，2赋给变量b的输入数据是（）", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "1,2", "1 2", "1;2", "12" ], "explanation": "scanf函数的格式控制字符串中，除了格式说明符（如%d）外，其他普通字符（如本题中的分号;）在输入时必须原样输入。因此输入两个整数时，中间必须用分号分隔，即1;2。" }, { "id": 792, "q": "以下关于逻辑运算符两侧运算对象的叙述中正确的是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "只能是整数0或非0整数", "可以是结构体类型的数据", "可以是任意合法的表达式", "只能是整数0或1" ], "explanation": "在C语言中，逻辑运算符（&&、||、!）两侧的运算对象不局限于整数0或1，也不局限于特定数据类型，可以是任意合法的表达式。系统会根据表达式的计算结果是否为0来判断逻辑真假。" }, { "id": 793, "q": "以下选项中合法的实型常量是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "0123", "3.13e-2.0", "-0.914", "2.0E" ], "explanation": "A项0123是八进制整型常量；B项指数部分-2.0不是整数，不合法；D项2.0E的指数部分缺失，不合法；C项-0.914是标准的小数形式实型常量，完全合法。" }, { "id": 794, "q": "以下选项中合法的标识符是(　　)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "++y", "li hua", "Mr.Smith", "n_date" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且首字符不能是数字。A含运算符++，B含空格，C含点号，均非法。D符合命名规则，是合法标识符。" }, { "id": 795, "q": "以下 符合 C 语 言语 法 的 赋值 表 达 式是 ______。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "d=9+e+f=d+9", "d=(9+e,f=d+9)", "d=d+1=9+e", "d=9+e++=d+7" ], "explanation": "赋值运算符左侧必须是可修改的左值。A、C、D中等号左侧均为算术表达式或常量，无法作为左值赋值。B使用逗号表达式，先计算9+e，再执行f=d+9并将结果赋给d，符合语法。" }, { "id": 796, "q": "以下程序段的输出结果是：\nint x,y=1; printf(\"%d\",x);", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0", "随机值", "编译出错", "1" ], "explanation": "局部变量x声明后未初始化，其值为内存中的随机垃圾值。C语言不会自动将局部变量初始化为0，因此输出结果不确定，为随机值。" }, { "id": 797, "q": "以下fact函数的功能是（）int fact（int n）\n{\nint f=1,i;\nfor(i=1;i<=n;i++)\nf*=i;\nreturn f;\n}", "t": "single", "ans": "B", "kp": "排序查找与简单算法", "o": [ "计算组合数", "计算阶乘", "计算平均值", "计算和" ], "explanation": "函数内循环从1到n，每次将i累乘到变量f中，初始f为1。该过程计算的是1×2×…×n，即n的阶乘。" }, { "id": 798, "q": "在执行下述程序段时，若从键盘输入7和9，则结果为（）。\ninta,b,s;\nscanf(\"%d%d\",&a,&b);\ns=a;\nif(a>b)\ns=b; s*=s;\nprintf(\"%d\",s);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "49", "81", "7", "以上都不对" ], "explanation": "输入a=7,b=9。执行s=a后s为7。if(a>b)条件不成立，跳过s=b。由于if后无大括号，仅s=b受条件控制，s*=s;始终执行，故s=7*7=49。" }, { "id": 799, "q": "执行下面程序后，x的值为（）。\nint a=0,b=0,c=0,x=3;\nif (!a) x=0;\nelse if (!b)x=2;\nelse if (!c) x=1;", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "初始a=0，!a为真，执行x=0。由于是if-else if链式结构，第一个条件满足后后续分支全部跳过，故x最终值为0。" }, { "id": 800, "q": "以下程序段执行后输出的结果是()。\nint a=5,b=4,c=3,d=2;\nif(a>b>c)\nprintf(\"%d\\n\",d+1);\nelse\nprintf(\"%d\\n\",d+2);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "2", "3", "4", "编译时有错，无结果" ], "explanation": "关系运算符从左向右结合，a>b>c等价于(a>b)>c。5>4结果为1，再判断1>3为假，执行else分支输出d+2，即2+2=4。" }, { "id": 801, "q": "以下程序段的输出结果是()\nint x=1,y=3,z=2;\nif(x>=y)\nz=-1;\nelse\nif(y<0) z=0;\nprintf(\"%d\\n\",z);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "0", "2", "-1", "3" ], "explanation": "x>=y为假，进入else分支。else后的if(y<0)条件也不成立，z未被重新赋值，保持初始值2，故输出2。" }, { "id": 802, "q": "有以下程序，执行后输出的结果是（　　）。\nmain(){\nint i;\ni=1;\ndo{\nif(i==2) break;\nswitch(i)\n{ case 1: printf(\"%d\",i);\ncase 2: printf(\"%d\",i);\ndefault: printf(\"%d\",i); }\ni++;\n} while(i<3);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "011122", "111", "11122", "012" ], "explanation": "i初值为1，进入do循环。switch(1)无break，依次执行case1、case2和default，连续输出三个1。i自增为2后满足while条件再次循环，此时i==2触发break跳出，最终输出111。" }, { "id": 803, "q": "以下程序的运行结果是（　　）。\nmain(){\nint i, j=0;\nfor(i=5; i>2;i--)\n{ j=j+i;\ni--;\n}\nprintf(\"%d\\n\",j);}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "10", "9", "8", "7" ], "explanation": "循环初值i=5。第一次循环j+=5得5，循环体内i--使i变4，for更新i--使i变3。第二次循环j+=3得8，体内i--使i变2，更新i--使i变1，不满足i>2退出。最终j为8。" }, { "id": 804, "q": "下面程序段的运行结果是()\nint num=0;\nwhile(num<=2)\n{num++;\nprintf(\"%d\\n\",num);\n}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1", "1\n2", "1\n2\n3", "1\n2\n3\n4" ], "explanation": "num初值0，循环条件num<=2。每次循环先自增再打印。num依次变为1、2、3并输出，当num为3时不满足条件退出，故输出1、2、3。" }, { "id": 805, "q": "以下程序的运行结果是( ) 。\nint sum=0, item =0;\nwhile(item<5)\n{ item++;\nif(item==2) continue;\nsum+=item;\n}\nprintf(\"%d\\n\", sum);", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "1", "10", "13", "15" ], "explanation": "item从0开始，每次循环先自增。当item为2时执行continue跳过累加，其余1、3、4、5均累加到sum。sum=1+3+4+5=13，循环结束输出13。" }, { "id": 806, "q": "下列程序的输出结果是( )。\nint i, j, m=0, n=0;\nfor(i=0; i<2; i++)\nfor(j=0; j<2; j++)\nif (j>=i) m=1;\nn++;\nprintf(\"%d \\n\",n);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "0", "1", "2", "4" ], "explanation": "本题的关键是没有大括号。两个for循环和if语句实际控制的语句只有m=1;，n++;不在循环体和if语句内。前面的双重循环只会反复给m赋值，循环结束后n仍为0；随后n++执行一次，n变为1，所以输出1。" }, { "id": 807, "q": "以下程序的输出结果是( )。\nmain()\n{\nint i=1,j=1,k=2;\nwhile((j++||k++)&&i++) { printf(\"%d,%d,%d\\n\",i,j,k);}\n}\n执行后输出的结果是 ( )。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1,1,2", "死循环", "2,2,2", "2,2,3" ], "explanation": "逻辑或||具有短路特性，j++初始为1，其值为真，因此k++不执行。由于j不断自增，j++始终非零为真；同时i++也始终非零为真。整个while条件永远成立，导致程序陷入死循环。" }, { "id": 808, "q": "以下程序的运行结果是（　　）\nfun(int x, int y, int z)\n{ z=x*x+y*y; }\nmain()\n{ int a=310;\nfun(5,2,a);\nprintf(\"%d\",a);\n}", "t": "single", "ans": "B", "kp": "函数", "o": [ "31", "310", "29", "300" ], "explanation": "C语言中函数参数传递采用值传递方式。在调用fun(5,2,a)时，实参a的值传递给形参z，在fun函数内部对z的修改不会影响到主函数中的实参a。因此，a的值保持初始值310不变。" }, { "id": 809, "q": "有关函数调用时形参和实参的关系描述中，正确的是（）。", "t": "single", "ans": "A", "kp": "函数", "o": [ "形参和实参的个数应相等", "形参个数大于实参个数", "形参个数小于实参个数", "A、B和C均可以" ], "explanation": "在C语言中，函数调用时实参和形参的个数必须严格相等，且类型应一致或兼容，顺序一一对应。如果个数不相等，编译器通常会报错或产生未定义行为。因此正确选项为A。" }, { "id": 810, "q": "以下程序的运行结果是（ ）\n#include\nint a=12,b=21;\nmax(int a, int b)\n{ int c ;\nc=a>b?a:b;\nreturn c;\n}\nmain()\n{ int a=35;\nprintf(\"%d\",max(a,b);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "35", "12", "21", "随机值" ], "explanation": "主函数中定义了局部变量a=35，根据局部优先原则，max(a,b)中的a使用局部变量35，b使用全局变量21。传入max函数后，通过三目运算符比较得出较大值35并返回。题目代码中printf缺少右括号，但不影响逻辑推导。" }, { "id": 811, "q": "全局变量的有效范围为( )", "t": "single", "ans": "D", "kp": "函数", "o": [ "该程序的所有文件", "从本源文件的开始到结束", "该程序的主函数", "从定义变量的位置开始到本源文件结束" ], "explanation": "在C语言中，全局变量（外部变量）的作用域是从其定义的位置开始，一直到本源文件结束。如果要在定义位置之前或其他文件中使用，需要使用extern关键字进行声明。因此默认有效范围是D。" }, { "id": 812, "q": "以下程序的运行结果是（） 。\nfun(int x)\n{ \n   if(x/2>0) fun(x/2);\n      printf(\"%d*\",x);\n}\nmain()\n{ \n  fun(6);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "1*3* 6*", "3* 6*1*", "6*3*1*", "3*1* 6*" ], "explanation": "本题考查递归函数的执行过程。调用fun(6)时，6/2>0成立，递归调用fun(3)；3/2>0成立，递归调用fun(1)；1/2>0不成立，停止递归并输出1*。随后逐层返回，依次输出3*和6*。最终结果为1*3*6*。" }, { "id": 813, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int i,x=0, a[6],b[3];\nfor(i=0;i<6;i++) a[i]=i+1;\nfor(i=0;i<3;i++) b[i]=a[i+1];\nfor(i=0;i<3;i++) x+=b[i]*3;\nprintf(\"%d\\n\",x)；}", "t": "single", "ans": "D", "kp": "数组", "o": [ "26", "不定值", "25", "27" ], "explanation": "第一个循环为数组a赋值，a的元素依次为1到6。第二个循环将a[1]、a[2]、a[3]的值赋给b，即b的元素为2、3、4。第三个循环计算x的累加和：x = 2*3 + 3*3 + 4*3 = 27。最终输出27。" }, { "id": 814, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{2,3,6},{2,7,9},{3,5,10},{5}};\nprintf(\"%d%d%d%d\\n\",a[0][3],a[1][2],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "0955", "095", "0950", "0951" ], "explanation": "二维数组部分初始化时，未显式赋值的元素自动初始化为0。a[0]初始化为{2,3,6,0}，故a[0][3]为0；a[1]为{2,7,9,0}，a[1][2]为9；a[2]为{3,5,10,0}，a[2][1]为5；a[3]为{5,0,0,0}，a[3][0]为5。拼接输出为0955。" }, { "id": 815, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint i,t[][3]={9,8,7,6,5,4,3,2,1,9};\nfor(i=0;i<3;i++) printf(\"%d\",t[3-i][i]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "924", "456", "234", "543" ], "explanation": "数组t共10个元素，按每行3列初始化，共4行。未赋值的元素补0。即t[0]为{9,8,7}，t[1]为{6,5,4}，t[2]为{3,2,1}，t[3]为{9,0,0}。循环中依次输出t[3][0]（9）、t[2][1]（2）和t[1][2]（4），结果为924。" }, { "id": 816, "q": "以下程序的运行结果是（ ）。\nmain( )\n{ char b[30];\nstrcpy(&b[0], \"CH\");\nstrcpy(&b[1], \"DEF\");\nstrcpy(&b[2], \"ABC\");\nprintf(\"%s \\n\",b）;}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "CDABC", "CHDEFABC", "ABC", "DEFABC" ], "explanation": "strcpy函数从目标地址开始覆盖字符并追加\\0。第一次b变为CH；第二次从b[1]开始覆盖，b变为CDEF；第三次从b[2]开始覆盖为ABC及\\0，此时b[0]和b[1]保持为C和D，最终字符串为CDABC。" }, { "id": 817, "q": "有以下程序段，其输出结果是()\nint a=1,b=2,c=3,d=4,r=0;\nif(a!=1);else r=1;\nif(b==2) r+=2;\nelse;if(c!=3)r+=3;\nelse;if(d==4)r+=4;\nprintf(\"%d\\n\",r);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "7", "6", "3", "10" ], "explanation": "首先a!=1为假，执行else分支，r=1。接着b==2为真，r+=2使r变为3，其后的else;为空语句不执行。随后的if(c!=3)和if(d==4)是独立的条件判断，c!=3为假不执行，d==4为真，执行r+=4，r最终为7。注意代码中else;后的if并非else if。" }, { "id": 818, "q": "下列函数的功能是（ ）\nvoid fun(char *a,char *b） { while((*b=*a）!='\\0') { a++; b++;} }", "t": "single", "ans": "C", "kp": "指针", "o": [ "使指针b指向a所指字符串", "将a所指字符串和b所指字符串进行比较", "将a所指字符串赋给b所指空间", "检查a和b所指字符串中是否有'\\0'" ], "explanation": "函数通过指针遍历，将a指向的字符逐个赋值给b指向的内存空间，直到遇到字符串结束符'\\0'。这实现了字符串的复制功能。选项A只是指针赋值，B是比较，D是检查，均不符合代码逻辑。" }, { "id": 819, "q": "以下语句或语句组中,能正确进行字符串赋值的是（　）。", "t": "single", "ans": "D", "kp": "字符串", "o": [ "char *sp; *sp=\"right!\";", "char s[10];s=\"right!\";", "char s[10]; *s=\"right!\";", "char *sp=\"right!\";" ], "explanation": "A中sp未初始化指向有效内存，直接解引用赋值会导致段错误；B中数组名s是常量指针，不能被赋值；C中*s是字符，不能赋值为字符串指针；D中定义字符指针sp并初始化指向字符串常量，语法正确。" }, { "id": 820, "q": "以下程序中的for循环执行的次数是（　　）。\n#define N 7\n#define M N+1\n#define NUM 2*M+1\n#main()\n{ int i;\nfor(i=1;i<=NUM;i++)\nprintf(\"%d\\n\",i);\n}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "18", "17", "16", "15" ], "explanation": "宏替换是纯文本替换。NUM展开为2*N+1+1，再展开为2*7+1+1。根据运算符优先级，先算乘法2*7=14，再加1+1，结果为16。循环条件为i<=16，i从1开始，因此循环执行16次。注意宏定义未加括号导致的优先级问题。" }, { "id": 821, "q": "以下程序的运行结果是（　　）。\n#define MUL(x,y) (x) *y+2\nmain( )\n{ int a=3，b=4，c;\nc=MUL(a,b);\nprintf(\"%d \\n\"，c); }", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "15", "20", "14", "18" ], "explanation": "宏替换后，c=(a)*b+2，即c=3*4+2。根据运算符优先级，先算乘法再算加法，结果为12+2=14。注意宏定义中y没有加括号，若传入表达式可能会出错，但此处传入的是变量，直接替换计算即可。" }, { "id": 822, "q": "给定程序modi1.c中函数fun的功能是：根据输入的三个边长（整型值），判断能否构成三角形：构成的是等边三角形，还是等腰三角形。若能构成等边三角形函数返回3，若能构成等腰三角形函数返回2，若能构成一般三角形函数返回1，若不能构成三角形函数返回0。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 823, "q": "给定程序中，函数fun的功能是：计算出形参s所指字符串中包含的单词个数，作为函数值返回。为便于统计，规定各单词之间用空格隔开。\n例如，形参s所指的字符串为：This is a C language program.，函数的返回值为6。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "在fun函数中通过字符串指针变量来访问字符串数组。变量n统计的是单词的个数，flag变量为同一单词的标志。while语句设置循环执行的条件，即字符串指针变量指向的地址内容不为空，第一个if语句判断当指针变量指向的地址内容不是空格并且标志为0（即下一个单词开始的标志）时，将单词的个数加1并将标志设为1，所以第一个空填：n++或与此语句相同功能的语句；如果指针变量指向的地址内容为空格，则将标志设为0，所以第二个空填：0或与此语句相同功能的语句；根据程序第三个空填：s++或与此语句相同功能的语句以保证循环的正确运行。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 824, "q": "请编写函数fun，函数的功能是：将M行N列的二维数组中的字符数据按列的顺序依次放到一个字符串中。\n例如，二维数组中的数据为：\nW W W W\nS S S S\nH H H H\n则字符串中的内容应是：WSHWSHWSHWSH。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(char s[][N], char *b)\n{\nint i,j,n=0;\nfor(i=0; i < N;i++) /* 请填写相应语句完成其功能 */\n{\nfor (j=0;j0)", "(x-y<0)", "(x-y<0║x-y>0)", "(x-y==0)" ], "explanation": "在C语言中，条件表达式的判断规则是\"非0为真，0为假\"。因此(x-y)为真等价于(x-y)不等于0，即(x-y!=0)。选项C中的\"(x-y0)\"应为\"(x-y!=0)\"的排版或识别错误，根据题意应选C。" }, { "id": 830, "q": "若有定义 int a=12, n=5, 则表达式 a%=(n%2) 运算后, a 的值()。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "0", "1", "12", "6" ], "explanation": "先计算括号内的n%2，即5%2=1。然后计算a%=1，即a=a%1。任何整数对1取余结果都为0，因此a的值为0。" }, { "id": 831, "q": "执行以下程序段的输出结果是 ( )。\nint a=14,b=15,x;\nchar c;\nfor(c='A';c<'D';c++)\nx=(a&&b)&&(c<'B');\nprintf(\"%d\",x);", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "值不确定", "程序段有语法错", "0", "1" ], "explanation": "循环执行3次，c分别为'A','B','C'。每次循环都会重新计算x的值。最后一次循环c='C'，此时c<'B'为假（0）。逻辑与运算中只要有一个操作数为0，结果即为0。因此最终x的值为0。" }, { "id": 832, "q": "下面程序段执行后， sum 的值为()。\nsum=0;i=1;\nwhile( i<=10)\n{ if(i%5==0)break;\nelse sum+=i;\ni++;\n}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "55", "50", "40", "10" ], "explanation": "循环从i=1开始，当i=1,2,3,4时，i%5!=0，sum累加1+2+3+4=10。当i=5时，i%5==0成立，执行break跳出循环。因此sum的最终值为10。注意i++在else分支外，但break直接跳出，不会执行后续的i++。" }, { "id": 833, "q": "以下程序的运行结果是（　　）。\nint x=2;\nwhile (x--) printf(\"%d\",x);\nprintf(\"%d\",x);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1 0", "1 0 -1", "1 -2", "死循环" ], "explanation": "初始x=2。第一次判断x--，表达式值为2（真），x变为1，输出1；第二次判断x--，表达式值为1（真），x变为0，输出0；第三次判断x--，表达式值为0（假），x变为-1，循环结束。最后输出x的值-1。因此输出1 0 -1。" }, { "id": 834, "q": "若已定义的函数没有返回值，则以下关于该函数调用的叙述中正确的是（　　）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "函数调用不能作为独立的语句存在", "函数调用不能作为另一个函数的实参", "函数调用不能出现在算术表达式中", "函数调用可以出现在赋值表达式中" ], "explanation": "在C语言中，若函数没有返回值（即void类型），其调用只能作为独立语句，不能参与赋值等表达式运算。若按题库答案D，可能题干本意为\"有返回值\"或指未声明返回类型时默认返回int，此时可出现在赋值表达式中。本题表述与常规规范存在冲突。" }, { "id": 835, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint p[8]={11,12,13,14,15,16,17,18},i=0,j=0;\nwhile(i++<5) if(p[i]%2==0) j+=p[i];\nprintf(\"%d\\n\",j);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "28", "42", "32", "30" ], "explanation": "while循环条件为i++<5。初始i=0，第一次判断0<5成立，i自增为1，p[1]=12为偶数，j=12；第二次i变2，p[2]=13为奇数；第三次i变3，p[3]=14为偶数，j=26；第四次i变4，p[4]=15为奇数；第五次i变5，p[5]=16为偶数，j=42；第六次5<5不成立，循环结束。最终j为42。" }, { "id": 836, "q": "以下对一维数组b进行正确初始化的语句是( )", "t": "single", "ans": "C", "kp": "数组", "o": [ "int b[5]={1,2,3,4,5,6};", "int b[5]={1;2;3;4;5;6};", "int b[ ] ={1,2,3,4,5,6};", "int b[5]={1 2 3 4 5 6};" ], "explanation": "A选项初始化元素个数超过数组定义长度；B选项元素间应使用逗号而非分号分隔；D选项元素间缺少逗号。C选项省略了数组长度，编译器会根据初始化列表中的元素个数自动确定数组长度为6，语法完全正确。" }, { "id": 837, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=1;i<3;i++) s+=a[i][0]+a[1][3-i-1];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "15", "16", "14", "17" ], "explanation": "数组a为3x3矩阵。循环i从1到2。当i=1时，s累加a[1][0]（值为3）和a[1][1]（值为4），s变为7；当i=2时，s累加a[2][0]（值为5）和a[1][0]（值为3），s增加8，最终s为15。注意数组下标从0开始计算。" }, { "id": 838, "q": "下面程序段的输出结果是（ ）\nmain( )\n{ int a[ ]={1,2,3,4,5,6,7,8,9,10,11,12},*p=a+5, *q=&a[2];\n*q=* (p+5);\nprintf(\"%d,%d\\n\",*p, *q); }", "t": "single", "ans": "A", "kp": "指针", "o": [ "6,11", "6,6", "5,5", "运行后报错" ], "explanation": "指针p指向a[5]（值为6），q指向a[2]。表达式p+5指向a[10]（值为11）。执行*q=*(p+5)后，a[2]的值被修改为11。最后输出*p和*q，即a[5]和a[2]的值，分别为6和11。" }, { "id": 839, "q": "给定程序MODI1.C中，函数int my_isalpha(char c)的功能是返回字符的种类：大写字母返回1，小写字母返回-1，其他字符返回0。\n函数void a()调用my_isalpha()，根据其返回值决定输出：是大写字母则输出*，是小写字母输出#，是其他字符则输出问号？。\n请改正函数a()中指定部位的错误，使它能得出正确的结果。\n注意：不要改动其他函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "(1)switch语句后面是一个普通表达式，根据表达式的值进行多分支运算，而条件表达式，一般用于两分支运算；再查看case各分支的值，可以确定switch后面表达式的值应为1、-1、0，正好是my_isalpha函数的返回值，即变量sort的值，所以这里应该改为\"switch(sort)\"。\n(2)switch ... case语句是执行满足条件的case标号后所有语句，即代码中的case 0部分也会执行，而从题意要求是不执行的，所以应在该行末尾加上break;语句。\n(3)do ... while语句的条件是满足执行，所以应为ch!='\\n'，即键入的不是回车换行符时满足执行条件。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 840, "q": "下面程序的结果是（）\nint i=1;\nwhile(i<3)\n{\ni++;\nprintf(\"%d \", i);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "2 3", "1 2 3", "1 2", "1 2 3 4" ], "explanation": "初始i=1。第一次循环，1<3成立，i自增为2，输出2；第二次循环，2<3成立，i自增为3，输出3；第三次判断3<3不成立，退出循环。因此输出结果为2 3。" }, { "id": 841, "q": "下面对实型常量描述错误的是", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "实型常量是指通常意义上的实数，也称浮点数", "实型常量由两种表示形式：十进制小数形式和指数形式", "用指数形式表示实型常量时，E前面可以是整数也可以是小数，但E后面必须是整数", "在C语言中，实型常量可以有3种形式：八进制、十进制和十六进制" ], "explanation": "实型常量（浮点数）在C语言中只有十进制小数形式和指数形式两种表示方法，不存在八进制和十六进制的实型常量表示法。八进制和十六进制仅用于整型常量。因此D选项描述错误。" }, { "id": 842, "q": "a, b 均为整数, 且 b!=0, 则表达式 a/b*b+a%b 的值是().", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "a", "b", "a 被 b 除的整数部分", "a 被 b 除的商的整数部分" ], "explanation": "在C语言中，整数除法a/b会截断小数部分得到商，再乘以b得到b的整数倍，加上a对b取余的结果a%b，恰好等于原被除数a。这是整数除法和取余运算的基本数学性质，即被除数等于商乘除数加余数。" }, { "id": 843, "q": "若变量已正确定义，以下程序段运行结果是( ) 。\nint a=3,b=5,c=7;\nif(a>b) a=b; c=a;\nif(c=a) c=b;\nprintf(\"%d,%d,%d\\n\",a,b,c);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "程序段有语法错", "3，5，3", "3，5，5", "3，5，7" ], "explanation": "第一个if语句后无大括号，仅a=b受条件控制，c=a无条件执行，此时c被赋值为3。第二个if条件为赋值表达式c=a，将a的值3赋给c，表达式结果为真，执行c=b，c被赋值为5。最终a=3，b=5，c=5。" }, { "id": 844, "q": "给定程序中，函数fun的功能是：将形参s所指字符串中的数字字符转换成对应的数值，计算出这些数值的累加和作为函数值返回。\n例如，形参s所指的字符串为：abs5def126jkm8，程序执行后的输出结果为：22。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 845, "q": "以下叙述错误的是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "C语言区分大小写。", "C程序中的一个变量，代表内存中一个相应的存储单元，变量的值可以根据需要随时修改。", "整数和实数都能用C语言准确无误地表示出来。", "在C程序中，正整数可以用十进制、八进制和十六进制的形式来表示。" ], "explanation": "C语言中，整型数据在表示范围内可精确表示，但实型（浮点型）数据在内存中以二进制指数形式存储，存在精度限制，无法准确无误地表示所有实数，会产生舍入误差。因此C选项叙述错误，其余选项均符合规范。" }, { "id": 846, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"12134211111\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "7211", "1111", "6211", "7212" ], "explanation": "程序遍历字符串s，利用switch语句将字符'1'到'4'分别映射到索引0到3，并对数组v中对应元素计数。字符串中包含7个'1'、2个'2'、1个'3'和1个'4'，因此v数组最终元素值为7、2、1、1，输出7211。" }, { "id": 847, "q": "以下关于字符串描述错误的是（）", "t": "single", "ans": "C", "kp": "字符串", "o": [ "字符串常量是由一对双引号括起来的零个或多个字符序列", "系统会在字符串的末尾自动加\\0字符，表示字符串的结束", "若想在字符串中间有双引号，可以这样表示\"你好\"a\"字母\"", "若想在字符串中间有双引号，可以这样表示\"你好\\\"a\\\"字母\"" ], "explanation": "在C语言中，字符串常量必须用一对双引号括起来。若要在字符串内部包含双引号，必须使用转义字符\\\"，如选项D所示。选项C的表示方法会导致语法错误，编译器会将其识别为多个独立的字符串和标识符。" }, { "id": 848, "q": "已知 int x=1, y=1;，表达式(!x&&y--)计算后，y的值", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "1", "0", "True", "False" ], "explanation": "逻辑与运算符&&具有短路特性。表达式中!x即!1，结果为0（假）。由于左侧为假，整个&&表达式的结果已确定为假，因此右侧的y--不会被执行，y的值保持初始值1不变。" }, { "id": 849, "q": "以下选项中合法的实型常量是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0x3.5", "3.13e2", "914", "E3" ], "explanation": "实型常量可用小数或指数形式表示。A选项十六进制浮点格式不规范；C选项914是整型常量；D选项指数形式缺少底数。B选项3.13e2符合科学计数法规则，是合法的实型常量。" }, { "id": 850, "q": "有以下程序，在VC平台上编译运行，程序运行后的输出结果是（　　）。\nint a,b;\nchar A='a';\ndouble B=6;\na=sizeof(A);\nb=sizeof (B);\nprintf(\"%d,%d\\n\",a,b);", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "1,4", "1,8", "4,4", "4,8" ], "explanation": "sizeof运算符用于计算数据类型或变量所占的字节数。在VC平台中，char类型变量A占用1个字节，double类型变量B占用8个字节。因此sizeof(A)为1，sizeof(B)为8，输出结果为1,8。" }, { "id": 851, "q": "若有以下程序，编译时出现错误，你认为出错的是（　　）。\n#include \nmain() {\nint a=0,b=0,c=0,d;\nc=(a+=b,b+=A); /*第4行*/\nd=c; /*第5行*/\n; /*第6行*/\nprintf(\"%d,%d,%d\\n\",a,b,c）; /*第7行*/\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "第4行", "第5行", "第6行", "第7行" ], "explanation": "程序第4行中使用了变量A，但在前面并未定义该变量（仅定义了小写a），导致编译时报未定义标识符错误。此外第7行printf末尾使用了全角右括号也会引发语法错误，但按执行顺序和选项设置，首要错误在第4行。" }, { "id": 852, "q": "以下程序的功能是将值为三位正整数的变量x中的数值按照个位、十位、百位的顺序拆分并输出。请填空。\nint x=256;\nprintf(\"%d-%d-%d\\n\",x%10 ,_____,x/100);", "t": "single", "ans": "D", "kp": "排序查找与简单算法", "o": [ "x%10/10", "x%10", "x/10", "x/10%10" ], "explanation": "提取三位数各数位的方法：个位通过x%10获取；百位通过x/100获取；十位需先去掉个位再取余，即x/10%10（或x%100/10）。因此填空处应为x/10%10，对应选项D。" }, { "id": 853, "q": "下列声明变量错误的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "int n=3.5;", "float pi=3.1415*3;", "char C=97;", "double k=3.5" ], "explanation": "C语言中每条语句必须以分号结束。A、B、C选项的声明和初始化均合法且带有分号。D选项double k=3.5末尾缺少分号，属于语法错误，因此声明变量错误的是D。" }, { "id": 854, "q": "以下程序的运行结果是（　　）\nint a=20;\nint f(int c){\nstatic int a=20;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "69", "68", "79", "78" ], "explanation": "函数f中a为静态局部变量，初值20。第一次调用f(3)，c变为4，返回20+4=24，静态a变为21；第二次调用f(3)，c变为4，返回21+4=25，静态a变为22。循环后k=24+25=49。最后k+=a中的a是全局变量20，故k=49+20=69。" }, { "id": 855, "q": "若执行以下程序时从键盘上输入9，则输出结果是( ) 。\nmain()\n{ int n;\nscanf(\"%d\",&n);\nif(++n <10) printf(\"%d\\n\",n--);\nelse printf(\"%d\\n\", --n);}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "11", "10", "9", "8" ], "explanation": "输入n=9。if条件中++n使n先自增为10，判断10<10为假，执行else分支。else中--n使n先自减为9，然后输出n的值，因此输出结果为9。" }, { "id": 856, "q": "以下程序的输出结果是( ) 。\nmain( )\n{ float x=2.0,y;\nif(x<0.0) y=0.0;\nelse if(x<10.0) y=1.0/x;\nelse y=1.0;\nprintf(\"%f\\n\",y); }", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0.000000", "0.250000", "0.500000", "1.000000" ], "explanation": "x初值为2.0。判断x<0.0为假；接着判断x<10.0为真，执行y=1.0/x，即y=1.0/2.0=0.5。最后以%f格式输出y，默认保留6位小数，结果为0.500000。" }, { "id": 857, "q": "有以下程序段:\nint a=0,b=0,c=0,d=0;\nif(a=1)\nb=1;\nc=2;\nelse d=3;\nprintf(\"%d,%d,%d,%d\\n\",a,b,c,d);\n程序输出（）", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0,0,0,3", "1,1,2,3", "编译有错", "0,1,2,0" ], "explanation": "if语句后若有多条执行语句必须用花括号括起。本题if(a=1)后跟了b=1;和c=2;两条语句，未加花括号，导致if的作用域仅到b=1;结束。随后的else找不到匹配的if，引发编译错误。" }, { "id": 858, "q": "若 int i=10; 执行下列程序后， 变量 i 的正确结果是() 。\nswitch(i)\n{\ncase 9: i+=1;\ncase 10: i+=1;break;\ncase 11: i+=1;\ndefault: i+=1;\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "10", "11", "12", "13" ], "explanation": "switch语句中i=10，匹配case 10。执行i+=1后i变为11，随后遇到break语句，直接跳出switch结构。case 9和case 11及default均不执行，最终i的值为11。" }, { "id": 859, "q": "下列程序的执行结果是( )。\nint x=2000,a=15,b=30,c=5,d=0;\nif (a2);\nprintf(\"%d\\n\",j);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "8", "9", "51", "52" ], "explanation": "do-while循环先执行循环体再判断条件。初始i=10，j=0。每次循环j加1，i减1。当i减到2时，条件i>2为假，循环结束。此时循环共执行了8次，因此j的值为8。" }, { "id": 861, "q": "下面程序的输出结果是（ ）。\nmain ( )\n{\nchar ch='6';\nint i;\nfor (i=0;i<3;i++)\nprintf(\"%c\",ch);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "666", "'666'", "66", "6" ], "explanation": "for循环控制变量i从0递增到2，共执行3次循环体。每次循环使用%c格式输出字符变量ch的值，ch的值在循环中未改变，始终为字符'6'，因此连续输出三个6，结果为666。" }, { "id": 862, "q": "以下叙述正确的是 ( )", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "do-while 语句构成的循环不能用其它语句构成的循环来代替。", "do-while 语句构成的循环只能用 break 语句退出。", "用 do-while 语句构成的循环,在while 后的表达式为非零时结束循环。", "用 do-while 语句构成的循环,在while 后的表达式为零时结束循环。" ], "explanation": "do-while循环的特点是先执行循环体，再判断while后的表达式。当表达式的值为非零（真）时继续循环，当表达式的值为零（假）时结束循环。它可以用while或for循环代替，也不仅能通过break退出。" }, { "id": 863, "q": "下面程序段的运行结果是()\nint a,b=1;\nfor(a=1;a<=10; a=a+4)\n{\nif(b>=5) break;\nif(b%3==1) continue;\nb-=5;\n}\nprintf(\"%d\\n\",a);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "13", "12", "10", "以上说法都不对" ], "explanation": "b初值为1。循环中b>=5为假，而b%3==1为真，所以每次都会执行continue，跳过b-=5，b始终为1。a依次为1、5、9并完成循环体，每次循环结束后执行a=a+4；当a变为13时不再满足a<=10，退出循环，最终输出13。" }, { "id": 864, "q": "以下程序段运行后的输出结果是()\nint k=0,i,m;\nfor(i=5;i<=15;i+=5)\n{m=i;\nwhile(m%5==0)\n{k++;m=m/5;}\n}\nprintf(\"%d\\n\",k);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "1", "2", "4", "3" ], "explanation": "外层for循环i依次取5、10、15。当i=5时，内层while循环执行1次，k变为1，m变为1；当i=10时，内层循环执行1次，k变为2，m变为2；当i=15时，内层循环执行1次，k变为3，m变为3。最终k的值为3。" }, { "id": 865, "q": "若运行以下程序段时,从键盘输入2473(表示回车),则下面程序段的运行结果是()\nint c;\nwhile ((c=getchar())!='\\n')\nswitch (c-'2')\n{case 0:\ncase 1: putchar(c+4);\ncase 2:putchar(c+4);break;\ncase 3:putchar(c+3);\ndefault:putchar(c+2);break;\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "668977", "668966", "66778777", "6688766" ], "explanation": "输入字符依次处理：'2'对应case 0，无break穿透至case 1和2，输出两个'6'；'4'对应case 2，输出'8'并break；'7'对应default，输出'9'并break；'3'对应case 1，无break穿透至case 2，输出两个'7'。最终结果为668977。" }, { "id": 866, "q": "C语言规定，函数返回值的类型是由 ( ) 。", "t": "single", "ans": "D", "kp": "函数", "o": [ "return语句中的表达式类型决定的", "调用该函数时的主调函数类型决定", "调用该函数时系统临时决定", "在定义该函数时所指定的函数类型所决定" ], "explanation": "在C语言中，函数返回值的类型是在函数定义时由函数头部的返回类型声明决定的。如果return语句中的表达式类型与函数声明的返回类型不一致，系统会自动将表达式的值转换为函数声明的返回类型。" }, { "id": 867, "q": "有以下程序\nvoid fun( int a, int b, int c )\n{\na=b; b=c; c=a;\n}\nmain() {\nint a=10 , b=20, c=30;\nfun( a, b, c );\nprintf(\"%d,%d,%d\\n\",c,b,a）; }\n程序运行后的输出结果是( )", "t": "single", "ans": "C", "kp": "函数", "o": [ "10,20,30", "20,30,10", "30,20,10", "0,0,0" ], "explanation": "C语言中函数参数传递采用值传递方式。在调用fun函数时，实参a、b、c的值被复制给形参，fun函数内部对形参的修改不会影响主调函数main中实参的值。因此，main函数中的c、b、a保持原值30、20、10不变。" }, { "id": 868, "q": "以下程序的输出结果是（）\nint a=4;\nint f(int n){\nint t=0;\nint a=5;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<2;i++) s+=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "27", "28", "29", "26" ], "explanation": "全局变量a=4，main中s初始为4。调用f(0)时，进入else分支，局部t=7，返回t+f内局部a(5)的后置自增结果12，s变为16。调用f(1)时，进入if分支，局部t=6，返回t+f内局部a(5)的后置自增结果11，s变为27。最终输出27。" }, { "id": 869, "q": "以下程序的输出结果是（）\n#include\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<3;i++)\nprintf(\"%d \",f(i));\n}\nint f(int a)\n{ int b=0; static int c=7;\nb++;c++;\nreturn(a+b+c++);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "9 12 15", "8 11 14", "9 11 13", "8 10 12" ], "explanation": "函数f中b是局部自动变量，每次调用初始化为0，b++后为1；c是静态局部变量，保留上次调用的值。第一次调用f(0)，c变为8，返回0+1+8=9，c自增为9；第二次f(1)，c变为10，返回1+1+10=12，c自增为11；第三次f(2)，c变为12，返回2+1+12=15。" }, { "id": 870, "q": "设有如下函数定义\nint fun(int k)\n{\nif(k<1) return 0;\nelse if(k==1) return 1;\nelse return fun(k-1)+1;\n}\n若执行调用语句：n=fun(3);，则函数fun总共被调用的次数是( )", "t": "single", "ans": "C", "kp": "函数", "o": [ "2", "4", "3", "5" ], "explanation": "执行fun(3)时，满足else条件，调用fun(2)；执行fun(2)时，满足else条件，调用fun(1)；执行fun(1)时，满足k==1条件，直接返回1，不再递归。因此，函数fun总共被调用了3次，分别是fun(3)、fun(2)和fun(1)。" }, { "id": 871, "q": "以下程序段的运行结果是（　　）。\n{\nint p[8]={11,12,13,14,15,16,17,18},i=0,j=0;\nwhile(i++<7)\nif(p[i]%2) j+=p[i];\nprintf(\"%d\\n\",j); }", "t": "single", "ans": "B", "kp": "数组", "o": [ "42", "45", "56", "60" ], "explanation": "while循环条件为i++<7，i初始为0。每次判断后i自增1，因此循环体内使用的i依次为1到7。数组p中下标1到7的元素为12到18。其中奇数有13、15、17，将它们累加到j中，即13+15+17=45。" }, { "id": 872, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{2,3,6},{2,7,9},{3,5,10},{3}};\nprintf(\"%d%d%d%d\\n\",a[0][3],a[1][2],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "0953", "0951", "0950", "095" ], "explanation": "二维数组部分初始化时，未赋值的元素自动初始化为0。a[0]第4个元素a[0][3]为0；a[1]第3个元素a[1][2]为9；a[2]第2个元素a[2][1]为5；a[3]第1个元素a[3][0]为3。因此输出0953。" }, { "id": 873, "q": "以下能正确定义一维数组的选项是( )", "t": "single", "ans": "D", "kp": "数组", "o": [ "float num(10);", "char num[A];", "double int[10];", "int a['A'];" ], "explanation": "定义数组时，数组名后必须使用方括号，排除A；数组长度必须是常量表达式，若A未定义为常量则B错误；C中int是关键字，不能作为数组名；D中'A'是字符常量，其ASCII值为65，可作为合法的数组长度。" }, { "id": 874, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint i,t[][4]={9,8,7,6,5,4,3,2,1,9};\nfor(i=0;i<3;i++) printf(\"%d\",t[2-i][1]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "948", "498", "489", "468" ], "explanation": "数组t按行优先初始化，共10个元素，推断为3行4列。t[0]为{9,8,7,6}，t[1]为{5,4,3,2}，t[2]为{1,9,0,0}。循环i从0到2，依次输出t[2][1]、t[1][1]、t[0][1]，对应的值分别为9、4、8，故输出948。" }, { "id": 875, "q": "以下程序的运行结果是（　　）\nmain()\n{\nchar s[]=\"abcdef\";\nstrcpy(s,\"abc\");\ns[1]='\\0';\nprintf(\"%s\\n\",s);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "a", "ab", "abc", "abcd" ], "explanation": "strcpy将\"abc\"复制到s中，s的内容变为'a','b','c','\\0','e','f','\\0'。接着将s[1]赋值为'\\0'，此时s的前两个字符为'a'和'\\0'。printf使用%s输出字符串时，遇到第一个'\\0'即停止，因此只输出字符a。" }, { "id": 876, "q": "有以下程序,程序的运行结果是()\nint x=1, y=0, a=0, b=0;\nswitch ( x )\n{\ncase 1: switch(y)\n{\ncase 0: a++; break;\ncase 1: b++; break;\n}\ncase 2: a++; b++; break;\ncase 3: a++; b++;\n}\nprintf(\"a=%d, b=%d\\n\", a, b);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "a=2，b=2", "a=3，b=2", "a=3，b=3", "a=2，b=1" ], "explanation": "x为1进入外层case 1，y为0进入内层case 0，执行a++后a为1，遇到break跳出内层switch。由于外层case 1后无break，程序继续穿透执行外层case 2，执行a++和b++，此时a为2，b为1，遇到break跳出外层switch。最终输出a=2, b=1。" }, { "id": 877, "q": "若有定义语句：int year=2009, *p=&year ; 以下不能使变量year中的值增至2010的语句是（ ）", "t": "single", "ans": "C", "kp": "指针", "o": [ "(*p)++;", "++(*p);", "*p++;", "*p+=1;" ], "explanation": "选项A、B通过括号改变优先级，直接对指针p所指向的变量year进行自增；选项D为复合赋值，也使year加1。选项C中，++运算符优先级高于*，*p++等价于*(p++)，其作用是使指针p本身向后移动，而不会改变year的值。" }, { "id": 878, "q": "下列程序段的输出结果是是（ ）。\nmain( )\n{ int b[10]={1,2,3,4,5,6,7,8,9,10},*p=&b[2],s=3;\nfor(i=1;i<4;i++)\ns+=*(p+i);\nprintf(\"%d\",s);}", "t": "single", "ans": "C", "kp": "指针", "o": [ "12", "15", "18", "21" ], "explanation": "指针p指向b[2]（值为3），s初始为3。循环i从1到3，*(p+i)分别访问b[3]、b[4]、b[5]，其值分别为4、5、6。s依次累加这三个值，即s = 3 + 4 + 5 + 6 = 18。" }, { "id": 879, "q": "以下程序的运行结果是( )\n#define x 6\n#define y x+1\n#define z y*x/2\nmain()\n{\nprintf(\"%d\",2*z);\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "15", "42", "21", "16" ], "explanation": "宏替换是简单的文本替换，不自动添加括号。z被替换为y*x/2，进一步替换为x+1*x/2，即6+1*6/2。计算2*z时，替换为2*6+1*6/2。根据运算符优先级，先算乘除后算加减，结果为12+3=15。" }, { "id": 880, "q": "有以下程序\n#include \n#define f(x) x*x*x\nmain()\n{\nint a=3,s,t ;\ns=f(a+1);\nt=f((a+1));\nprintf(\"%d,%d\\n\",s,t);\n}\n程序运行后的输出结果是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "10,10", "10,64", "64,10", "64,64" ], "explanation": "宏替换是纯文本替换。s=f(a+1)展开为a+1*a+1*a+1，代入a=3得3+1*3+1*3+1=10。t=f((a+1))展开为(a+1)*(a+1)*(a+1)，代入a=3得4*4*4=64。因此输出10,64。" }, { "id": 881, "q": "给定程序modi1.c中函数fun的功能是：首先将大写字母转换为对应小写字母；若小写字母为a～u，则将其转换为其后的第5个字母；若小写字母为v～z，使其值减21。转换后的小写字母作为函数值返回。例如,若形参是字母A，则转换为小写字母f；若形参是字母W，则转换为小写字母b。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 882, "q": "给定程序中，函数fun的功能是：找出100～999之间（含100和999）所有整数中各位上数字之和为x（x为一正整数）的整数，然后输出；符合条件的整数个数作为函数值返回。\n例如，当x值为5时，100～999之间各位上数字之和为5的整数有：104、113、122、131、140、203、212、221、230、302、311、320、401、410、500。共有15个。当x值为27时，各位数字之和为27的整数是：999。只有1个。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "在fun函数中，对整数进行判断是否符合题目中规定的条件。while语句设置循环结束的条件，由题面可知第一个空填：999；变量s1，s2，s3分别是整数的个位、十位以及百位上的数值，所以第二个空填：t/10；if语句进行条件判断，判断s1+s2+s3的值是否与输入的值相等，所以第三个空填：x。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 883, "q": "请编写函数fun，其功能是：计算并输出S=1+(1+2^0.5)+(1+2^0.5+3^0.5)+……+(1+2^0.5+3^0.5+……+n^0.5)\n例如，在主函数中从键盘给n输入20后，输出为：s=534.188884。\n注意：要求n的值大于1但不大于100。\n部分源程序在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun(int n)\n{int i; /*定义一个整形变量*/\ndouble fac=1.0; /*定义变量fac、sum为双精度型*/\ndouble sum=1.0;\nif (n>1&&n<=100)\nfor(i=2;i<=n;i++)\n{fac+=sqrt(i); /*使用sqrt()函数求出每一个多项式的值*/\nsum+=fac; /*通过sum+=fac;计算出所有多项式之和*/\n}\nreturn sum; /*返回结果*/\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 884, "q": "程序执行后的输出结果是（）\nint y=4;\nwhile(--y);\nprintf(\"%d\\n\",y);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "1", "-1", "while构成无限循环" ], "explanation": "while循环的条件是--y，即先将y减1再判断。y初始为4，依次递减为3、2、1时条件为真，继续循环；当y减至0时，条件为假，循环结束。此时y的值保持为0，故输出0。" }, { "id": 885, "q": "下列合法的整型常量是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "35.8", "089", "0x78", "123." ], "explanation": "A和D包含小数点，属于浮点型常量；B以0开头表示八进制，但八进制数字只能是0-7，包含8和9是非法的；C以0x开头，表示十六进制整型常量，7和8均为合法的十六进制字符。" }, { "id": 886, "q": "设有定义： int x=2; 以下表达式中，值不为6的是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2*x, x+=2", "x++,2*x", "x*=(1+x)", "x*=x+1" ], "explanation": "A为逗号表达式，取最后一个表达式x+=2的值，x变为4，结果为4；B中x++后x变为3，2*x结果为6；C等价于x=x*(1+x)，即2*3=6；D等价于x=x*(x+1)，即2*3=6。因此值不为6的是A。" }, { "id": 887, "q": "若已定义x和y为double类型，则表达式x=1,y=x+3/2的值是______。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1", "2", "2.0", "2.5" ], "explanation": "逗号表达式从左到右计算。先执行x=1，再计算y=x+3/2。由于3和2是整型，3/2整除结果为1。x为double型，1.0+1结果为2.0并赋给y。整个表达式的值为最后一个子表达式的值，即2.0。" }, { "id": 888, "q": "以下选项中合法的变量是（）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "5a", "A%", "_10_", "sizeof" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头，也不能是关键字。A以数字开头，B包含非法字符%，D是关键字。C以下划线开头且仅含数字和下划线，完全合法。" }, { "id": 889, "q": "以下程序的运行结果是（　　）\nint a=20;\nint f(int c){\nstatic int a=10;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "49", "50", "51", "48" ], "explanation": "全局变量a=20。函数f中静态局部变量a初始为10。循环2次，每次传入局部变量a=3，c变为4。第一次f返回10+4=14，静态a变11；第二次返回11+4=15，静态a变12。k累加为29。最后k+=a中的a是全局变量20，故k=49。" }, { "id": 890, "q": "程序的输出结果是().\nint a=1,b=2,c=3,d=4;\nif ((a=2)||(b=1)) c=2;\nif ((c==3) || (d=-1)) a=5;\nprintf(\"%d,%d,%d,%d\\n\", a,b,c,d);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "2,1,2,4", "2,2,2,4", "5,2,2,-1", "5,1,2,-1" ], "explanation": "第一个if中，a=2为真，发生短路，b不变仍为2，执行c=2。第二个if中，c==3为假，计算d=-1，非0为真，执行a=5。最终a=5，b=2，c=2，d=-1。" }, { "id": 891, "q": "有以下程序\nmain()\n{ int a=5,b=4,c=3,d=2;\nif(a>b>c)\nprintf(\"%d\\n\",d);\nelse if((c-1>=d)==0)\nprintf(\"%d\\n\",d+1);\nelse printf(\"%d\\n\",d+2);\n}\n执行后输出的结果是（）。", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "2", "3", "4", "编译时有错，无结果" ], "explanation": "关系运算符从左到右结合。a>b>c即(5>4)>3，5>4结果为1，1>3结果为0（假）。else if中，(c-1>=d)==0即(2>=2)==0，1==0为假。执行else分支，输出d+2即4。" }, { "id": 892, "q": "以下选项中与\nif (a==1) a=b;\nelse a++;\n语句功能不同的switch语句是( ) 。", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "switch(a)\n{case 1: a=b; break;\ndefault: a++;\n}", "switch(a)\n{ default : a++; break;\ncase 1: a=b;\n}", "switch(a==1)\n{case 1: a=b; break;\ncase 0: a++;\n}", "switch(a==1)\n{case 0: a=b; break;\ncase 1: a++;\n}" ], "explanation": "原语句当a==1时执行a=b，否则执行a++。A、B、C选项均能实现此逻辑。D选项中，switch(a==1)的case 0对应a!=1，却执行了a=b；case 1对应a==1，却执行了a++，逻辑完全相反。" }, { "id": 893, "q": "以下选项中与\nif(a==1)a=b;\nelse a++;\n语句不同的switch语句是( )", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "switch(a)\n{case1:a=b;break;\ndefault:a++;\n}", "switch(a==1)\n{case 0:a=b;break;\ncase 1:a++;\n}", "switch(a)\n{default:a++;break;\ncase 1:a=b;\n}", "switch(a==1)\n{case 1:a=b;break;\ncase 0:a++;\n}" ], "explanation": "与上题同理，寻找逻辑不同的选项。B选项中，switch(a==1)的case 0执行a=b，case 1执行a++，将a==1和a!=1的执行分支弄反了，与原if-else语句功能不同。A选项中case1缺少空格属排版瑕疵。" }, { "id": 894, "q": "以下程序的输出结果是( ) 。\nmain()\n{ int a=100,x=10,y=20,ok1=5,ok2=0;\nif(x=20) break;\nif(b%3==1)\n{ b+=3;continue;}\nb-=5;}\nprintf(\"%d\\n\",a);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "7", "8", "9", "10" ], "explanation": "初始a=1、b=1。每次循环中b%3==1成立时，b加3并continue，随后for更新a。b依次变为4、7、10、13、16、19、22；下一轮开始时a为8，b>=20成立，执行break退出循环，因此输出8。" }, { "id": 897, "q": "要输出下面的图形， 请完善程序。\n1\n2 2\n3 3 3\n4 4 4 4\n5 5 5 5 5\n6 6 6 6 6 6\nfor(i=1;i<=6;i++)\n{\nfor(k=1;_____;k++)\nprintf(\"%2d\",i);\nprintf(\"\\n\");\n}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "i<=k", "i2) return(fib(n-1)+fib(n-2));\nelse return (2); }\nmain()\n{ printf(\"%d\\n\",fib(4)); }", "t": "single", "ans": "D", "kp": "函数", "o": [ "2", "4", "6", "5" ], "explanation": "程序执行时，main函数首先调用fib(4)（第1次）。由于4>2，返回fib(3)+fib(2)，分别调用fib(3)（第2次）和fib(2)（第3次）。在计算fib(3)时，由于3>2，返回fib(2)+fib(1)，分别调用fib(2)（第4次）和fib(1)（第5次）。fib(2)和fib(1)均不大于2，直接返回2，不再产生递归调用。因此总共调用了5次。" }, { "id": 902, "q": "以下对一维数组a进行正确初始化的语句是（ ）。", "t": "single", "ans": "C", "kp": "数组", "o": [ "int a[10]=(0,0,0,0,0);", "int a[10]={1;3;6;8;9};", "int a[ ]={0,1};", "int a[10]={ };" ], "explanation": "C语言中数组初始化必须使用花括号{}，且元素之间用逗号分隔，因此A和B错误。D选项中花括号内为空，不符合C语言标准语法（至少需要一个初始值如{0}）。C选项省略了数组长度，编译器会根据初始化列表中的元素个数自动推断数组长度为2，是合法且正确的初始化方式。" }, { "id": 903, "q": "以下程序段的运行结果是（　　）。\nint x[3][3]={2,4,6,8,10,12,14,16,18},s=0,i,j;\nfor (i=0;i<3;i++)\nfor (j=0;j<3;j++)\n{ x[i][j]=i+j;\nif(i=j)\ns=s+x[i][j]; }\nprintf(\"s=%d\",s);", "t": "single", "ans": "D", "kp": "数组", "o": [ "s=26", "s=10", "s=2", "s=28" ], "explanation": "if(i=j)是赋值表达式，将j的值赋给i。当i=0时，j=0时i=0为假；j=1时i=1为真，s加上x[1][1]的初始值10；j=2时i=2为真，s加上x[2][2]的初始值18。内层循环结束后i自增为3，不满足外层循环条件，循环结束。最终s=28。题目中x[i][j]=i+j可能为排版笔误，按初始值推导符合答案。" }, { "id": 904, "q": "以下程序输出结果是\nint m=5;\nif(m++>5)printf(\"%d\\n\", m);\nelse printf(\"%d\\n\",m--);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "7", "6", "5", "4" ], "explanation": "条件判断m++>5中，m++是后缀自增，先使用m的原值5进行比较，5>5为假，随后m自增为6。因此程序进入else分支。在else分支中，m--是后缀自减，先输出m的当前值6，然后m自减为5。因此最终输出结果为6。" }, { "id": 905, "q": "设有定义 double a[10] ,*s=a; 以下能够代表数组元素a[3]的是（ ）", "t": "single", "ans": "D", "kp": "指针", "o": [ "(*s)[3]", "*s[3]", "*s+3", "*(s+3)" ], "explanation": "指针s指向数组a的首元素，即s等价于&a[0]。根据指针运算规则，s+3指向数组的第4个元素a[3]的地址，因此*(s+3)表示取该地址对应的值，即a[3]。选项A和B语法错误，选项C表示a[0]的值加3。" }, { "id": 906, "q": "给定程序modi1.c中，函数fun的功能是：计算并输出k以内最大的10个能被13或17整除的自然数之和。k的值由主函数传入，若k的值为500，则函数值为4622。\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "观察题目可知，if语句表达的条件必须是能够整除13或整除17，即某个数除以13或17后等于0。\"=\"是赋值运算符，\"==\"才是关系运算符。所以，\"if ((k%13 = 0) || (k%17 = 0))\"应改为\"if ((k%13 == 0) || (k%17 == 0))\"。\n题面中要求计算K以内的自然数，所以第二处的\"k++;\"应该修改为\"k--;\"\n每一个C程序的函数体部分都必须由大括弧{ }括起来。{ }对应要完整，所以在横线处应填入\"}\"。\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 907, "q": "给定程序MODI1.C中函数fun的功能是：从低位开始依次取长整型变量s中奇数位上的数，构成一个新数放在t中（注意：位置从0开始计算）。\n例如：输入：12345678，则输出：1357\n输入：123456789，则输出：2468\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "当执行完s/=10;之后，s的最后一位即是我们需要的数字，故第一处应该用s%10来得到s的最后一位，所以第一处应改为：*t = s % 10;，循环中重复此算法即可。第二处表达式中类型不一致，t是一个指针，如果要引用指针所指的存储单元的值，应使用*间接访问运算符来获取指针t所指向的存储单元的值，故第二处应改为：*t = s % 10 * sl + *t;。因为我们在取s中的数字的时候是从低位开始获取，每次获取的数字在t中都应该是高位上的数字，故第三处应改为：sl *= 10;，让每次获取出来的数在*sl后能成为新数的高位上的数字。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 908, "q": "以下程序段的输出结果是( ) 。\nint a=100,x=10,y=20,m=0,n=0;\nif(y!=10)\nif(m) a=1;\nelse\nif(n) a=10;\na=-2;\nprintf(\"%d\\n\",a);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "1", "0", "-2", "值不确定" ], "explanation": "程序中的if-else语句没有使用花括号，因此每个分支只控制紧跟其后的一条语句。y!=10为真，进入内层if(m)，m为0条件为假，接着匹配else分支的if(n)，n为0条件也为假。最后，语句a=-2;独立于if-else结构之外，无论前面条件如何都会执行，将a赋值为-2并输出。" }, { "id": 909, "q": "若有定义int d[3][4];，以下选项中对数组a的数组元素不正确引用的是（　　）。", "t": "single", "ans": "B", "kp": "数组", "o": [ "d[0][0]", "d[3][4]", "d[3>4][1]", "d[2][1]" ], "explanation": "数组d定义为3行4列，其行下标范围是0到2，列下标范围是0到3。选项B中的d[3][4]行下标和列下标均超出了合法范围，属于越界访问，是不正确的引用。选项C中3>4结果为0，等价于d[0][1]，是合法的。" }, { "id": 910, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=8-i;\nprintf(\"%d%d%d\",a[2],a[6],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "620", "731", "842", "026" ], "explanation": "循环从i=9递减到0，依次对数组元素赋值a[i]=8-i。根据该公式计算指定下标的元素值：a[2]=8-2=6，a[6]=8-6=2，a[8]=8-8=0。printf语句连续输出这三个元素的值，中间无分隔符，因此最终输出结果为620。" }, { "id": 911, "q": "以下程序的功能是判断输入的年份是否是闰年。程序中空格应填的正确表达式是（   ）。\nmain(){int y,f;\nscanf(\"%d\",&y);\nif(y%400==0) f=1;\nelse if(________) f=1;\nelse f=0;\nif(f) printf(\"%d is\",y);\nelse printf(\"%d is not\",y);\nprintf(\"a leap year\\n\");}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "y%100!=0||y%4==0", "y%100!=0&&y%4==0", "y/400==0", "y%400!=0" ], "explanation": "闰年的判断规则是：年份能被400整除，或者能被4整除但不能被100整除。程序中第一个if已经判断了能被400整除的情况，因此else if中需要判断另一种情况，即\"能被4整除且不能被100整除\"，对应的C语言表达式为y%4==0 && y%100!=0，与选项B逻辑一致。" }, { "id": 912, "q": "给定程序modi1.c中函数fun的功能是：将字符串s中位于奇数位置的字符或ASCII码为偶数的字符放入字符串t中(规定第一个字符放在第0位中)。\n例如，字符串中的数据为：AABBCCDDEEFF，则输出应当是：ABBCDDEFF。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "程序中的第一个错误：题目要求字符串s中位于奇数位置或者ASCII码为偶数的字符放入字符串t中，两个条件是或者的关系应该用逻辑或而不是逻辑与。所以此处的\"if(i%2 && s[i]%2==0)\"应该修改为\"if(i%2 || s[i]%2==0)\"\n程序中的第二个错误：字符串结束标志'\\0'应该加在字符数组的末尾。所以此处的\"t[i]='\\0';\"应该修改为\"t[j]='\\0';\"\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 913, "q": "请编写一个函数fun，它的功能是：求出一个2×M整型二维数组中最大元素的值，并将此值返回调用函数。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "int fun (int a[][M])\n{int i,j,max;\nmax=a[0][0]; /*将二维数组的第一个元素赋给变量max，该变量是存放数组中最大元素的值*/\nfor(i=0;i<2;i++)/*设置循环变量*/\nfor(j=0;j5时进入。进入后判断x!=20，成立则输出。因此只有当输入值大于5且不等于20时，才会执行printf输出结果。" }, { "id": 916, "q": "程序段的输出结果是( )。\nint i=0, sum=1;\ndo\n{ sum+=i++;}\nwhile(i<6);\nprintf(\"%d\\n\", sum);", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "11", "15", "16", "22" ], "explanation": "do-while循环先执行后判断。初始sum=1,i=0。循环体内sum+=i++等价于先加i再自增。依次累加：1+0=1(i=1),1+1=2(i=2),2+2=4(i=3),4+3=7(i=4),7+4=11(i=5),11+5=16(i=6)。此时i<6为假，循环结束，输出sum为16。" }, { "id": 917, "q": "执行以下程序段的输出结果是 ( )。\nint c1=1,c2=6,c3=0;\nfor(c1=3;c1b>c)\n{printf(\"%d\\n\",d); printf(\"%d\\n\",d+1);}\n}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "2 3", "2", "3", "无输出结果" ], "explanation": "关系运算符>结合性为从左到右。表达式a>b>c先计算a>b（5>4为真，值为1），再计算1>c（1>3为假，值为0）。循环条件初始即为假，while循环体一次也不执行，故无任何输出。" }, { "id": 927, "q": "该程序的执行结果是（）\nint x=43;\ndo\n{ printf(\"%d\",x--); }\nwhile(!x);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "43", "42", "不输出任何内容", "死循环" ], "explanation": "do-while循环至少执行一次。首次执行printf输出当前x值43，随后x自减为42。循环条件!x即!42，非零值取反为假（0），循环终止。因此仅输出一次43。" }, { "id": 928, "q": "以下选项中,非法的字符常量是( )", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "'\\a'", "'\\17'", "\"\\n\"", "'\\xaa'" ], "explanation": "C语言中字符常量必须用单引号括起。选项C使用双引号，表示的是字符串常量而非字符常量，因此非法。A为转义字符（响铃），B为八进制转义字符，D为十六进制转义字符，均符合字符常量语法。" }, { "id": 929, "q": "有以下程序\nmain() {\nchar c1='A', c2='Y';\nprintf( \"%d, %d\\n\", c1,c2 ); }\n程序的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "输出格式不合法，输出出错信息", "65,90", "65,89", "A,Y" ], "explanation": "'A'的ASCII码为65，'Y'与'A'相差24，故ASCII码为89。printf使用%d格式控制符，将字符按十进制整数输出，因此输出65, 89。" }, { "id": 930, "q": "语句: printf(\"%d\", (a=1) && (b=-5) ) ; 的输出结果是()", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "无输出", "结果不确定", "-1", "1" ], "explanation": "逻辑与运算符&&两侧表达式非零即为真。赋值表达式a=1值为1（真），b=-5值为-5（非零，真）。真与真的结果为1，按%d输出即为1。" }, { "id": 931, "q": "我们写的每条C语句，经过编译最终将转换成二进制的机器指令。\n关于转换以下，说法错误的是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "一条C语句可能会被转换成多条机器指令。", "一条C语句对应转换成一条机器指令。", "一条C语句可能会被转换成零条机器指令。", "某种类型和格式的C语句被转换成机器指令的条数是固定的。" ], "explanation": "C语言语句与机器指令并非一一对应。一条C语句编译后可能转换成多条机器指令，也可能因编译器优化被转换为零条指令。因此\"一条C语句对应转换成一条机器指令\"的说法错误。" }, { "id": 932, "q": "有以下程序\nmain() {\nfloat a=3.5; //第一行\nint b='K'; //第二行\n; //第三行\nprintf( \"%d, %c\\n\", a,b ); //第四行\n}\n程序的输出结果不是“3.500000,K”的原因是第几行的问题（）", "t": "single", "ans": "D", "kp": "输入输出", "o": [ "第一行", "第二行", "第三行", "第四行" ], "explanation": "变量a为float型，但在printf中使用了%d（十进制整数）格式控制符，类型不匹配会导致输出错误结果。应使用%f等浮点数格式。问题出在第四行的printf语句。" }, { "id": 933, "q": "以下选项中合法的标识符有(　　)", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "circle-area", "dollar$", "c#", "Unsigned" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且首字符必须为字母或下划线。A含减号，B含$，C含#，均不合法。C语言区分大小写，Unsigned不是关键字，是合法标识符。" }, { "id": 934, "q": "以下四个程序中，错误的是（　　）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "#include\nmain()\n{\ndouble a=6,b=5,c;\nc=a*b;\nprintf(\" c=%f\\n\",c);\n}", "#include\nmain()\n{\ndouble a=6,b=5,c;\nc=a*b;\nprintf(\" c=%lf\\n\",c);\n}", "#include\nmain()\n{\ndouble a=6e0,b=5,c;\nc=a*b;\nprintf(\" c=%f\\n\",c);\n}", "#include\nmain()\n{\ndouble a=6,b=5,c;\nC=a*b;\nprintf(\" c=%f\\n\",C);\n}" ], "explanation": "C语言严格区分大小写。选项D中定义了小写变量c，但在赋值和输出时使用了大写字母C，导致使用了未定义的标识符，编译会报错。" }, { "id": 935, "q": "以下选项中,两个条件语句语义等价的是( )。", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "if(a=10) printf(\"%d\\n\",a);\nif(a==10) printf(\"%\\n\",a);", "if(a-10) printf(\"%d\\n\",a);\nif(a!=10) printf(\"%\\n\",a);", "if(a) printf(\"%d\\n\",a);\nif(a==0) printf(\"%\\n\",a);", "if(a-10) printf(\"%d\\n\",a);\nif(a==10) printf(\"%\\n\",a);" ], "explanation": "选项B中，a-10作为条件时，非零即真，等价于a!=10；而a!=10直接表示a不等于10。两者语义完全等价。其他选项的赋值、等于或不等于逻辑均不等价。" }, { "id": 936, "q": "执行以下程序段时\nx=-1;\ndo\n{ x=x*x; }\nwhile(! x);\n则下面描述正确的是( )", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "循环体将执行一次", "循环体将执行两次", "循环体将执行无限次", "系统将提示有语法错误" ], "explanation": "初始x=-1。进入do-while循环，执行循环体x=x*x，x变为1。接着判断条件!x，即!1，结果为0（假），循环结束。因此循环体仅执行一次。" }, { "id": 937, "q": "有以下程序段运行后的输出结果是（　　）。\nmain()\n{ int a[10]={1,2,3,4,5,6,7,8,9}, *p=a;\np++;\np++;\nprintf(\"%d\\n\", (*++p,*p++ )); }", "t": "single", "ans": "B", "kp": "指针", "o": [ "3", "4", "5", "6" ], "explanation": "初始p指向a[0]，两次p++后p指向a[2]。逗号表达式(*++p, *p++)中，先算*++p，p指向a[3]（值为4）；再算*p++，取a[3]的值4，随后p指向a[4]。逗号表达式取最后值4。" }, { "id": 938, "q": "以下程序中的for循环执行的次数是（　　）。\n#define N 4\n#define M N+1\n#define NUM 2*(M+1)\n#main()\n{ int i;\nfor(i=1;i<=NUM;i++)\nprintf(\"%d\\n\",i);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "11", "12", "10", "9" ], "explanation": "宏替换为纯文本替换。M替换为4+1，NUM替换为2*(4+1+1)，计算得12。for循环条件为i<=12，i从1递增到12，共执行12次。" }, { "id": 939, "q": "给定程序modi1.c中函数fun的功能是：从3个红球，5个白球，6个黑球中任意取出8个作为一组，进行输出。在每组中，可以没有黑球，但必须要有红球和白球。组合数作为函数值返回。正确的组合数应该是15。程序中i的值代表红球数，j的值代表白球数，k的值代表黑球数。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "程序中的第一个错误：因为抽出的球必须要有红球和白球，所以i的值应至少为1，从1开始循环；将\"for(i=0; i<=3; i++)\"改为\"for(i=1;i<=3;i++)\"；\n程序中的第二个错误：用变量k来表示黑球的数量，这里的k是小写，大小写需要进行区分，所以将\"if(K>=0 && K<=6)\"改为\"if(k>=0&&k<=6)\"。\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 940, "q": "编写函数fun，它的功能是：求n以内（不包括n）同时能被3与7整除的所有自然数之和的平方根s，并作为函数值返回。\n例如若n为1000时，函数值应为：s=153.909064。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun(int n)\n{ int i;double s=0.0;\nfor (i=1;i\nmain()\n{\nint a = 0, b = 1;\nif (++a == b++)\nprintf(\"T\");\nelse\nprintf(\"F\");\nprintf(\"a=%d,b=%d\\n\", a, b);\nprintf(\"\\n\");\n}\n程序运行后的输出结果是", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "Ta=1,b=2", "Fa=1,b=2", "Ta=0,b=1", "Fa=0,b=2" ], "explanation": "++a使a变为1，b++表达式的值为1且之后b变为2。1==1条件成立，输出T。随后输出a和b的值，即a=1,b=2。综合输出为Ta=1,b=2。" }, { "id": 947, "q": "以下程序段执行后，c3中的值是( )。\nint c1=1,c2=2,c3;\nc3=1.0/c2*c1;", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "0", "0.5", "1", "2" ], "explanation": "1.0为双精度浮点数，1.0/c2结果为0.5，再乘c1仍为0.5。将其赋值给整型变量c3时，小数部分被截断，最终c3的值为0。" }, { "id": 948, "q": "以下程序的运行结果是（　　）\nint k=10;\nint fun(int m)\n{ m+=k; k+=m;\nreturn m;\n}\nmain()\n{ int i=4,s=0;\ns=s+fun(i++); printf(\"%d %d %d\\n\",i,k,s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "5 24 14", "5 24", "5 14 24", "4 24 14" ], "explanation": "i++作为实参，传入fun的值为4，随后i自增为5。在fun中，m=4，m+=k使m变为14，k+=m使全局变量k变为24，返回14。s=0+14=14。最终输出i、k、s的值分别为5、24、14。" }, { "id": 949, "q": "有以下程序 main()\n{ int i=1,j=1,k=3;\nif((j++||k++)&&i++) printf(\"%d,%d,%d\\n\",i,j,k); }\n执行后输出的结果是( )。", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "1,1,3", "2,2,4", "2,2,3", "2,1,3" ], "explanation": "逻辑或运算中，j++的值为1（真），触发短路效应，k++不执行，k保持为3，j变为2。接着计算逻辑与，i++的值为1（真），i变为2。条件成立，输出i、j、k的值分别为2、2、3。" }, { "id": 950, "q": "运行下面程序时，若从键盘输入数据为\"25\"，则输出结果是( )。\nmain( )\n{ int num ,k;\nscanf(\"%d\",&num);\nif (num>99)\nk=3;\nelse if(num>9)\nk=2;\nelse\nk=1;\nprintf(\"%d\\n\",k);}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "3", "2", "1", "0" ], "explanation": "输入25赋给num。判断num>99为假，接着判断num>9为真，执行k=2并跳出if-else结构。最后输出k的值2。" }, { "id": 951, "q": "与 y=(x>0?1:x<0?-1:0); 的功能相同的if语句是( )。", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "if (x>0) y=1;\nelse if (x<0) y=-1;\nelse y=0;", "if(x)\nif (x>0) y=1;\nelse if (x<0) y=-1;\nelse y=0;", "y=-1;\nif(x)\nif (x>0) y=1;\nelse if (x==0) y=0;\nelse y=-1;", "y=0;\nif (x>=0)\nif (x>0) y=1;\nelse y=-1;" ], "explanation": "嵌套的条件表达式x>0?1:x<0?-1:0表示：若x>0则y=1；否则若x<0则y=-1；否则y=0。这与A选项的if-else if-else结构逻辑完全一致。" }, { "id": 952, "q": "有以下程序,程序运行后的输出结果是 （）\nint i;\nfor(i=0;i<3;i++)\nswitch(i)\n{\ncase 0:printf(\"%d\",i);\ncase 2:printf(\"%d\",i);\ndefault:printf(\"%d\",i);\n}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "022111", "0012", "000122", "012" ], "explanation": "i=0时，匹配case 0，因无break语句，穿透执行case 2和default，输出三个0；i=1时，无匹配case，执行default输出一个1；i=2时，匹配case 2，穿透执行default，输出两个2。最终结果为000122。" }, { "id": 953, "q": "下面程序运行结果为（）。\nint a=2,b=-1, c=2;\nif(a>b)\nif(b<0) c=0;\nelse c+=1;\nprintf(\"%d\\n\",c) ;", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "a>b（2>-1）成立，进入内层if。b<0（-1<0）成立，执行c=0。else与内层if配对，不执行。最终输出c的值0。注意C语言中else总是与最近的未配对if结合。" }, { "id": 954, "q": "以下程序运行完后的输出数据是( )。\nmain()\n{\nint a=5 ;\nfor( ; a ; )\n{\na--;\nif(a==0) break;\nprintf(\"a\");\n}\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "aaaa", "aaaaa", "aaa", "aaaaaa" ], "explanation": "初始a=5。循环中先执行a--，当a分别为4、3、2、1时，不满足a==0，打印4次a；当a减至0时，满足a==0触发break跳出循环。因此共输出4个a，即aaaa。" }, { "id": 955, "q": "设有以下程序段\nint x=0,s=0;\nwhile(!x!=0) s+=++x;\nprintf(\"%d\",s);\n则( )", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "运行程序段后输出0", "运行程序段后输出1", "循环的控制表达式不正确", "程序段执行无限次" ], "explanation": "初始x=0，!x为1，条件1!=0成立进入循环。执行s+=++x，x先自增为1，s变为1。再次判断条件，此时!x为0，0!=0不成立，退出循环。最终输出s的值为1。" }, { "id": 956, "q": "下面程序的输出结果是( )。\nint y=9;\nfor(;y>0;y--)\n{\nif(y%3==0)\n{\nprintf(\"%d\",--y);\ncontinue;\n}\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "852", "741", "963", "875421" ], "explanation": "y初值为9。当y=9时满足y%3==0，输出--y即8，执行continue跳过后续语句，但for循环的y--仍执行，y变7。y=7不满足，y--后为6。y=6满足，输出--y即5，y--后为4。y=4不满足，y--后为3。y=3满足，输出--y即2，y--后为1。y=1不满足，y--后为0退出。输出852。" }, { "id": 957, "q": "以下程序的运行结果是（　　）。\nmain()\n{int i,j;\nfor(i=2;i>=1;i--) {\nj=1;\nwhile(j<=2)\n{printf(\"%d\",i+j); j++;}\nprintf(\"\\n \") ;}}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "3 4\n2 3", "4 3 2\n5 4 3", "2 3\n3 4", "4 5\n3 4" ], "explanation": "外层循环i从2递减到1。当i=2时，内层循环j从1到2，依次输出i+j即3和4，然后换行。当i=1时，内层循环j从1到2，依次输出2和3，然后换行。因此输出结果为34和23，对应选项A的排版。" }, { "id": 958, "q": "int i=0; while( i++ < 5); 循环结束后i的值是( )。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "8", "7", "6", "5" ], "explanation": "while循环条件为i++ < 5。i初值为0，每次判断时先使用i的当前值与5比较，然后i自增1。当i为5时，5<5为假，循环结束，但i仍会执行自增操作变为6。因此循环结束后i的值为6。" }, { "id": 959, "q": "已知函数f的调用在前，函数f的定义在后。下列（）情况可省略函数声明。", "t": "single", "ans": "C", "kp": "函数", "o": [ "函数f的返回值类型为 float", "函数f的返回值类型为 double ;", "函数f的返回值类型为 int", "函数f的返回值类型为 char" ], "explanation": "在C语言中，如果函数的返回值类型为int，且调用在定义之前，编译器会默认进行隐式函数声明，将其返回值视为int类型，因此可以省略函数声明。其他类型如float、double等则必须显式声明。" }, { "id": 960, "q": "有以下程序执行后输出的结果是( )\nvoid f(int x,int y)\n{ int t;\nif(x\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<3;i++)\nprintf(\"%d \",f(i));\n}\nint f(int a)\n{ int b=0; static int c=7;\nb++;\nreturn(a+b+c++);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "8 10 12", "8 10", "10 12", "8 9" ], "explanation": "函数f中，b是自动变量，每次调用初始化为0后自增为1；c是静态变量，仅初始化一次为7，且每次调用后自增。第一次f(0)返回0+1+7=8，c变8；第二次f(1)返回1+1+8=10，c变9；第三次f(2)返回2+1+9=12。" }, { "id": 963, "q": "以下程序的运行结果是（　　）\nint f(int x) {\nint y;\nif(x==0||x==1) return (3);\ny=x-f(x-2);\nreturn y;\n}\nmain(){\nint z;\nz=f(3);\nprintf(\"%d\\n\",z);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "0", "1", "2", "3" ], "explanation": "主函数调用f(3)。在f(3)中，x=3不满足x==0||x==1，执行y=3-f(1)。递归调用f(1)，此时x=1满足条件，直接返回3。因此f(3)中y=3-3=0，最终返回0并赋值给z，输出0。" }, { "id": 964, "q": "以下程序的运行结果是（　　）\nmain()\n{ int s[12]={0,2,3,0,4,3,2,1,1,1,2,3},c[5]={0},i;\nfor(i=0;i<12;i++) c[s[i]]++;\nfor(i=0;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "23331", "0331", "2331", "3331" ], "explanation": "程序通过循环遍历数组s，将s[i]的值作为数组c的下标并累加，实质是统计s中0到4各数字出现的次数。s中0出现2次，1出现3次，2出现3次，3出现3次，4出现1次。因此c数组元素依次为2,3,3,3,1，输出23331。" }, { "id": 965, "q": "以下程序段的输出结果是（）\nmain( )\n{ int i,j,x[3][4]={{1,0},{2,0},{3,0}};\nfor(i=1,j=0;i<3;i++,j++)\nprintf(\"%d,\",x[i][j]);}", "t": "single", "ans": "B", "kp": "数组", "o": [ "1,0", "2,0", "3,0", "1,2" ], "explanation": "二维数组x初始化后，第一行为1,0,0,0，第二行为2,0,0,0，第三行为3,0,0,0。循环中i从1到2，j从0到1。当i=1,j=0时，输出x[1][0]即2；当i=2,j=1时，输出x[2][1]即0。因此输出2,0,。" }, { "id": 966, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=1+i;\nprintf(\"%d%d%d\",a[2],a[4],a[6],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "357", "3579", "246", "579" ], "explanation": "循环将数组a赋值为a[i]=1+i，因此a[2]=3，a[4]=5，a[6]=7，a[8]=9。在printf函数中，格式控制字符串里只有3个%d，因此只会输出前3个对应的参数a[2]、a[4]和a[6]的值，第4个参数被忽略。最终输出357。" }, { "id": 967, "q": "以下程序的运行结果是（　　）。\n{\nchar arr[2][4];\nstrcpy(arr[0],\"you\");\nstrcpy(arr[1],\"me\");\narr[0][3]='&';\nprintf(\"%s\\n\",arr);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "you&me", "you", "me", "err" ], "explanation": "二维数组在内存中连续存放。初始时arr[0]为you加结束符，arr[1]为me加结束符。执行arr[0][3]='&'后，原arr[0]末尾的结束符被替换为&，内存连续变为you&me加结束符。printf以%s输出时从首地址开始直到遇到结束符停止，因此输出you&me。" }, { "id": 968, "q": "若有定义: int a=1, b=2, c=3; 则执行以下程序段后 a, b, c 的值分别为（ ） 。\nif (a\nmain( )\n{\nint a[ ]={1,2,3,4,5,6},*p;\np=a;\n*(p+3)+=2;\nprintf(\"%d,%d\\n\",*p,*(p+3));\n}", "t": "single", "ans": "D", "kp": "指针", "o": [ "0,5", "1,5", "0,6", "1,6" ], "explanation": "p指向数组首元素a[0]。*(p+3)等价于a[3]，初始值为4，执行+=2后变为6。*p始终指向a[0]，值保持为1。因此printf输出1,6。" }, { "id": 970, "q": "若有以下说明和语句，其输出结果是()\nchar *sp=\"\\x69\\082\\n\"；\nprintf(\"%d\"，strlen(sp))；", "t": "single", "ans": "C", "kp": "字符串", "o": [ "3", "5", "1", "字符串中有非法字符，输出值不定" ], "explanation": "字符串字面量中，\\x69是十六进制转义字符，代表字符i。紧随其后的\\0是字符串结束标志。strlen函数计算长度时遇到\\0即停止，因此只统计到\\0前的一个字符，长度为1。后续字符被忽略。" }, { "id": 971, "q": "以下程序段的运行结果是( )\n#define N 9\n#define M1 (N+1)\n#define M2 M1*2\nmain()\n{ printf(\"%d\\n\",M2); }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "20", "11", "9", "10" ], "explanation": "宏替换是纯文本替换。M2展开为M1*2，进一步展开为(N+1)*2，最终替换为(9+1)*2。按算术优先级先算括号内加法得10，再乘以2，结果为20。" }, { "id": 972, "q": "给定程序MODI1.C中，函数fun的功能是求矩阵（二维数组）a[N][N]中每行的最小值，结果存放到数组b中。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "第一处错误：a[0][0]是表示数组a的第0行第0列的元素，按题目要求，应该将每行的第一个元素赋给b[i]，所以应将\"a[0][0]\"改为\"a[i][0]\"。\n第二处错误：变量j是表示数组a的列下标，列下标的上限是N-1。所以\"for (j=1; j a[i][j]\"或等效形式。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 973, "q": "给定程序中，函数fun的功能是将a和b所指的两个字符串转换成面值相同的整数，并进行相加，将结果作为函数值返回，规定字符串中只含9个的以下数字字符。\n例如，主函数中输入字符串：32486和12345，在主函数中输出的函数值为：44831。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "在fun函数和ctod函数中通过字符串指针变量来访问字符串数组。ctod函数的功能是将数字字符转换成数值型。在ctod函数中的if语句判断字符串的字符是否为数字字符，若是则将其转换为数值，所以第一个空填：48或与此语句相同功能的语句；while语句设置循环结束条件，若指针变量指向的地址内容为空则结束循环，所以第二个空填：s++或与此语句相同功能的语句；fun函数将转换后的整数的和作为函数值返回，所以第三个空填：ctod(a)+ctod(b)或与此语句相同功能的语句。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 974, "q": "请编写函数fun，函数的功能是：将M行N列的二维数组中的数据按列的顺序依次放到一维数组中。\n例如，二维数组中的数据为：\n33 33 33 33\n44 44 44 44\n55 55 55 55\n则一维数组中的内容应是：\n33 44 55 33 44 55 33 44 55 33 44 55。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int (*s)[10], int *b, int *n, int mm, int nn)\n{\nint i,j,np=0; /* np用作b数组下标 */\nfor(j=0;j是C语句", "C程序的每行中只能写一条语句", "C语言本身没有输入输出语句", "在对一个C程序进行编译的过程中，可以发现注释中的拼写错误" ], "explanation": "C语言标准库提供输入输出函数，但语言核心语法本身不包含I/O语句。#include是预处理指令非语句；C语言允许一行写多条语句；注释在编译预处理阶段已被移除，编译器不会检查其拼写。" }, { "id": 979, "q": "设变量a是整型，则表达式 a+1/2 值的数据类型为()", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "int", "float", "double", "不确定" ], "explanation": "表达式中1和2均为整型常量，1/2执行整数除法结果为0，类型为int。整型变量a与int型结果相加，遵循整型运算规则，最终结果数据类型仍为int。" }, { "id": 980, "q": "以下程序的输出结果是（ ）。\nfun (int x,int y,int z)\n{ z =x*x+y*y;}\nmain ()\n{ int a=31;\nfun (6,3,a）:\nprintf (\"%d\",a) ;}", "t": "single", "ans": "B", "kp": "函数", "o": [ "30", "31", "32", "33" ], "explanation": "C语言函数参数采用值传递。调用fun时，实参a的值被复制给形参z。函数内部修改z仅影响局部副本，不会改变main函数中变量a的值，因此a仍为31。" }, { "id": 981, "q": "以下程序的输出结果是（ ）。\n#include\nint a=3,b=7;\nmax(int a,int b)\n{int c;\nc=a>b?a:b\nreturn c;}\nmain()\n{int a=8;\nprintf(\"%d \",max(a,b);}", "t": "single", "ans": "B", "kp": "函数", "o": [ "7", "8", "3", "15" ], "explanation": "main中定义了局部变量a=8，屏蔽了全局变量a。调用max实际传入8和7。max函数内形参a为8，b为7，条件a>b成立，返回a的值8。故输出8。" }, { "id": 982, "q": "有以下程序\nfun(int x)\n{ int p;\nif(x==0‖x==1) return(3);\np=x-fun(x-2);\nreturn p;\n}\nmain( )\n{ printf(\"%d\\n\",fun(7));}\n执行后的输出结果是 ( )", "t": "single", "ans": "D", "kp": "函数", "o": [ "3", "7", "0", "2" ], "explanation": "递归调用过程：fun(1)直接返回3；fun(3)=3-fun(1)=0；fun(5)=5-fun(3)=5；fun(7)=7-fun(5)=2。按递归展开逐层返回，最终输出结果为2。" }, { "id": 983, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{2,3,6},{2,7,9},{3,5,10},{2}};\nprintf(\"%d%d%d%d\\n\",a[0][3],a[1][2],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "0952", "0951", "0950", "095" ], "explanation": "二维数组部分初始化时，未赋值的元素自动补0。a[0][3]为0，a[1][2]为9，a[2][1]为5，a[3][0]为2，因此输出0952。" }, { "id": 984, "q": "以下程序的运行结果是（　　）\nmain()\n{\nchar arr[2][4];\nstrcpy(arr[0],\"abc\");\nstrcpy(arr[1],\"me\");\nprintf(\"%s\\n\",arr);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "abc", "me", "abcme", "abcabc" ], "explanation": "二维字符数组在内存中连续存储。arr[0]存入\"abc\\0\"，arr[1]存入\"me\\0\"。使用%s输出arr时，从首地址开始打印，遇到arr[0]末尾的字符串结束符'\\0'即停止，故只输出abc。" }, { "id": 985, "q": "在下列选项中不会引起二义性的宏定义是( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "#define f(a) ((a)*(a))", "#define f(a) a*a", "#define f(a) (a*a)", "#define f(a) (a)*(a)" ], "explanation": "宏替换是简单的文本替换。为避免运算符优先级引起的二义性，宏定义中的参数和整个表达式都应加上括号。选项A将参数和整体均用括号括起，能正确计算复杂表达式。" }, { "id": 986, "q": "给定程序modi1.c中fun函数的功能是：分别统计字符串中大写字母和小写字母的个数。\n例如：给字符串ss输入：\"AAaaBBb123CCccccd\"，则输出结果应为：upper = 6, lower = 8\n请改正fun函数中的错误，使它能计算出正确的结果。\n注意：不要改动 main 函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "从主函数中的\"fun( s, &upper, &lower);\"语句可以看出，fun函数的后两个参数均为整型指针。因此，应该把原程序中的\"void fun ( char *s, int a, int b )\"语句改为\"void fun ( char *s, int *a, int *b )\"或相同作用的语句。\n程序中，a是一个整型指针，因此a++只是地址递增，要使a指向的数据实现递增，则要把指针改为实际数据，即把原程序中的\"*a=a+1;\"语句改为\"*a=*a+1;\"或相同作用的语句；同样道理，\"*b=b+1;\"语句也应改为\"*b=*b+1;\"或相同作用的语句。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 987, "q": "用筛选法可得到2～n（n<10000）之间的所有素数，方法是：首先从素数2开始，将所有2的倍数的数从数表中删去（把数表中相应位置的值置成0）；接着从数表中找下一个非0数，并从数表中删去该数的所有倍数；依此类推，直到所找的下一个数等于n为止。这样会得到一个序列：\n2，3，5，7，11，13，17，19，23，……\n函数fun用筛选法找出所有小于等于n的素数，并统计素数的个数作为函数值返回。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本程序的while循环中又嵌套了一个for和while循环，内嵌的for循环用于进行素数倍数的筛选，筛选的步长为a[i]，故第一空填a[i]；内嵌的while循环用于判断下一个即将被筛选的数是否为零，如果为零，则跳过（通过i++实现），即不对它的倍数进行筛选，故第二空应填a[i]；最后通过一个for循环统计素数的个数，其中的if用于判断a[i]是否为零，如果为零则说明a[i]不是素数，如果不为零则说明a[i]为素数，使得记录素数个数的变量count+1，故第三空应填0。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 988, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "D", "kp": "函数", "o": [ "可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行。", "C语言程序将从源程序中第一个函数开始执行。", "main的各种大小写拼写形式都可以作为主函数名，如：MAIN，Main等。", "C语言规定必须用main作为主函数名，程序将从此开始执行。" ], "explanation": "C语言程序总是从main函数开始执行，且主函数名必须严格拼写为小写的main，C语言区分大小写，MAIN或Main均不被识别为主函数。" }, { "id": 989, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[10]=\"12342233\";\nint v[4]={1,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "2331", "1331", "3331", "1332" ], "explanation": "程序通过switch语句统计字符串中各字符出现次数并累加到数组v中。初始v[0]=1，遍历字符串，'1'出现1次，'2'出现3次，'3'出现3次，'4'出现1次。最终v数组元素分别为2、3、3、1。" }, { "id": 990, "q": "一个char型数据,它的值在内存中存放的是().", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "ASCII代码值", "十进制代码值", "BCD代码值", "字形" ], "explanation": "在C语言中，字符型数据在内存中是以其对应的ASCII码值（整数形式）进行存储的，而不是十进制代码、BCD码或字形。" }, { "id": 991, "q": "以下选项中，当x为大于1的奇数时，值为0的表达式是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "x/2", "x%2==0", "x%2!=0", "x%2==1" ], "explanation": "当x为奇数时，x%2的结果为1。选项B中表达式1==0的结果为假，在C语言中逻辑假的值为0。其他选项在x为奇数时结果均不为0。" }, { "id": 992, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "整型常量和实型常量都是数值型常量.", "常量的值可以根据程序需要而改变.", "预定义的标识符是C语言关键字的一种，不能另作它用.", "只能在函数体内定义变量，其他地方不允许定义变量." ], "explanation": "整型常量和实型常量统称为数值型常量。常量的值在程序运行期间不能改变；预定义标识符如printf不是关键字，可作他用；变量既可在函数内定义，也可在函数外定义为全局变量。" }, { "id": 993, "q": "有以下程序\n#include\nmain() {\nint x, y, z;\nx=y=1;\nz=(++x,y++,++y);\nprintf(\"%d,%d,%d\\n\",x,y,z); }\n程序运行后的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2,3,1", "2,3,2", "2,3,3", "2,2,1" ], "explanation": "逗号表达式按从左至右顺序求解，整个表达式的值为最后一个子表达式的值。执行++x后x为2；执行y++后y为2；执行++y后y为3，且该子表达式值为3赋给z。故输出2,3,3。" }, { "id": 994, "q": "以下叙述中正确的是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "a是实型变量，a=10在C语言中是允许的，因此可以说：实型变量中可以存放整型数", "在赋值表达式中，赋值号的右边可以是变量，也可以是任意表达式", "若有int a=4,b=9; 执行了a=b后，a的值已由原值改变为b的值，b的值变为0", "若有int a=4,b=9; 执行了a=b;b=a;之后，a的值为9，b的值为4" ], "explanation": "在赋值表达式中，赋值号右侧可以是变量或任意合法的表达式。实型变量存放的是转换后的浮点数而非整型数；赋值操作不会改变右侧变量的值；连续赋值后两变量值相同。" }, { "id": 995, "q": "以下程序段运行后的输出结果是（）。\nint i=1,j=3,k=3;\nif(i++==1&&(++j==3||k++==3)) printf(\"%d,%d,%d\\n\",i,j,k);", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1,2,3", "2,3,4", "2,4,4", "2,3,3" ], "explanation": "逻辑与&&左侧i++==1为真，i自增为2；接着计算右侧逻辑或||，++j==3为假，j自增为4；因||左侧为假，需计算右侧k++==3，k自增为4且表达式为真。最终输出2,4,4。" }, { "id": 996, "q": "在嵌套使用if语句时，c语言规定else总是( ) 。", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "之前与其最近的if配对", "和之前与其最近的未配对的if配对", "和之前与其具有相同缩进位置的if配对", "和之前的第一个if配对" ], "explanation": "C语言语法规定，在嵌套的if语句中，else总是与它前面最近的、且尚未与其他else配对的if语句结合，与代码的缩进格式无关。" }, { "id": 997, "q": "下面程序的运行结果是( )。\n#include\nmain()\n{int k=1;\nswitch (k)\n{case 1: printf(\"%d\",k++);\ncase 2:printf(\"%d\",k++);\ncase 3:printf(\"%d\",k++);\ncase 4:printf(\"%d\",k++);break;\ndefault:printf(\"Full!\\n\");\n}\n}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "1", "2", "1234", "2345\n2345" ], "explanation": "switch语句中，k=1匹配case 1，输出1后k自增为2。由于没有break语句，程序会发生穿透，继续执行case 2、3、4的代码，分别输出2、3、4，k最终变为5。在case 4末尾遇到break跳出，故输出1234。" }, { "id": 998, "q": "以下程序的结果是（）。\nint a=1,b=2,c=3;\nif(ac) printf(\"%d\", a) ;\nelse printf(\"%d\", b) ;\nelse printf(\"%d\", c) ;", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "1", "2", "3", "以上答案都错误" ], "explanation": "C语言中else总是与最近的未配对if配对。ac即1>3为假，执行内层else，输出b的值2。" }, { "id": 999, "q": "下面程序的运行结果是( )。\nint a,b;\na=-1;\nb=0;\ndo\n{\n++a;\n++a;\nb+=a;\n} while(a<9);\nprintf(\"%d\\n\",b);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "24", "25", "26", "36" ], "explanation": "初始a=-1,b=0。do-while循环先执行后判断。每次循环a自增两次（即加2），b累加a的值。循环过程：a变1,b=1；a变3,b=4；a变5,b=9；a变7,b=16；a变9,b=25。此时a<9不成立，退出循环，输出25。" }, { "id": 1000, "q": "下面的循环体执行完后，a的值是: ( )。\nfor( a=2; a<8; a++) a*=2 ;", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "12", "11", "10", "9" ], "explanation": "for循环执行过程：初始a=2；第1次判断2<8成立，执行a*=2得4，步进a++得5；第2次判断5<8成立，执行a*=2得10，步进a++得11；第3次判断11<8不成立，退出循环。最终a的值为11。" }, { "id": 1001, "q": "设有程序段\nint k=20;\nwhile(k=0) k=k+1;\n则下面描述中正确的是( )", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "while循环执行20次", "循环是无限循环", "循环体语句一次也不执行", "循环体语句执行一次" ], "explanation": "while循环的条件表达式为\"k=0\"，这是一个赋值表达式而非关系表达式\"k==0\"。赋值后k的值为0，在C语言中0代表逻辑假，因此循环条件一开始就不成立，循环体语句一次也不执行。" }, { "id": 1002, "q": "以下程序的运行结果是（）。\nint n=1;\nwhile(n<=10)\n{\nn++;\nif(n%3==0) continue;\nprintf(\"%d\",n);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "245781011", "369", "12457810", "12" ], "explanation": "n初始为1。每次循环先n++，若n能被3整除则continue跳过输出。n依次为2(输出),3(跳过),4(输出),5(输出),6(跳过),7(输出),8(输出),9(跳过),10(输出),11(输出后判断11<=10为假退出)。故输出245781011。" }, { "id": 1003, "q": "以下程序段运行后的输出结果是()\nint n=0,i,j,k;\nfor(i=1;i<=2;i++)\nfor(k=1;k<=2;k++)\nfor(j=1;j<=2;j++)\nn++;\nprintf(\"n=%d\\n\",n);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "n=6", "n=8", "n=0", "n=4" ], "explanation": "这是一个三重嵌套循环。外层i循环执行2次，中层k循环执行2次，内层j循环执行2次。最内层循环体\"n++\"总共执行2×2×2=8次。n初始为0，最终结果为8。" }, { "id": 1004, "q": "下列有关函数的定义，不正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "函数是完成程序中部分功能的子程序", "函数是实现某个功能的模块", "C语言函数只能实现数学函数的功能", "C语言函数与数学上函数的含义完全相同" ], "explanation": "C语言中的函数不仅用于实现数学上的计算功能，还可以实现输入输出、控制硬件等各种复杂的程序功能模块，且允许无返回值或带有副作用，与数学中严格的函数概念不完全相同。故C选项说法错误。" }, { "id": 1005, "q": "局部变量前面加上static后，下列说法不正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "存放在静态存储区", "作用域没有变化", "生存期没有变化", "生存期得以延长" ], "explanation": "局部变量加上static修饰后，其存储类别由动态存储变为静态存储，生存期延长至整个程序运行期间，但其作用域依然局限于定义它的函数或复合语句内部。因此\"生存期没有变化\"的说法是错误的。" }, { "id": 1006, "q": "以下程序的输出结果是（）\n#include\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<3;i++)\nprintf(\"%d \",f(i));\n}\nint f(int a)\n{ int b=0; static int c=6;\nb++;c++;\nreturn(b+c);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "8 9 10", "7 8 9", "8 10 12", "9 10 11" ], "explanation": "函数f中b是自动变量，每次调用初始化为0；c是静态局部变量，只初始化一次且保留上次值。第1次调用(i=0)：b=1,c=7，返回8；第2次(i=1)：b=1,c=8，返回9；第3次(i=2)：b=1,c=9，返回10。输出8 9 10。" }, { "id": 1007, "q": "有如下程序输出结果是（）\nlong fib(int n)\n{ if(n>5) return(fib(n-1)+fib(n-2));\nelse return (3); }\nmain()\n{ printf(\"%d\\n\",fib(6)); }", "t": "single", "ans": "D", "kp": "函数", "o": [ "9", "0", "3", "6" ], "explanation": "递归函数fib中，当n>5时返回fib(n-1)+fib(n-2)，否则返回3。计算fib(6)时，因6>5，返回fib(5)+fib(4)。而5和4均不大于5，故fib(5)=3，fib(4)=3。最终结果为3+3=6。" }, { "id": 1008, "q": "以下程序段的运行结果是（　　）。\nint m[ ][3]={3,6,7,2,4,8,1,0,7};\nint j,n=1;\nfor(j=0;j<3;j++)\nprintf(\"%d \",m[n][j]);", "t": "single", "ans": "A", "kp": "数组", "o": [ "2 4 8", "3 6 7", "1 0 7", "6 2 4" ], "explanation": "二维数组m按行优先顺序初始化，每行3个元素。m[0]为{3,6,7}，m[1]为{2,4,8}，m[2]为{1,0,7}。循环中n=1，依次输出m[1][0]、m[1][1]、m[1][2]的值，即第2行的元素2、4、8。" }, { "id": 1009, "q": "以下对二维数组错误的定义语句是（　）", "t": "single", "ans": "C", "kp": "数组", "o": [ "int z[ ][3]={{1,1,2},{1,2},{1}};", "int z[4][3]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};", "int z[3][ ]={{1,2,3},{1,2,3},{1,2,3}};", "int z[4][4]={{1},{2},{3,4},{5,6,7}};" ], "explanation": "在C语言中定义二维数组时，可以省略第一维（行数）的长度，由编译器根据初始化数据自动推断，但第二维（列数）的长度绝对不能省略。选项C省略了第二维长度，因此是错误的定义语句。" }, { "id": 1010, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=0;i<3;i++) s+=a[i][0]+a[i][2-i];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "27", "28", "26", "29" ], "explanation": "程序计算二维数组两条对角线元素之和。i=0时，s加a[0][0]和a[0][2]即1+9=10；i=1时，加a[1][0]和a[1][1]即3+4=7，s=17；i=2时，加a[2][0]和a[2][0]即5+5=10，s=27。注意中心元素a[1][1]被计算了两次，最终结果为27。" }, { "id": 1011, "q": "以下程序的运行结果是（　　）。\nmain()\n{ char st[20]=\"hello\\0\\t\\\\\";\nprintf(\"%d %d \\n\",strlen(st),sizeof(st)); }", "t": "single", "ans": "B", "kp": "字符串", "o": [ "9 9", "5 20", "13 20", "20 20" ], "explanation": "strlen函数计算字符串有效长度，遇到第一个'\\0'结束，'hello'长为5。sizeof运算符计算变量或类型所占的内存字节数，数组st定义大小为20，故为20。因此输出5和20。" }, { "id": 1012, "q": "执行下列语句后的输出为（）。\nint j=-1;\nif(j<=1) printf(\"****\\n\");\nelse printf(\"%%%%\\n\");", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "****", "%%%%", "****\n%%%%", "有错,执行不正确" ], "explanation": "变量j初始化为-1，条件判断j<=1即-1<=1为真，因此执行if分支的语句，输出'****'。else分支不会被执行。" }, { "id": 1013, "q": "有以下程序段运行后的输出结果是( )\nmain()\n{ int a[10]={1,2,3,4,5,6,7,8,9}, *p=a,*q=&a[3];\nq++;\n++p;\nprintf(\"%d\\n\", *p + *q); }", "t": "single", "ans": "C", "kp": "指针", "o": [ "8", "5", "7", "6" ], "explanation": "初始时p指向a[0]（值为1），q指向a[3]（值为4）。执行q++后，q指向a[4]（值为5）；执行++p后，p指向a[1]（值为2）。最后计算*p + *q，即2+5=7。" }, { "id": 1014, "q": "若有以下定义语句，则值为3的表达式是()\nint a[ ]={1，2，3，4，5，6，7，8，9，10}，*p=a；", "t": "single", "ans": "A", "kp": "指针", "o": [ "p+=2 ,*(p++)", "p+=2，*++p", "p+=3 , *p++", "p+=2，++*p" ], "explanation": "数组a首元素为1。A选项中p+=2使p指向a[2]（值为3），*(p++)先取当前值3，再使p自增，表达式值为3。B选项*++p先自增再取值，结果为4。C选项p+=3指向4，结果为4。D选项++*p将所指元素加1，结果为4。" }, { "id": 1015, "q": "有下列程序：\n#include \n#define N 5\n#define M N+1\n#define f(x) (x*M)\nmain( )\n{\nint i1,i2;\ni1=f(2);\ni2=f(1+1);\nprintf(\"%d %d\\n\", i1,i2);\n}\n程序的运行结果是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "12 7", "12 12", "11 11", "11 7" ], "explanation": "宏替换是纯文本替换。f(2)展开为(2*N+1)即(2*5+1)=11。f(1+1)展开为(1+1*N+1)即(1+1*5+1)，根据乘法优先级，计算结果为1+5+1=7。注意宏定义中未加括号导致的优先级问题。" }, { "id": 1016, "q": "给定程序modi1.c中函数fun的功能是：计算n的5次方的值（规定n的值大于2、小于8），通过形参指针传回主函数。并计算该值的个位、十位、百位上数字之和作为函数值返回。例如，7的5次方是16807，其低3位数的和值是15。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "程序中第一个for循环的作用是计算n的5次方，计算结果存放于变量d中，第二个for循环语句实现了计算变量d中个位、十位、百位上数字之和，结果存放于变量s中，并返回s。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1017, "q": "若变量已正确定义为int 型，要通过语句scanf(\"%d,%d,%d\",&a,&b,&c）；给a 赋值1、给b 赋值2、给c 赋值3，以下输入形式中错误的是（口代表一个空格符）（　　）。", "t": "single", "ans": "B", "kp": "输入输出", "o": [ "口口口1,2,3", "1口2口3", "1,口口口2,口口口3", "1,2,3" ], "explanation": "scanf的格式控制字符串中若包含普通字符（如逗号），输入时必须原样输入该字符。选项B使用空格分隔，无法与格式串中的逗号匹配，导致输入失败。其他选项均正确包含了逗号分隔符。" }, { "id": 1018, "q": "表达式：(int)((double)9/2)-9%2的值是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0", "3", "4", "5" ], "explanation": "首先计算(double)9/2，9被转换为双精度浮点数，除以2得4.5。接着强制类型转换(int)4.5截断小数部分得4。然后计算9%2取余得1。最后相减4-1=3。" }, { "id": 1019, "q": "如果从键盘上输入： 12 33 ，则m的值为（）\nscanf(\"%d%d\",&m,&n);\nwhile (m!=n)\n{\nwhile (m>n) m-=n;\nwhile (n>m) n-=m;\n}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "0", "1", "2", "3" ], "explanation": "该程序使用辗转相减法求两个数的最大公约数。初始m=12，n=33。循环中较大数减去较小数：33-12=21，21-12=9；接着12-9=3；然后9-3=6，6-3=3。最终m和n都等于3，循环结束，m的值为3。" }, { "id": 1020, "q": "运行下列程序段时，如果输入ABC，则输出结果是（　　）。\n{\nchar ss[10]= \"12345\";\ngets(ss);strcat(ss, \"6789\");\nprintf(\"%s\\n\",ss);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "ABC6789", "ABC67", "12345ABC6", "ABC45678" ], "explanation": "gets(ss)读取输入'ABC'并自动在末尾添加'\\0'，此时ss的内容变为'ABC'。随后strcat函数将'6789'拼接到'ABC'之后，覆盖原有的'\\0'并在新末尾添加'\\0'。最终ss的内容为'ABC6789'。" }, { "id": 1021, "q": "若有宏定义如下：\n#define X 5\n#define Y X+1\n#define Z Y*X/2\n则执行以下printf语句后，输出的结果是( )。\nint a;\na=Y;\nprintf(\"%d,\",Z);\nprintf(\"%d\\n\",--a);", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "7,6", "12,6", "12,5", "7,5" ], "explanation": "宏替换为直接文本替换。Z展开为X+1*X/2，即5+1*5/2，根据优先级先算乘除得5+5/2，整除得5+2=7。a=Y展开为a=5+1，故a初值为6。--a使a先自减为5再输出。因此输出7,5。" }, { "id": 1022, "q": "标准C语言中，以下注释合法的是（　　）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "//这是注释", "/*这是注释", "（*这是注释*）", "" ], "explanation": "C语言中，单行注释使用//，多行注释使用/*...*/。选项A是合法的C99单行注释。选项B缺少结束的*/。选项C使用了中文括号，不合法。选项D为空。现代C语言标准支持//注释，因此选A。" }, { "id": 1023, "q": "以下程序段的输出结果是( )\nint a=0,n=1,s=0;\nwhile(a=0)\n{ s=s+n+a;\nn++;\na++;}\npirntf(\"%d\",s);}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "1", "无限循环", "无确定值" ], "explanation": "while循环的条件是a=0，这是一个赋值表达式，将0赋给a，表达式的值为0（即逻辑假）。因此循环体一次也不会执行。循环结束后，s的值保持初始值0。题目代码中printf拼写错误，但不影响逻辑推导，输出结果为0。" }, { "id": 1024, "q": "以下叙述正确的是( )。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "continue 语句的作用是结束整个循环的执行", "只能在循环体内和 switch 语句体内使用 break语句", "在循环体内使用 break语句或 continue 语句的作用相同", "从多层循环嵌套中退出时,只能使用 goto 语句" ], "explanation": "A错误，continue只结束本次循环，break才结束整个循环。B正确，break语句只能用于循环语句和switch语句中。C错误，两者作用不同。D错误，多层循环嵌套退出可以使用标志变量结合break或return等，并非只能用goto。" }, { "id": 1025, "q": "以下程序段中，内循环体的总的执行次数是（）\nfor (i=5;i;i--)\nfor (j=0;j<4;j++)\n{...}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "20", "24", "25", "30" ], "explanation": "外层循环变量i初始为5，条件为i非0，每次减1，因此i依次取5、4、3、2、1，共执行5次。内层循环变量j初始为0，条件为j<4，每次加1，因此j依次取0、1、2、3，共执行4次。内外层循环嵌套，内循环体总执行次数为5×4=20次。" }, { "id": 1026, "q": "以下程序的运行结果是（　　）。\nmain( )\n{ int m[ ][3]={1,2,3,4,5,6,7,8,9};\nint i,j,k=2;\nfor(i=0;i<3;i++)\nprintf(\"%d \",m[k][i]); }", "t": "single", "ans": "D", "kp": "数组", "o": [ "1 2 3", "4 5 6", "6 7 8", "7 8 9" ], "explanation": "二维数组m按行优先初始化，共9个元素，每行3个，因此m是3行3列的数组。第0行是1,2,3，第1行是4,5,6，第2行是7,8,9。变量k=2，循环中i从0到2，依次输出m[2][0]、m[2][1]、m[2][2]，即第3行的元素7、8、9。" }, { "id": 1027, "q": "以下不合法的字符常量是( )", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "'\\\"'", "'\\\\'", "'\\018'", "'\\xab'" ], "explanation": "字符常量中，转义字符\\后跟八进制数时，数字只能是0-7。选项C中\\018包含了数字8，不是合法的八进制转义字符。选项A是双引号，选项B是反斜杠，选项D是十六进制转义字符（\\x后跟十六进制数），均合法。" }, { "id": 1028, "q": "如下程序的运行结果是（　　）。\nlong fib(int n)\n{ if(n>2) return(fib(n-1)+fib(n-2));\nelse return 2; }\nmain()\n{ printf(\"%d\\n\",fib(4)); }", "t": "single", "ans": "C", "kp": "函数", "o": [ "2", "4", "6", "8" ], "explanation": "这是一个递归函数。计算fib(4)：因为4>2，返回fib(3)+fib(2)。计算fib(3)：因为3>2，返回fib(2)+fib(1)。计算fib(2)和fib(1)：均不大于2，返回2。所以fib(3)=2+2=4。最终fib(4)=fib(3)+fib(2)=4+2=6。" }, { "id": 1029, "q": "void fun(int a, int b ）\n{ int t;\nt=a;a=b;b=t;}\nmain()\n{ int c[10]={1,2,3,4,5,6,7,8,9,0},i;\nfor(i=0;i<10;i+=2) fun(c[i],c[i+1]);\nfor(i=0;i<10;i++) printf(\"%d,\",c[i]);\nprintf(\"\\n\");}", "t": "single", "ans": "A", "kp": "函数", "o": [ "1,2,3,4,5,6,7,8,9,0,", "2,1,4,3,6,5,8,7,0,9,", "0,9,8,7,6,5,4,3,2,1,", "0,1,2,3,4,5,6,7,8,9," ], "explanation": "函数fun的参数是值传递，在函数内部交换a和b的值不会影响主函数中实参数组c的元素。因此，调用fun后数组c的内容保持不变，仍为初始的1到9和0。输出时依次打印数组元素并用逗号分隔，结果为1,2,3,4,5,6,7,8,9,0,。" }, { "id": 1030, "q": "以下程序的运行结果是（　　）\nmain()\n{ int s[12]={0,2,4,0,4,3,2,1,1,1,2,3},c[5]={0},i;\nfor(i=0;i<12;i++) c[s[i]]++;\nfor(i=0;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "23322", "2332", "23332", "03322" ], "explanation": "数组c初始全为0。第一个循环遍历数组s，将s[i]的值作为c的下标，并使对应的c元素加1，即统计s中各数字出现的次数。s中0出现2次，1出现3次，2出现3次，3出现2次，4出现2次。因此c[0]到c[4]的值分别为2、3、3、2、2。输出结果为23322。" }, { "id": 1031, "q": "以下程序的运行结果是（　　）。\nmain()\n{ char st[12]=\" type\\t\\\\\";\nprintf(\"%d %d \\n\",strlen(st),sizeof(st)); }", "t": "single", "ans": "B", "kp": "字符串", "o": [ "6 6", "6 12", "7 7", "7 12" ], "explanation": "字符串字面量中，\\t和\\\\各算一个字符。若按题面计算，包含首空格共7个字符，strlen应为7。但根据给定答案B，出题人可能忽略了首空格，按无空格计算得出strlen为6。sizeof(st)计算的是数组声明的固定大小，即12字节。本题题面与答案存在出入。" }, { "id": 1032, "q": "以下程序的运行结果是（　）。\nmain()\n{ int a=25, *p;\np=&a;\nprintf(\"%d\\n\",++*p); }", "t": "single", "ans": "D", "kp": "指针", "o": [ "23", "24", "25", "26" ], "explanation": "指针p指向变量a，*p即为a的值25。表达式++*p中，*和++优先级相同，结合性从右到左，相当于++(*p)，即先将p所指向的变量a的值加1，变为26，然后再输出该值。因此输出结果为26。" }, { "id": 1033, "q": "给定程序中，函数fun的功能是：计算下式前n项的和作为函数值返回。\n例如，当形参n的值为10时，函数返回：9.612558。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "变量s用来作为前n项和的返回值，需要首先为其赋初始值，所以第一处填：0.0或相同作用的语句；由题意可知，循环的终止值应为n，所以第二处答案为：n；根据题目中的公式可以得出每项的分母是该数值的倍数的平方，所以第三处答案为：(t*t)或相同作用的语句。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1034, "q": "以下选项中合法的标识符有(　　)", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1-1", "1_1", "_11", "1_ _" ], "explanation": "C语言规定，标识符只能由字母、数字和下划线组成，且第一个字符必须是字母或下划线。选项A包含减号，不合法；选项B和D以数字开头，不合法；选项C以下划线开头，且只包含下划线和数字，是合法的标识符。" }, { "id": 1035, "q": "以下程序运行后的输出结果是（ ）。\nint i=1,j=2,k=3;\nif(i++==1&&(++j==3||k++==3)) printf(\"%d,%d,%d\\n\",i,j,k);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "1,2,3", "2,3,4", "2,2,3", "2,3,3" ], "explanation": "i++==1为真，i变为2。逻辑与左侧为真，继续计算右侧。++j==3为真，j变为3。由于逻辑或的短路特性，右侧k++==3不执行，k保持为3。最终输出2,3,3。" }, { "id": 1036, "q": "有以下程序段运行后的输出结果是( ) 。\nint a=3,b=2,c=5,d=2;\nif(b>c)\nprintf(\"%d\",d++ +1);\nelse\nprintf(\"%d\",++d +1);\nprintf(\"%d\\n\",d);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "2", "3", "43", "44" ], "explanation": "b>c即2>5为假，执行else分支。++d使d变为3，输出3+1即4。随后执行最后的printf，输出此时d的值3。因此总输出为43。" }, { "id": 1037, "q": "有如下程序\nint x=0,a=0,b=1;\nswitch(x){\ncase 0: b++;\ncase 1: a++;\ncase 2: a++;b++;\n}\nprintf(\"a=%d,b=%d\\n\",a,b);\n该程序的输出结果是（）。", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "a=2,b=1", "a=2,b=2", "a=1,b=2", "a=2,b=3" ], "explanation": "switch语句中x为0，匹配case 0，执行b++使b为2。因无break语句，发生穿透，继续执行case 1的a++使a为1，再穿透执行case 2的a++和b++，最终a为2，b为3。" }, { "id": 1038, "q": "程序运行后，m的值为（）。\nint i,j,m=55;\nfor(i=1;i<=3;i++)\nfor(j=1;j<=i;j++)\nm=m%j;", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0", "1", "2", "3" ], "explanation": "外层循环i从1到3，内层循环j从1到i。当i=1, j=1时，m=55%1=0。此后m的值始终为0，0对任何非零整数取余结果仍为0。因此最终m的值为0。" }, { "id": 1039, "q": "有以下程序运行后的输出结果是( ) 。\nint f( int x,int y )\n{ return ((y-x)*x);}\nmain()\n{ int a=3,b=4,c=5,d;\nd=f(f(a,b）,f(a,c）);\nprintf(\"%d\\n\",d）; }", "t": "single", "ans": "B", "kp": "函数", "o": [ "10", "9", "8", "7" ], "explanation": "函数f返回(y-x)*x。先计算内层f(a,b)即f(3,4)=(4-3)*3=3；f(a,c)即f(3,5)=(5-3)*3=6。再计算外层f(3,6)=(6-3)*3=9。最终输出9。" }, { "id": 1040, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=12-i;\nprintf(\"%d%d%d\",a[4],a[6],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "864", "468", "248", "842" ], "explanation": "循环将数组a赋值为a[i]=12-i。因此a[4]=12-4=8，a[6]=12-6=6，a[8]=12-8=4。printf连续输出这三个元素，中间无分隔符，结果为864。" }, { "id": 1041, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int a[3][3]={1,3,5,7,9,11,13,15,17},sum=0,i,j;\nfor (i=0;i<3;i++)\nfor (j=0;j<3;j++)\n{ a[i][j]=i+j;\nif(i=j)\nsum=sum+a[i][j]; }\nprintf(\"sum=%d\",sum);}", "t": "single", "ans": "A", "kp": "数组", "o": [ "sum=26", "sum=1", "sum=6", "sum=25" ], "explanation": "题干中if(i=j)为赋值操作，会导致循环提前结束且结果不为26；若为if(i==j)，对角线元素和为0+2+4=6。无论哪种情况，结果均与答案26不符，题目或答案存在异常。" }, { "id": 1042, "q": "请编写一个函数fun，它的功能是：找出一维整型数组元素中最大的值和它所在的下标，最大的值和它所在的下标通过形参传回。数组元素中的值已在主函数中赋予。主函数中x是数组名，n是x中的数据个数，max存放最大值，index存放最大值所在元素的下标。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int a[], int n , int *max, int *d )\n{\nint i,base,subscript;\nbase=a[0]; /*假定第一个元素的值最大*/\nsubscript=0; /*subscript用于存放数组下标*/\nfor(i=1;ibase) { /*将数组中的其他元素与变量base作比较，如果大于它则交换两者的值*/\nsubscript=i;\nbase=a[i];\n}\n}\n*max=base; /*将最大值元素的值赋给*max*/\n*d=subscript; /*将最大值元素的下标赋给*d*/\n}", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 1043, "q": "以下程序的运行结果是（　　）。\nmain()\n{\nchar arr[3][4];\nstrcpy(arr[0],\"you\");\nstrcpy(arr[1],\"me\");\nstrcpy(arr[2],\"her\");\narr[0][3]='&';\narr[1][2]='&';\narr[1][3]='&';\nprintf(\"%s\\n\",arr);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "you&me&&her", "you&me", "you&me&her", "youmeher" ], "explanation": "arr[0]存入you，arr[1]存入me，arr[2]存入her。修改后arr[0]和arr[1]末尾的'\\0'均被'&'替换。使用%s输出arr时，会连续打印直到遇到arr[2]末尾的'\\0'，结果为you&me&&her。" }, { "id": 1044, "q": "若变量已正确定义执行语句 scanf(\"%d%d%d \",&k1,&k2,&k3);( )是正确的输入。", "t": "single", "ans": "B", "kp": "输入输出", "o": [ "12,3", "1 2 3", "1,23", "1,2,3" ], "explanation": "scanf的格式控制字符串\"%d%d%d\"中未包含逗号等非空白字符，因此输入时多个数据之间必须使用空白字符（如空格、回车或Tab）分隔，不能使用逗号。" }, { "id": 1045, "q": "设有定义语句\"int a=3，b，*p=&a；\"，则下列语句中使b不为3的语句是()", "t": "single", "ans": "D", "kp": "指针", "o": [ "b=*&a;", "b=*p;", "b=a;", "b=*a;" ], "explanation": "选项A、B、C均能正确将a的值3赋给b。选项D中，a是普通整型变量而非指针，对其进行解引用操作*a会导致语法错误，无法使b为3。" }, { "id": 1046, "q": "下列给定程序中，对于函数void fun(int *dt,int n)，传递给形参dt整型数组名、传递给形参n该数组的数据个数，函数的功能是在数组中找出值最小的元素并将其与第1个元素交换。\n如原数组数据为30，20，15，64，85，28，则经函数处理后为15，20，30，64，85，28。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在文件BLANK1.C中，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "(1)从代码中可以看出m是dt数组的下标变量，变量在使用前要赋初始值，另根据for循环可以看出dt数组遍历了除第一个数的所有数，且题目要求求最小值（求最大、最小值一般假设第一个或最后一个满足）故填m=0。\n(2)for循环遍历所有数，依次与假设最小数比较，即dt[i]\nf(int a)\n{ int b=0; static int c=5;\nb++;c++;\nreturn(a+b+c);}\nmain( )\n{int i;\nfor(i=0;i<3;i+=2)\nprintf(\"%d \",f(i));\n}", "t": "single", "ans": "D", "kp": "函数", "o": [ "7 7", "7 8", "7 9", "7 10" ], "explanation": "函数f中b是局部变量，每次调用初始化为0；c是静态变量，只初始化一次且保留上次修改的值。第一次调用f(0)：b=0，c=5，执行后b=1，c=6，返回0+1+6=7。第二次调用f(2)：b=0，c=6，执行后b=1，c=7，返回2+1+7=10。因此输出7 10。" }, { "id": 1051, "q": "以下程序的功能是：统计字符串(长度不超过1000个字符)中每个字母的个数（不区分大小写），若字符不是字母，则统一归为其他字符。\n请在程序的下划线处填入正确的内容并把下划线删除：使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 1052, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[10]=\"12342233\";\nint v[4]={1,1,1,1},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "2442", "1331", "1111", "2222" ], "explanation": "数组v初始全为1。遍历字符串，遇到'1'时v[0]++，'2'时v[1]++，'3'时v[2]++，'4'时v[3]++。字符串中'1'有1个，'2'有3个，'3'有3个，'4'有1个。因此v[0]=1+1=2，v[1]=1+3=4，v[2]=1+3=4，v[3]=1+1=2。最终输出2442。" }, { "id": 1053, "q": "若有定义\nint a;\nfloat b;\ndouble c;\n程序运行时输入：\n3 4 5\n能把值3输入给变量a、4输入给变量b、5输入给变量c的语句是", "t": "single", "ans": "A", "kp": "输入输出", "o": [ "scanf(\"%d%f%lf\", &a,&b,&c);", "scanf(\"%d%lf%lf\", &a,&b,&c);", "scanf(\"%d%f%f\", &a,&b,&c);", "scanf(\"%lf%lf%lf\", &a,&b,&c);" ], "explanation": "scanf格式控制符需与变量类型严格匹配。int对应%d，float对应%f，double对应%lf。选项B中b是float却用%lf，选项C中c是double却用%f，选项D全错。只有A完全匹配。" }, { "id": 1054, "q": "当a=1,b=3,c=5,d=4时，执行完下面一段程序后x的值是()\nif(a0) ;", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "2", "3", "4", "5" ], "explanation": "第一次循环：b=0+2=2，a=10-(2+2)=6，判断a>0成立，继续。第二次循环：b=2+2=4，a=6-(2+4)=0，判断a>0不成立，退出循环。循环体共执行2次。" }, { "id": 1056, "q": "以下程序的运行结果是（　　）。\nmain( )\n{ int i,j;\nfor(i=0;i<2;i++) {\nj=i*10+6;\nprintf(\"%d ,\",j);\n}\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "6，", "6,16，", "6,22，", "16，" ], "explanation": "循环执行两次。当i=0时，j=0*10+6=6，输出6和逗号；当i=1时，j=1*10+6=16，输出16和逗号。因此最终打印结果为6,16,。选项B符合该输出序列。" }, { "id": 1057, "q": "对于整型变量x, 与 while(!x) 等价的是（ ）。", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "while(x!=0)", "while(x==0)", "while(x!=1)", "while(~x)" ], "explanation": "在C语言中，逻辑非运算符!将非零值转换为0，将0转换为1。因此!x为真（非零）的条件是x的值为0。这与x==0完全等价。x!=0等价于while(x)，x!=1和~x（按位取反）均不符合逻辑非的语义。" }, { "id": 1058, "q": "有以下程序，若运行时输入3.6 2.4，则输出的结果是( )。\nmain( )\n{float x,y,z;\nscanf(\"%f%f\",&x,&y);\nz=x/y;\nwhile(1)\n{ if(fabs(z)>1.0)\n{ x=y; y=z; z=x/y;}\nelse\nbreak;}\nprintf(\"%f\\n\",y);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "1.500000", "1.600000", "2.000000", "2.400000" ], "explanation": "初始x=3.6, y=2.4, z=1.5。进入循环：fabs(z)>1.0成立，x=2.4, y=1.5, z=1.6。第二次：fabs(1.6)>1.0成立，x=1.5, y=1.6, z=0.9375。第三次：fabs(0.9375)>1.0不成立，break退出。输出y的值1.600000。" }, { "id": 1059, "q": "设int gcd（int x, int y）函数的功能是求两个正整数的最大公约数，则求四个正整数a,b,c,d的最大公约数，gcd函数需要调用（）次", "t": "single", "ans": "C", "kp": "函数", "o": [ "1", "2", "3", "4" ], "explanation": "求多个数的最大公约数可以两两求解。先求a和b的公约数t1=gcd(a,b)，再求t1和c的公约数t2=gcd(t1,c)，最后求t2和d的公约数gcd(t2,d)。因此总共需要调用3次gcd函数。" }, { "id": 1060, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{1,3,5},{2,3,4},{3,5,7},{3,9,8,4}};\nprintf(\"%d%d%d%d\\n\",a[0][1],a[1][1],a[2][1],a[3][3]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "3354", "3333", "4444", "3355" ], "explanation": "二维数组按行优先初始化，未赋值的元素自动补0。第一行{1,3,5,0}，a[0][1]=3；第二行{2,3,4,0}，a[1][1]=3；第三行{3,5,7,0}，a[2][1]=5；第四行{3,9,8,4}，a[3][3]=4。拼接输出结果为3354。" }, { "id": 1061, "q": "以下能正确定义一维数组的选项是（）。", "t": "single", "ans": "B", "kp": "数组", "o": [ "int num[ ];", "#define N 100\nint num[N];", "int num[0..100];", "int N=100;\nint num[N];" ], "explanation": "C语言中定义数组时，方括号内必须是常量表达式。A缺少大小；C语法错误，不能用..；D中N是变量，在C89标准中不能用变量定义数组长度。B通过宏定义N为100，预处理后为常量，符合语法规则。" }, { "id": 1062, "q": "当a=1，b=3，c=5，d=4时，执行下面一段程序后，x的值为( ).\nif (ac)\nif (b>d) x=2;\nelse x=3;\nelse x=6;\nelse x=7;", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "1", "2", "3", "6" ], "explanation": "ac即1>5为假，因此执行else x=6。最终x的值为6。" }, { "id": 1063, "q": "以下程序的输出结果是()\nmain()\n{\nchar a[10]={'1','2','3','4','5','6','7','8','9',0}，*p；\nint i=8；\np=a+i；\nprintf(\"%s\\n\"，p-3);\n}", "t": "single", "ans": "B", "kp": "指针", "o": [ "6", "6789", "'6'", "789" ], "explanation": "指针p初始指向a[8]即字符9，p-3使指针向前移动3个位置，指向a[5]即字符6。使用%s格式符输出时，从6开始依次输出后续字符，直到遇到字符串结束标志0，因此输出6789。" }, { "id": 1064, "q": "给定程序中，函数fun的功能是：找出100至x（x≤999）之间各位上的数字之和为15的所有整数，然后输出；符合条件的整数个数作为函数值返回。\n例如，当x值为500时，各位数字之和为15的整数有：159、168、177、186、195、249、258、267、276、285、294、339、348、357、366、375、384、393、429、438、447、456、465、474、483、492。共有26个。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "fun函数是用来对整数进行判断是否符合题目中规定的条件。首先对变量赋初值，n返回的是符合条件的整数的个数，因此第一个空填：0；while语句用于求出100至x（x≤999）之间的符合条件的整数个数，故第二个空填：x；由while循环语句可知第三个空是设置循环变量的步长，根据题义可知循环步长是1，因此第三个空填：t++或与此语句相同功能的语句。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 1065, "q": "以下程序的运行结果是（　　）\nmain()\n{ char cf[3][5]={\"AAAA\",\"BBB\",\"CC\"};\nprintf(\"\\\"%s\\\"\\n\",cf[0]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "\"AAAA\"", "\"AAA\"", "\"AA\"", "\"AAAABBBCC\"" ], "explanation": "二维字符数组cf的第一行cf[0]存储了字符串AAAA。在printf函数中，格式控制字符串里的反斜杠加双引号用于转义输出双引号本身，%s用于输出字符串内容。因此最终输出结果会在AAAA两侧加上双引号。" }, { "id": 1066, "q": "以下叙述中不正确的是( )。", "t": "single", "ans": "C", "kp": "字符串", "o": [ "空字符串(即两个双引号连写) 只占一个存储单元", "字符型常量可以放在字符型变量中", "字符串常量可以放在字符变量中", "字符型常量可以与整数混合运算, 而字符串常量不可以" ], "explanation": "字符变量在内存中只占一个字节，只能存储单个字符常量。而字符串常量是由多个字符及结尾的结束符组成的字符数组，无法直接赋值或存储在单个字符变量中，必须使用字符数组或字符指针来存储。" }, { "id": 1067, "q": "若有定义语句int a=10;double b=3.14;，则(int) ('A'+a+b)值的类型是          。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "int", "char", "float", "double" ], "explanation": "C语言中，强制类型转换运算符会将表达式的计算结果转换为指定的类型。本题中明确将后面括号内表达式的最终计算结果强制转换为整型，因此该表达式的值类型为int。" }, { "id": 1068, "q": "以下选项中可用作C程序合法实数的是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "3.0e0.2", "e9", "0.1e0", "9.12e" ], "explanation": "C语言中科学计数法表示实数时，字母e或E之前必须有数字，且e后面的指数部分必须是整数。选项A指数为小数，选项B和D在e前或e后缺少数字，只有选项C完全符合语法规则。" }, { "id": 1069, "q": "以下程序的运行结果是（　　）。\n# include\nmain()\n{\nint i=5, j=5;\nprintf(\"i=%d,\", ++i);\nprintf(\"j =%d,\", j++);\nprintf(\"j =%d\", j);\n}", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "i=6,j=6,j=6", "i=6,j=5,j=6", "i=5,j=6,j=6", "i=5,j=5,j=6" ], "explanation": "++i为前置自增，i先加1变为6再输出；j++为后置自增，先输出j的当前值5，然后j再加1变为6；最后一次输出j时，其值已更新为6。因此依次输出i=6，j=5，j=6。" }, { "id": 1070, "q": "若有定义语句：int a=3,b=2,c=1; 以下选项中错误的赋值表达式是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "a=b=c+1;", "a=(b=4)=3;", "a=(b=4) +c;", "a=1+(b=c=4);" ], "explanation": "在C语言中，赋值运算符的左侧必须是可修改的左值如变量。选项B中，(b=4)是一个赋值表达式，其计算结果为4，属于右值，不能再作为左值被赋值为3，因此该表达式语法错误。" }, { "id": 1071, "q": "有以下定义语句，编译时会出现编译错误的是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "char a='\\n';", "char a=\"aa\";", "char a='a';", "char a='\\x2d';" ], "explanation": "单引号括起来的是字符常量，可以赋值给char类型变量；而双引号括起来的是字符串常量，在内存中占用多个字节且包含结尾的结束符，不能直接赋值给单个字符变量，会导致编译错误。" }, { "id": 1072, "q": "以下程序的运行结果是（）。\n　　main() {int a=0;\n　　if(a=1) printf(\"A\");\n　　printf(\"B\");}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "AB", "A", "B", "ABAB" ], "explanation": "if语句的条件表达式为a=1，这是一个赋值表达式而非关系表达式a==1。赋值后a的值为1，在C语言中非0即为真，因此条件成立，执行输出A。随后顺序执行下一条语句输出B，最终结果为AB。" }, { "id": 1073, "q": "阅读以下程序，（）说法正确。\nmain()\n{\nint a=7,b=0,c=0;\nif(a=b+c) printf(\"***\\n \");\ne1se printf(\"$$$\\n\");\n}", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "有语法错不能通过编译", "可以通过编译但不能通过连接", "输出***", "输出$$$" ], "explanation": "if语句的条件为赋值表达式a=b+c，计算后a的值为0。在C语言中0表示逻辑假，因此跳过if分支，执行else分支输出$$$。题干中的e1se应为else的排版或识别笔误。" }, { "id": 1074, "q": "若以下选项中的变量a, b, y均已正确定义并赋值，则语法正确的switch语句是().", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "switch( a*a+b*b ) { default : break; case 3 : y=a+b; break; case 2 : y=a-b; break; }", "switch( a+b ) { case1 : case3 : y=a+b; break; case0 : case4 : y=a-b; }", "switch (a+9) { case a : y=a-b; case b : y=a+b; }", "switch a*b { case 10 : y=a+b; default : y=a-b; }" ], "explanation": "switch语句的语法要求：表达式必须用括号括起，排除D；case标签后必须是整型常量表达式且与case间有空格，排除B和C。选项A格式规范，default位置灵活，各分支以break结束，语法完全正确。" }, { "id": 1075, "q": "有以下程序段: ( )\nint a=1,b=2,c=3;\nif(a>b)\nif(bb)`条件为假，其后的内层`if-else`语句整体被跳过。程序直接执行最后的`printf`。`a++`为后置自增，先使用原值1输出，随后`a`自增。故输出1。" }, { "id": 1076, "q": "以下程序的输出结果是( )。\nint i=1;\ndo\n{\nif(i%2)printf(\"*\");\nelse break;\nprintf(\"#\");\ni++;\n}\nwhile(i<=5);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "*#", "*#*#*", "***##", "**###" ], "explanation": "初始`i=1`。第一次循环`i%2`为真，输出`*`和`#`，`i`增至2；第二次循环`i%2`为假，执行`else break;`直接跳出。最终仅输出`*#`。" }, { "id": 1077, "q": "下边循环执行完后，a为（ ）。\nfor ( a= 1;a< 5; a++ )\na = 2 * a;", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "8", "7", "5", "4" ], "explanation": "初始`a=1`满足条件，执行`a=2`后自增为3；再次满足条件，执行`a=6`后自增为7；此时`7<5`不成立，循环终止。最终`a`值为7。" }, { "id": 1078, "q": "下列循环的输出结果是( )。\nint n=9;\ndo\n{\nprintf(\"%d\\n\",n);\nn--;\n}while(n>7);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "8\n7", "9\n8", "9\n8\n7", "8\n7\n6" ], "explanation": "`do-while`至少执行一次。首次输出9，`n`减为8，判断`8>7`成立继续；第二次输出8，`n`减为7，判断`7>7`不成立退出。故依次输出9和8。" }, { "id": 1079, "q": "以下程序输出结果( )\n#include\nmain()\n{ int s=0,n=1;\nwhile(n<=10)\n{ if(n==4) break;\ns=s+n;\nn++;}\nprintf(“%d”,s); }", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "6", "无法确定", "10", "死循环" ], "explanation": "循环中`n`从1开始累加至`s`。当`n`为1、2、3时`s`依次累加为6。当`n`增至4时触发`break`跳出循环，不再累加。最终`s`值为6。" }, { "id": 1080, "q": "程序段的输出结果是().\nfor( i=0; i<4; i++, i++)\nfor(k=1; k<3; k++);\nprintf(\"*\");", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "********", "****", "**", "*" ], "explanation": "外层循环每次迭代`i`增加2，共执行两次。内层循环体为空语句（分号结尾），不产生输出。循环全部结束后，仅执行一次`printf`，故输出一个`*`。" }, { "id": 1081, "q": "下面程序的结果是()\nint sum=0;\nint i=2;\nwhile (i++<=9)\nif (10%i==0)\nsum=sum+i;\nprintf(\"%d\\n\", sum);", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "0", "7", "15", "死循环" ], "explanation": "`while(i++<=9)`为后置自增，判断后`i`加1。循环内`i`实际参与取余的值依次为3至10。其中`10%5==0`和`10%10==0`成立，`sum`累加5和10，结果为15。" }, { "id": 1082, "q": "以下函数调用语句中，含有的实参个数是( )\nfunc( exp1,exp2, (exp3,exp4,exp5));", "t": "single", "ans": "A", "kp": "函数", "o": [ "3", "4", "5", "2" ], "explanation": "函数实参以顶层逗号分隔。`(exp3,exp4,exp5)`是逗号表达式，整体作为一个实参求值（结果为`exp5`）。因此该调用共包含3个实参。" }, { "id": 1083, "q": "若已定义的函数有返回值，则以下关于该函数调用的叙述中正确的是（　　）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数调用不返回值", "函数调用只能返回一个值", "函数调用可返回2个值", "函数调用可返回3个值" ], "explanation": "C语言规定，函数通过`return`语句只能向调用处返回一个确定的值。若需传递多个结果需借助指针或结构体，但直接返回值始终唯一。" }, { "id": 1084, "q": "以下叙述中正确的是( ) 。", "t": "single", "ans": "B", "kp": "函数", "o": [ "全局变量的作用域一定比局部变量的作用域范围大", "静态(static）类别变量的生存期贯穿于整个程序的运行期间", "函数的形参都属于全局变量", "未在定义语句中赋初值的auto变量和static变量的初值都是随机值" ], "explanation": "`static`变量具有静态存储期，内存空间在程序启动时分配，直至程序结束才释放，生存期贯穿整个运行期间。其他选项关于作用域、形参属性及默认初值的描述均有误。" }, { "id": 1085, "q": "以下程序的输出结果是（）\n#include\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<3;i++)\nprintf(\"%d，\",f(i));\n}\nint f(int a)\n{ int b=0; static int c=5;\nb++;c++;\nreturn(a+b+c);}", "t": "single", "ans": "D", "kp": "函数", "o": [ "5，6，7", "7，8，9", "5，7，9", "7，9，11" ], "explanation": "`b`为自动变量每次重置为0，自增后恒为1；`c`为静态变量仅初始化一次，每次调用自增并保留值。三次调用中`c`依次为6、7、8，结合`i`值返回`0+1+6=7`、`1+1+7=9`、`2+1+8=11`。" }, { "id": 1086, "q": "以下程序的运行结果是（　　）\nint fun(int a,int b)\n{ if(b==0) return a;\nelse return(fun(--a,--b));\n}\nmain()\n{ printf(\"%d\\n\", fun(6,3));}", "t": "single", "ans": "A", "kp": "函数", "o": [ "3", "1", "4", "2" ], "explanation": "递归调用过程：`fun(6,3)`调用`fun(5,2)`，再调用`fun(4,1)`，最后调用`fun(3,0)`。当`b`减至0时触发基线条件返回`a`，此时`a`已同步递减为3，故结果为3。" }, { "id": 1087, "q": "以下程序的运行结果是（　　）\nmain()\n{ int s[12]={0,2,4,0,4,3,2,3,1,1,2,3},c[5]={0},i;\nfor(i=0;i<12;i++) c[s[i]]++;\nfor(i=0;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "22332", "23333", "2233", "22333" ], "explanation": "程序通过c[s[i]]++统计数组s中各元素出现的次数。s中0出现2次，1出现2次，2出现3次，3出现3次，4出现2次。因此c数组的值依次为2、2、3、3、2，循环输出即为22332。" }, { "id": 1088, "q": "以下对二维数组正确的定义语句是（　）。", "t": "single", "ans": "D", "kp": "数组", "o": [ "int z[ ][3]={{1,1,2}; {1,2}; {1}};", "int z[4][3]={{1;2;3},{1;2;3},{1;2;3},{1;2;3}};", "int z[3][3]={{1;2;3};{1;2;3};{1;2;3}};", "int z[3][3]={{1},{3,4},{5,6,7}};" ], "explanation": "二维数组初始化时，同一行元素之间必须用逗号分隔，且整体用大括号括起。选项A、B、C中错误地使用了分号分隔元素或行。选项D语法正确，对部分元素初始化，未赋值的元素自动初始化为0。" }, { "id": 1089, "q": "以下对一维数组x进行正确初始化的语句是（　　）。", "t": "single", "ans": "D", "kp": "数组", "o": [ "int x[6]=(1,2,3,4,5);", "int x[6]={2 4 6 8 10};", "int x[6]={2;4;6;810 };", "int x[6 ]={3,6,9};" ], "explanation": "一维数组初始化必须使用大括号{}将初始值括起来，且各元素之间必须用逗号分隔。选项A误用圆括号，选项B缺少逗号，选项C误用分号。选项D格式正确，未赋值的后三个元素自动初始化为0。" }, { "id": 1090, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int a[3][3]={ {2,4},{6,8},{10,12} },i,j,s=0;\nfor(i=1;i<3;i++)\nfor(j=0;j<=i;j++) s+=a[i][j];\nprintf(\"%d\\n\",s); }", "t": "single", "ans": "D", "kp": "数组", "o": [ "30", "20", "42", "36" ], "explanation": "数组a未完全初始化，缺失元素默认为0，即a[1]为{6,8,0}，a[2]为{10,12,0}。外层循环i从1到2，内层j从0到i。当i=1时，累加a[1][0]和a[1][1]即6+8=14；当i=2时，累加a[2][0]到a[2][2]即10+12+0=22。最终s=14+22=36。" }, { "id": 1091, "q": "以下程序段的运行结果是（　　）\n{\nchar st[15]=\"how\\101you?\";\nprintf(\"%d %d \\n\",strlen(st),sizeof(st));\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "8 15", "11 15", "8 12", "11 12" ], "explanation": "字符串中的'\\101'是八进制转义字符，代表单个字符'A'。因此字符串实际内容为howAyou?，包含8个可见字符，strlen计算有效字符长度为8。而sizeof计算的是数组定义时分配的总内存大小，即15个字节。" }, { "id": 1092, "q": "以下程序中的for循环执行的次数是（　）。\n#define N 2\n#define M N+1\n#define NUM 2*M+1\n#main()\n{ int i; for(i=1;i<=NUM;i++) printf(\"%d\\n\",i); }", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "5", "6", "7", "8" ], "explanation": "宏定义在预处理时进行简单的文本替换，不自动添加括号。M替换为N+1即2+1，NUM替换为2*M+1即2*2+1+1。根据运算符优先级，先算乘法2*2=4，再加1+1，最终NUM的值为6。循环条件为i<=6，因此循环执行6次。" }, { "id": 1093, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"12134214241\";\nint v[4]={0,0,0,1},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "B", "kp": "字符串", "o": [ "4313", "4314", "4444", "4312" ], "explanation": "程序通过switch语句将字符'1'到'4'映射为索引0到3，并统计各字符在字符串中出现的次数。字符串中'1'出现4次，'2'出现3次，'3'出现1次，'4'出现3次。由于v[3]初始值为1，加上3次后变为4，其余从0开始累加，最终输出4314。" }, { "id": 1094, "q": "以下不合法的字符常量是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "'\\\"'", "'\\\\'", "'\\018'", "'\\xcc'" ], "explanation": "C语言中，以反斜杠开头的八进制转义字符只能包含数字0到7。选项C中的'\\018'包含了数字8，不符合八进制转义字符的语法规则，因此是不合法的字符常量。其他选项均为合法的转义字符。" }, { "id": 1095, "q": "以下叙述中正确的是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "\"a\"表示一个字符常量", "'\\0'表示字符0", "表达式：'a' > 'b'的结果是\"假\"", "'\\\"'是非法的" ], "explanation": "选项A中双引号括起的是字符串常量；选项B中'\\0'是ASCII码为0的空字符，而非字符'0'；选项D中'\\\"'是合法的转义字符，代表双引号。选项C中字符'a'的ASCII码小于'b'，因此表达式结果为假，叙述正确。" }, { "id": 1096, "q": "以下选项中合法的标识符是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1-1", "1_1", "_11", "1_ _" ], "explanation": "C语言规定标识符只能由字母、数字和下划线组成，且第一个字符必须是字母或下划线，不能是数字。选项A包含非法字符减号，选项B和D均以数字开头，只有选项C以下划线开头且仅含合法字符，是正确的标识符。" }, { "id": 1097, "q": "若有以下程序\n#include \nmain() {\nint a=0,b=0,c= (a+=++b, b+=4);\nprintf(\"%d,%d,%d\\n\",a,b,c); }\n则程序的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1,5,1", "-1,4,4", "1,5,5", "-1,4,-1" ], "explanation": "括号内为逗号表达式，从左到右依次计算。首先计算a+=++b，b自增为1，a加1后也为1；接着计算b+=4，b变为5。逗号表达式的最终结果为最后一个表达式的值，即5，赋给c。因此a、b、c的值分别为1、5、5。" }, { "id": 1098, "q": "若有定义语句： int x=5; 则表达式x-=x+x的值为()。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "-10", "0", "-5", "5" ], "explanation": "复合赋值运算符-=的优先级低于加法运算符+。因此表达式x-=x+x等价于x=x-(x+x)。将x=5代入，计算过程为x=5-(5+5)，即5-10，最终结果为-5。" }, { "id": 1099, "q": "以下选项中正确的定义语句是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "double a;b;", "double a=b=7;", "double a=7,b=7;", "double,a,b;" ], "explanation": "C语言中，同一类型的多个变量可在一条语句中定义并用逗号分隔，且可分别初始化，如double a=7,b=7;。A项分号结束了a的定义，b缺少类型说明；B项连续赋值在定义时不合法，b未定义；D项类型和变量名间不能用逗号。" }, { "id": 1100, "q": "printstar（）函数的功能是在屏幕上打印（）个星号\nvoid printstar（）\n{\nint i=5；\nfor(i=1;i<=10;i++)\nputchar('*');\nputchar(10);\n}", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "5", "2", "10", "6" ], "explanation": "虽然初始定义了i=5，但在for循环中i被重新初始化为1。循环条件为i<=10，每次循环后i自增1，因此循环体执行10次，打印10个星号。初始的i=5被覆盖，不影响循环次数。" }, { "id": 1101, "q": "以下程序的运行结果是（）。\nmain( )\n{ int n=1,m=2,x=0;\nif(!n) x-=1;\nif(m) x-=2;\nif(x) x-=3;\nprintf(\"%d\\n\",x);}", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "-1", "-2", "0", "-5" ], "explanation": "初始n=1, m=2, x=0。第一个if判断!n即!1为假，x不变。第二个if判断m即2为真，执行x-=2，x变为-2。第三个if判断x即-2为真，执行x-=3，x变为-5。最终输出-5。" }, { "id": 1102, "q": "若x,y,z的值分别为2,1,3， 程序的输出结果为（）\nif(y>z)printf(\"%d\\n\",z);\nelse if (z>x)printf(\"%d\\n\",x);\nelse if (x>y)printf(\"%d\\n\",y);\nelse printf(\"%d\\n\",0);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "已知x=2, y=1, z=3。首先判断y>z即1>3为假；接着判断z>x即3>2为真，执行对应的语句printf(\"%d\\n\",x);，输出x的值2。后续的else if分支不再执行。" }, { "id": 1103, "q": "以下程序的输出结果是( ) 。\n{int a=-1,b=1,k;\nif((++a<0) && (b--<=0))\nprintf(“%d %d\\n”,a,b);\nelse\nprintf(“%d %d\\n”,b,a); }", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "-1 1", "0 1", "1 0", "0 0" ], "explanation": "判断条件(++a<0) && (b--<=0)。先计算++a，a变为0，0<0为假。由于逻辑与&&的短路特性，左侧为假时不再计算右侧，因此b--不执行，b仍为1。条件整体为假，执行else分支，输出b和a的值，即1和0。" }, { "id": 1104, "q": "有以下程序, 程序的运行结果是 ( ) 。\nmain() { int x=1,y=0,a=0,b=0;\nswitch(x)\n{ case 1:\nswitch(y)\n{ case 0: a++; break;\ncase 1: b++; break; }\ncase 2: a++; b++; break;\ncase 3: a++; b++; }\nprintf(\"a=%d,b=%d\\n\",a,b）; }", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "a=1,b=0", "a=2,b=2", "a=1,b=1", "a=2,b=1" ], "explanation": "x=1进入外层case 1。y=0进入内层case 0，执行a++（a=1），遇break跳出内层switch。由于外层case 1无break，继续穿透执行外层case 2，执行a++（a=2）和b++（b=1），遇break跳出。最终a=2, b=1。" }, { "id": 1105, "q": "下列程序的执行结果是( )。\nint x=2000,a=15,b=30,c=5,d=0;\nif (a\nint a=10,b=20;\nmax(int a, int b)\n{ int c ;\nc=a=0;i--) a[i]=6+i;\nprintf(\"%d%d%d\",a[0],a[1],a[2]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "678", "876", "789", "987" ], "explanation": "循环从i=9递减到0，执行a[i]=6+i。因此a[0]=6+0=6，a[1]=6+1=7，a[2]=6+2=8。最后printf按顺序输出a[0]、a[1]、a[2]的值，即678。" }, { "id": 1115, "q": "以下程序段的运行结果是（　　）\n｛ int b[3][3]={2,4,6,8,10,12,14,16},s=0,i,j;\nfor (i=0;i<3;i++)\nfor (j=0;j<3;j++)\n{ if(i==j)\ns=s+b[i][j]; }\nprintf(\"s=%d\",s); ｝", "t": "single", "ans": "A", "kp": "数组", "o": [ "s=12", "s=28", "s=24", "s=20" ], "explanation": "二维数组b按行优先初始化，未赋值的元素默认为0。b[0][0]=2，b[1][1]=10，b[2][2]=0（因只给8个初值）。循环中当i==j时累加，即求主对角线元素之和：s = b[0][0] + b[1][1] + b[2][2] = 2 + 10 + 0 = 12。" }, { "id": 1116, "q": "以下程序的运行结果是（　　）\nmain( )\n{\nchar b[30];\nstrcpy(&b[0],\"CHINA\");\nstrcpy(&b[1],\"DEF\");\nstrcpy(&b[2],\"ABC\");\nprintf(\"%s \\n\",b);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "CDABC", "CHINA", "DEF", "CDA" ], "explanation": "strcpy(&b[0],\"CHINA\")使b为\"CHINA\"；strcpy(&b[1],\"DEF\")从b[1]开始覆盖，b变为\"CDEF\"；strcpy(&b[2],\"ABC\")从b[2]开始覆盖，b变为\"CDABC\"。最后输出字符串b，即CDABC。" }, { "id": 1117, "q": "若执行程序时， 从键盘上输入 1234,则输出结果是（）。\nchar c1,c2,c3,c4;\nint n, x;\nc1=c2=c3=c4=0;\nscanf(\"%d\",&x);\nif (x>=1000) n=4;\nelse if (x>=100) n=3;\nelse if (x>=10) n=2;\nelse n=1;\nswitch (n)\n{\ncase 4:c4=x%10+'0';x=x/10;\ncase 3:c3=x%10+'0';x=x/10;\ncase 2:c2=x%10+'0';x=x/10;\ncase 1:c1=x%10+'0';\n}\nprintf(\"%c%c%c%c\\n\",c4,c3,c2,c1);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "4", "43", "432", "4321" ], "explanation": "输入1234，x=1234，满足x>=1000，n=4。进入switch匹配case 4：c4='4'，x=123；因无break语句发生穿透，继续执行case 3：c3='3'，x=12；case 2：c2='2'，x=1；case 1：c1='1'。最后输出c4到c1，结果为4321。" }, { "id": 1118, "q": "对于基类型相同的两个指针变量之间,不能进行的运算是()", "t": "single", "ans": "C", "kp": "指针", "o": [ "<", "=", "+", "-" ], "explanation": "基类型相同的两个指针可以进行关系运算（如<、>）、赋值运算（=）以及减法运算（-，表示两个地址间的元素个数）。但指针相加（+）没有实际物理意义，C语言不允许两个指针直接相加。" }, { "id": 1119, "q": "#define MUL(x,y) x*y\nmain( )\n{ int a=6，b=8，c；\nc=MUL(a++,b++);\nprintf(\"%d \\n\"，c)； }", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "8", "6", "63", "48" ], "explanation": "宏展开为纯文本替换，c=MUL(a++,b++)替换为c=a++*b++。计算时先取a和b的当前值参与乘法，即6*8=48赋给c，之后a和b再自增。因此输出48。" }, { "id": 1120, "q": "给定程序modi1.c中，函数fun的功能是：根据整型形参m的值，计算如下公式的值。\n例如：若m中的值为：5，则应输出： 0.536389。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "首先，我们必须先读懂题中程序的大致意思，这是发现并改正程序中错误的重要前提。\n程序中的重要思想如下：\n1、函数fun()的功能是根据一个整型形参计算题目中的数学公式；\n2、由于公式中运用了除法，所以公式的最终值必须使用double型，以保持最终值的精确性。\n题中的第一个错误出现在函数fun()中的语句\"for(i = 2 ; i < m ; i++)\"中，请注意这个循环的条件部分，仔细看看，就可以知道，如果这么写，公式中的最后一项将被丢掉。正确语句如下：\"for(i = 2 ; i <= m ; i++)\"；\n题中的第二个错误是在for循环的循环体中，即计算公式的那条语句\"y -= 1 / (i * i) ;\"，前面分析过，公式的最终值为一个double型，题中除数位置使用了整数，这样的话，会造成不匹配错误，所以，正确语句如下：\"y -= 1.0 / (i * i) ;\"。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1121, "q": "给定程序中，函数fun的作用是：统计整型变量m中各数字出现的次数，并存放到数组a中，其中：a[0]存放0出现的次数，a[1]存放1出现的次数，…… a[9]存放9出现的次数。\n例如，若m为14579233，则输出结果应为：0,1,1,2,1,1,0,1,0,1,\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "要得到整型变量m中的各位数字，则从m的个位入手，通过m%10或m-m/10*10可求得m的个位数字，然后通过\"a[i]++;\"将个位数字出现的次数增一。所以第二空填m%10或m-m/10*10；\nm的个位数字判断后，再将m的个位数字去掉，形成一个新的数，再对新数的个位数字进行判断。新数的形成可通过m/10实现，所以第三空填m/10。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1122, "q": "请编写函数fun，其功能是：分别求一个双精度数的整数部分和小数部分，并通过指针返回。\n例如：程序输入的数为：5104.7583，则输出的整数部分是：5104，小数部分是：0.758300。\n注意：部分源程序存在文件PROG1.C中。\n请勿更改主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入所编写的若干语句。", "t": "fill", "ans": "void fun( double aa, int *x, double *y )\n{\n*x=(int)(aa);\n*y=aa-*x;\n}", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1123, "q": "下列非法的字符常量是          。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "'\\101'", "'B'", "'\\xab'", "'\\xyz'" ], "explanation": "C语言中字符常量可用单引号括起的单个字符或转义字符表示。'\\101'是八进制转义，'B'是普通字符，'\\xab'是十六进制转义。'\\xyz'不是合法的转义字符，八进制转义应为\\后跟1至3位八进制数字。" }, { "id": 1124, "q": "能正确表示逻辑关系：\"a≥=10或a≤0\"的C语言表达式是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "a>=10 or a<=0", "a>=0|a<=10", "a>=10 &&a<=0", "a>=10||a<=0" ], "explanation": "C语言中逻辑或运算符为\"||\"，逻辑与为\"&&\"。\"a≥=10或a≤0\"表示a大于等于10或者a小于等于0，对应的C语言表达式为a>=10||a<=0。选项A使用了非C语言关键字or，B和C逻辑关系错误。" }, { "id": 1125, "q": "若有以下程序\n#include \nmain() {\nint b=10, a=-11;\na %= b %= 4;\nprintf(\"%d %d\\n\", a, b); }\n则程序的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1 2", "-1 -2", "-1 2", "1 -2" ], "explanation": "表达式a %= b %= 4从右向左结合。先计算b %= 4，即b = 10 % 4 = 2；再计算a %= 2，即a = -11 % 2。在C语言中，负数取余结果的符号与被除数相同，因此-11 % 2 = -1。最终a为-1，b为2。" }, { "id": 1126, "q": "以下程序的运行结果是（　　）\nint k=20;\nint fun(int m)\n{ m+=k; k+=m;\nreturn m+k;\n}\nmain()\n{ int i=4,s=0;\ns=s+fun(i++); printf(\"%d %d %d\\n\",i,k,s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "5 44 68", "4 44 68", "5 68 44", "4 68 44" ], "explanation": "全局变量k=20。调用fun(i++)时，i++为后置自增，传入m的值为4，随后i变为5。在fun中，m+=k使m=24，k+=m使k=44，返回m+k即68。s=0+68=68。最终输出i、k、s的值为5、44、68。" }, { "id": 1127, "q": "执行下面程序的输出结果是( ) 。\nint a=5, b=0, c=0;\nif (a==b+c) printf(\"****\\n\") ;\nelse printf(\"####\\n\") ;", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "有语法错误不能编译", "能通过编译,但不能通过连接", "输出 ****", "输出 ####" ], "explanation": "变量a=5，b=0，c=0。if条件判断a==b+c，即5==0+0，结果为假。因此跳过if分支，执行else分支，输出####。" }, { "id": 1128, "q": "下列有关函数调用时形参和实参的关系描述中，正确的是（）。", "t": "single", "ans": "C", "kp": "函数", "o": [ "形参类型与实参类型没有关系", "实参类型只能是int", "形参类型与实参类型应该一致", "形参类型只能是int" ], "explanation": "函数调用时，形参和实参的类型应当一致或兼容，以确保数据正确传递。形参和实参不仅限于int类型，且两者类型有严格的对应关系，故C选项正确。" }, { "id": 1129, "q": ".已有变量定义和函数调用语句：int a=25; print_value(&a); 下面函数的正确输出结果是\nvoid print_value(int *x)\n{\nprintf(\"%d\\n\",++(*x));\n}", "t": "single", "ans": "D", "kp": "指针", "o": [ "23", "24", "25", "26" ], "explanation": "函数调用传递的是变量a的地址。在print_value中，指针x指向a。表达式++(*x)先对x所指向的值（即a）进行自增，a变为26，然后输出该值，故结果为26。" }, { "id": 1130, "q": "有以下程序\nint a=2, c=5;\nprintf( \"a=%%d,b=%%d\\n\", a,c ); }\n程序的输出结果是( )", "t": "single", "ans": "B", "kp": "输入输出", "o": [ "a=%2,b=%5", "a=%d,b=%d", "a=2,b=5", "a=%%d,b=%%d" ], "explanation": "在printf格式字符串中，%%用于输出一个百分号字符%。因此%%d会原样输出%d，而不会作为格式控制符解析。后面的变量a和c没有对应的格式符，不会被输出，结果为a=%d,b=%d。" }, { "id": 1131, "q": "以下程序段的输出结果是( )\nint x=10,y=10,c;\nc=++x>y++?x++:y++;\nprintf(\"%d\",c);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "10", "11", "12", "13" ], "explanation": "表达式++x>y++中，++x为11，y++值为10（之后y变11），11>10为真。执行x++，此时x为11，x++表达式的值为11（之后x变12），故c被赋值为11。" }, { "id": 1132, "q": "下列定义变量的语句中错误的是（）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "char ch=1 ;", "int x=1;", "float y=1.0;", "double d=1.0;" ], "explanation": "在C语言基础语法考查中，char类型变量通常应赋字符常量（如'1'），直接赋整型常量1常被视为类型不匹配的错误写法。其他选项的int、float、double赋值均符合常规类型定义规则。" }, { "id": 1133, "q": "以下程序段运行结果是( )。\nint a=1,b=2,c=3,d=0;\nif(a=3) ｛ b=1;c=2;｝\nelse d=3;\nprintf(\"%d,%d,%d,%d\\n\",a,b,c,d);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "3,1,2,0", "1,2,3,3", "1,1,2,0", "编译有错" ], "explanation": "if语句中的条件为a=3，这是赋值运算而非关系运算。a被赋值为3，条件表达式的值为3（非0，即真），因此执行if分支，b被赋为1，c被赋为2，d保持0。输出3,1,2,0。" }, { "id": 1134, "q": "运行下面程序时，从键盘输入\"1605\"，\n则输出结果是( )。\nmain( )\n{ int t,h,m;\nscanf(\"%d\",&t);\nh=(t/100)%12;\nif (h==0) h=12;\nprintf(\"%d:\",h);\nm=t%100;\nif (m<10) printf(\"0\");\nprintf(\"%d\",m);\nif (t<1200||t==2400)\nprintf(\"AM\");\nelse printf(\"PM\");}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "6:05PM", "4:05PM", "16:05AM", "12:05AM" ], "explanation": "输入1605，t=1605。h=(1605/100)%12=16%12=4，输出4:。m=1605%100=5，因m<10输出05。判断t<1200或t==2400均为假，执行else输出PM。最终结果为4:05PM。" }, { "id": 1135, "q": "有如下嵌套的if语句\nif(a='a' && ss[i]<='z') /*判断该字符是否为小写字母*/\nss[i]=ss[i]-'a'+'A'; /*若上述条件成立，则将其转换为大写字母*/\n}", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 1142, "q": "请编写函数fun，其功能是：统计s所指字符串中的数字字符个数，并作为函数值返回。\n例如，s所指字符串中的内容是：2def35adh25 3kjsdf 7/kj8655x，函数fun返回值为：11\n注意: 部分源程序在文件PROG1.C文件中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "int fun(char *s)\n{int n=0;\nwhile(*s!='\\0'){//判断s是否指向字符串结束标志符\nif(*s>='0'&&*s<='9'){//判断s指向的字符是否是数字字符\nn++;//如果是数字字符，则数字字符个数加一\n}\ns++;//将s指向下一个字符\n}\nreturn n;//返回数字字符个数\n}", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 1143, "q": "以下程序段的运行结果是（　　）。\n{ int a[]={1,2,3,4,5,6,7,8,9,10,11,12},*p;\np=&a[3];\np++;\nprintf(\"%d,\",*p++);\nprintf(\"%d\",*++p);\n}", "t": "single", "ans": "D", "kp": "指针", "o": [ "4,5", "4,6", "5,6", "5,7" ], "explanation": "p初始指向a[3]（值为4）。p++后指向a[4]（值为5）。第一个printf中*p++先取*p的值5输出，然后p指向a[5]（值为6）。第二个printf中*++p先将p自增指向a[6]（值为7），再取值输出。因此结果为5,7。" }, { "id": 1144, "q": "给定程序modi1.c中函数fun的功能是：从整数10到55之间，选出能被3整除、且有一位上的数是5的那些数，并把这些数放在b所指的数组中，这些数的个数作为函数值返回。规定，函数中a1放个位数，a2放十位数。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "由于题目要求a2存放十位数，所以将k/10赋值给a2，所以\"a2=k/1O;\"应该改为\"a2=k/10;\"。\n程序中通过变量i来记录符合条件值的个数，由题意可知，数的个数作为函数值返回，所以程序中的语句\"return k;\"应改为\"return i;\"或相同作用的语句。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1145, "q": "以下叙述中错误的是( )。", "t": "single", "ans": "D", "kp": "综合编程/调试改错", "o": [ "计算机不能直接执行用C语言编写的源程序", "C程序编译后，生成后缀为.obj的文件是一个二进制文件", "后缀为.obj的文件，经连接程序生成后缀为.exe的文件是一个二进制文件", "后缀为.obj和.exe的二进制文件都可以直接运行" ], "explanation": "C语言源程序需经编译生成目标文件（.obj），再经链接生成可执行文件（.exe）。.obj是中间二进制文件，不能直接运行，只有.exe文件可以直接在操作系统中运行。因此D选项叙述错误。" }, { "id": 1146, "q": "对下列二维字符数组的定义，描述正确的（）\nchar str1[ 7 ]=\"Thanks\";\nchar str2[ ]=\"Thanks\";", "t": "single", "ans": "D", "kp": "字符串", "o": [ "str1不是字符串，str2是字符串", "str1是字符串，str2不是字符串", "str1和str2都不是字符串", "str1和str2都是字符串" ], "explanation": "字符串\"Thanks\"包含6个可见字符和1个隐藏的结束符'\\0'，共占7个字节。str1指定长度为7，正好容纳；str2未指定长度，编译器会自动推断其长度为7。两者均正确初始化并包含'\\0'，都是合法的字符串。" }, { "id": 1147, "q": "以下叙述中正确的是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "字符常量在内存中占2个字节", "转义字符要用双引号括起来，以便与普通的字符常量区分开", "字符常量需要用单引号括起来", "字符常量是不能进行关系运算的" ], "explanation": "字符常量在内存中占1个字节；转义字符和普通字符常量一样，都需要用单引号括起来；字符常量本质上是其ASCII码值，可以进行关系运算。因此只有C选项叙述正确。" }, { "id": 1148, "q": "以下选项中不能用作C程序合法常量的是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "'\\123'", "1,234", "123", "\"\\x7D\"" ], "explanation": "C语言中的数值常量不能包含逗号作为千位分隔符，因此1,234不是合法的常量。'\\123'是合法的八进制转义字符，123是合法的整型常量，\"\\x7D\"是合法的十六进制转义字符串常量。" }, { "id": 1149, "q": "以下选项中不合法的标识符是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "_00", "char", "a1", "a_1" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头，同时不能是C语言的关键字。char是C语言的关键字，用于声明字符类型，因此不能作为用户自定义标识符。" }, { "id": 1150, "q": "设 a=1, b=2, c=3, d=4, 则表达式: a\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<2;i++)\nprintf(\"%d \",f(i));\n}\nint f(int a)\n{ int b=0; static int c=6;\nb++;c++;\nreturn(a+b+c);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "8 10", "7 9", "8 9", "7 8" ], "explanation": "b是局部自动变量，每次调用初始化为0；c是静态变量，只初始化一次且保留上次值。第一次调用f(0)，b=1,c=7，返回8；第二次调用f(1)，b重新为1，c保留为8，返回10。" }, { "id": 1165, "q": "以下程序的运行结果是（　　）\nfun(int x)\n{ if(x/2>0) fun(x/2);\nprintf(\"%d \",x);\n}\nmain()\n{ fun(4); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "1 2 4", "4", "1 2", "1 2 3" ], "explanation": "递归调用过程：fun(4)调用fun(2)，fun(2)调用fun(1)。fun(1)中1/2>0为假，直接输出1并返回；接着fun(2)输出2并返回；最后fun(4)输出4。输出顺序为1 2 4。" }, { "id": 1166, "q": "以下程序的功能是求出数组x中各相邻两个元素的和并依次存放到a数组中，然后输出。请选择填空。\nmain()\n{  int x[10],a[9],i;\nfor (i=0;i\nscanf(\"%d\",&x[i]);\nfor(i=1;i\n   a[i-1]=x[i]+[       ] ;\nfor(i=0;i\n printf(\"%d\",a[i]);\nprintf(\"\\n\");}", "t": "single", "ans": "B", "kp": "数组", "o": [ "x[i+1]", "x[i-1]", "x[i-2]", "x[i+2]" ], "explanation": "数组x相邻元素为x[i]和x[i-1]。循环变量i从1开始，a[i-1]用于存放第i个和第i-1个元素的和，因此空缺处应填入x[i-1]以完成相邻元素相加。" }, { "id": 1167, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{1,3,5},{2,4,6},{3,5,7},{2}};\nprintf(\"%d%d%d%d\\n\",a[0][1],a[1][1],a[2][1],a[3][0]);\n}", "t": "single", "ans": "B", "kp": "数组", "o": [ "3451", "3452", "3450", "345" ], "explanation": "二维数组部分初始化时，未指定的元素自动补0。第一行a[0]为{1,3,5,0}，a[0][1]为3；第二行a[1]为{2,4,6,0}，a[1][1]为4；第三行a[2]为{3,5,7,0}，a[2][1]为5；第四行a[3]为{2,0,0,0}，a[3][0]为2。因此输出3452。" }, { "id": 1168, "q": "以下程序段的运行结果是（　　）\n{ int x[3][4]={0,1,2,3,4,5,6,7,8,9,10},i,j,t=0;\nfor(i=0;i<4;i+=2)\nfor(j=i;j<4;j++)\nt=t+x[i][j];\nprintf(\"%d\\n\",t); }", "t": "single", "ans": "A", "kp": "数组", "o": [ "16", "33", "25", "41" ], "explanation": "一维列表初始化二维数组，按行优先赋值。x[0]为{0,1,2,3}，x[1]为{4,5,6,7}，x[2]为{8,9,10,0}。外层循环i取0和2。当i=0时，内层j从0到3，累加x[0]行所有元素得6；当i=2时，内层j从2到3，累加x[2][2]和x[2][3]即10和0得10。最终t为16。" }, { "id": 1169, "q": "对于整型变量 x， 下述 if 语句（ ） 与赋值语句：x=x%2==0?1:0;不等价。", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "if (x%2! =0) x=0;\nelse x=1;", "if (x%2) x=1;\nelse x=0;", "if (x%2==0) x=1;\nelse x=0;", "if (x%2==1) x=0;\nelse x=1;" ], "explanation": "原语句利用条件运算符，当x%2==0（即x为偶数）时赋1，否则赋0。选项A、C、D均在x为偶数时赋1，奇数时赋0，与原语句逻辑等价。选项B在x%2非零（即x为奇数）时赋1，偶数时赋0，逻辑恰好相反，因此不等价。" }, { "id": 1170, "q": "以下叙述中正确的是（ ）", "t": "single", "ans": "D", "kp": "指针", "o": [ "函数的类型不能是指针类型", "函数的形参类型不能是指针类型", "基类型不同的指针变量可以相互混用", "设有指针变量为 double *p，则 p+1 将指针p移动8个字节" ], "explanation": "函数的返回值类型和形参类型都可以是指针类型，故A、B错误。基类型不同的指针变量不能直接相互赋值或混用，必须进行强制类型转换，故C错误。指针加1移动的字节数取决于其基类型的大小，double类型通常占8个字节，因此p+1将指针移动8个字节，D正确。" }, { "id": 1171, "q": "若有以下定义和语句，则输出结果是（　　）\nint a[10]={2,4,6,8,10,12,14,16,18,20},*p=a;\npritnf(\"%d\",*(p+4)+a[2]);", "t": "single", "ans": "A", "kp": "指针", "o": [ "16", "14", "18", "12" ], "explanation": "指针p指向数组a的首地址，*(p+4)等价于a[4]，其值为10。数组元素a[2]的值为6。两者相加结果为16。注意题干代码中printf拼写为pritnf，实际考试中属印刷错误，按正常逻辑推导即可。" }, { "id": 1172, "q": "以下程序段的运行结果是( )\n#define N 6\n#define M1 ( N+1)\n#define M2 M1*2\nmain()\n{ printf(\"%d\\n\",M2); }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "14", "8", "9", "10" ], "explanation": "宏替换是简单的文本替换。M2被替换为M1*2，进一步替换为( N+1)*2，最后替换为( 6+1)*2。由于括号的存在，先计算6+1得到7，再乘以2得到14。若M1定义时未加括号，结果才会是6+1*2=8。" }, { "id": 1173, "q": "给定程序modi1.c中函数fun的功能是：输出M行M列整数方阵，然后求两条对角线上各元素之和，返回此和数。\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "首先，根据C语言中的语法规定，在定义数组变量时，用变量或不定量说明数组的大小是不对的，所以第一处的错误\"int fun(int n, int xx[][])\"应修改为\"int fun(int n,int xx[][M])\"；其次，语句printf( \"%f\", xx[i][j] )错误，因为根据题意方阵中的数为整型，所以，这里的语句应为printf(\"%4d\",xx[i][j]);。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1174, "q": "给定程序中，函数fun的功能是：将a所指4×3矩阵中第k行的元素与第0行元素交换。\n例如，有下列矩阵：\n1 2 3\n4 5 6\n7 8 9\n10 11 12\n若k为2，程序执行结果为：\n7 8 9\n4 5 6\n1 2 3\n10 11 12\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "函数fun中需要定义一个形参变量，用于接收从主函数fun(x,2)中传递的数值，又由\"a[k][i]=temp;\"可知第一处填：k；变量i用来控制每行元素中的下标，且N表示每行中数组元素的个数，所以第二处填：N；在满足for循环条件下进行第k行的元素与第0行元素交换，所以第三处填：a[k][i]。\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1175, "q": "编写函数fun，它的功能是：根据以下公式求P的值，结果由函数值带回。m与n为两个正整数且要求m>n。\n　　　　 m!\n　　P = ─────\n　　 n!(m-n)!\n例如：m=12,n=8时，运行结果为495.000000。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "float fun(int m,int n)\n{int i;\nfloat s=1,f=1,h=1;\nfloat x;\nfor (i=m;i>=1;i--) s=s*i; /*求出m的阶乘*/\nfor (i=n;i>=1;i--) f=f*i; /*求出n的阶乘*/\nfor (i=m-n;i>=1;i--) h=h*i;/*求出m-n的阶乘*/\nx=s/(f*h);\nreturn (x);\n}", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1176, "q": "以下程序段运行后的输出结果是（ ）。\n{ char s[20]=\"ASbc7eDf56Fg89hqw\";\nint i,n=0;\nfor(i=0;s[i]!='\\0';i++)\nif(s[i]>=97&&s[i]<=122 )\nn++;\nprintf(\"%d\",n);\n}", "t": "single", "ans": "D", "kp": "字符串", "o": [ "17", "4", "5", "8" ], "explanation": "程序遍历字符串中的每个字符，通过条件s[i]>=97&&s[i]<=122判断是否为小写字母（即'a'到'z'的ASCII码范围）。字符串中共有b、c、e、f、g、h、q、w这8个小写字母，因此计数器n的最终值为8。" }, { "id": 1177, "q": "C语言中char类型数据占字节数为", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2", "3", "1", "4" ], "explanation": "在C语言标准中，char类型（字符型）数据固定占用1个字节的内存空间，通常用于存储ASCII字符。其他常见类型如int通常占4字节，float占4字节，double占8字节。" }, { "id": 1178, "q": "以下程序的运行结果是          。\nint a=1, b=2;\na=a+b; b=a-b; a=a-b;\nprintf(\"%d,%d\\n\", a, b );", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "1,2", "2,1", "3,2", "2,3" ], "explanation": "这是经典的利用加减法交换两个变量值的算法。第一步a=a+b使a变为3；第二步b=a-b即3-2，使b变为1（原a的值）；第三步a=a-b即3-1，使a变为2（原b的值）。最终实现a和b的值互换，输出2,1。" }, { "id": 1179, "q": "若运行下面程序时,给变量a输入18,则输出结果是( )。\nmain( )\n{ inta,b;\nscanf(\"%d\",&a);\nif (b=a>15?a+10:a-10)\nprintf(\"%d\\n\",b) ;\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "18", "28", "8", "10" ], "explanation": "程序首先通过scanf读取a的值为18。接着计算条件表达式a>15?a+10:a-10，因为18>15成立，所以表达式的值为18+10即28，并将其赋值给b。if语句判断b的值，28为非零真值，因此执行printf输出b的值28。" }, { "id": 1180, "q": "执行下面程序时,若从键盘输入\"b\"，则程序的运行结果是( )。\n#include \nmain( )\n{ int k; char cp;\ncp=getchar( );\nif (cp>='0' && cp<='9')\nk=cp-'0';\nelse if (cp>='a' && cp<='f')\nk=cp-'a'+10;\nelse k=cp-'A'+10;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "2", "4", "11", "10" ], "explanation": "程序读取字符'b'赋给cp。'b'不属于'0'到'9'，但属于'a'到'f'，因此执行k=cp-'a'+10。'b'-'a'为1，结果为11。" }, { "id": 1181, "q": "以下程序中关于变量i的描述，不正确的是（）\n#include\nfloat k;\nmain( )\n{\nstatic int i=0,m;\nfloat j,k;\n…\n}", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "i是局部变量", "i是静态变量", "i的初值为0", "i是全局变量" ], "explanation": "变量i定义在main函数内部，因此它是局部变量而非全局变量，选项D描述错误。同时，i使用了static关键字修饰，属于静态局部变量，其生命周期贯穿整个程序运行期，且显式初始化为了0，故A、B、C的描述均正确。" }, { "id": 1182, "q": "以下程序的运行结果是（　　）\nfun(int x)\n{ if(x/2>0) fun(x/2);\nprintf(\"%d \",x);\n}\nmain()\n{ fun(10); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "1 2 5 10", "10", "1 2 5", "5 10" ], "explanation": "递归函数fun中，当x/2>0时递归调用。fun(10)调用fun(5)，再调用fun(2)，再调用fun(1)。fun(1)时x/2=0不递归，打印1；随后逐层返回，依次打印2、5、10。因此输出1 2 5 10。" }, { "id": 1183, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[4][4]={{1,3,5},{2,3,4},{3,5,7},{2}};\nprintf(\"%d%d%d%d\\n\",a[0][1],a[1][1],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "3352", "3351", "3350", "3252" ], "explanation": "二维数组部分初始化时，未赋值的元素自动初始化为0。a[0][1]为3，a[1][1]为3，a[2][1]为5，a[3][0]为2。按格式连续输出这四个元素，结果为3352。" }, { "id": 1184, "q": "以下对数组a定义正确的是", "t": "single", "ans": "D", "kp": "数组", "o": [ "int a(10);", "int n=10,a[n];", "int n; scanf(“%d”,&n);\nint a[n];", "#define SIZE 10\nint a[SIZE];" ], "explanation": "C语言标准中，数组定义的长度必须是常量表达式。A使用圆括号错误；B和C使用变量作为数组长度，在传统C语言中不合法；D使用宏定义常量SIZE，符合常量表达式要求，定义正确。" }, { "id": 1185, "q": "若有说明:int *p,m=5,n; 以下正确的程序段是( )", "t": "single", "ans": "D", "kp": "指针", "o": [ "p=&n;\nscanf(\"%d\",&p);", "p=&n;\nscanf(\"%d\",*p);", "scanf(\"%d\",&n);\n*p=n", "p=&n;\n*p=m;" ], "explanation": "A选项scanf需要变量地址，&p是指针本身的地址，错误；B选项*p是值而非地址，错误；C选项指针p未初始化指向合法内存，直接解引用赋值会导致野指针错误；D选项p指向n，*p=m等价于n=m，合法且正确。" }, { "id": 1186, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int a[]={2,4,6,8,10};\nint y=1,x, *p;\np=&a[1];\nfor(x=0;x<3;x++)\ny+=* (p+x);\nprintf(\"%d\\n\",y); }", "t": "single", "ans": "C", "kp": "指针", "o": [ "17", "18", "19", "20" ], "explanation": "指针p指向数组a的第2个元素a[1]（值为4）。循环执行3次，x分别为0、1、2。*(p+x)依次访问a[1]、a[2]、a[3]，即4、6、8。y初始为1，累加后y = 1 + 4 + 6 + 8 = 19。" }, { "id": 1187, "q": "#define MUL(x,y) x*y\nmain( )\n{ int a=4，b=5，c；\nc=MUL(++a,++b);\nprintf(\"%d \\n\"，c)； }", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "5", "4", "20", "30" ], "explanation": "宏替换是纯文本替换，MUL(++a,++b)展开为++a*++b。按常规考试逻辑，a先自增为5，b先自增为6，相乘得30。注意：实际C标准中此表达式存在未定义行为，但应试时按直接展开计算即可。" }, { "id": 1188, "q": "给定程序modi1.c中函数fun的功能是：从低位开始取出长整型变量s中偶数位上的数，依次构成一个新数放在t中。\n例如，当s中的数为：7654321时，t中的数为：642。\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "从主函数中可以看出，t是一个字符串，因此在fun函数的参数表中应将t改为字符指针或字符数组，即把\"void fun(long s, long t)\"语句改为\"void fun(long s,long *t)\"或相同作用的语句。\n根据题面要求，从低位开始取出长整型变量s中偶数位上的数来设计功能函数，用*t = s % 10取出长整型变量s中的第一个偶数位上的数字，并放在新串t中，然后利用while循环体依次取出长整型变量s中的其它偶数位，在这里while ( s < 0)应改为while(s > 0)或其等效语句！\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1189, "q": "下列给定程序中，函数fun根据所给n名学生的成绩，计算出所有学生的平均成绩，把高于平均成绩的学生成绩求平均值并返回。\n例如，若有成绩为：50,60,70,80,90,100,55,65,75,85,95,99，则运行结果应为：91.5。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在文件BLANK1.C中，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "（1）第一个for循环遍历所有数并求出和，将和赋给变量avg中，题目要求进行平均值的比较，所以第一个空所在语句应该求平均值，所以第一个空为成绩的总数n。\n（2）第二个for循环是找出大于平均值的成绩的和与个数。所以第二个空所在语句应该是求和，为sum。\"k++；\"语句是记录大于平均成绩的成绩个数。\n（3）题目要求为返回高于平均成绩的平均成绩，所以第三个空为sum/k。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1190, "q": "函数fun的功能是：将两个两位数的正整数a、b合并形成一个整数放在c中，合并的方式是：将a数的十位和个位数依次放在c数的千位和十位上，b数的十位和个位数依次放在c数的个位和百位上。\n例如，当a=45,b=12。调用该函数后，c=4251。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int a, int b, long *c)\n{\nint a_up,a_low,b_up,b_low;/*a_up、a_low、b_up和b_low分别存放指针c的千位、十位、百位和个位数上的数字*/\na_up=a/10;\na_low=a%10;\nb_up=b/10;\nb_low=b%10;\n*c=a_up*1000+b_low*100+a_low*10+b_up;\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 1191, "q": "程序的输出结果是()\nint a, b, c;\na=10; b=50; c=30;\nif (a>b) a=b, b=c,c=a;\nprintf(\"a=%d b=%d c=%d\\n\", a, b, c);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "a=10 b=50 c=30", "a=10 b=30 c=10", "a=10 b=50 c=10", "a=50 b=30 c=50" ], "explanation": "if语句的条件为a>b，即10>50，结果为假。因此不执行后面的逗号表达式赋值操作，变量a、b、c保持初始值不变。直接输出a=10 b=50 c=30。" }, { "id": 1192, "q": "有以下程序段\nint a=1,b=2,c=3,d=0;\nif(a==1||b++==2)\nif(b!=2&&c--!=3)\n{b++;c--;}\nelse {--b;++c;};\nprintf(\"%d,%d,%d\\n\",a,b,c);\n程序运行后的输出结果是( )", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "1,1,4", "3,3,2", "3,1,4", "1,2,2" ], "explanation": "逻辑或运算中，a==1为真，触发短路，b++不执行，b仍为2。进入内层if，逻辑与运算中b!=2为假，触发短路，c--不执行，c仍为3。随后执行else分支，--b使b变为1，++c使c变为4。输出1,1,4。" }, { "id": 1193, "q": "下列程序中，注释方法不正确的是（ ）。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "#incl/*头文件*/ude\nmain()\n{ }", "#include\nmain(/*主函数*/)\n{ }", "#include\nmain( )\n{\nint /*初始化*/=10;\n/*输出*/printf(?°%d?±,x);\n}", "#include\nmain()\n{ int x=10;\n/*输出*/printf(\"%d\",x);\n}" ], "explanation": "C语言注释不能插入在关键字或标识符中间。A选项将预处理指令#include拆分为#incl和ude，导致预处理器无法识别该指令，属于注释位置错误。其他选项的注释未破坏关键字或标识符的完整性。" }, { "id": 1194, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"12134214444\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "3215", "3214", "3211", "3212" ], "explanation": "程序通过switch语句统计字符串中字符'1'到'4'的出现次数，分别存入v[0]到v[3]。字符串中'1'出现3次，'2'出现2次，'3'出现1次，'4'出现5次。最后循环输出数组v的元素，结果为3215。" }, { "id": 1195, "q": "设有定义：double x=2.12;，以下不能完整输出变量x值的语句是", "t": "single", "ans": "A", "kp": "输入输出", "o": [ "printf(\"x=%5.0f\\n\",x);", "printf(\"x=%f\\n\",x);", "printf(\"x=%lf\\n\",x);", "printf(\"x=%0.5f\\n\",x);" ], "explanation": "printf中%f格式符的精度指定小数位数。A选项%5.0f指定小数位数为0，会四舍五入且不输出小数部分，只能输出整数2，无法完整输出2.12。其他选项均能保留并输出小数部分。" }, { "id": 1196, "q": "有以下程序\nmain() {\nint x=35, B;\nchar z='B' ;\nB = (( x ) && ( z <'b' ));\nprintf(\"%d\\n\", B ); }\n程序运行后的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "0", "35", "1", "66" ], "explanation": "逻辑与运算中，x=35非零为真；字符'B'的ASCII码66小于'b'的98，z<'b'也为真。真与真结果为1。因此B被赋值为1，输出1。" }, { "id": 1197, "q": "以下有关整型常量描述错误的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "整型常量表示通常意义上的整数，如2、0、-7", "在C语言中，整型常量可以有3种形式：八进制、十进制和十六进制", "在整型常量后可以添加后缀字母L或l表示长整型，如54L", "八进制整型常量由正、负号和数字0-7组成，数字部分以0开头，如-408" ], "explanation": "八进制数只能包含0到7的数字，选项D中的\"408\"包含了数字8，不是合法的八进制数。A、B、C选项对整型常量的描述均正确。" }, { "id": 1198, "q": "下列不正确的标识符是( )", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2A", "A2", "INT", "DO" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且第一个字符必须是字母或下划线。选项A以数字2开头，不符合标识符的命名规则。" }, { "id": 1199, "q": "设有 int x=11; 则表达式 (x++ * 1/3) 的值是( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "3", "4", "11", "12" ], "explanation": "表达式中x++是后置自增，先取x的当前值11参与计算，计算完后再自增。11 * 1 / 3 按照从左到右结合，11乘1等于11，11除以3整除结果为3。" }, { "id": 1200, "q": "若变量x、y已正确定义并赋值，以下符合C语言语法的表达式是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "++x,y=x--", "x+1=y", "x=x+10=x+y", "double(x)/10" ], "explanation": "A是逗号表达式，语法正确。B中赋值号左侧x+1不是左值；C中连续赋值x+10=x+y语法错误，x+10不能作为左值；D中强制类型转换正确写法应为(double)x。" }, { "id": 1201, "q": "以下程序段的输出结果是：\nint x,y=1;\nx=2.2;\ny=x+2.8;\nprintf(\"%d,%d\",y,x);", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "2.2,5", "5,2", "5,2.2", "4,2" ], "explanation": "x和y均为int型。x=2.2时发生隐式类型转换，截断小数部分，x变为2。y=x+2.8即y=2+2.8=4.8，赋值给int型y时截断为4。按%d格式输出y和x，结果为4,2。" }, { "id": 1202, "q": "以下程序的运行结果是（　　）\nint k=10;\nint fun(int m)\n{ m+=k; k+=m;\nreturn m;\n}\nmain()\n{ int i=4,s=0;\ns=s+fun(i++); printf(\"%d %d\\n\",i,s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "5 14", "5 24", "5 10", "4 14" ], "explanation": "全局变量k初值为10。调用fun(i++)时，i先传值4给m，然后i自增为5。在fun中，m+=k即m=4+10=14；k+=m即k=10+14=24。返回m的值14赋给s。最终i为5，s为14。" }, { "id": 1203, "q": "程序的输出结果是()\nint a=1,b=2,c=3,d=4, r=0;\nif (a!=1) ;\nelse r=1;\nif (b==2) r+=2;\nif (c==3); r+=3;\nif (d==4) r+=4;\nprintf(\"%d\\n\", r);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "7", "10", "6", "8" ], "explanation": "a=1，a!=1为假，执行else，r=1。b=2，b==2为真，r+=2，r变为3。c=3，if(c==3)后跟空语句，接着执行r+=3，r变为6。d=4，d==4为真，r+=4，r变为10。最终输出10。" }, { "id": 1204, "q": "设变量x和y均已正确定义并赋值。以下if语句中，在编译时将产生错误信息的是 ( ) 。", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "if(x++);", "if(x>y&&y!=0);", "if(x>y) x- -\nelse y++;", "if(y<0) {;}\nelse x++;" ], "explanation": "C选项中x--和else之间缺少分号，导致语法错误，正确写法应为x--;。A选项if后跟空语句合法；B选项逻辑表达式合法；D选项复合语句和else分支均合法。" }, { "id": 1205, "q": "执行下列程序，输入为2的输出结果是( )。\n#include \nmain( )\n{int k;\nscanf(\"%d\",&k) ;\nswitch (k)\n{case 1: printf(\"%d\\n\",k++);\ncase 2: printf(\"%d\\n\",k++);\ncase 3: printf(\"%d\\n\",k++);\ncase 4: printf(\"%d\\n\",k++); break;\ndefault: printf(\"Full!\\n\");\n}\n}", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "2", "3", "3\n4", "2\n3\n4" ], "explanation": "输入k=2，匹配case 2，输出k++的值2，k变为3；因无break，穿透到case 3，输出k++的值3，k变为4；继续穿透到case 4，输出k++的值4，k变为5，遇到break跳出。最终输出2 3 4。" }, { "id": 1206, "q": "该程序的输出结果是().\nint a=2,b=-1,c=2;\nif (a>b)\nif (b>0) c=0;\nelse c++;\nprintf(\"%d\\n\",c);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "C语言中else总是与最近的未匹配的if结合。此处else与if(b>0)匹配。a>b(2>-1)为真，进入内层if；b>0(-1>0)为假，执行else分支c++，c由2变为3。最终输出3。" }, { "id": 1207, "q": "程序段的输出结果是( )。\nint i=0, sum=1;\ndo\n{ sum+=++i;}\nwhile(i<6);\nprintf(\"%d\\n\", sum);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "11", "15", "16", "22" ], "explanation": "循环执行过程：i=1,sum=2；i=2,sum=4；i=3,sum=7；i=4,sum=11；i=5,sum=16；i=6,sum=22。当i=6时，条件i<6为假，退出循环。最终sum为22。" }, { "id": 1208, "q": "以下程序的运行结果是（　　）。\nmain(){\nchar c1,c2;\nfor(c1='0';c1<'5';c1++)\nprintf(\"%c \",c1);\nprintf(\"\\n\");}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "'0'", "01234", "012345", "\"01234\"" ], "explanation": "循环变量c1从字符'0'开始，每次递增1，直到不满足小于'5'的条件。依次输出字符'0'、'1'、'2'、'3'、'4'。%c格式控制符输出字符本身，不带引号。选项B省略了代码实际输出中的空格。" }, { "id": 1209, "q": "下面程序段的运行结果是()\nint a=1,b=2,c=2,t;\nwhile(a3) break;\nm*=i*j;\n}\nprintf(\"m=%d\\n\",m);}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "m=32", "m=4", "m=1", "m=8" ], "explanation": "题目代码存在明显乱码与缺失（如\"i3\"），导致无法进行准确的逻辑推导。根据给定答案A，推测原题可能包含特定的循环与条件判断逻辑以得出32。建议结合原卷或教材进行人工复核。" }, { "id": 1212, "q": "则程序的输出结果是（）\nint a=-2, b=0;\nwhile(++a) ++b ;\nprintf(\"%d,%d\\n\", a, b);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0,1", "1,2", "1,3", "2,3" ], "explanation": "初始a=-2, b=0。第一次循环：++a使a变为-1，非零为真，++b使b变为1。第二次循环：++a使a变为0，为零为假，退出循环。最终a=0, b=1。输出0,1。" }, { "id": 1213, "q": "以下函数返回值的类型是 ( )\nfloat fun ( double x )\n{ int y;\ny= 3*x-4;\nreturn y;\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "float", "double", "int", "不确定" ], "explanation": "函数返回值的类型由函数定义时的类型说明符决定，与return语句中表达式的类型或函数内部变量的类型无关。本题中函数头定义为float fun(double x)，因此返回值类型为float。" }, { "id": 1214, "q": "以下程序的运行结果是（　　）\nfun(int a, int b){\nif(a>b) return(a);\nelse return(b);\n}\nmain(){\nint x=3, y=8, z=16, r;\nr=fun(fun(x,y), z);\nprintf(\"%d\\n\", r);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "16", "32", "8", "10" ], "explanation": "fun函数用于返回两个参数中的较大值。首先计算内层fun(x,y)即fun(3,8)，返回8。然后计算外层fun(8, z)即fun(8,16)，返回16。最终r的值为16。" }, { "id": 1215, "q": "下列有关全局变量的说法，正确的是（）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "全局变量存放在动态存储区", "全局变量建立了函数间数据交换的另一渠道", "全局变量左边不能加static", "全局变量是在函数内部定义的" ], "explanation": "全局变量定义在函数外部，存放在静态存储区，故A、D错误。全局变量可以用static修饰以限制其作用域，故C错误。全局变量可以被多个函数共享，从而建立了函数间数据交换的另一渠道，B正确。" }, { "id": 1216, "q": "以下程序中有()个局部变量\n#include\nfloat k;\nmain()\n{\nstatic int i=0,m=1;\nfloat j,k;\n…\n}", "t": "single", "ans": "D", "kp": "函数", "o": [ "5", "2", "3", "4" ], "explanation": "局部变量是在函数内部或复合语句内定义的变量。main函数内部定义了i、m、j、k共4个变量。虽然i和m是static静态局部变量，k与全局变量同名，但它们的作用域均在main函数内，属于局部变量。全局变量k不计入。" }, { "id": 1217, "q": "以下程序的运行结果是（）。\nmain()\n{ int i,k,a[10],p[3];\nk=5;\nfor(i=0;i<10;i++) a[i]=i;\nfor(i=0;i<3;i++) p[i]=a[i*(i+1)];\nfor(i=0;i<3;i++) k+=p[i]*2;\nprintf(\"%d\\n\",k)；}", "t": "single", "ans": "B", "kp": "数组", "o": [ "23", "21", "22", "63" ], "explanation": "第一个循环使a[0]~a[9]的值分别为0~9。第二个循环中，i=0时p[0]=a[0]=0；i=1时p[1]=a[2]=2；i=2时p[2]=a[6]=6。第三个循环计算k，初始k=5，依次加上p[i]*2，即k = 5 + 0*2 + 2*2 + 6*2 = 21。" }, { "id": 1218, "q": "以下程序的运行结果是（　　）。\nmain()\n{ int i, a[5][5]={1,2,3,4,5,6,7,8,9};\nfor(i=0;i<5;i+=2) printf(\"%d,\",a[i][i]);}", "t": "single", "ans": "A", "kp": "数组", "o": [ "1,0,0,", "1,4,7,", "3,5,7,", "3,6,9," ], "explanation": "二维数组a[5][5]部分初始化，前9个元素按行优先赋值，其余自动初始化为0。即第一行为1至5，第二行为6至9和0，第三行及之后全为0。循环中i依次取0、2、4，分别输出a[0][0]、a[2][2]、a[4][4]，结果为1,0,0,。" }, { "id": 1219, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=7-i;\nprintf(\"%d%d%d\",a[0],a[1],a[2]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "765", "567", "234", "456" ], "explanation": "循环从i=9递减到0，执行a[i]=7-i。当i=0时，a[0]=7-0=7；当i=1时，a[1]=7-1=6；当i=2时，a[2]=7-2=5。最后输出a[0],a[1],a[2]，即765。" }, { "id": 1220, "q": "以下程序的运行结果是（ ）。\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=0;i<3;i++)\ns+=a[i][i]+a[i][3-i-1];\nprintf(\"%d\\n\",s); }", "t": "single", "ans": "B", "kp": "数组", "o": [ "18", "30", "12", "15" ], "explanation": "数组a的主对角线元素为a[0][0]=1, a[1][1]=4, a[2][2]=7；副对角线元素为a[0][2]=9, a[1][1]=4, a[2][0]=5。循环累加主副对角线元素，注意a[1][1]被计算了两次。s = (1+9) + (4+4) + (7+5) = 30。" }, { "id": 1221, "q": "当执行下列程序时，如果输入a，则输出结果是( )。\nmain()\n{\nchar ss[10]=\"12345\";\ngets(ss);strcat(ss,\"6789\");\nprintf(\"%s\\n\",ss);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "a6789", "12345567", "1236789", "123456789" ], "explanation": "gets函数读取字符串时会覆盖原数组内容，并在末尾添加'\\0'。输入a后，ss的内容变为\"a\"。随后strcat函数将\"6789\"拼接到ss末尾，最终ss的内容为\"a6789\"。因此输出结果为a6789。" }, { "id": 1222, "q": "若执行程序时， 从键盘上输入 1234,则输出结果是（）。\nchar c1,c2,c3,c4;\nint n;\nint x;\nc1=c2=c3=c4=0;\nscanf(\"%d\",&x);\nif (x>=1000) n=4;\nelse if (x>=100) n=3;\nelse if (x>=10) n=2;\nelse n=1;\nswitch (n)\n{\ncase 4:c4=x%10+'0';x=x/10;\ncase 3:c3=x%10+'0';x=x/10;break;\ncase 2:c2=x%10+'0';x=x/10;\ncase 1:c1=x%10+'0';\n}\nprintf(\"%c%c%c%c\\n\",c4,c3,c2,c1);", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "4", "43", "432", "4321" ], "explanation": "输入1234，x>=1000，故n=4。进入switch的case 4，c4被赋值为'4'，x变为123；因无break语句，继续执行case 3，c3被赋值为'3'，x变为12，遇到break跳出。c1和c2保持初始值0（即空字符'\\0'）。printf输出时，'4'和'3'正常显示，'\\0'不显示，故输出43。" }, { "id": 1223, "q": "以下程序中调用scanf函数给变量a输入数值的方法是错误的，其错误原因是( )\nmain()\n{int *p,*q,a,b;\np=&a;\nprintf(\"input a:\");\nscanf(\"%d\",*p);\n……\n}", "t": "single", "ans": "B", "kp": "指针", "o": [ "*p表示的是指针变量p的地址", "*p表示的是变量a的值,而不是变量a的地址", "*p表示的是指针变量p的值", "*p只能用来说明p是一个指针变量。." ], "explanation": "scanf函数要求传入变量的地址以便存储输入的数据。指针p指向变量a，*p表示的是变量a的值，而不是变量a的地址。正确的写法应该是传入p或&a。因此，使用*p作为scanf的参数会导致传入的是值而非地址，引发错误。" }, { "id": 1224, "q": "有以下程序段运行后的输出结果是（　）。\nmain()\n{ int a[10]={1,2,3,4,5,6,7,8,9}, *p=&a[3], * q=p+2;\nprintf(\"%d\\n\", *p + *q); }", "t": "single", "ans": "B", "kp": "指针", "o": [ "16", "10", "8", "6" ], "explanation": "数组a初始化后，a[3]的值为4，a[5]的值为6。指针p指向a[3]，因此*p的值为4。指针q等于p+2，即指向a[3+2]也就是a[5]，因此*q的值为6。最后计算*p + *q，即4 + 6，结果为10。" }, { "id": 1225, "q": "下列说法正确的是（　　）。", "t": "single", "ans": "D", "kp": "输入输出", "o": [ "#define和printf都是C语句", "#define是C语句，但printf不是语句", "printf是C语句，但#define不是语句", "#define和printf都不是C语句" ], "explanation": "在C语言中，#define是预处理指令，在编译预处理阶段处理，不属于C语言的执行语句。同时，C语言本身不提供输入输出语句，printf和scanf等只是标准库函数，通过函数调用的形式实现输入输出功能，因此它们也不是C语言的语句。" }, { "id": 1226, "q": "给定程序modi1.c中函数fun的功能是：将长整型数中每一位上为奇数的数依次取出，构成一个新数放在t中。高位仍在高位，低位仍在低位。\n例如，当s中的数为：87653142时，t中的数为：7531。\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "首先，根据主函数中\"fun(s, &t);\"，这里的t是指针，所以语句t=0错误，应该修改为*t=0，其次，if (d%2 == 0)语句在这里所起的作用是将每一位上的偶数取出而不是题目所要求的奇数取出，这里的语句应改为if(d%2==1)或其等效语句。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1227, "q": "给定程序中，函数fun的功能是：根据形参c中存储的整数序列，将偶数下标位置所有偶数元素求和，减去奇数下标位置所有奇数元素的和，所得差由函数值返回。形参d中存储的是序列的长度。\n例如：若c中存储的数值依次为13,15,4,7,20，d为5，则函数返回(4+20) - (15+7) = 2，主程序输出2。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在文件BLANK1.C中，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1228, "q": "请编写函数fun，它的功能是：计算并输出n（包括n）以内能被5或9整除的所有自然数的倒数之和。\n例如，在主函数中从键盘给n输入20后，输出为：s=0.583333。\n注意：要求n的值不大于100。\n部分源程序在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun(int n)\n{int i;\ndouble sum=0.0; /*将sum定义为双精度型变量，并给其赋初值为0.0*/\nif(n>0&&n<=100)\n{for (i=1;i<=n;i++)\nif(i%5==0||i%9==0) /*判断i是否能被5或者9整除*/\nsum+=1.0/i; /*累加自然数的倒数之和，放入变量sum中*/\n}\nreturn sum; /*返回结果*/\n}", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1229, "q": "以下对数组d定义正确的是( )：", "t": "single", "ans": "D", "kp": "数组", "o": [ "int d(5);", "int h=5,a[h];", "int h; scanf(“%d”,&h);\nint d[h];", "#define SIZE 8\nint a[SIZE];" ], "explanation": "C语言中定义数组时，数组名后必须使用方括号[]，故A错误。在标准C中，数组的长度必须是常量表达式，不能是变量，故B和C错误。D选项使用宏定义SIZE代表常量8，符合数组长度必须为常量的要求。" }, { "id": 1230, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "字符常量在内存中占2个字节", "转义字符要用双引号括起来，以便与普通的字符常量区分开", "字符常量需要用单引号括起来", "字符常量是不能进行关系运算的" ], "explanation": "字符常量在内存中占1个字节，故A错误。转义字符和普通字符常量一样，都需要用单引号括起来，故B错误。字符常量在底层以ASCII码值存储，因此可以参与关系运算，故D错误。字符常量必须用单引号括起来，C选项叙述正确。" }, { "id": 1231, "q": "阅读以下程序，该程序编译时产生错误，其出错原因是（　　）。\n#include\nmain()\n{\nint case; float printF;\nprintf(\"请输入2个数：\");\nscanf(\"%d %f\",&case,&printF);\nprintf(\"%d %f\\n\",case,printF);\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "定义语句出错，case是关键字，不能用作用户自定义标识符", "定义语句出错，printF不能用作用户自定义标识符", "定义语句无错，scanf不能作为输入函数使用", "定义语句无错，printf不能输出case的值" ], "explanation": "C语言规定，关键字不能用作用户自定义的标识符（如变量名、函数名等）。在程序中，case是C语言的关键字，用于switch语句中，因此将其定义为整型变量名会导致编译错误。printF不是关键字，可以作为标识符。" }, { "id": 1232, "q": "有以下程序\n#include \nmain() {\nint a=1,b=0;\nprintf(\"%d,\",b=a+b);\nprintf(\"%d\\n\",a=2*b); }\n程序运行后的输出结果是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1,0", "3,2", "1,2", "0,0" ], "explanation": "程序首先执行第一个printf，计算赋值表达式b=a+b，此时a为1，b为0，故b被赋值为1，输出1。接着执行第二个printf，计算赋值表达式a=2*b，此时b为1，故a被赋值为2，输出2。因此最终输出结果为1,2。" }, { "id": 1233, "q": "以下程序段的运行结果是()\nint m=5;\nif(m++>4)\nprintf(\"%d\",--m);\nelse\nprintf(\"%d\",m++);", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "4", "5", "6", "7" ], "explanation": "初始m=5。在if条件判断中，m++>4先使用m的当前值5进行比较，5>4为真，随后m自增变为6。因为条件为真，执行if分支中的printf语句。输出参数为--m，即m先自减1变为5，然后输出5。因此最终运行结果为5。" }, { "id": 1234, "q": "C语言中的函数( )", "t": "single", "ans": "D", "kp": "函数", "o": [ "可以嵌套定义。", "不可以嵌套调用。", "可以嵌套调用，但不能递归调用。", "嵌套调用和递归调用均可。" ], "explanation": "C语言规定，函数不能嵌套定义，即不能在一个函数体内定义另一个函数。但是，C语言允许函数的嵌套调用，即在一个函数执行过程中调用另一个函数；同时也允许函数的递归调用，即函数直接或间接地调用自身。因此，嵌套调用和递归调用均是合法的。" }, { "id": 1235, "q": "假设外部变量的定义为 float x；有关外部变量的申明正确的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "float x ;", "double x;", "x extern float;", "extern float x;" ], "explanation": "在C语言中，声明外部变量需要使用extern关键字，以告诉编译器该变量在其他文件中定义。正确的声明格式为extern加数据类型加变量名。因此，对于外部浮点型变量x，正确的声明方式是extern float x;。选项A是变量定义而非外部声明。" }, { "id": 1236, "q": "给定程序modi1.c中，函数fun的功能是：从字符串s中删除所有小写字母c。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1237, "q": "下列给定程序中，函数fun的功能是：从键盘输入一行字符，统计其中的数字、小写字母、大写字母的个数，并通过参数传回主函数。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在文件BLANK1.C中，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "由考题可知fun函数的功能是分别统计数字字符、大写字母和小写字母的个数，根据给定的代码，第一处判断数字字符的个数，应填写：c<='9'，第二处判断大写字母的个数，应填写：c>='A'，第三处判断小写字母的个数，应填写：c<='z'。", "kp": "字符串", "o": [], "rawType": "operation" }, { "id": 1238, "q": "以下四个程序中，完全正确的是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "#include \nmain();\n{/*/ Programming\n/*/ printf(\"programming!\\n\"); }", "#include \nmain()\n{ /* programming */\nprintf(\"programming!\\n\"); }", "#include \nmain()\n{/*/* programming */*/\nprintf(\"programming!\\n\"); }", "include \nmain()\n{/* programming */\nprintf(\"programming!\\n\"); }" ], "explanation": "A选项中main函数后多分号且注释格式错误；C选项中C语言注释不能嵌套；D选项中include前缺少#号。B选项语法和注释均完全正确。" }, { "id": 1239, "q": "对两个数组a与b初始化后,描述正确语句是( )\nchar a[ ]=\"how?\";\nchar b[ ]={ 'h', 'o', 'w','?' };", "t": "single", "ans": "C", "kp": "字符串", "o": [ "a与b数组完全相同", "a与b长度相同", "a数组比b数组长度长", "a与b定义均是语法错误" ], "explanation": "使用字符串初始化字符数组时，系统会自动在末尾添加结束符'\\0'，因此a的长度为5；而使用字符列表初始化不会自动添加'\\0'，b的长度为4。故a数组比b数组长度长。" }, { "id": 1240, "q": "以下选项中不属于字符常量的是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "'C'", "\"C\"", "'\\xCC'", "'\\072'" ], "explanation": "C语言中字符常量必须用单引号括起来，如'C'。选项B使用双引号，表示的是字符串常量，而不是字符常量。" }, { "id": 1241, "q": "以下程序的输出结果是()\nmain()\n{\nint a=12, b=12;\nprintf(\"%d, %d\\n\", --a, ++b) ;\n}", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "10, 11", "12, 12", "11, 10", "11, 13" ], "explanation": "--a是前缀递减，先减1再使用，a的值变为11；++b是前缀递增，先加1再使用，b的值变为13。因此printf输出结果为11, 13。" }, { "id": 1242, "q": "若运行以下程序段时,从键盘输入Adescriptor(表示回车),则下面程序段的运行结果是()\nchar c;\nint v0=0,v1=0,v2=0;\ndo {switch(c=getchar())\n{case 'a':case'A':case 'e':case'E':\ncase 'i':case 'I':case 'o':case 'O':\ncase 'u':case 'U':v1+=1;\ndefault:v2+=1;}\nv0+=1;\n} while(c!='\\n');\nprintf(\"v0=%d,v1=%d,v2=%d\\n\",v0,v1,v2);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "v0=7,v1=4,v2=7", "v0=11,v1=4,v2=11", "v0=12,v1=4,v2=11", "v0=12,v1=4,v2=12" ], "explanation": "循环读取字符，遇到元音字母v1和v2加1，其他字符及回车符均走default使v2加1，每次循环v0加1。共读取12个字符(含回车)，v0=12；元音A,e,i,o共4个，v1=4；所有字符均执行v2+=1，v2=12。" }, { "id": 1243, "q": "语句while(!E);中的!E等价于()", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "E==0", "E!=1", "E!=0", "E==1" ], "explanation": "在C语言中，!E表示逻辑非运算，当E的值为0时，!E的结果为真（1）。因此!E等价于判断E是否等于0，即表达式E==0。" }, { "id": 1244, "q": "以下叙述中正确的是 ( ) 。", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "break语句只能用于switch语句题中", "continue语句的作用是：使程序的执行流程跳出包含它的所有循环", "break 语句只能用在循环体内和switch语句体内", "在循环体内使用break语句和continue语句的作用相同" ], "explanation": "break语句可用于switch和循环体中，用于跳出当前结构；continue只能用于循环体，跳过本次循环剩余语句。A、B、D描述均错误，C选项叙述正确。" }, { "id": 1245, "q": "若函数调用时的实参为变量时，以下关于函数形参和实参的叙述中正确的是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "形参只是形式上的存在，不占用具体存储单元", "函数的形参和实参分别占用不同的存储单元", "同名的实参和形参占同一存储单元", "函数的实参和其对应的形参共占同一存储单元" ], "explanation": "C语言函数参数传递是单向的值传递。函数调用时，系统会为形参分配独立的存储单元，实参和形参分别占用不同的内存空间，互不影响。" }, { "id": 1246, "q": "以下叙述中不正确的是（ ）。\n#include \nvoid f(int n);\nmain()\n{ void f(int n);\nf(5); }\nvoid f(int n)\n{ printf(\"%d\\n\",n); }", "t": "single", "ans": "C", "kp": "函数", "o": [ "只在主函数中对函数f进行声明,只能在主函数中正确调用函数f", "若在主函数前对函数f进行声明,则在主函数和其后的其它函数中都可以正确调用函数f。", "对以上程序,编译时系统会提示出错信息:提示对f函数重复声明", "函数f无返回值，所以可用void将其类型定义为无值型" ], "explanation": "C语言允许对同一个函数进行多次声明，只要声明的返回类型和参数列表一致即可，编译器不会提示重复声明错误。因此选项C的叙述是不正确的。" }, { "id": 1247, "q": "有如下程序的输出结果是( ) 。\nlong fib(int n)\n{ if(n>2) return(fib(n-1)+fib(n-2));\nelse return(2); }\nmain()\n{ printf(\"%d\\n\",fib(3)); }", "t": "single", "ans": "B", "kp": "函数", "o": [ "2", "4", "6", "8" ], "explanation": "递归函数fib中，当n>2时返回fib(n-1)+fib(n-2)，否则返回2。计算fib(3)即调用fib(2)+fib(1)，两者均满足n<=2返回2，故最终结果为2+2=4。" }, { "id": 1248, "q": "以下程序的运行结果是（　　）。\nvoid swap1(int c[ ])\n{ int t;\nt=c[0];c[0]=c[1];c[1]=t;}\nvoid swap2(int c0,int c1)\n{ int t;\nt=c0;c0=c1;c1=t;\n}\nmain( )\n{ int a[2]={3,5},b[2]={3,5};\nswap1(a); swap2(b[0],b[1]);\nprintf(\"%d %d %d %d\\n\",a[0],a[1],b[0],b[1]);}", "t": "single", "ans": "B", "kp": "函数", "o": [ "5 3 5 3", "5 3 3 5", "3 5 3 5", "3 5 5 3" ], "explanation": "swap1传入数组名，直接修改原数组a，a变为5,3；swap2传入数组元素的值，属于值传递，不改变原数组b，b仍为3,5。故最终输出5 3 3 5。" }, { "id": 1249, "q": "以下程序段的运行结果是（ ）。\n{\nint a[4][4]={{1,3,5},{2,4,6},{3,5,7}};\nprintf(\"%d%d%d%d\\n\",a[0][3],a[1][2],a[2][1],a[3][0]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "0650", "1470", "5430", "输出值不确定" ], "explanation": "二维数组部分初始化时，未显式赋值的元素自动初始化为0。由此可知a[0][3]为0，a[1][2]为6，a[2][1]为5，a[3][0]为0。按格式连续输出即为0650。" }, { "id": 1250, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={ {1,2},{3,4},{5,6} },i,j,s=0;\nfor(i=1;i<3;i++)\nfor(j=0;j<=2;j++)s+=a[i][j];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "18", "19", "17", "16" ], "explanation": "二维数组部分初始化时，未赋值元素默认为0。数组a的第1、2行分别为{3,4,0}和{5,6,0}。外层循环i从1到2，内层j从0到2，累加a[1]和a[2]的所有元素。s = (3+4+0) + (5+6+0) = 18。" }, { "id": 1251, "q": "以下程序的运行结果是（　　）。\nmain()\n{\nchar arr[3][4];\nstrcpy(arr[0],\"you\");\nstrcpy(arr[1],\"me\");\nstrcpy(arr[2],\"her\");\narr[0][3]='&';\nprintf(\"%s\\n\",arr);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "you&me", "you&her", "you", "her" ], "explanation": "二维字符数组在内存中连续存储。arr[0]原为you加结束符，将arr[0][3]修改为&后，arr[0]失去字符串结束符。使用%s打印arr时，会越过arr[0]的边界继续读取arr[1]的内容，直到遇到arr[1]末尾的结束符，因此输出you&me。" }, { "id": 1252, "q": "以下程序段的运行结果是( )\n#define N 6\n#define M1 N*3\n#define M2 N*2\nmain()\n{ int i;\ni=M1+M2;\nprintf(\"%d\\n\",i); }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "30", "18", "12", "35" ], "explanation": "宏替换是纯文本替换，不会自动添加括号。M1替换为6*3，M2替换为6*2。表达式i=M1+M2展开后为i=6*3+6*2。根据运算符优先级，先计算乘法再计算加法，即18+12=30。" }, { "id": 1253, "q": "#define f(x) (x*x)\nmain( )\n{ int i;\ni=f(5+5)/f(3+3);\nprintf(\"%d\\n\",i);\n}", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "43", "2", "96", "3" ], "explanation": "宏定义f(x)展开时直接替换参数。f(5+5)展开为(5+5*5+5)，值为35；f(3+3)展开为(3+3*3+3)，值为15。表达式变为35/15，由于是整数除法，结果截断为2。注意宏定义参数未加括号导致的优先级问题。" }, { "id": 1254, "q": "给定程序modi1.c中函数fun的功能是：求整数x的y次方的低3位值。例如，整数5的6次方为15625，此值的低3位值为625。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "程序中的第一个错误：根据for循环的定义，当i=y时，不执行，本题要求y个x相乘，应当计算，所以\"for(i=1; i\nmain()\n{\nint a, b, c=241;\na = c/100 % 9;\nb = ( -1 )&&( -1 );\nprintf(\"%d, %d\\n\", a, b );\n}\n程序运行后的输出结果是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2,1", "6,1", "6,0", "2,0" ], "explanation": "表达式c/100%9中，除法与取模优先级相同且左结合，先算241/100得2，再算2%9得2，故a=2。逻辑与运算中，非零值视为真，(-1)&&(-1)结果为1，故b=1。最终输出2,1。" }, { "id": 1259, "q": "下列四个选项中，均是不合法的整型常量的选项是 ______。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "-0f1 -0xffff 0011", "-0xcdf 017 12,3456", "-018 999 5e2", "-0x48eg -068 03f" ], "explanation": "八进制数以0开头，只能包含0-7；十六进制以0x开头，包含0-9和a-f。A中-0f1错；B中12,3456错；C中-018和5e2错；D中-0x48eg含非法字符g，-068含非法数字8，03f缺少0x前缀，三个均不合法。" }, { "id": 1260, "q": "以下正确的标识符是( )", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "do", "struct", "ty_1", "for" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且首字符必须是字母或下划线，同时不能是关键字。do、struct和for均为C语言保留关键字，不能作为标识符。ty_1符合命名规则。" }, { "id": 1261, "q": "执行下列程序后的输出结果是( ) 。\nmain( )\n{\nint k=4, a=3, b=2, c=1;\nprintf(\"%d\\n\", ky);", "if (x=y&&x!=0) x+=y;", "if (x>0) z=z/x;\nelse (x<=0) z=z*x;", "if (x>y) x++;y++;" ], "explanation": "C选项中else后面直接跟了条件表达式(x<=0)，语法错误。else后应直接跟语句，若需判断条件应使用else if。其他选项语法均合法，A为空语句，B为赋值与逻辑运算，D为两条独立语句。" }, { "id": 1265, "q": "假定所有变量均已正确说明,下列程序段运行后x的值是（）。\na=b=c=0;x=35;\nif (!a) x--;\nelse if (b);\nif (c) x=3;\nelse x=5;", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "34", "5", "35", "3" ], "explanation": "初始a=b=c=0，x=35。第一个if(!a)条件为真，x自减为34，跳过else if。接着判断if(c)，c为0条件为假，执行else分支，将x赋值为5。因此最终x的值为5。" }, { "id": 1266, "q": "以下程序的运行结果是( ) 。\n　　main()\n{ int p=1,a=0;\nif(p=a!=0)\nprintf(\"%d\\n\",p);\nelse\nprintf(\"%d\\n\",p+2);}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "表达式p=a!=0中，!=优先级高于=。先计算a!=0，因a为0，结果为0（假）。再将0赋值给p，此时p为0。if条件为假，执行else分支，输出p+2的值，即2。" }, { "id": 1267, "q": "有以下程序，程序运行后的输出结果是( )。\nmain( )\n{int a=15,b=21,m=0;\nswitch(a%3)\n{ case 0:m++;break;\ncase 1:m++;\nswitch(b%2)\n{ default:m++;\ncase 0:m++;break; }\n}\nprintf(\"%d\\n\",m); }", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "1", "2", "3", "4" ], "explanation": "a%3的值为0，进入switch的case 0分支，m自增为1，遇到break跳出switch语句。不会执行case 1及内部的嵌套switch。最终输出m的值1。" }, { "id": 1268, "q": "则程序的输出结果是\nint a=1,b=2,c=3,d=4, r=0;\nif (a!=1) ;  else  r=1;\nif (b==2)   r+=2;\nelse ;\nif (c!=3)  r+=3;\nelse ;\nif (d==4)   r+=4;\nprintf(\"%d\\n\", r);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "10", "6", "7", "3" ], "explanation": "依次判断四个if语句：a!=1为假，执行else使r=1；b==2为真，r+=2得3；c!=3为假，执行else空语句；d==4为真，r+=4得7。最终输出r的值7。" }, { "id": 1269, "q": "下面的循环执行完后，循环次数是（ ）次。\nk=10;\ndo{\nk--;\n}while(k);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "9", "10", "11", "无穷次" ], "explanation": "k初值为10，do-while循环先执行k--，再判断k的值。k依次从9递减到0，当k为0时条件为假，循环结束。循环体共执行了10次。" }, { "id": 1270, "q": "以下程序运行完后a的值是（ ）。\nmain()\n{\nint i, a=0 ;\nfor(i=0; i<10; i++)\na++, i++;\nprintf(\"%d\", a);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "4", "5", "6", "10" ], "explanation": "for循环中，循环体为a++, i++。每次循环a和i各加1，随后for的表达式3再使i加1，即i每次实际增加2。i依次取0,2,4,6,8时执行循环体，共执行5次，a最终值为5。" }, { "id": 1271, "q": "下面程序段的运行结果是()\nint y=10;\ndo {y--;}while(--y);\nprintf(\"%d\\n\",y--);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "-1", "1", "8", "0" ], "explanation": "y初值为10。do-while循环中，先执行y--，再判断--y。每次循环y减少2。当y减至1时，y--后为1，--y后为0，循环结束，此时y为0。最后printf输出y--的值0，随后y变为-1。" }, { "id": 1272, "q": "以下程序的运行结果是（）。\nint n=1;\nwhile(n<=10)\n{\nif(n%3==0) break;\nprintf(\"%d\",n);\nn++;\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "12", "12345678910", "369", "12457810" ], "explanation": "n从1开始，当n=1和2时，n%3不为0，输出1和2，n递增。当n=3时，n%3==0成立，执行break跳出循环。因此最终输出结果为12。" }, { "id": 1273, "q": "下面程序段的运行结果是()\nint i,b,k=0;\nfor(i=1;i<=5;i++)\n{b=i%2;\nwhile(b-->=0) k++;\n}\nprintf(\"%d,%d\",k,b);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "3,-1", "8,-1", "3,0", "8,-2" ], "explanation": "外层for循环中i从1到5。每轮先令b=i%2：i为奇数时while条件会成功2次，i为偶数时成功1次，5轮共执行2+1+2+1+2=8次，因此k=8。while使用后置自减，最后一次条件判断失败时b仍会再减1，最后一轮退出后b=-2。故选D。" }, { "id": 1274, "q": "以下函数返回值的类型是 ( )\ndouble fun ( double x )\n{ int y;\ny= 3*x-4;\nreturn y;\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "double", "float", "int", "char" ], "explanation": "C语言中，函数返回值的类型由函数定义时指定的类型决定，与return语句中表达式的类型无关。本题函数头声明返回类型为double，因此返回值类型为double，返回时会将int型的y自动转换。" }, { "id": 1275, "q": "下列有关函数的说法，不正确的是（）", "t": "single", "ans": "C", "kp": "函数", "o": [ "函数可以没有形式参数", "函数可以有多个形式参数", "函数只能有1个形式参数", "函数定义时不能省略形参类型" ], "explanation": "C语言中，函数可以没有形参（如void func()），也可以有多个形参，因此A和B正确，C错误。在函数定义时，形参的类型必须明确指定，不能省略，D正确。本题要求选不正确的，故选C。" }, { "id": 1276, "q": "外部变量前面加上static后，下列说法正确的是（）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "存放在动态存储区", "存放在自由空间区", "生存期没有变化", "生存期得以延长" ], "explanation": "外部变量（全局变量）本身就存放在静态存储区，其生存期为整个程序运行期间。加上static关键字后，只是限制了它的作用域（仅在本文件内可见），其存储位置和生存期均没有发生变化。故选C。" }, { "id": 1277, "q": "有关动态变量和静态变量的说法，正确的是（）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "前面有static 的才是静态变量", "静态变量存放在静态数据区", "自动变量属于静态变量", "自动变量是在编译时分配内存空间的" ], "explanation": "静态变量存放在静态数据区（静态存储区），B正确。全局变量即使不加static也是静态变量，A错误。自动变量（局部变量）属于动态变量，在程序运行时进入其作用域才分配内存空间，C、D错误。故选B。" }, { "id": 1278, "q": "以下程序的运行结果是（　　）。\nint f(int n)\n{ if (n==1) return 1;\nelse return f(n-1)+1; }\nmain()\n{ int i,j=0;\nfor(i=1;i<4;i++) j+=f(i);\nprintf(\"%d\\n\",j);\n}", "t": "single", "ans": "D", "kp": "函数", "o": [ "4", "3", "5", "6" ], "explanation": "函数f(n)是一个递归函数，由f(1)=1且f(n)=f(n-1)+1可知，f(n)的返回值即为n。主函数中循环变量i从1递增到3，分别计算f(1)=1，f(2)=2，f(3)=3。j初始为0，累加后j=1+2+3=6。故选D。" }, { "id": 1279, "q": "以下程序段的输出结果是（ ）\nint add(int a,int b)；\nmain( )\n{ int s=0, a[6]={1,2,3,5,7,8};\nadd(a[1],a[3]);\ns1=a[1]+a[3];\nprintf(“%d,%d,%d”,a[1],a[3],s1);}\nint add(int a,int b)\n{ int s;\na=a+1; b=b+2; s=a+b;\nreturn s;}", "t": "single", "ans": "C", "kp": "函数", "o": [ "2,510", "3,7,10", "2,5,7", "3,7,7" ], "explanation": "C语言函数参数传递是单向值传递，add函数内对形参的修改不会影响实参数组元素。a[1]和a[3]初值分别为2和5，调用add后其值不变。s1=a[1]+a[3]=2+5=7。最终输出2,5,7。题干中s1未声明但不影响逻辑推导。故选C。" }, { "id": 1280, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=6-i;\nprintf(\"%d%d%d\",a[0],a[1],a[2]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "654", "456", "567", "678" ], "explanation": "循环中i从9递减到0，数组元素赋值为a[i]=6-i。当i=0时，a[0]=6；当i=1时，a[1]=5；当i=2时，a[2]=4。printf语句连续输出a[0]、a[1]、a[2]的值且中间无分隔符，因此结果为654。故选A。" }, { "id": 1281, "q": "以下程序段的运行结果是（　　）。\nmain()\n{ int a[3][3]={ {3},{4,5},{6,7,8} },i,j,s=0;\nfor(i=1;i<3;i++)\nfor(j=0;j<=i;j++) s+=a[i][j];\nprintf(\"%d\\n\",s); }", "t": "single", "ans": "A", "kp": "数组", "o": [ "30", "33", "13", "24" ], "explanation": "二维数组按行初始化，{3}补为3,0,0，{4,5}补为4,5,0，第三行是6,7,8。循环中i=1时累加a[1][0]+a[1][1]=4+5，i=2时累加a[2][0]+a[2][1]+a[2][2]=6+7+8，总和为30。故选A。" }, { "id": 1282, "q": "两次运行下面程序，如果从键盘上分别输入 4和 6 ，则输出结果是().\nint x;\nscanf(\"%d\",&x);\nif(++x>5) printf(\"%d\",x);\nelse printf(\"%d\",--x);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "4和7", "4和6", "5和7", "5和6" ], "explanation": "输入4时，++x使x变为5，条件5>5为假，执行else分支，--x使x变回4并输出。输入6时，++x使x变为7，条件7>5为真，执行if分支，直接输出7。因此两次运行输出结果分别是4和7。故选A。" }, { "id": 1283, "q": "以下程序的运行结果是（　　）。\n#define NULL 0\nmain()\n{ int a[]={1,2,3,4,5,6,7,8,9,10,11,12};\nint *p=a+5, *q=NULL;\n*q=*(p+5);\nprintf(\"%d%d\\n\",*p, *q); }", "t": "single", "ans": "A", "kp": "指针", "o": [ "运行后报错", "6 6", "6 11", "5 5" ], "explanation": "指针q被初始化为NULL（即地址0），指向空地址。执行*q=*(p+5)时，程序试图向空地址写入数据，这会导致内存访问违规（段错误），因此程序运行后会报错崩溃。故选A。" }, { "id": 1284, "q": "以下程序的运行结果是（　）。\nmain()\n{ char p1[10]=\"abc\", *p2=\"ABC\", str[50]=\"xyz\";\nstrcpy(str+2,strcat(p1,p2));\nprintf(\"%s\\n\",str);}", "t": "single", "ans": "D", "kp": "字符串", "o": [ "xyzabcABC", "zabcABC", "yzabcABC", "xyabcABC" ], "explanation": "strcat(p1,p2)将p2拼接到p1后，p1变为\"abcABC\"。strcpy(str+2, \"abcABC\")将拼接后的字符串复制到str从索引2开始的位置，覆盖原有的'z'及后续内容。str原为\"xyz\"，替换后保留前两个字符，结果为\"xyabcABC\"。故选D。" }, { "id": 1285, "q": "以下程序中的for循环执行的次数是（　　）。\n#define N 3\n#define M N+1\n#define NUM 2*M+1\n#main()\n{ int i; for(i=1;i<=NUM;i++)\nprintf(\"%d\\n\",i); }", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "10", "6", "9", "8" ], "explanation": "宏替换是纯文本替换，不进行计算。NUM替换为2*M+1，进一步替换为2*N+1+1，最终替换为2*3+1+1。计算该表达式得6+1+1=8。循环条件为i<=8，i从1开始，共执行8次。故选D。" }, { "id": 1286, "q": "#include\n#define MAX(x,y) (x)>(y)?(x):(y)\nmain()\n{ int a=6,b=3,c=6,d=7,t;\nt=MAX(a+b,c+d) *10;\nprintf(\"%d\\n\",t);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "90", "9", "130", "13" ], "explanation": "宏替换后表达式为t=(a+b)>(c+d)?(a+b):(c+d)*10。代入数值得t=9>13?9:13*10。由于乘法优先级高于条件运算符，假值部分为13*10=130。条件9>13为假，最终t被赋值为130。故选C。" }, { "id": 1287, "q": "给定程序modi1.c中函数fun的功能是：找出100至n（不大于1000）之间三位数字相等的所有整数，把这些整数放在s所指数组中，个数作为函数值返回。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1288, "q": "给定程序中，函数fun的作用是：不断从终端读入整数，由变量a统计大于0的个数，用变量b来统计小于0的个数，当输入0时结束输入，并通过形参px和py把统计的数据传回主函数进行输出。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "fun函数中，首先需要定义a，b，k，由于变量a和b在下面的运行语句中有自增操作，所以需要赋初值，所以第一空填\"a=0,b=0,k\"。第二空是while的循环条件，题目要求中提到当输入0时结束输入，所以当k不等于0时，即执行while语句，故第二空填(k)或其他等价形式。题面中要求不断从终端读入整数，直到输入0时结束，所以当k不为0时，需要继续输入整数，故第三空填\"scanf(\"%d\", &k)\"。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1289, "q": "请编写函数fun，其功能是：计算并输出给定数组（长度为9）中每相邻两个元素之平均值的平方根之和。\n例如，给定数组中的9个元素依次为12.0、34.0、4.0、23.0、34.0、45.0、18.0、3.0、11.0，输出应为：s=35.951014。\n注意：部分源程序在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "double fun(double x[9])\n{int i ;\ndouble avg=0.0,sum=0.0; /*将变量avg、sum定义为双精度型，并给其赋初值为0.0*/\nfor (i=0;i<8;i++)\n{avg=(x[i]+x[i+1])/2; /*通过for循环分别求出相邻两个元素的平均值放入变量avg中*/\nsum+=sqrt(avg); /*使用求平方根函数sqrt()对各平均值开方求和，最终结果输出到变量sum*/\n}\nreturn sum; /*返回计算结果*/\n}", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1290, "q": "以下叙述中正确的是( )。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "C程序的基本组成单位是语句", "C程序中每一行只能写一条语句", "C语句必须以分号结束", "C语句必须在一行内写完" ], "explanation": "C程序的基本组成单位是函数，而非语句；C程序书写格式自由，一行可写多条语句，一条语句也可分多行写；但每条语句必须以分号作为结束标志。因此选项C正确。" }, { "id": 1291, "q": "设有定义： int a; 执行 scanf(\"%2d\", &a); 语句时，若从键盘输入 1234 则a的值是 ()", "t": "single", "ans": "A", "kp": "输入输出", "o": [ "12", "1234", "随机值", "程序报错" ], "explanation": "scanf函数中的格式控制符\"%2d\"表示最多读取2位十进制整数。当输入1234时，系统只截取前两位数字12赋给变量a，剩余的34留在输入缓冲区中。因此a的值为12。" }, { "id": 1292, "q": "以下程序的运行结果是（　　）\nmain(){\nchar p[20]={'a','b','c','d'},q[]=\"abc\", r[]=\"abcde\";\nstrcat(p,r); strcpy(p+strlen(q),q);\nprintf(\"%d \\n\",strlen(p));\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "6", "20", "12", "7" ], "explanation": "p初始化为\"abcd\"，q为\"abc\"，r为\"abcde\"。strcat(p,r)将r拼接到p后，p变为\"abcdabcde\"。strlen(q)为3，strcpy(p+3, q)将\"abc\"及结束符复制到p的第4个字符起的位置，p变为\"abcabc\"。求strlen(p)结果为6。" }, { "id": 1293, "q": "给定程序modi1.c中，函数fun的功能是：求S的值。设\n例如，当k为10时，函数值应为：1.533852。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1294, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=0;i<3;i++) s+=a[i][0]+a[1][3-i-1];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "24", "23", "25", "26" ], "explanation": "数组a第一列为1,3,5；第二行为3,4,8。循环i从0到2：i=0时，s+=a[0][0]+a[1][2]即1+8=9；i=1时，s+=a[1][0]+a[1][1]即3+4=7，s=16；i=2时，s+=a[2][0]+a[1][0]即5+3=8，s=24。最终输出24。" }, { "id": 1295, "q": "变量x,y,z已正确定义，以下对变量的初始化正确的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "x==1;", "x=4=y+1;", "z+1=9;", "x=z=8;" ], "explanation": "C语言中赋值运算符左侧必须是变量，不能是表达式或常量，故B和C错误；A选项使用了关系运算符\"==\"而非赋值运算符\"=\"；D选项是连续赋值表达式，将8赋给z，再将z的值赋给x，语法正确。" }, { "id": 1296, "q": "若以下选项中的变量a,b,y均已正确定义并赋值,则语法正确的switch语句是()", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "switch(a*a+b*b)\n{default:break;\ncase 3:y=a+b; break;\ncase 2:y=a-b; break;\n}", "switch a*b\n{case 10:y=a+b;\ndefault:y=a-b;\n}", "switch(a+9)\n{case a:y=a-b;\ncase b:y=a+b;\n}", "switch(a+b)\n{ case 1:case 3:y=a+b; break;\ncase 3:case 4:y=a-b;\n}" ], "explanation": "switch后的表达式必须用括号括起，B错误；case后的标签必须是常量表达式，不能是变量，C错误；同一个switch语句中case标签的值不能重复，D中出现了两个case 3，错误。A选项语法完全正确，default位置灵活。" }, { "id": 1297, "q": "以下程序运行结果是( )。\nmain()\n{ int a=0,b=0,c=0,d=0;\nwhile(a==1) b=1;c=2;\nprintf(\"%d,%d,%d,%d\\n\",a,b,c,d);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0,0,2,0", "0,1,2,0", "死循环", "0,1,0,0" ], "explanation": "while(a==1)后没有大括号，因此循环体仅为b=1;这一条语句。由于a初始为0，条件a==1为假，循环不执行，b保持为0。c=2;在循环外部，正常执行使c变为2。d未改变仍为0。最终输出0,0,2,0。" }, { "id": 1298, "q": "从键盘输入9，17，8数，以下程序的输出结果是( )。\n#include\nmain()\n{\nint a,b,c,t;\nscanf(\"%d,%d,%d\",&a,&b,&c);\nif(a>b) {t=a;a=b;b=t;}\nif(a>c) {t=a;a=c;c=t;}\nif(b>c) {t=b;b=c;c=t;}\nprintf(\" %d %d %d\",a,b,c);\n}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "17，9，8", "8，9，17", "8，17，9", "17，8，9" ], "explanation": "程序通过三个if语句对a,b,c进行两两比较和交换，实现升序排序。输入9,17,8后，a=9,b=17,c=8。第一个if不交换；第二个if交换a和c，变为a=8,c=9；第三个if交换b和c，变为b=9,c=17。最终输出8,9,17。" }, { "id": 1299, "q": "请编写函数fun，其功能是：统计出x所指数组中偶数的个数，通过函数值返回主函数；并计算出偶数的平均值放到形参ave所指的存储单元中。\n例如，当数组内容为：12,5,9,8,23,4,7,21时，输出结果应该是：n=3,ave=8.000000\n注意：部分源程序存在文件PROG1.C中。\n请勿更改主函数main和其他函数中的任何内容，仅在函数fun的花括号中填入所编写的若干语句。", "t": "fill", "ans": "int fun(int x[],double *ave)\n{\nint i,n=0;\n*ave=0;\nfor(i=0;i\nmain()\n{\nint a,b=5,c=5;\na=++b+c--;\nprintf(\"%d,%d,%d\\n\", a,b,c);\n}", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "10,5,5", "10,6,4", "11,6,5", "11,6,4" ], "explanation": "b和c初始均为5。表达式a=++b+c--中，++b是前置自增，b先变为6再参与运算；c--是后置自减，c先以原值5参与运算，之后c再减1变为4。因此a的值为6+5=11。最终a=11，b=6，c=4。" }, { "id": 1301, "q": "若 int i=10; 执行下列程序后， 变量 i 的正确结果是() 。\nswitch(i)\n{\ncase 9: i+=1;\ncase 10: i+=1;\ncase 11: i+=1;break;\ndefault: i+=1;\n}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "10", "11", "12", "13" ], "explanation": "i初始为10，匹配case 10。执行i+=1后i变为11；由于没有break语句，发生穿透，继续执行case 11的i+=1，i变为12；遇到break跳出switch语句。default不执行。最终i的值为12。" }, { "id": 1302, "q": "以下程序的输出结果是( )。\nmain()\n{\nint x=1,y=2,z=3;\nfor(;x>y;)\nprintf(\"%d\",++z);\nprintf(\"%d\",++y);\nprintf(\"%d\\n\", x++ );\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "31", "431", "2", "无结果" ], "explanation": "x=1,y=2,z=3。for循环条件x>y即1>2为假，循环体不执行。接着执行循环外的printf输出++y，y前置自增变为3并输出3；然后执行printf输出x++，输出x的当前值1，之后x自增。因此最终输出31。" }, { "id": 1303, "q": "若变量已正确定义，程序结束后，i的值为（）\ni=0;\ndo\n{ printf(\"%d,\",i); }\nwhile( i++ );", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "0", "-1", "1", "死循环" ], "explanation": "do-while循环先执行循环体，输出0。然后判断条件i++，此时i的值为0，条件为假，循环结束，但i在判断后发生后置自增，变为1。因此程序结束后i的值为1。" }, { "id": 1304, "q": "下面程序段执行后， 内外层循环 i 和 j 总共分别执行的次数为 （） 。\nfor(i=1; i<=9; i++)\n{\nfor(j=1; j<=i; j++)\nprintf(\"%4d\", i*j) ;\nputchar(' \\n' ) ;\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "45 45", "9 45", "9 9", "45 9" ], "explanation": "外层循环变量i从1递增到9，共执行9次。内层循环变量j的终值依赖于i，每次执行次数分别为1到9，总次数为1+2+...+9=45次。因此i执行9次，j执行45次。" }, { "id": 1305, "q": "以下函数调用语句中，含有的实参个数是( ) 。\nfunc( (exp1,exp2), (exp3,exp4,exp5));", "t": "single", "ans": "B", "kp": "函数", "o": [ "1", "2", "4", "5" ], "explanation": "函数调用时，参数由逗号分隔。本题中使用了逗号表达式，(exp1,exp2)整体作为一个实参，(exp3,exp4,exp5)整体作为第二个实参。因此该函数调用共包含2个实参。" }, { "id": 1306, "q": "有关自动变量的说法，正确的是（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "不同函数的自动变量可以同名", "不同函数的自动变量不可以同名", "自动变量不能与外部变量同名", "BC都正确" ], "explanation": "自动变量即局部变量，其作用域仅限于定义它的函数或复合语句内部。由于作用域相互独立，不同函数中定义的自动变量可以同名且互不干扰。外部变量与自动变量同名时，局部会屏蔽全局。" }, { "id": 1307, "q": "以下程序的运行结果是（　　）\nmain()\n{ int s[12]={0,2,4,0,4,3,2,3,1,1,3,3},c[5]={0},i;\nfor(i=0;i<12;i++) c[s[i]]++;\nfor(i=0;i<5;i++) printf(\"%d\",c[i]);\nprintf(\"\\n\");\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "22242", "22241", "22222", "02232" ], "explanation": "数组c初始全为0。第一个循环遍历数组s，将s[i]的值作为c的下标并使其自增，从而统计s中0到4各数字出现的次数。s中0、1、2、4各出现2次，3出现4次。第二个循环输出c[0]到c[4]，结果为22242。" }, { "id": 1308, "q": "若有定义语句char s[10]= \"howare\\0\\tyou?\";，则strlen(s)的值是（　　）。", "t": "single", "ans": "A", "kp": "字符串", "o": [ "6", "7", "12", "11" ], "explanation": "strlen函数用于计算字符串的有效长度，遇到第一个结束标志\\0时停止计数。字符串\"howare\\0\\tyou?\"中，\\0前有howare共6个字符，因此长度为6。" }, { "id": 1309, "q": "以下程序的运行结果是( )\n#define x 5\n#define y x+1\n#define z y*x/2\nmain()\n{\nprintf(\"%d\",2*z);\n}", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "12", "15", "30", "10" ], "explanation": "宏替换是纯文本替换，不考虑运算优先级。2*z替换为2*y*x/2，进一步替换为2*x+1*x/2。代入x=5，表达式为2*5+1*5/2。根据优先级先算乘除，即10+5/2，整除结果为10+2=12。" }, { "id": 1310, "q": "给定程序MODI1.C中，函数fun()的功能是统计s所指一维数组中0的个数（存在变量zero中）和1的个数（存在变量one中），并输出结果。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "第一处错误：zero是统计s所指一维数组中0的个数，其初始值为0，所以\"int i, one=0, zero ;\"应改为\"int i, one=0, zero=0;\"或其等效形式。\n第二处错误：switch后的\"表达式\"要用\"()\"括起来，但括号后不带有\";\"，所以\"switch( s[i] );\"应改为\"switch( s[i] )\"。\n第三处错误：当switch后面表达式的值，与某个case后面的常量表达式的值相同，就执行该case后面的语句（组），如果case语句后面没有break，并不跳出switch，而是继续执行下面的case语句，直到遇到break语句或switch语句结束。本题switch后面的表达式如果为0（数组的第i个元素为0），则执行第一个case语句，zero会增一，由于此case语句后面没有break，则继续执行第二个case语句，one也增一，所以\"case 0 : zero++;\"应改为\"case 0;zero++;break;\"。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1311, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "D", "kp": "综合编程/调试改错", "o": [ "程序设计的任务就是编写程序代码。", "程序设计的任务就是确定所用数据结构。", "程序设计的任务就是确定所用算法。", "以上三种说法都不完整。" ], "explanation": "程序设计是一个系统工程，不仅包括编写代码，还涵盖需求分析、算法与数据结构设计、调试测试及维护等多个阶段。选项A、B、C都只描述了其中的一部分，因此都不完整。" }, { "id": 1312, "q": "对下列二维字符数组的定义，描述正确的（）\nchar str1[3][5]={{'g','o','o','d'},{'h','a','p','y'},{'b','o','o','k'}}；\nchar str2[3][5]={{\"good\"},{\"hapy\"},{\"book\"}}；", "t": "single", "ans": "C", "kp": "字符串", "o": [ "str1不是字符串，str2是字符串", "str1是字符串，str2不是字符串", "str1和str2都是字符串", "str1和str2都不是字符串" ], "explanation": "两个二维数组在初始化时，每行提供的初始值个数均小于列数5，C语言会自动将剩余元素初始化为\\0。因此，str1和str2的每一行都包含字符串结束标志，都可以作为字符串处理。" }, { "id": 1313, "q": "以下正确的字符串常量是", "t": "single", "ans": "A", "kp": "字符串", "o": [ "\"\\n\"", "\"\\\\\\\"", "'abc'", "Olympic Games" ], "explanation": "字符串常量必须用双引号括起来。选项A是包含换行符的合法字符串常量；选项B转义字符书写有误或缺少闭合双引号；选项C是字符常量；选项D未加双引号，属于标识符。" }, { "id": 1314, "q": "以下选项中，当x为大于1的奇数时，值为0的表达式( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "x%2==1", "x/2", "x%2!=0", "x%2==0" ], "explanation": "当x为大于1的奇数时，x除以2的余数必定为1。因此，x%2==1和x%2!=0的值均为1（真），x/2的值大于0。只有x%2==0判断余数是否为0，对于奇数其结果为0（假）。" }, { "id": 1315, "q": "以下程序的运行结果是(小数点后只写一位)（　　）。\ndouble d=1,y;\nint x;\nx=1.2;\ny=(x+3.8)/2;\nprintf(\"%f \\n\", d*y);", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "2.4", "2.5", "0", "3.07" ], "explanation": "变量x为整型，赋值x=1.2时发生隐式类型转换，截断小数部分，x的值为1。计算y=(1+3.8)/2，结果为2.4。最后计算d*y即1*2.4，结果为2.4，按%f格式输出保留一位即2.4。" }, { "id": 1316, "q": "以下程序的运行结果是（　　）\nint a=30;\nint f(int c){\nstatic int a=20;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<1;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "54", "44", "34", "55" ], "explanation": "全局变量a=30。循环执行1次，调用f(3)。f内静态局部变量a初值为20，c=4，返回20+4=24，随后静态a自增为21，此时k=24。循环结束后，执行k+=a，此处的a为全局变量30，故k=24+30=54。" }, { "id": 1317, "q": "执行下面程序后，x的值为（）。\nint a=0,b=0,c=0,x=3;\nif (a) x=0;\nelse if (b==0)x=2;\nelse if (c) x=1;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "a为0，if(a)为假；执行else if(b==0)，b为0条件为真，执行x=2。后续else if不再执行。因此x的值为2。" }, { "id": 1318, "q": "有以下程序\nmain()\n{ int a=12,b=21,m=0;\nswitch(a%3)\n{ case 0:m++;break;\ncase 1:m++;\nswitch(b%2)\n{ default:m++;\ncase 0:m++;break;\n}\n}\nprintf(\"%d\\n\",++m);\n}\n程序运行后的输出结果是（）。", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "1", "2", "3", "4" ], "explanation": "a=12，a%3为0，匹配case 0，执行m++后m变为1，遇到break跳出switch语句。最后执行printf输出++m，m先自增为2再输出，结果为2。" }, { "id": 1319, "q": "下面程序段的运行结果是()\nx=y=0;\nwhile(x<15)\ny++,x+=++y;\nprintf(\"%d,%d\",y,x);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "20,7", "6,12", "20,8", "8,20" ], "explanation": "初始x=0,y=0。第1次循环：y变1，x+=2即x=2；第2次：y变3，x+=4即x=6；第3次：y变5，x+=6即x=12；第4次：y变7，x+=8即x=20。此时x<15不成立退出，输出8,20。" }, { "id": 1320, "q": "若有以下函数调用语句fun(a+b, (x,y), fun(n+k,d,(a,B）));在此函数调用语句中实际参数的个数是( )", "t": "single", "ans": "A", "kp": "函数", "o": [ "3", "4", "5", "6" ], "explanation": "函数调用时，实际参数由逗号分隔。第一个参数是a+b，第二个参数是逗号表达式(x,y)，第三个参数是函数调用fun(n+k,d,(a,B))。因此外层函数共有3个实际参数。" }, { "id": 1321, "q": "以下程序的输出结果是（）\nint a=40;\nint f(int n){\nint t=0;\nint a=7;\nif(n%2) {int a=6; t+=a++;}\nelse {int a=7 ;t+=a++;}\nreturn t+a++;\n}\nmain(){\nint s=a,i=0;\nfor(;i<2;i++) s+=f(i);\nprintf (\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "67", "27", "13", "66" ], "explanation": "全局a=40，main中s=40。i=0调f(0)，走else分支，局部t=7，返回t+a++即7+7=14，s变54；i=1调f(1)，走if分支，局部t=6，返回6+7=13，s变67。输出67。" }, { "id": 1322, "q": "以下程序中的运行结果是（）\n#include\nextern k;\nmain()\n{\nstatic int i=0,m;\nfloat j, k=5;\nprintf（\"k=%.0f\", k）;\n}\nfloat k=10;", "t": "single", "ans": "B", "kp": "函数", "o": [ "k=10", "k=5", "k=5.000000", "k=0" ], "explanation": "main函数内定义了局部变量float k=5，屏蔽了外部的全局变量float k=10。printf使用%.0f格式输出浮点数k，不保留小数，因此输出k=5。" }, { "id": 1323, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[5][4]={{1,3,5},{2,3,4},{3,5,7},{3,9,8,4}};\nprintf(\"%d%d%d%d\\n\",a[0][1],a[1][1],a[2][1],a[4][3]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "3350", "3351", "3333", "5555" ], "explanation": "二维数组部分初始化，未赋值元素默认为0。a[0][1]是3，a[1][1]是3，a[2][1]是5；a[4]未初始化全为0，a[4][3]是0。按%d连续输出，结果为3350。" }, { "id": 1324, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=0;i<3;i++) s=a[i][0]+a[1][2-i];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "8", "15", "16", "10" ], "explanation": "循环中s被反复赋值而非累加。i=0时，s=a[0][0]+a[1][2]=1+8=9；i=1时，s=a[1][0]+a[1][1]=3+4=7；i=2时，s=a[2][0]+a[1][0]=5+3=8。最终s为8。" }, { "id": 1325, "q": "有以下程序段运行后的输出结果是（　）。\nmain()\n{ int a[10]={1,2,3,4,5,6,7,8,9}, *p=&a[2];\nprintf(\"%d\\n\", *++p ); }", "t": "single", "ans": "C", "kp": "指针", "o": [ "2", "3", "4", "5" ], "explanation": "指针p初始指向a[2]（值为3）。表达式*++p中，++p先将指针p向后移动一个位置，指向a[3]（值为4），然后解引用获取该位置的值，因此输出4。" }, { "id": 1326, "q": "C语言的编译系统中宏命令是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "在程序运行时进行代换处理的", "在程序连接时进行处理的", "和源程序中其他C语句同时进行编译的", "在对源程序中其他成分正式编译之前进行处理的" ], "explanation": "宏命令属于预处理指令。C语言编译过程分为预处理、编译、汇编和链接。宏替换等预处理操作是在对源程序其他成分正式编译之前进行的。" }, { "id": 1327, "q": "给定程序modi1.c中函数fun的功能是：从m个学生的成绩中统计出低于平均分的学生人数，此人数由函数值返回，aver返回平均分。\n例如，若输入8名学生的成绩：80.5 60 72 90.5 98 51.5 88 64 则低于平均分的学生人数为：4（平均分为：75.5625）。\n请改正函数fun中的错误，使它能统计出正确的结果。\n注意：不要改动main 函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "1、要注意存放学生分数的数组是一个float型的数组，故总分和平均分都应当是float型的；\n2、函数fun()中的第三个形参是一个指针，这表示在未来赋值时的方法是特殊的。\n本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1328, "q": "给定程序BLANK1.C中函数fun的功能是：将整数n的值进行逆序转换，其结果通过函数值返回。\n例：输入：123，则输出：321\n输入：-810，则输出：-18\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 1329, "q": "请编写函数fun，函数的功能是求出二维数组周边元素之和，作为函数值返回。二维数组中的值在主函数中赋予。\n例如：二维数组中的值为\n1 3 5 7 9\n2 9 9 9 4\n6 9 9 9 8\n1 3 5 7 0\n则函数值为61。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "int fun ( int a[M][N] )\n{\nint i, j, sum = 0;\nfor (i = 0; i < M; i++)\nfor (j = 0; j < N; j++)\nif ((i == 0)||(i == M - 1)||(j == 0)||(j == N - 1) )/*判断a[i][j]是否为数组中的第一行或最后一行或第一列或最后一列*/\nsum += a[i][j];/*对a数组的周边元素求和*/\nreturn sum;\n}", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 1330, "q": "若i为整型变量，则以下循环执行的结果是（　　）。\nint i=2;\nwhile(i!=0) printf(\"%d\",i--);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "2", "2 1", "2 1 0", "-1" ], "explanation": "i初始为2，满足i!=0，输出i的值2，然后i自减为1；再次判断满足条件，输出1，i自减为0；此时条件为假退出循环。因此依次输出2和1。" }, { "id": 1331, "q": "若有定义: int x=3, y=6, z=10; 则以下程序段运行后 z 的值为（ ） 。\nif(xn) m-=n;\nwhile (n>m) n-=m;\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "0", "1", "2", "3" ], "explanation": "本题考查辗转相减法求最大公约数。初始m=25，n=14。进入外层循环，因m>n，执行m-=n，m变为11；接着n>m，执行n-=m，n变为3。依次类推，m和n不断相减，直到m和n相等时退出循环。最终m和n的值均为1，即25和14的最大公约数。因此m的值为1。" }, { "id": 1346, "q": "以下程序的输出结果是( )。\nmain(){ int i=0,a=0;\nwhile(i<20)\n{ for(;;)\n{ if((i%10)==0) break;\nelse i--;}\ni+=11; a+=i;}\nprintf(\"%d\\n\",a）;}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "21", "32", "33", "11" ], "explanation": "初始i=0，a=0。第一次外层循环，i%10==0成立，跳出内层循环，i+=11使i=11，a=11。第二次外层循环，i=11不满足i%10==0，执行i--使i=10，随后i%10==0成立跳出内层循环，i+=11使i=21，a=11+21=32。第三次判断i<20不成立，退出外层循环。最终输出a的值为32。" }, { "id": 1347, "q": "以下叙述中错误的是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "函数调用可以作为一个独立的语句存在", "函数形参的值也可以传回给对应的实参", "若函数有返回值，必须通过return语句返回", "C程序必须由一个或一个以上的函数组成" ], "explanation": "C语言中函数参数传递是单向的值传递，形参的改变不会影响实参，因此形参的值不能传回给对应的实参，选项B错误。函数调用可作为独立语句；有返回值的函数必须用return返回；C程序至少包含一个main函数。" }, { "id": 1348, "q": "局部变量前面加上static后，下列说法正确的是（）", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "缩小了作用域", "存放在静态存储区", "增加了作用域", "生存期没有变化" ], "explanation": "局部变量加上static修饰后，其存储类别由自动变量变为静态变量，存放在静态存储区，生存期延长至整个程序运行期间。但其作用域仍限制在定义它的函数或复合语句内，并未改变。因此选项B正确。" }, { "id": 1349, "q": "以下程序的运行结果是（　　）\nfun(int x)\n{ if(x/2>0) fun(x/2);\nprintf(\"%d \",x);\n}\nmain()\n{ fun(5); }", "t": "single", "ans": "A", "kp": "函数", "o": [ "1 2 5", "1 3 6", "1 2", "1 2 4" ], "explanation": "本题考查递归函数。调用fun(5)，x/2=2>0，递归调用fun(2)；在fun(2)中，x/2=1>0，递归调用fun(1)；在fun(1)中，x/2=0不满足条件，执行printf输出1。随后逐层返回，fun(2)输出2，fun(5)输出5。最终输出结果为1 2 5。" }, { "id": 1350, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint p[8]={11,12,13,14,15,16,17,18},i=0,j=0;\nwhile(i++<3) if(p[i]%2) j+=p[i];\nprintf(\"%d\\n\",j);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "13", "45", "14", "11" ], "explanation": "数组p初始化为11到18。while循环条件i++<3，第一次判断i=0，之后i=1，p[1]=12为偶数；第二次判断i=1，之后i=2，p[2]=13为奇数，j+=13；第三次判断i=2，之后i=3，p[3]=14为偶数；第四次判断i=3不满足条件退出。最终j的值为13。" }, { "id": 1351, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=7+i;\nprintf(\"%d%d%d\",a[0],a[1],a[2]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "789", "987", "123", "012" ], "explanation": "循环for(i=9;i>=0;i--)将数组a赋值为a[i]=7+i。因此a[0]=7+0=7，a[1]=7+1=8，a[2]=7+2=9。printf语句连续输出a[0]、a[1]、a[2]的值，中间无空格，最终输出结果为789。" }, { "id": 1352, "q": "以下程序的运行结果是（　　）。\nmain()\n{\nchar arr[3][4];\nstrcpy(arr[0],\"you\");\nstrcpy(arr[1],\"me\");\nstrcpy(arr[1],\"her\");\narr[0][3]='&';\nprintf(\"%s\\n\",arr);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "you&her", "you&me", "you", "youme" ], "explanation": "二维数组arr在内存中连续存储。arr[0]存入you，arr[1]先存me后被her覆盖。arr[0][3]原为'\\0'，被修改为'&'后，arr[0]失去字符串结束标志。使用%s输出arr时，会从arr[0][0]一直输出到arr[1]的'\\0'，即拼接输出you&her。" }, { "id": 1353, "q": "以下程序的运行结果是（　）。\nvoid fun1(char *p)\n{ char *q;\nq=p;\nwhile(*q!= '\\0')\n{ (*q)++;q++;}\n}\nmain(){\nchar a[]={\"Program\"},*p;\np=&a[3];\nfun1(p);\nprintf(\"%s\\n\",a);}", "t": "single", "ans": "A", "kp": "指针", "o": [ "Prohsbn", "Prphsbn", "Progsbn", "Program" ], "explanation": "指针p指向a[3]即字符'g'。fun1函数通过指针q遍历字符串，将'g'及之后的每个字符ASCII值加1。'g'变'h'，'r'变's'，'a'变'b'，'m'变'n'。前三个字符Pro不变，最终数组a的内容变为Prohsbn并输出。" }, { "id": 1354, "q": "#define f(x) x*x\nmain( )\n{ int i;\ni=f(5+5)/f(3+3);\nprintf(\"%d\\n\",i);\n}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "2", "96", "43", "42" ], "explanation": "宏替换是简单的文本替换。f(5+5)/f(3+3)展开为5+5*5+5/3+3*3+3。根据运算符优先级，先算乘除：5*5=25，5/3=1（整除），3*3=9。再算加法：5+25+1+9+3=43。因此输出结果为43。" }, { "id": 1355, "q": "给定程序modi1.c中，函数fun的功能是：计算n!\n例如，给n输入5，则输出120.000000。\n请改正程序中的错误，使它能得出正确结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "第一处错误：if语句中缺少括号，运算符\"==\"之间无空格，所以此处的\"if n = = 0\"应修改为\"if (n==0)\"。\n第二处错误：C语言中每条语句都以\";\"结束，所提此处的\"result *= n--\"应修改为\"result *= n-- ;\"。\n本评析只作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1356, "q": "给定程序中，函数fun的功能是：在3×4的矩阵中找出在行上最大、在列上最小的那个元素，若没有符合条件的元素则输出相应信息。\n例如，有下列矩阵：\n1 2 13 4\n7 8 10 6\n3 5 9 7\n程序执行结果为：find:a[2][2]=9\n请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1357, "q": "以下选项中能表示合法常量的是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "整数：1，200", "实数：1.5E2.0", "字符斜杠：'\\'", "字符串：\"\\007\"" ], "explanation": "选项A整数中不能包含逗号；选项B科学计数法E后面的指数必须为整数；选项C单引号内的反斜杠必须与后续字符构成合法转义字符，不能单独存在；选项D\\007是合法的八进制转义字符表示的字符串。因此D正确。" }, { "id": 1358, "q": "t为int型,进入下面的循环之前， t的值为0\nwhile (t=1) { …… }\n则以下叙述中正确的是()", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "循环控制表达式的值为 0", "循环控制表达式的值为 1", "循环控制表达式不合法", "以上说法都不对" ], "explanation": "while循环的条件表达式为t=1，这是一个赋值表达式。在C语言中，赋值表达式的值等于被赋予的值，即1。由于表达式的值为非0（真），循环将无限执行。因此循环控制表达式的值为1。" }, { "id": 1359, "q": "以下程序段中的变量已正确定义，则输出结果是(　　)。\nfor(i=0；i<4;i++,i++)\nfor(k=l;k<3;k++)；\nprintf(\"*\")；", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "********", "****", "**", "*" ], "explanation": "外层for循环没有大括号，其循环体仅为内层for语句。内层for语句后紧跟分号，表示其循环体为空语句。因此，printf语句并不在任何循环体内，而是在两个循环都执行完毕后才执行一次，最终只输出一个星号。" }, { "id": 1360, "q": "设有两条语句\"int a，*p=&a；\"和\"*p=a；\"，则下列说法中正确的是()", "t": "single", "ans": "C", "kp": "指针", "o": [ "两条语句中的\"*P\"含义完全相同", "两条语句中的\"*p=&a\"和\"*p=a\"功能完全相同", "第1条语句中的\"*p=&a\"是定义指针变量p并对其初始化", "第2条语句中的\"*p=a\"是将a的值赋予变量p" ], "explanation": "第一条语句是定义整型变量a和指针变量p，并将a的地址赋给p进行初始化，此处的星号是指针声明符。第二条语句是赋值语句，将a的值赋给p所指向的内存单元，此处的星号是解引用运算符。两者含义和功能均不同。" }, { "id": 1361, "q": "给定程序中，函数fun的功能是：将形参n中，各位上为偶数的数取出，并按原来从高位到低位的顺序组成一个新的数，并作为函数值返回。\n例如，从主函数输入一个整数：27638496，函数返回值为：26846。\n请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本子函数fun中变量s的作用是存放每次循环后，舍去个位上的数之后的数，变量i的作用使得取得的偶数能正确地依次组合成一个数字，所以i的初值为1，这样才能使得找到的第一个偶数（从低位到高位）正确地放到个位上（x=x+t*i;），所以第一空应填1；\nwhile循环体的作用是找到偶数正确地组合成另一个数，所以while循环的条件应该被找那个数\"s\"各位上的数字是否判断结束，即s/10是否为0，当值不为0，则继续循环，若值为0，则结束循环，所以第二空应填\"s!=0\"或与其等效的形式；\n要使得第二个偶数放到十位上，则应使用i的值乘以10，由于i*10在循环体中，所以每一次循环i的值都在上次的基础上乘以10，这样就可使得第三个偶数正确地放到百位上，依此类推，故第三空应填i*10。\n本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1362, "q": "函数fun的功能是：将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是：将a数的十位和个位数依次放在c数的百位和个位上，b数的十位和个位数依次放在c数的十位和千位上。\n例如，当a=45,b=12。调用该函数后，c=2415。\n注意：部分源程序存在文件prog1.c中。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int a, int b, long *c)\n{\nint a_up,a_low,b_up,b_low;\na_up=a/10; /*求正整数a的十位数*/\na_low=a%10; /*求正整数a的个位数*/\nb_up=b/10; /*求正整数b的十位数*/\nb_low=b%10; /*求正整数b的个位数*/\n*c=b_low*1000+a_up*100+b_up*10+a_low; /*将a数的十位和个位数依次放在c数的百位和个位上，b数的十位和个位数依次放在c数的十位和千位上*/\n}", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1363, "q": "下列叙述中错误的是（　　）。", "t": "single", "ans": "B", "kp": "函数", "o": [ "C程序可以由多个程序文件组成", "一个C语言程序只能实现一种算法", "C程序可以由一个或多个函数组成", "一个C函数可以单独作为一个C程序文件存在" ], "explanation": "C程序可以由一个或多个函数组成，也可以分布在多个程序文件中，每个函数可单独作为一个文件存在。一个C语言程序可以实现多种算法，以完成复杂的任务，因此\"只能实现一种算法\"的说法是错误的。" }, { "id": 1364, "q": "程序的输出结果是()\nint a, b, c;\na=10; b=50; c=30;\nif (a>b) a=b;b=c,c=a;\nprintf(\"a=%d b=%d c=%d\\n\", a, b, c);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "a=10 b=30 c=10", "a=10 b=50 c=10", "a=50 b=30 c=50", "a=10 b=50 c=30" ], "explanation": "if语句后没有大括号，其控制范围仅限紧随其后的单条语句a=b。由于a>b不成立，该赋值不执行。随后的逗号表达式语句b=c,c=a不在if控制内，必定执行。执行后b变为30，c变为a的值10。最终a为10，b为30，c为10。" }, { "id": 1365, "q": "有以下程序段, 程序的运行结果是 ( ) 。\nint x=1,y=1,a=2,b=3;\nswitch(x)\n{ case 1:\nswitch(y)\n{ case 0: a++; break;\ncase 1: b++; break; }\ncase 2: a++; b++; break;\ncase 3: a++; b++; }\nprintf(\"a=%d,b=%d\\n\",a,b);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "a=3，b=5", "a=3,b=4", "a=4,b=5", "a=4,b=4" ], "explanation": "x为1进入外层case 1。y为1进入内层case 1，执行b加1后break跳出内层switch。由于外层case 1后无break，发生穿透，继续执行case 2的语句：a加1和b加1，然后break跳出外层switch。最终a为3，b为5。" }, { "id": 1366, "q": "以下程序，程序的结果是（　　）。\nmain(){\nint j,a=3,n=3;\nlong s=0,t=0;\nfor(j=0;j=1;i--) {\nfor(j=1;j<=2;j++)\nprintf(\"%d\",i+j);\nprintf(\"\\n \") ;}}", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "2 3 4\n3 4 5", "4 3 2\n5 4 3", "2 3\n3 4\n4 5", "4 5\n3 4\n2 3" ], "explanation": "外层循环i从3递减到1。当i为3时，内层j从1到2，输出i加j即4和5，然后换行；当i为2时，输出3和4并换行；当i为1时，输出2和3并换行。因此输出结果依次为45、34、23，对应选项D的序列。" }, { "id": 1369, "q": "有关函数说法，不正确的是（）", "t": "single", "ans": "A", "kp": "函数", "o": [ "函数可以嵌套定义", "函数可以被其它函数调用", "函数可以递归调用", "各个函数是平行定义的" ], "explanation": "C语言规定，函数可以嵌套调用，也可以递归调用，各个函数之间是平行定义的，不允许在一个函数内部嵌套定义另一个函数。因此\"函数可以嵌套定义\"的说法是错误的。" }, { "id": 1370, "q": "设有定义语句\"int x，*p=&x；\"，则下列表达式中错误的是()", "t": "single", "ans": "B", "kp": "指针", "o": [ "*&x", "&*x", "*&p", "&*p" ], "explanation": "p是指向x的指针。*&x等价于x，合法；*&p等价于p，合法；&*p等价于&(*p)即&x，合法。而x是普通整型变量，不是指针，不能对其进行解引用操作，因此*x非法，&*x也是错误的表达式。" }, { "id": 1371, "q": "关于“while(条件表达式)循环体”，以下叙述正确的是（）", "t": "single", "ans": "C", "kp": "循环结构", "o": [ "循环体的执行次数总是比条件表达式的执行次数多一次", "条件表达式的执行次数与循环体的执行次数一样", "条件表达式的执行次数总是比循环体的执行次数多一次", "条件表达式的执行次数与循环体的执行次数无关" ], "explanation": "在while循环中，每次执行循环体之前都必须先计算并判断条件表达式。当条件表达式首次为假或某次判断为假时，循环终止，此时条件表达式执行了，但循环体未执行。因此条件表达式的执行次数总是比循环体多一次。" }, { "id": 1372, "q": "以下选项中叙述错误的是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "在C程序的同一函数中，各复合语句内可以定义变量，其作用域仅限本复合语句内", "C程序函数中定义的赋有初值的静态变量，每调用一次函数，赋一次初值", "C程序函数中定义的自动变量，系统不自动赋确定的初值", "C程序函数的形参不可以说明为static型变量" ], "explanation": "静态局部变量在程序编译时分配内存并初始化，且只初始化一次。在函数多次调用期间，它会保留上一次调用结束时的值，不会每次调用都重新赋初值。因此选项中关于静态变量每次调用都赋初值的叙述是错误的。" }, { "id": 1373, "q": "下列描述正确的是（）", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ "在C语言程序中可以有多个main()函数", "在C程序中，可以不使用注释语句", "在C程序中，必需要使用注释语句", "输入函数scanf( )和输出函数print( )都是C语句" ], "explanation": "C程序只能有一个main函数，A错。注释不是必须的，B对C错。C语言中没有print函数，只有printf，且函数调用需加分号才是语句，D错。" }, { "id": 1374, "q": "设i,j,k均为int型变量，k初值为0，执行完下面的for循环后，k的值为（ ）。\nfor (i=0,j=10; i<=j; i++,j--) k=i+j;", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "10", "9", "8", "7" ], "explanation": "初始i=0, j=10，i<=j成立，k=0+10=10；i++,j--后i=1,j=9，i<=j成立，k=1+9=10；以此类推，每次循环i+j始终为10。当i=5,j=5时执行后i=6,j=4，循环结束。k最终值为10。" }, { "id": 1375, "q": "程序运行后输出结果是()\nint a = -1, b = 0;\nwhile (++a || b++) ;\nprintf(\"%d,%d\\n\", a, b );", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "0,1", "1,1", "1,0", "0,0" ], "explanation": "初始a=-1, b=0。第一次判断++a，a变为0，条件为假；由于是逻辑或，继续判断b++，b变为1（表达式值为0），条件为假，循环结束。此时a=0, b=1。输出0,1。" }, { "id": 1376, "q": "以下说法中正确的是( )", "t": "single", "ans": "C", "kp": "函数", "o": [ "形参是全局变量，其作用范围仅限于函数内部", "形参是全局变量，其作用范围从定义之处到文件结束。", "形参是局部变量，其作用范围仅限于函数内部", "形参是局部变量，其作用范围从定义之处到文件结束。" ], "explanation": "形参属于局部变量，其作用范围仅限于定义它的函数内部，函数调用结束后形参即被释放。A、B说形参是全局变量错误，D说作用范围到文件结束错误。" }, { "id": 1377, "q": "以下程序段的输出结果是( )\n#include\ninc()\n{static int x=3;\nx+=1;\nprintf(“%d,”,x);\n}\nmain()\n{ inc();\ninc(); }", "t": "single", "ans": "C", "kp": "函数", "o": [ "4,4", "3,3", "4,5", "3,4" ], "explanation": "inc函数中的x是静态局部变量，只初始化一次。第一次调用inc()，x变为4，输出4；第二次调用inc()，x保留上次的值4，加1变为5，输出5。因此结果为4,5。" }, { "id": 1378, "q": "给定程序modi1.c中函数fun的功能是：给一维数组a输入任意4个整数，并按下例的规律输出。例如输入1、2、3、4，程序运行后将输出以下方阵。\n4 1 2 3\n3 4 1 2\n2 3 4 1\n1 2 3 4\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "程序中的第一个错误：本题考的是用数组名作函数参数，此时实参与形参都应用数组名（或用数组指针），所以\"void fun(int a)\"应当改为\"fun(int a[4])\"或\"fun(int *a)\"等；\n程序中的第二个错误：数组名为a，a[j]=a[j+1]是将数组中下标为j的下一个值赋给a[j]，所以\"aa[j]=a[j-1];\"应当改为\"a[j]=a[j-1];\"。\n本评析仅供参考。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 1379, "q": "以下叙述中正确的是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "字符变量在定义时不能赋初值", "同一英文字母的大写和小写形式代表的是同一个字符常量", "字符常量可以参与任何整数运算", "转义字符用@符号开头" ], "explanation": "字符变量定义时可以赋初值，A错。大小写字母ASCII码不同，代表不同常量，B错。字符常量本质是整型（ASCII码），可参与整数运算，C对。转义字符用反斜杠开头，D错。" }, { "id": 1380, "q": "有以下程序，运行结果是（）。\nchar c1,c2;\nc1='A'+'9'-'2';\nc2='A'+'7'-'3';\nprintf( \"%c,%d\\n\",c1,c2);", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "H,69", "G,70", "H,70", "G,69" ], "explanation": "'A'的ASCII码为65，'9'为57，'2'为50。c1 = 65 + 57 - 50 = 72，对应字符'H'。'7'为55，'3'为51。c2 = 65 + 55 - 51 = 69。%c输出字符'H'，%d输出整数69。结果为H,69。" }, { "id": 1381, "q": "下列合法的整型常量是", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "0xEFG", "3.5", "'a'", "0123" ], "explanation": "A中十六进制包含G，非法；B是浮点型常量；C是字符常量；D以0开头，是合法的八进制整型常量，包含数字0-7，合法。" }, { "id": 1382, "q": "有以下程序\n#include \n#include \nmain()\n{\nint a=1, b=4, c=2;\ndouble x=10.5, y=4.0, z;\nz = ( a+b )/c + sqrt( y ) * 1.2 / c + x;\nprintf(\"%f\\n\", z);\n}\n程序运行后的输出结果是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "13.700000", "14.000000", "15.400000", "14.900000" ], "explanation": "(1+4)/2 = 5/2 = 2（整除）。sqrt(4.0)=2.0。2.0 * 1.2 / 2 = 1.2。z = 2 + 1.2 + 10.5 = 13.7。默认%f输出6位小数，即13.700000。" }, { "id": 1383, "q": "下列变量定义错误的是", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "int p=0.9;", "int a,b,double x,y;", "int _x=0;", "char printF='a';" ], "explanation": "C语言中一条声明语句只能定义一种类型的变量，不能在同一语句中用逗号分隔不同类型。B选项试图同时定义int和double类型，语法错误。A发生隐式转换，C标识符合法，D合法。" }, { "id": 1384, "q": "以下程序的运行结果是（　　）\nint a=21;\nint f(int c){\nstatic int a=5;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "40", "38", "39", "41" ], "explanation": "全局a=21。main中局部a=3。第一次调用f(3)：c=4，静态a=5，返回5+4=9，a变6。k=9。第二次调用f(3)：c=4，静态a=6，返回6+4=10，a变7。k=19。循环结束，k+=全局a(21)，k=40。" }, { "id": 1385, "q": "运行下面程序时，若从键盘输入数据为\"76\"，\n则输出结果是( )。\nmain( )\n{ int t;\nscanf(\"%d\",&t);\nif (t>=90) printf(\"A\\n\");\nelse if (t>=80) printf(\"B\\n\");\nelse if (t>=70) printf(\"C\\n\");\nelse if (t>=60) printf(\"D\\n\");\nelseprintf(\"E\\n\");\nprintf(\"OK\\n\");}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "C", "C OK", "C\nOK", "C\nD" ], "explanation": "输入76，满足t>=70，执行printf(\"C\\n\")，然后跳出if-else结构，执行最后的printf(\"OK\\n\")。因此输出C和OK。选项B和C内容重复，存在录入异常。" }, { "id": 1386, "q": "以下if语句语法正确的是（）", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "if (x>10) printf(\"%f\",x); else printf(\"%f\",-x);", "if \"x>10\" {x=x+y;printf(\"%f\",x);} else printf(\"%f\",-x);", "if(x>10) x=x+y;printf(\"%f\",x);else printf(\"%f\",-x);", "if(x>10){x=x+y;printf(\"%f\",x)};else printf(\"%f\",-x);" ], "explanation": "A选项语法正确。B选项if条件缺少圆括号；C选项if和else之间包含多条语句但未使用花括号括起，导致else无法正确匹配；D选项if语句块后的花括号外多了一个分号，使得else失去匹配的if。" }, { "id": 1387, "q": "C 语言的switch 语句中，case 后( )。", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "只能为常量", "只能为常量或常量表达式", "可为常量及表达式或有确定值的变量及表达式", "可为任何量或表达式" ], "explanation": "switch语句中，case标签后面必须跟常量或常量表达式，不能是变量或包含变量的表达式，以便在编译时确定分支地址。因此选B。" }, { "id": 1388, "q": "以下程序的结果是（）。\nint a=1,b=2,c=3;\nif(a>b)\nif(a>c) printf(\"%d\", a) ;\nelse printf(\"%d\", b) ;\nelse printf(\"%d\", c) ;", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "1", "2", "3", "以上答案都错误" ], "explanation": "C语言中else总是与最近的未匹配的if结合。本题中第一个if(a>b)条件为假，因此其控制的整个内部if-else语句块均不执行，直接执行与第一个if匹配的最外层else，输出c的值3。" }, { "id": 1389, "q": "以下程序的运行结果是（　　）。\nmain(){\nint k=3,n=0;\ndo{\nn++;\nif(n%3!=0) break;\nk--;\n}while(n=3，即p等于12345或n大于等于3。" }, { "id": 1391, "q": "运行时，若输入1 2 3 4 5 0，则输出结果是()\nint s;\nscanf(\"%d\",&s);\nwhile(s>0)\n{\nswitch(s)\n{\ncase 1:printf(\"%d\",s+5);\ncase 2:printf(\"%d\",s+4);break;\ncase 3:printf(\"%d\",s+3);\ndefault:printf(\"%d\",s+1);break;\n}\nscanf(\"%d\",&s);\n}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "66656", "6566456", "66666", "6666656" ], "explanation": "输入1时，匹配case 1输出6，无break穿透至case 2输出5并break；输入2时，匹配case 2输出6并break；输入3时，匹配case 3输出6，穿透至default输出4并break；输入4和5时，均无匹配，执行default分别输出5和6并break。输入0结束。总输出6566456。" }, { "id": 1392, "q": "以下正确的函数的形式是( ) 。", "t": "single", "ans": "B", "kp": "函数", "o": [ "double fun(int x,int y)\n{ z=x+y; return z; }", "fun(int x,int y)\n{ int z=9; return z; }", "fun(int x, int y);\n{ int x,y ; double z;\nz=x+y;return z:}", "double fun(int x,y)\n{ double z;\nz=x+y; return z:}" ], "explanation": "A选项变量z未定义；C选项函数头后多分号且return语句误用冒号；D选项形参y未声明类型且return误用冒号。B选项省略返回类型（旧标准默认为int），语法正确。" }, { "id": 1393, "q": "以下程序的输出结果是（ ）。\nint abc(int u,int v)\n{ int w;\nwhile(v)\n{ w=u%v;u=v;v=w;}\nreturn u;}\nmain()\n{ int a=24,b=16;\nc=abc(a,b）;\nprintf(\"%d\\n\",c）; }", "t": "single", "ans": "C", "kp": "函数", "o": [ "6", "7", "8", "9" ], "explanation": "函数abc使用辗转相除法求最大公约数。初始u=24,v=16；第一次循环w=8,u=16,v=8；第二次循环w=0,u=8,v=0；循环结束返回u的值8。" }, { "id": 1394, "q": "以下程序的输出结果是（）\n#include\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<3;i++)\nprintf(\"%d \",f(i));\n}\nint f(int a)\n{ int b=0; static int c=6;\nb++;c++;\nreturn(a+b+c++);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "8 11 14", "8 9 10", "8 11 13", "8 10 12" ], "explanation": "变量c为静态局部变量，只初始化一次。i=0时，b=1,c=7，返回0+1+7=8，c变为8；i=1时，b=1,c=9，返回1+1+9=11，c变为10；i=2时，b=1,c=11，返回2+1+11=14。输出8 11 14。" }, { "id": 1395, "q": "fgcd函数的功能是（）\nint fgcd(int m,int n)\n{ if(n==0)\nreturn m;\nelse\nfgcd(n,m%n);\n}", "t": "single", "ans": "B", "kp": "函数", "o": [ "求两个数的最小公倍数", "求两个数的最大公约数", "求两个数的和", "求两个数的差" ], "explanation": "函数通过递归调用fgcd(n, m%n)实现辗转相除法，其算法意图是求两个数的最大公约数。" }, { "id": 1396, "q": "以下错误的定义语句是（ ）。", "t": "single", "ans": "C", "kp": "数组", "o": [ "int x[][3]={{ 0 },{1},{1,2,3}};", "int x[4][3]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};", "int x[4][]={{1,2,3},{1,2,3},{1,2,3},{1,2,3}};", "int x[][3]={1,2,3,4};" ], "explanation": "定义二维数组时，可以省略第一维（行数）的大小，但第二维（列数）的大小绝对不能省略，因为编译器需要列数来计算元素的内存偏移地址。C选项省略了列数，因此是错误的定义。" }, { "id": 1397, "q": "以下能正确定义一维数组的选项是（　　）。", "t": "single", "ans": "C", "kp": "数组", "o": [ "char c[ ];", "char 5b[6];", "#define H 10\nint c[H];", "int x=100;\nint c[x];" ], "explanation": "A选项未指定大小且未初始化，非法；B选项数组名不能以数字开头；D选项使用变量定义数组大小属于C99特性，在传统C89标准考试中视为错误。C选项使用宏定义的常量作为数组大小，完全合法。" }, { "id": 1398, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={ {1,2},{3,4},{5,6} },i,j,s=0;\nfor(i=1;i<2;i++)\nfor(j=0;j<=2;j++)s+=a[i][j];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "7", "18", "8", "19" ], "explanation": "数组部分初始化时，未赋值元素自动为0。a[1]被初始化为{3,4,0}。外层循环i=1仅执行一次，内层循环j从0到2，累加a[1][0]、a[1][1]和a[1][2]，即3+4+0=7。" }, { "id": 1399, "q": "以下程序的运行结果是（　）。\nint *f(int *x,int *y)\n{ if(*x<*y) return x;\nelse return y; }\nmain()\n{ int a=7,b=8, *p, *q, *r;\np=&a; q=&b;\nr=f(p,q);\nprintf(\"%d,%d,%d\\n\",*p, *q, *r); }", "t": "single", "ans": "B", "kp": "指针", "o": [ "7,8,8", "7,8,7", "8,7,7", "8,7,8" ], "explanation": "函数f比较两个指针指向的值，返回较小值的指针。a=7，b=8，*p<*q成立，返回p赋给r。因此*p、*q、*r分别对应a、b、a的值，即7,8,7。" }, { "id": 1400, "q": "在宏定义#define PI 3.14159中，用宏名代替一个( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "常量", "单精度数", "双精度数", "字符串" ], "explanation": "宏定义在预处理阶段进行简单的文本替换，宏名PI代替的是一个字符串，而不是直接代替常量或特定精度的数值类型。" }, { "id": 1401, "q": "下面程序的运行结果是( )。\n#define ADD(x) x+x\nmain()\n{\nint m＝1,n＝2,k＝3;\nint sum＝ADD(m+n)*k;\nprintf(\"%d\",sum);\n}", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "9", "10", "12", "18" ], "explanation": "宏替换是纯文本替换，不自动加括号。ADD(m+n)*k展开为m+n+m+n*k。代入m=1,n=2,k=3，表达式为1+2+1+2*3，根据优先级先算乘法，结果为10。" }, { "id": 1402, "q": "给定程序中，函数fun的功能是：计算形参x所指数组中N个数的平均值（规定所有数均为正数），将所指数组中小于平均值的数据依次移至数组的前部，大于等于平均值的数据依次移至x所指数组的后部，平均值作为函数值返回，在主函数中输出平均值和移动后的数据。\n例如，有10个正数：41 17 34 0 19 24 28 8 12 14，平均值为：19.700000\n移动后的输出为：17 0 19 8 12 14 41 34 24 28\n请在程序的下划线处填入正确的内容并把下划线删除,使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1403, "q": "若有以下说明，则正确的赋值表达式是( )\nint x,*p;", "t": "single", "ans": "A", "kp": "指针", "o": [ "p=&x", "p=x", "*p=&x", "*p=*x" ], "explanation": "p是指针变量，x是整型变量。将整型变量x的地址赋给指针p，应使用取地址符&，即p=&x。其他选项存在类型不匹配或语法错误。" }, { "id": 1404, "q": "有以下程序， 已知字母A的ASCII码为65，程序运行后的输出结果是（　　）。\nchar c1,c2;\nc1='A'+'8'-'4';\nc2='A'+'8'-'5';\nprintf( \"%c,%d\\n\",c1,c2);", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "D,69", "E,68", "E,D", "输出无定值" ], "explanation": "字符参与运算时使用其ASCII码。'8'-'4'等于4，'A'+4为'E'；'8'-'5'等于3，'A'+3为'D'。'D'的ASCII码为68。按%c和%d格式输出，结果为E,68。" }, { "id": 1405, "q": "若有定义语句double x,y, *px, *py,执行了px=&x, py=&y;之后,正确的输入语句是（　）。", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "scanf（\"%f%f\",x,y）;", "scanf（\"%f%f\",&x,&y）;", "scanf（\"%lf%lf\",px,py）;", "scanf（\"%lf%lf\",x,y）;" ], "explanation": "double类型变量在scanf中需使用%lf格式控制符。px和py本身已是double型指针即地址，无需再加取地址符&，故正确语句为scanf(\"%lf%lf\",px,py);。" }, { "id": 1406, "q": "以下叙述中正确的是( )。", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "用C程序实现的算法必须要有输入和输出操作", "用C程序实现的算法可以没有输出但必须要输入", "用C程序实现的算法可以没有输入但必须要有输出", "用C程序实现的算法可以既没有输入也没有输出" ], "explanation": "算法的五个基本特征包括有穷性、确定性、可行性、输入和输出。其中，算法可以没有输入（零个或多个输入），但必须至少有一个输出。" }, { "id": 1407, "q": "以下程序的运行结果是（　　）。\nmain()\n{ char ch[3][5]={\"AAAA\",\"BBB\",\"CC\"};\nprintf(\"\\\"%s\\\"\\n\",ch[1]); }", "t": "single", "ans": "B", "kp": "字符串", "o": [ "\"AAAA\"", "BBB", "BBBCC", "CC" ], "explanation": "二维字符数组ch初始化后，ch[1]代表第二行字符串BBB。printf中的\\\"用于输出双引号字符，理论上应输出带双引号的BBB，选项B最符合题意但缺失引号。" }, { "id": 1408, "q": "有以下程序\nchar a,b,c,d;\nscanf(\"%c%c\",&a,&b);\nc=getchar();\nd=getchar();\nprintf(\"%c%c%c%c\\n\",a,b,c,d);\n按下列方式输入数据(注意：回车也是一个字符)，则输出结果是( )。\n12\n34", "t": "single", "ans": "C", "kp": "输入输出", "o": [ "1234", "12", "12\n3", "12\n34" ], "explanation": "scanf按%c读取不会跳过空白符。a读入1，b读入2；第一个getchar读入回车符，第二个读入3。输出时1、2后跟换行再输出3，选项C用空格示意了换行效果。" }, { "id": 1409, "q": "以下选项中合法的实型常量是", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "0", "3.13e-2.1", ".914", "2.0E" ], "explanation": "实型常量指数部分必须为整数，排除B、D；A选项0默认为整型常量；C选项.914省略了整数部分的0，是合法的实型常量，等价于0.914。" }, { "id": 1410, "q": "以下选项中合法的标识符有(　　)", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "_0_", "8_8", "void", "unsigned" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头，排除B；不能是关键字，排除C、D；_0_以下划线开头，完全符合标识符命名规则。" }, { "id": 1411, "q": "若有定义语句：int x=10;，则表达式x-=x+x的值为（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "-20", "-10", "0", "10" ], "explanation": "复合赋值运算符`-=`的优先级低于算术运算符`+`。先计算右侧表达式`x+x`，此时x为10，结果为20。然后执行`x = x - 20`，即`10 - 20`，最终结果为-10。" }, { "id": 1412, "q": "有以下程序：输出结果是（ ）。\n#include \nmain(){\nint x=1,y=0,a=2,b=0;\nswitch(x)\n{ case 1:\nswitch(y)\n{\ncase 0: a++; break;\ncase 1: b++; break;\n}\ncase 2 : a++; b++; break;\ncase 3: a++; b++;\n}\nprintf(\"a=%d,b=%d\\n\",a,b);\n}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "a=4,b=2", "a=2,b=1", "a=4,b=1", "a=3,b=0" ], "explanation": "外层`switch(x)`匹配`case 1`，进入内层`switch(y)`匹配`case 0`，执行`a++`（a变为3）后`break`跳出内层`switch`。由于外层`case 1`后无`break`，程序发生穿透，继续执行`case 2`中的`a++; b++;`（a变为4，b变为1），随后`break`跳出外层`switch`。最终输出a=4,b=1。" }, { "id": 1413, "q": "以下程序的运行结果是( )。\nint a=0,b=1,c=0,d=20,x;\nif (a) d=d-10;\nelse if (!b)\nif (!c) x=15;\nelse x=25;\nprintf(\"%d\\n\",d);", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "15", "25", "20", "10" ], "explanation": "首先判断`if(a)`，因a=0为假，进入`else if(!b)`。由于b=1，`!b`为0（假），因此其后的`if(!c)...else...`语句块均不执行。变量d在整个过程中未被重新赋值，保持初始值20。最终输出20。" }, { "id": 1414, "q": "若变量已正确定义，执行以下程序段的输出结果是 ( )。\nint a=4,b=6,c=7;\nfor(a=5;ab) a=b; c=a;\nif(c!=a) c=b;\nprintf(\"%d,%d,%d\\n\",a,b,c);", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "程序段有语法错", "6，6，6", "5，6，6", "6，6，7" ], "explanation": "题目代码存在排版遗漏，按正确逻辑应为`for(a=5;ab`（6>6为假），执行`c=a`使c=6。最后判断`c!=a`为假。最终a、b、c的值均为6，输出6,6,6。" }, { "id": 1415, "q": "以下程序的运行结果是( )\nmain()\n{ int i=5;\ndo{ if(i%3==1)\nif(i%5==2)\n{ printf(\"*%d\",i); break; }\ni++;\n} while(i!=0);\nprintf(\"\\n\");}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "*7", "*3*5", "*5", "*2*6" ], "explanation": "程序使用`do-while`循环，初始i=5。当i=5和6时，`i%3==1`不成立，i递增。当i=7时，`7%3==1`成立，且内层`7%5==2`也成立，执行打印`*7`并`break`跳出循环。因此最终输出结果为*7。" }, { "id": 1416, "q": "从循环体内某一层跳出，继续执行循环体外的语句是：（ ）。", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "break语句", "return语句", "continue语句", "空语句" ], "explanation": "`break`语句用于终止当前所在的循环或`switch`语句，跳出循环体并继续执行循环外的后续语句。`continue`是跳过本次循环剩余语句进入下一次循环，`return`是结束整个函数执行。" }, { "id": 1417, "q": "下列程序的输出结果是( )。\nint i, j, m=0, n=0;\nfor(i=0; i<2; i++)\nfor(j=0; j<2; j++)\nif (j>=i) {m=1; n++;}\nprintf(\"%d \\n\",n);", "t": "single", "ans": "D", "kp": "循环结构", "o": [ "0", "1", "2", "3" ], "explanation": "双重循环中i和j都取0、1。条件j>=i成立的情况有三次：i=0时j=0、1成立，i=1时j=1成立。if后面的复合语句包含n++，因此每次条件成立都会使n加1，最终n为3。" }, { "id": 1418, "q": "以下程序的运行结果是（　　）\nint f(int x) {\nint y;\nif(x==0||x==1) return (3);\ny=x-f(x-2);\nreturn y;\n}\nmain(){\nint z;\nz=f(4);\nprintf(\"%d\\n\",z);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "5", "0", "1", "4" ], "explanation": "本题考查递归函数调用。计算`f(4)`时，调用`f(2)`；计算`f(2)`时，调用`f(0)`。由于`f(0)`满足`x==0`，返回3。回溯计算：`f(2) = 2 - f(0) = 2 - 3 = -1`；`f(4) = 4 - f(2) = 4 - (-1) = 5`。最终输出5。" }, { "id": 1419, "q": "以下程序的运行结果是（　　）\nmain()\n{\nint a[5][4]={{1,3,5},{2,3,4},{3,5,7},{3,9,8,4},{7,1}};\nprintf(\"%d%d%d%d\\n\",a[0][1],a[1][1],a[2][1],a[4][1]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "3351", "3354", "3357", "3359" ], "explanation": "二维数组部分初始化时，未赋值的元素自动补0。第一行`a[0]`为{1,3,5,0}，`a[0][1]`为3；第二行`a[1]`为{2,3,4,0}，`a[1][1]`为3；第三行`a[2]`为{3,5,7,0}，`a[2][1]`为5；第五行`a[4]`为{7,1,0,0}，`a[4][1]`为1。按格式连续输出即为3351。" }, { "id": 1420, "q": "c语言中,一维数组的定义方式为：类型符 数组名[ ]", "t": "single", "ans": "B", "kp": "数组", "o": [ "[字符或整型常量]", "[常量]或[常量表达式]", "[整型常量]或[整型表达式]", "[字符常量]或[字符表达式]" ], "explanation": "在C语言中定义一维数组时，方括号内必须指定数组的长度，且该长度必须是整型常量或整型常量表达式（如宏定义、sizeof等），不能是变量或普通的整型表达式。选项B最符合传统C语言教材对数组长度定义的要求。" }, { "id": 1421, "q": "有以下程序,程序的运行结果是()\nint x=1, y=0, a=0, b=0;\nswitch ( x )\n{\ncase 1: switch(y)\n{\ncase 0: a++; break;\ncase 1: b++; break;\n}\ncase 2: a++; b++;\ncase 3: a++; b++; break;\n}\nprintf(\"a=%d, b=%d\\n\", a, b);", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "a=3, b=2", "a=2, b=2", "a=2, b=1", "a=3, b=3" ], "explanation": "外层`switch`匹配`case 1`，进入内层`switch`匹配`case 0`，执行`a++`（a=1）后`break`跳出内层。由于外层`case 1`和`case 2`后均无`break`，程序发生连续穿透，依次执行`case 2`的`a++;b++;`（a=2,b=1）和`case 3`的`a++;b++;`（a=3,b=2），最后`break`跳出。输出a=3, b=2。" }, { "id": 1422, "q": "以下程序的运行结果是（　　）。\n#define MUL(x,y) (x+2) *y\nmain( )\n{ int a=3，b=4，c；\nc=MUL(a,b);\nprintf(\"%d \\n\"，c）； }", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "22", "20", "25", "28" ], "explanation": "宏替换是简单的文本替换。将`MUL(a,b)`替换为`(a+2)*b`，代入变量值后表达式为`(3+2)*4`。先计算括号内的加法得到5，再与4相乘，最终结果为20。注意宏定义中若参数参与复杂运算需加括号，但本题直接代入不影响优先级。" }, { "id": 1423, "q": "以下选项中，不合法的C语言用户标识符是（　　）。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "AaBc", "a-b", "a_b", "_1" ], "explanation": "C语言标识符只能由字母、数字和下划线组成，且不能以数字开头。选项B中包含减号，属于非法字符，因此不合法。其他选项均符合标识符命名规则。" }, { "id": 1424, "q": "以下程序段的运行结果是（ ）\nvoid swap(int b[ ])\n{ int t;\nt=b[0];b[0]=b[1];b[1]=t;}\nmain( )\n{ int a[2]={7,8};\nswap(a);\nprintf(\"%d %d \",a[0],a[1]);}", "t": "single", "ans": "B", "kp": "数组", "o": [ "7 8", "8 7", "7 7", "8 8" ], "explanation": "C语言中数组名作为函数参数时，传递的是数组的首地址。在swap函数中对形参数组元素的修改，实际上直接修改了实参数组的内存空间。因此a[0]和a[1]的值被成功交换。" }, { "id": 1425, "q": "有如下程序段,执行该程序段后,a的值为()。\nint *p,a=10,b=1;\np=&a; a=*p+b;", "t": "single", "ans": "B", "kp": "指针", "o": [ "12", "11", "10", "编译出错" ], "explanation": "指针p指向变量a的地址，因此*p的值即为a的当前值10。执行赋值操作时，相当于a=10+1，计算结果为11并重新赋值给a。" }, { "id": 1426, "q": "下列说法不正确的是（　　）。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "宏替换不占用运行时间", "宏无类型", "宏替换只是字符替换", "宏名必须用大写字母表示" ], "explanation": "宏替换在预处理阶段进行，不占用运行时间，且宏名无类型，仅作简单的字符替换。虽然习惯上宏名常使用大写字母以便与变量名区分，但C语言语法并未强制要求，小写字母同样合法。" }, { "id": 1427, "q": "给定程序MODI1.C中，调用fun函数输出字符串，当奇数次调用时要求把字符串中的小写字母转换成大写字母，偶数次调用时按输入字符串的逆序输出字符串。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "(1)静态变量的定义标识符错，应为小写：static int n = 1;。\n(2)for循环是遍历所有字符，条件部分判断字符串没到结尾，使用下标i判断，i的最大值不是字符串的长度（或叫个数），因为下标值是从0开始的，所以i的最大值是字符串的长度减1。即条件应为i=0。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1428, "q": "以下程序的运行结果是（　　）\nmain()\n{char s[12]=\"1234223311\";\nint v[4]={0,0,0,0},k,i;\nfor(k=0;s[k];k++)\n{\nswitch(s[k])\n{\ncase '1':i=0;break;\ncase '2':i=1;break;\ncase '3':i=2;break;\ncase '4':i=3;break;\n}\nv[i]++;\n}\nfor(k=0;k<4;k++)\nprintf(\"%d\",v[k]);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "3331", "1111", "2222", "3332" ], "explanation": "程序遍历字符串，通过switch语句将字符1到4映射为索引0到3，并对数组v对应元素累加。字符串中包含3个1、3个2、3个3和1个4，因此v数组最终值为3,3,3,1，输出3331。" }, { "id": 1429, "q": "C语言中运算对象必须是整型的运算符是( )。", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "%=", "？", "=", "<=" ], "explanation": "取余运算符及其复合赋值形式要求其左右操作数必须均为整型数据。其他选项如条件运算符、赋值运算符和关系运算符均可用于浮点型等其他数据类型。" }, { "id": 1430, "q": "有以下程序\n#include \nmain()\n{ int a=0;b=0;\nb=20; /* 给b赋值 */\nprintf(\"a+b=%d\\n\",a+b); /* 输出计算结果 */\n}\n程序运行后的输出结果是", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "出错", "a+b=30", "a+b=20", "a+b=0" ], "explanation": "变量定义时必须明确指定类型。语句中b前面没有类型说明符，且不能用分号与a共享int类型，若共享应使用逗号。因此编译时会报语法错误。" }, { "id": 1431, "q": "以下程序的输出结果是( )\nmain(){\nint a=100,x,y,ok1=5,ok2=0;\nfor(x=10,y=20;xb) c=a;a=b;b=c;", "if(a>b) {c=a,a=b,b=c;}", "if(a>b) c=a,a=b,b=c;", "if(a>b) {c=a;a=b;b=c;}" ], "explanation": "选项A中if语句后没有大括号，只控制c=a这一条语句。由于条件不成立，c=a不执行，但后续的赋值会无条件执行，导致a和b改变。而其他选项通过大括号或逗号表达式将三条语句作为整体，条件不成立时均不执行。" }, { "id": 1436, "q": "一个能指向具有5个整型元素的一维数组指针的正确定义方式是()", "t": "single", "ans": "A", "kp": "指针", "o": [ "int (*p)[5]；", "int *p[5]；", "int (*p[5])；", "int *(p[5])；" ], "explanation": "A选项中，*p加括号表示p是一个指针，指向包含5个int型元素的数组，即数组指针。B选项是包含5个指针的指针数组。C和D选项在语法上等同于指针数组。因此正确定义数组指针的方式是A。" }, { "id": 1437, "q": "以下关于宏的叙述中正确的是( )。", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "宏定义必须位于源程序中所有语句之前。", "宏名必须用大写字母表示。", "宏调用比函数调用耗费时间。", "宏替换没有数据类型限制。" ], "explanation": "宏定义可以出现在程序的任何位置，只要在使用前即可；宏名习惯用大写但并非强制；宏替换在预处理阶段完成，不占用运行时间，比函数调用快；宏替换只是简单的文本替换，不进行类型检查，没有数据类型限制。" }, { "id": 1438, "q": "给定程序modi1.c中函数fun的功能是：判断一个整数是否是素数，若是返回1，否则返回0。\n在main()函数中，若fun返回1输出YES，若fun返回0输出NO!。\n请改正程序中的错误，使它能得出正确的结果。\n注意：不要改动main函数。不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "素数即只能被1及其本身整除的数。\nC语言中，分号是语句的组成部分，各语句间以分号作为分隔。源程序中\"k++\"语句是错误的，应改为\"k++;\"或相同作用的语句。\nC语言中，判断变量或表达式相等用\"==\"。源程序中\"if(m=k)\"语句是错误的，应改为\"if(m==k)\"或相同作用的语句。\n本评析仅作参考。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 1439, "q": "给定程序中，函数fun的功能是：找出N×N矩阵中每列元素中的最大值，并按顺序依次存放于形参b所指的一维数组中。\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 1440, "q": "已知字母A的ASCⅡ代码值为65，若变量kk为char型，以下不能正确判断出kk中的值为大写字母的表达式是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "kk>='A'&&kk<='Z'", "!(kk>='A'‖kk<='Z')", "(kk+32)>='a'&&(kk+32)<='z'", "isalpha(kk)&&(kk<91)" ], "explanation": "B选项中，由于'A'的ASCII码小于'Z'，任何字符都满足kk>='A'或kk<='Z'至少一个条件，括号内恒为真，取反后恒为假，无法正确判断大写字母。A、C、D选项均能通过范围或库函数正确判断大写字母。" }, { "id": 1441, "q": "以下叙述中正确的是( )", "t": "single", "ans": "B", "kp": "函数", "o": [ "只有全局变量才有自己的作用域，函数中的局部变量没有作用域", "只要是用户定义的标识符，都有一个有效的作用域", "只有在函数内部定义的变量才是局部变量", "局部变量不能被说明为static" ], "explanation": "局部变量也有作用域，即定义它的函数或复合语句内；用户定义的标识符都有其有效作用域；形参也是局部变量，不只在函数内部定义；局部变量可以被说明为static，成为静态局部变量。因此只有B选项叙述正确。" }, { "id": 1442, "q": "给定程序MODI1.C中函数fun的功能是：根据整型形参n，计算如下公式的值。\n例如，若n=10，则应输出：0.617977。\n请改正程序中的语法错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "综合编程/调试改错", "o": [], "rawType": "operation" }, { "id": 1443, "q": "给定程序中，函数fun的功能是：根据所给的一组学生的成绩，由公式：\n计算出标准差（Standard Deviation）σ并返回。公式中μ为平均成绩，N为学生人数，xi为学生成绩。\n例如，如有成绩为：50,60,70,80,90,100,55,65,75,85,95,99，则运行结果应为：16.527754\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在文件BLANK1.C中，不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅作参考。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 1444, "q": "以下程序执行后输出的结果是( )。\nmain(){ int a=5,b=4,c=3,d=2;\nif(a>b>c）\nprintf(\"%d\\n\",d）;\nelse if((c-1>=d）==1)\nprintf(\"%d\\n\",d+1);\nelse\nprintf(\"%d\\n\",d+2);}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "2", "3", "4", "编译时有错，无结果" ], "explanation": "条件a>b>c等价于(a>b)>c，即(5>4)>3，结果为1>3，为假(0)。进入else if，判断(c-1>=d)==1，即(3-1>=2)==1，2>=2为真(1)，1==1为真。执行printf输出d+1，即2+1=3。" }, { "id": 1445, "q": "以下程序输出的结果是( )\nmain()\n{ int a,b,k=6,m=4,*p1=&k,*p2=&m;\na=*p1/2;\nb=(-*p1)/(*p2)+7;\nprintf(\"%d,%d\\n\",a,b);\n｝", "t": "single", "ans": "B", "kp": "指针", "o": [ "3,7", "3,6", "2,6", "2,7" ], "explanation": "p1指向k(6)，p2指向m(4)。a=*p1/2即6/2=3。b=(-*p1)/(*p2)+7即(-6)/4+7。C语言中整数除法向零取整，-6/4结果为-1，因此b=-1+7=6。最终输出3,6。" }, { "id": 1446, "q": "以下选项中非法的C语言字符常量是( ).", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "'9'", "'\\09'", "'\\x09'", "'\\x9d'" ], "explanation": "A是普通字符常量。B中\\0开头表示八进制转义字符，但八进制数字只能是0-7，出现9是非法的。C和D中\\x开头表示十六进制转义字符，09和9d都是合法的十六进制数。因此B选项非法。" }, { "id": 1447, "q": "有关标识符的说法正确的是（）", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "C语言中用户定义的标识符必须以字母开头", "标识符中可以包含字母、数字和-", "不允许使用关键字作为标识符，但允许用户对预定义标识符重新定义，比如scanf、printf、sqrt等等这些库函数的名字", "if、else、for可以作为标识符使用" ], "explanation": "标识符可以以字母或下划线开头；只能包含字母、数字和下划线，不能包含连字符；关键字不能作为标识符，但预定义标识符（如库函数名）可以被用户重新定义；if、else、for是关键字，不能作为标识符。" }, { "id": 1448, "q": "以下程序运行后的输出结果是(小数点后只写一位) ( )。\ndouble d;\nfloat f;\nlong l;\nint i;\ni=f=l=d=20/3;\nprintf(\"%d %ld %f %lf \\n\", i,l,f,d）;", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "6 6 6.000000 6.0000000", "6 6 6.7 6.7", "6 6 6.0 6.7", "6 6 6.7 6.0" ], "explanation": "20/3是两个整数相除，结果为整数6。然后依次赋值给d、l、f、i，它们的值均为6。%f默认输出6位小数，%lf在printf中与%f等效，也输出6位小数。因此输出6 6 6.000000 6.000000。" }, { "id": 1449, "q": "若函数中有定义语句：int k；，则( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "系统将自动给k赋初值0", "这时k中值无定义", "系统将自动给k赋初值-1", "这时k中无任何值" ], "explanation": "在函数内部定义的局部变量，如果没有显式初始化，系统不会自动赋初值，其值是未定义的（即内存中的随机垃圾值）。只有全局变量或静态局部变量才会自动初始化为0。因此k中的值是无定义的。" }, { "id": 1450, "q": "以下程序的运行结果是（　　）\nint a=30;\nint f(int c){\nstatic int a=1;\nc=c+1;\nreturn (a++)+(c++);\n}\nmain(){\nint i,k=0;\nfor(i=0;i<2;i++) { int a=6; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "47", "46", "45", "48" ], "explanation": "第一次循环调用f(6)，静态a=1，c=7，返回1+7=8，a变2，k=8。第二次调用f(6)，静态a=2，c=7，返回2+7=9，a变3，k=17。循环结束后，k+=a中的a是全局变量30，k=17+30=47。" }, { "id": 1451, "q": "以下程序执行后输出的结果是 ( )。\nmain()\n{int i=1,j=1,k=2;\nif((j++||k++)&&i++) printf(\"%d,%d,%d\\n\",i,j,k);}", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "1,1,2", "2,2,1", "2,2,2", "2,2,3" ], "explanation": "逻辑或||具有短路特性。j++的值为1（真），因此k++不执行，k保持2，j变为2。接着计算&&右侧的i++，值为1（真），执行后i变为2。整个条件为真，输出i,j,k的值，即2,2,2。" }, { "id": 1452, "q": "下列循环的输出结果是( )。\nint n=9;\ndo\n{\nn--;\nprintf(\"%d\\n\",n);\n}while(n>7);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "8\n7", "9\n8", "9\n8\n7", "8\n7\n6" ], "explanation": "do-while循环先执行后判断。初始n=9，第一次执行n--后n为8，输出8，判断8>7成立；第二次执行n--后n为7，输出7，判断7>7不成立，退出循环。因此输出8和7。" }, { "id": 1453, "q": "以下叙述中不正确的是( ) 。", "t": "single", "ans": "D", "kp": "函数", "o": [ "在不同的函数中可以使用相同名字的变量", "函数中的形式参数是局部变量", "在一个函数内定义的变量只在本函数范围内有效", "在一个函数内的复合语句中定义的变量在本函数范围内有效" ], "explanation": "在C语言中，变量的作用域由其定义位置决定。在函数内的复合语句（即花括号内）中定义的变量，其作用域仅限于该复合语句内部，而不是在整个函数范围内有效。因此选项D叙述错误。" }, { "id": 1454, "q": "有以下程序\n#include \n#define SQR(X) X*X\nmain()\n{\nint a=10, k=2, m=1;\na /= SQR(k+m)/SQR(k+m);\nprintf(\"%d\\n\",a);\n}\n程序的输出结果是( )。", "t": "single", "ans": "B", "kp": "数据类型与表达式", "o": [ "0", "1", "2", "10" ], "explanation": "宏替换是纯文本替换，不自动添加括号。表达式展开为a /= k+m*k+m/k+m*k+m。代入k=2,m=1，根据优先级先算乘除：1*2=2，1/2=0，1*2=2。原式变为a /= 2+2+0+2+1，即a /= 7。10/7整除结果为1。" }, { "id": 1455, "q": "给定程序MODI1.C中，函数fun的功能是：找出n的所有因子，统计因子的个数，并判断n是否是\"完数\"。当一个数的因子之和恰好等于这个数本身时，就称这个数为\"完数\"。例如：6的因子包括1、2、3，而6=1+2+3，所以6是完数。如果是完数，函数返回值为1，否则函数返回值为0。数组a中存放的是找到的因子，变量k中存放的是因子的个数。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "第一处错误：fun函数中的for循环语句用来找出n的因子，并将其存放在数组a中，由于因子从整数1开始计算，所以\"for( i=0; i 6", "(3 != 4) > 2", "3 <= 4" ], "explanation": "关系表达式的结果为真（1）或假（0）。选项C中，3!=4成立，结果为1；接着计算1>2，显然不成立，结果为假（0）。其他选项的最终比较结果均为真（1）。" }, { "id": 1460, "q": "以下选项中不合法的标识符是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "print", "FOR", "&a", "_00" ], "explanation": "C语言规定标识符只能由字母、数字和下划线组成，且第一个字符必须是字母或下划线。选项C中包含特殊字符\"&\"，不符合标识符的命名规则，因此是不合法的标识符。" }, { "id": 1461, "q": "以下程序运行后的输出结果是( )。\nint y=3,x=3,z=1;\nprintf(\"%d %d\\n\",(++x,y++),z+2);", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "3 4", "4 2", "4 3", "3 3" ], "explanation": "printf的第一个参数是逗号表达式(++x,y++)，逗号表达式的值取最右侧表达式的值，即y++。由于是后缀自增，y++的值为自增前的值3。第二个参数是z+2，即1+2=3。因此输出3 3。" }, { "id": 1462, "q": "以下叙述中正确的是（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "字符变量在定义时不能赋初值", "同一英文字母的大写和小写形式代表的是同一个字符常量", "字符常量可以参与整数运算", "转义字符用@符号开头" ], "explanation": "字符常量在内存中以其ASCII码值（整数）形式存储，因此可以直接参与整数运算，选项C正确。字符变量定义时可以赋初值；大小写字母的ASCII码不同；转义字符以反斜杠\"\\\"开头。" }, { "id": 1463, "q": "以下程序的运行结果是（　　）\nint a=30;\nint f(int c){\nstatic int a=1;\nc=c+1;\nreturn (a++)+c;\n}\nmain(){\nint i,k=0;\nfor(i=0;i<1;i++) { int a=3; k+=f(a);}\nk+=a;\nprintf(\"%d\\n\",k);\n}", "t": "single", "ans": "A", "kp": "函数", "o": [ "35", "34", "44", "36" ], "explanation": "函数f中的a是静态局部变量，初值为1。调用f(3)时，c变为4，返回1+4=5，静态a自增为2。main中k累加5。循环结束后，k+=a中的a指全局变量a（值为30），故k=5+30=35。注意局部变量对全局变量的屏蔽规则。" }, { "id": 1464, "q": "若从键盘输入39,则以下程序的运行结果是（）。\nmain(){int a; scanf(\"%d\",&a);\nif(a>40) printf(\"%d\",a);\nif(a>35) printf(\"%d\",a);\nif(a>37) printf(\"%d\",a);}", "t": "single", "ans": "B", "kp": "选择结构", "o": [ "39", "3939", "393939", "39\n39" ], "explanation": "程序依次判断三个独立的if条件。输入a=39，不满足a>40；满足a>35，执行printf输出39；满足a>37，再次执行printf输出39。由于printf格式控制中没有空格或换行符，两次输出连在一起，最终结果为3939。" }, { "id": 1465, "q": "执行下面程序后，x的值为（）。\nint a=0,b=0,c=0,x=3;\nif (a) x=0;\nelse if (b)x=2;\nelse if (c) x=1;", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "0", "1", "2", "3" ], "explanation": "a、b、c初始值均为0，在C语言中0表示逻辑假。因此if(a)、else if(b)、else if(c)的条件判断结果均为假，不会执行其后的任何赋值语句。变量x保持初始值3不变。" }, { "id": 1466, "q": "为了避免嵌套的if-else语句的二义性，C语言规定else总是与( )组成配对关系。", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "缩排位置相同的if", "在其之前未配对的if", "同一行上的if", "在其之前未配对的最近的if" ], "explanation": "C语言语法明确规定，在嵌套的if-else结构中，else总是与它前面最近的、且尚未与其他else配对的if语句结合。这一规则消除了代码结构上的二义性，与代码的缩进或换行格式无关。" }, { "id": 1467, "q": "有如下程序段，该程序的输出结果是 ( )。\nint x=1,a=2,b=3;\nswitch(x){\ncase 0: b++;\ncase 1: a++; break;\ncase 2: a++;b++; }\nprintf(\"a=%d,b=%d\\n\",a,b);", "t": "single", "ans": "D", "kp": "选择结构", "o": [ "a=2,b=1", "a=2,b=3", "a=3,b=4", "a=3,b=3" ], "explanation": "变量x为1，匹配switch中的case 1分支。执行a++后a变为3，随后遇到break语句直接跳出switch结构。case 0和case 2均未执行，b保持初始值3。最终输出a=3,b=3。" }, { "id": 1468, "q": "设变量a,b,c,d和y都是已正确定义并赋值。若有以下语句：\nif(a20) break;\n}while(a=14);", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "12 12\n16 28", "12 12\n14 16", "12 12\n14 26", "12 12\n16 20" ], "explanation": "第一次循环：a=12, y=12，输出12 12，y不大于20。判断while(a=14)，赋值表达式结果为14即真，a被重置为14。第二次循环：a=16, y=28，输出16 28，此时y>20触发break跳出循环。" }, { "id": 1470, "q": "以下程序，程序的结果是（　　）。\nmain(){ int i,m=0;\nfor(i=2;i<=10;i+=5)\n{m++;i++;}\nprintf(\"%d,%d\",i,m);}", "t": "single", "ans": "B", "kp": "循环结构", "o": [ "2,14", "14,2", "2,10", "10,2" ], "explanation": "初始i=2,m=0。第一次循环：i<=10成立，m变1，i++后i=3，步长i+=5后i=8。第二次循环：i<=10成立，m变2，i++后i=9，步长i+=5后i=14。第三次判断i<=10不成立退出。输出14,2。" }, { "id": 1471, "q": "有以下程序运行后的输出结果是( )\nmain()\n{int a=4,b=3,c=5,d=2;\ndo{printf(\"%d\",d+1);}while(a6)\nprintf(\"%d\",n--);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "987", "876", "8765", "9876" ], "explanation": "初始n=9。第一次判断9>6成立，输出9，n自减为8。第二次判断8>6成立，输出8，n自减为7。第三次判断7>6成立，输出7，n自减为6。第四次判断6>6不成立，退出循环。连续输出987。" }, { "id": 1475, "q": "采用单步调试时，在函数调用时按F10键，则（）", "t": "single", "ans": "B", "kp": "综合编程/调试改错", "o": [ "跟踪进入函数内部", "调试系统将函数作为一条语句执行", "在函数调用处停留", "程序无法单步调试" ], "explanation": "在多数集成开发环境的单步调试中，F10键（Step Over）用于单步执行，遇到函数调用时将其视为一条普通语句直接执行完毕，不进入函数内部；而F11键（Step Into）才会跟踪进入函数内部调试。" }, { "id": 1476, "q": "局部变量前面加上static后，下列说法正确的是（）", "t": "single", "ans": "D", "kp": "数据类型与表达式", "o": [ "缩小了作用域", "仍然存放在动态存储区", "增加了作用域", "生存期得以延长" ], "explanation": "局部变量加上static修饰后变为静态局部变量。其作用域仍局限于定义它的函数内，但存储方式由动态存储区改为静态存储区，生存期延长至整个程序运行期间，且只在首次调用时初始化一次。" }, { "id": 1477, "q": "以下程序的输出结果是（）\n#include\nint f(int a);\nmain()\n{ int i;\nfor(i=0;i<3;i++)\nprintf(\"%d \",f(i));\n}\nint f(int a)\n{ int b=0; static int c=6;\nb++;c++;\nreturn(a+b+c);}", "t": "single", "ans": "A", "kp": "函数", "o": [ "8 10 12", "8 10", "7 9", "7 9 11" ], "explanation": "静态变量c在函数调用间保持值，每次调用c自增。局部变量b每次调用重新初始化为0后自增为1。第一次调用a=0,b=1,c=7返回8；第二次a=1,b=1,c=8返回10；第三次a=2,b=1,c=9返回12。" }, { "id": 1478, "q": "以下程序的执行过程中fun（）函数共调用了（）次 。\nlong fun( int n)\n{ long s;\nif(n==1 || n==2) s=2;\nelse s=n-fun(n-2);\nreturn s; }\nmain()\n{ printf(\"%l\\n\", fun(6)); }", "t": "single", "ans": "C", "kp": "函数", "o": [ "1", "2", "3", "4" ], "explanation": "main函数调用fun(6)为第1次；fun(6)中n不等于1或2，执行else分支调用fun(4)为第2次；fun(4)同理调用fun(2)为第3次；fun(2)满足条件直接返回，不再递归。因此共调用3次。" }, { "id": 1479, "q": "以下程序的输出结果是（ ）。\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=10-i;\nprintf(\"%d%d%d\",a[2],a[5],a[8]);}", "t": "single", "ans": "C", "kp": "数组", "o": [ "258", "741", "852", "369" ], "explanation": "循环逆序给数组赋值，a[i]的值为10-i。当i=2时，a[2]=10-2=8；当i=5时，a[5]=10-5=5；当i=8时，a[8]=10-8=2。最后按顺序输出a[2]、a[5]和a[8]的值，即852。" }, { "id": 1480, "q": "以下能正确定义二维数组的选项是（　　）。", "t": "single", "ans": "C", "kp": "数组", "o": [ "char c[ ][ ];", "char 5b[3][3];", "int b5[3][3];", "int int[3][3] ;" ], "explanation": "定义二维数组时，第一维长度可省略但第二维不可省，A错；标识符不能以数字开头，B错；不能使用关键字作为变量名，D错。C选项语法正确，标识符合法且指定了二维大小。" }, { "id": 1481, "q": "以下程序的运行结果是（　　）\nmain()\n{ int i, a[10];\nfor(i=9;i>=0;i--) a[i]=9-i;\nprintf(\"%d%d%d\",a[2],a[6],a[8]);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "731", "842", "137", "248" ], "explanation": "循环逆序赋值，a[i]的值为9-i。计算指定下标的元素值：当i=2时，a[2]=9-2=7；当i=6时，a[6]=9-6=3；当i=8时，a[8]=9-8=1。printf依次输出a[2]、a[6]、a[8]，结果为731。" }, { "id": 1482, "q": "以下程序的运行结果是（　　）\nmain()\n{ int a[3][3]={{1,2,9},{3,4,8},{5,6,7}},i,s=0;\nfor(i=0;i<3;i++) s+=a[i][0]+a[0][2-i];\nprintf(\"%d\\n\",s);\n}", "t": "single", "ans": "A", "kp": "数组", "o": [ "21", "22", "20", "23" ], "explanation": "循环计算第一列元素与第一行逆序元素之和。i=0时，累加a[0][0]和a[0][2]即1+9=10；i=1时，累加a[1][0]和a[0][1]即3+2=5；i=2时，累加a[2][0]和a[0][0]即5+1=6。总和s=10+5+6=21。" }, { "id": 1483, "q": "以下程序的运行结果是（　　）\nmain()\n{\nchar s[]=\"abcdef\";\nstrcpy(s,\"abcdefg\");\ns[5]='\\0';\nprintf(\"%s\\n\",s);\n}", "t": "single", "ans": "A", "kp": "字符串", "o": [ "abcde", "abc", "abcd", "abcdef" ], "explanation": "字符数组s初始包含abcdef及结束符。strcpy将abcdefg覆盖到s中。随后将s[5]赋值为'\\0'，即在索引5处截断字符串。索引0到4的字符为a到e，因此输出abcde。" }, { "id": 1484, "q": "int a=2,b=7,c=5;\nswitch(a>0)\n{\ncase 1:switch(b>0)\n{\ncase 1: printf(\"@\");\ncase 0: printf(\"!\");\n}\ncase 0:switch(c==5)\n{\ncase 0: printf(\"*\");\ncase 1: printf(\"#\");\ndefault: printf(\"%%\");\n}\ndefault: printf(\"&\");\n}", "t": "single", "ans": "A", "kp": "选择结构", "o": [ "@!#%&", "!#&", "@*&", "%%" ], "explanation": "外层a>0为1，进入case 1。内层b>0为1，输出@，无break继续输出!。外层无break穿透到case 0。内层c==5为1，跳过case 0，执行case 1输出#，无break继续执行default输出%。外层继续穿透到default输出&。最终结果为@!#%&。" }, { "id": 1485, "q": "以下程序段的运行结果是（　　）。\n{ int a[]={1,2,3,4,5,6,7,8,9,10,11,12},*p;\np=&a[3];\np++;\nprintf(\"%d,\",(*p++,*++p));\nprintf(\"%d\",*++p);\n}", "t": "single", "ans": "D", "kp": "指针", "o": [ "7,9", "5,6", "6,7", "7,8" ], "explanation": "p初始指向a[3]，p++后指向a[4]。逗号表达式(*p++,*++p)从左向右计算：先执行*p++，p指向a[5]；再执行*++p，p指向a[6]并取值7，故第一处输出7。接着计算*++p，p指向a[7]并取值8，故第二处输出8。" }, { "id": 1486, "q": "以下程序的运行结果是（ ）。\nvoid swap(char *x,char *y)\n{ char t;\nt=*x; *x=*y; *y=t; }\nmain()\n{ char a[5]=\"abc\", b[5]=\"123\",*s1=a,*s2=b;\nswap(s1,s2);\nprintf(\"%s,%s\",s1,s2);}", "t": "single", "ans": "C", "kp": "指针", "o": [ "123,abc", "abc,123", "1bc,a23", "321,cba" ], "explanation": "s1和s2分别指向数组a和b的首地址。swap函数通过指针交换了它们所指向的第一个字符，即a[0]和b[0]互换。a由abc变为1bc，b由123变为a23。最后按字符串格式输出，结果为1bc,a23。" }, { "id": 1487, "q": "设有以下定义：\n#define N 3\n则执行语句z=3* N;后，z的值为（　　）。", "t": "single", "ans": "C", "kp": "数据类型与表达式", "o": [ "出错", "12", "9", "14" ], "explanation": "宏定义N的值为3。在预处理阶段，语句中的N被直接替换为3，因此原语句等价于z=3*3。计算乘法得到z的值为9。" }, { "id": 1488, "q": "以下程序的运行结果是（　　）。\n#define MUL(x,y) (x) *y\nmain( )\n{ int a=3，b=4，c；\nc=MUL(a++,b++);\nprintf(\"%d \\n\"，c)； }", "t": "single", "ans": "A", "kp": "数据类型与表达式", "o": [ "12", "15", "20", "16" ], "explanation": "宏替换后语句为c=(a++)*b++。计算时先取a和b的当前值进行乘法运算，即3*4=12，赋值给c。随后a和b各自自增。因此c的值为12，输出12。" }, { "id": 1489, "q": "给定程序MODI1.C中，函数fun的功能是：对于长整数n中的各个位置上的数值，分别统计出为0和为1的个数，并传递回主函数输出。\n例如，若n的值为120311，即为0的个数是1；为1的个数是3，则应输出：c0=1,c1=3。\n请改正函数fun中指定部位的错误，使它能得出正确的结果。\n注意：不要改动main函数，不得增行或删行，也不得更改程序的结构。", "t": "fill", "ans": "(1)从题意可以看出c0、c1存放的是0和1的个数，故初始值应为0。所以此处应该修改为\"*c0=*c1=0;\"。\n(2)将一个整型数的各个位分解出来。方法是将所求位变换到个位上，然后与10求余，即%10。变换到个位上是利用了整型数相除无小数的原理。本空是求个位上的数存入变量k中，求个位上的数使用的是%10，所以此处应该修改为\"k= n%10;\"。\n(3)将n的值缩小10倍，也就是将n的十位变到个位上，需要除以10，所以此处应该修改为\"n=n/10;\"。", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 1490, "q": "给定程序中，函数fun的功能是：计算形参x所指数组中N个数的平均值（规定所有数均为正数），将所指数组中大于平均值的数据移至数组的前部，小于等于平均值的数据移至x所指数组的后部，平均值作为函数值返回，在主函数中输出平均值和移动后的数据。\n例如，有10个正数：46 30 32 40 6 17 45 15 48 26，平均值为：30.500000\n移动后的输出为：46 32 40 45 48 30 6 17 15 26\n请在程序的下划线处填入正确的内容并把下划线删除，使程序得出正确的结果。\n注意：源程序存放在考生文件夹下的BLANK1.C中。\n不得增行或删行，也不得更改程序的结构！", "t": "fill", "ans": "本评析仅供参考。", "kp": "数组", "o": [], "rawType": "operation" }, { "id": 1491, "q": "函数fun的功能是：将两个两位数的正整数a、b合并形成一个整数放在c中。合并的方式是：将a数的十位和个位数依次放在c数的个位和百位上，b数的十位和个位数依次放在c数的千位和十位上。\n例如，当a=45，b=12时，调用该函数后，c=1524。\n注意：部分源程序存在文件PROG1.C中。数据文件IN.DAT中的数据不得修改。\n请勿改动主函数main和其它函数中的任何内容，仅在函数fun的花括号中填入你编写的若干语句。", "t": "fill", "ans": "void fun(int a, int b, long *c)\n{\n*c=b/10*1000+a%10*100+b%10*10+a/10;/*a数的十位和个位数放在c数的个位和百位上，b数的十位和个位数放在c数的千位和十位上*/\n}", "kp": "排序查找与简单算法", "o": [], "rawType": "operation" }, { "id": 1492, "q": "已知字符a的ASCll十进制代码为97，则以下程序运行后的输出结果是( )。\nchar ch;\nint k;\nch='a';\nk=12;\nprintf(\"%c,%d,\",ch,ch,k);\nprintf(\"k=%d\\n\",k);", "t": "single", "ans": "D", "kp": "输入输出", "o": [ "因变量类型与格式描述符的类型不匹配输出无定值", "输出项与格式描述符个数不符，输出为零值或不定值", "a,97,12k=12", "a,97,k=12" ], "explanation": "第一个printf中有3个输出项但只有2个格式控制符，C语言中多余的输出项会被忽略，因此输出'a,97,'。第二个printf正常输出'k=12'。拼接后结果为'a,97,k=12'。" }, { "id": 1493, "q": "以下程序的输出结果是( )。\nmain( )\n{ int a=-1,b=1,k;\nif((++a<0)&&!(b--<=0))\nprintf(\"%d %d\\n\",a,b);\nelse\nprintf(\"%d %d\\n\",b,a);}", "t": "single", "ans": "C", "kp": "选择结构", "o": [ "-1 1", "0 1", "1 0", "0 0" ], "explanation": "初始a=-1，b=1。判断条件时先计算++a，a变为0，++a<0为假。由于逻辑与(&&)的短路特性，右侧表达式不执行，b保持为1。条件为假执行else分支，输出b和a的值，即1和0。" }, { "id": 1494, "q": "以下程序的输出结果是( )。\nmain(){\nint a=5,b=4,c=3,d=2;\ndo{\nprintf(\"%d \",d); }while(a>b>c);\nprintf(\"%d\",d+1);\n}", "t": "single", "ans": "A", "kp": "循环结构", "o": [ "2 3", "2 2", "2", "无结果" ], "explanation": "do-while循环先执行一次循环体，输出d的值2和空格。接着判断条件a>b>c，关系运算符左结合，先算5>4得1，再算1>3得0(假)，循环结束。最后执行循环外的语句输出d+1即3。最终输出'2 3'。" }, { "id": 1495, "q": "下列程序的运行结果是( )。\nmain()\n{\nint a=2,c=5;\nfor(;a