[{"data":1,"prerenderedAt":6864},["ShallowReactive",2],{"content:\u002F2026\u002Fcpp-oop-final-review":3,"surround:\u002F2026\u002Fcpp-oop-final-review":6853},{"id":4,"title":5,"body":6,"categories":6825,"date":6827,"description":6828,"draft":6829,"extension":6830,"image":6831,"meta":6832,"navigation":6834,"path":6835,"permalink":6835,"published":6836,"readingTime":6837,"recommend":6836,"references":6836,"seo":6842,"sitemap":6843,"stem":6844,"tags":6845,"type":6850,"updated":6851,"__hash__":6852},"content\u002Fposts\u002F2026\u002FC++面向对象期末复习资料.md","2026 | C++ 面向对象期末复习资料",{"type":7,"value":8,"toc":6648},"minimark",[9,13,18,29,33,38,45,48,56,59,65,79,85,88,94,100,103,106,153,160,165,168,174,177,183,186,192,198,201,207,212,218,221,229,236,242,248,255,260,262,268,270,276,279,285,287,293,299,302,316,323,326,328,334,337,343,349,356,362,373,379,385,388,399,403,406,409,415,423,429,435,438,444,449,455,466,477,483,491,498,504,511,513,519,525,531,533,539,552,558,561,567,570,576,584,589,591,597,599,605,608,614,620,628,631,637,642,646,649,655,658,664,667,673,676,746,749,755,758,764,766,772,779,785,787,793,795,801,804,810,813,819,822,828,835,840,842,848,850,856,863,869,871,877,879,885,889,893,896,898,904,906,912,915,925,928,934,937,943,945,951,955,958,960,966,968,974,977,983,985,991,993,1012,1014,1020,1024,1027,1029,1035,1037,1043,1045,1051,1053,1059,1062,1068,1071,1077,1091,1093,1099,1101,1107,1111,1114,1120,1122,1128,1130,1136,1138,1144,1147,1153,1156,1159,1161,1167,1170,1176,1179,1190,1192,1198,1201,1207,1213,1219,1221,1235,1238,1240,1246,1250,1253,1255,1261,1263,1269,1271,1277,1280,1283,1286,1292,1294,1300,1306,1309,1315,1318,1324,1326,1332,1336,1339,1341,1347,1349,1355,1357,1363,1366,1377,1380,1383,1389,1392,1395,1398,1404,1406,1412,1416,1420,1423,1425,1431,1434,1460,1463,1469,1482,1485,1488,1494,1498,1501,1504,1510,1513,1519,1522,1528,1531,1542,1544,1550,1561,1564,1570,1629,1632,1638,1643,1646,1652,1656,1659,1665,1668,1674,1688,1693,1696,1699,1705,1714,1722,1727,1729,1735,1741,1747,1754,1759,1768,1774,1777,1783,1785,1791,1795,1798,1801,1807,1809,1815,1818,1824,1827,1849,1851,1857,1860,1866,1869,1872,1878,1881,1887,1890,1896,1899,1905,1914,1916,1922,1926,1929,1931,1937,1939,1945,1948,1954,1957,1960,1963,1976,1978,1984,1987,1993,2007,2009,2015,2019,2022,2024,2030,2033,2039,2042,2050,2054,2057,2059,2065,2067,2073,2076,2080,2086,2093,2097,2103,2112,2115,2121,2124,2128,2134,2137,2143,2153,2155,2161,2165,2168,2170,2176,2178,2184,2187,2207,2210,2216,2219,2225,2235,2237,2243,2247,2250,2252,2258,2268,2271,2277,2279,2285,2288,2294,2304,2307,2313,2316,2322,2324,2330,2334,2337,2339,2345,2347,2353,2356,2359,2365,2368,2374,2377,2383,2386,2396,2404,2407,2413,2416,2422,2424,2430,2437,2442,2444,2450,2459,2462,2473,2475,2481,2485,2489,2492,2495,2515,2517,2523,2526,2528,2534,2538,2541,2543,2549,2559,2562,2568,2572,2575,2578,2584,2593,2596,2602,2609,2611,2617,2621,2624,2626,2632,2635,2642,2648,2654,2657,2663,2666,2669,2675,2681,2687,2690,2693,2706,2710,2713,2715,2721,2723,2729,2732,2738,2741,2744,2750,2753,2759,2762,2768,2773,2779,2789,2793,2796,2799,2805,2808,2814,2816,2842,2845,2848,2851,2857,2860,2866,2869,2873,2876,2878,2884,2894,2896,2902,2905,2911,2914,2925,2929,2932,2934,2940,2942,2948,2951,2954,2960,2963,2972,2976,2979,2981,2987,2992,2998,3001,3007,3013,3019,3024,3030,3035,3037,3043,3047,3052,3054,3060,3063,3065,3071,3074,3079,3083,3086,3092,3094,3100,3102,3110,3113,3119,3122,3128,3131,3137,3140,3142,3148,3152,3155,3158,3164,3166,3171,3177,3182,3188,3193,3199,3203,3208,3214,3217,3220,3226,3229,3235,3238,3244,3247,3253,3256,3258,3264,3268,3272,3275,3277,3283,3286,3289,3295,3298,3300,3306,3310,3313,3315,3321,3323,3329,3334,3337,3343,3346,3352,3359,3361,3369,3372,3378,3382,3385,3391,3399,3402,3408,3416,3419,3422,3428,3430,3436,3440,3443,3445,3451,3453,3459,3462,3468,3471,3477,3479,3485,3489,3492,3495,3501,3504,3510,3513,3519,3522,3528,3530,3536,3539,3547,3555,3558,3564,3566,3572,3575,3581,3584,3590,3593,3631,3633,3639,3642,3648,3656,3658,3664,3671,3676,3679,3685,3687,3693,3695,3701,3707,3710,3716,3719,3721,3727,3729,3747,3750,3754,3757,3760,3766,3773,3776,3782,3785,3791,3794,3807,3811,3814,3816,3822,3825,3831,3834,3845,3848,3855,3860,3862,3868,3870,3876,3879,3885,3888,3894,3897,3903,3906,3912,3915,3921,3924,3930,3940,3944,3948,3951,3953,3959,3961,3967,3977,3983,3986,3997,4000,4006,4009,4013,4016,4022,4025,4097,4100,4106,4108,4126,4130,4133,4135,4141,4144,4155,4158,4164,4167,4173,4176,4180,4183,4189,4204,4207,4213,4223,4225,4231,4235,4238,4240,4246,4248,4254,4256,4262,4265,4271,4279,4283,4286,4292,4294,4300,4306,4309,4315,4317,4323,4327,4330,4332,4338,4347,4349,4355,4358,4364,4367,4373,4377,4380,4382,4388,4390,4396,4399,4405,4408,4414,4416,4422,4429,4434,4436,4442,4444,4452,4454,4460,4463,4469,4473,4476,4479,4485,4494,4500,4503,4509,4517,4520,4528,4530,4536,4539,4541,4547,4551,4555,4558,4561,4575,4578,4617,4619,4625,4629,4632,4634,4640,4642,4648,4650,4656,4658,4664,4667,4701,4703,4709,4713,4716,4722,4725,4731,4734,4776,4791,4798,4801,4807,4810,4816,4818,4824,4830,4833,4836,4839,4842,4851,4854,4860,4862,4868,4871,4877,4879,4885,4888,4891,4897,4900,4907,4912,4915,4920,4923,4930,4933,4935,4941,4943,4949,4952,4968,4970,4973,4979,4985,4996,5000,5003,5009,5011,5017,5019,5022,5025,5027,5033,5037,5040,5046,5053,5055,5061,5066,5069,5075,5088,5093,5099,5102,5107,5113,5116,5122,5127,5133,5136,5142,5149,5153,5159,5161,5167,5170,5176,5179,5185,5188,5201,5204,5210,5215,5217,5235,5237,5243,5247,5250,5252,5258,5260,5266,5279,5281,5294,5298,5301,5307,5309,5315,5318,5321,5327,5330,5336,5339,5345,5348,5354,5356,5362,5366,5370,5373,5375,5381,5383,5389,5391,5397,5405,5411,5414,5416,5423,5425,5431,5435,5438,5440,5446,5448,5454,5461,5464,5468,5471,5473,5479,5481,5487,5489,5495,5497,5511,5515,5518,5521,5527,5530,5536,5539,5545,5547,5553,5555,5561,5564,5570,5576,5579,5585,5591,5595,5598,5600,5606,5608,5614,5616,5626,5628,5636,5638,5644,5646,5652,5656,5659,5662,5670,5673,5679,5682,5688,5691,5697,5700,5704,5707,5709,5715,5718,5750,5757,5763,5767,5770,5772,5778,5780,5797,5800,5806,5809,5812,5816,5820,5823,5826,5872,5874,5880,5896,5900,5903,5906,5922,5925,5947,5950,5956,5959,5963,5966,5968,5974,5977,5983,5986,5992,5995,5999,6002,6004,6010,6017,6019,6025,6028,6034,6038,6042,6044,6049,6051,6102,6107,6112,6116,6118,6124,6127,6133,6136,6142,6145,6151,6155,6158,6164,6167,6173,6176,6182,6186,6189,6191,6197,6199,6205,6207,6213,6215,6223,6227,6231,6234,6237,6251,6254,6257,6263,6266,6272,6279,6281,6287,6289,6295,6298,6304,6311,6317,6326,6332,6338,6340,6346,6350,6353,6356,6359,6361,6367,6377,6380,6384,6387,6393,6396,6410,6413,6417,6421,6424,6430,6433,6439,6442,6448,6452,6455,6461,6464,6470,6473,6479,6483,6486,6499,6502,6508,6516,6520,6523,6529,6532,6536,6544,6550,6556,6562,6565,6571,6577,6580,6586,6591,6594,6601,6607,6613,6621,6627,6632,6638,6642],[10,11,12],"p",{},"想着把 C++ 的内容重新整理一遍。文章里没有介绍入门语法，主要讲解了构造析构、复制控制、继承访问、多态、模板等内容。",[14,15,17],"h2",{"id":16},"_0-总知识点大纲","0. 总知识点大纲",[19,20,26],"pre",{"className":21,"code":23,"language":24,"meta":25},[22],"language-text","C++ 基础差异\n-> 函数增强\n-> 类和对象\n-> 数据共享与保护\n-> 数组、指针、字符串、动态内存\n-> 继承与派生\n-> 多态与运算符重载\n-> 模板和群体数据\n-> STL、流、异常\n","text","",[27,28,23],"code",{"__ignoreMap":25},[14,30,32],{"id":31},"_1-c-基础差异","1. C++ 基础差异",[34,35,37],"h3",{"id":36},"_11-最小-c-程序","1.1 最小 C++ 程序",[10,39,40,41,44],{},"C++ 程序通常从 ",[27,42,43],{"code":43},"main"," 函数开始执行。",[10,46,47],{},"语法：",[19,49,54],{"className":50,"code":52,"language":53,"meta":25},[51],"language-cpp","#include \u003Ciostream>\nusing namespace std;\n\nint main()\n{\n    cout \u003C\u003C \"Hello C++\" \u003C\u003C endl;\n    return 0;\n}\n","cpp",[27,55,52],{"__ignoreMap":25},[10,57,58],{},"逐句看：",[19,60,63],{"className":61,"code":62,"language":53,"meta":25},[51],"#include \u003Ciostream>\n",[27,64,62],{"__ignoreMap":25},[10,66,67,68,71,72,71,75,78],{},"表示使用标准输入输出流库。",[27,69,70],{"code":70},"cout","、",[27,73,74],{"code":74},"cin",[27,76,77],{"code":77},"endl"," 都在这个库里。",[19,80,83],{"className":81,"code":82,"language":53,"meta":25},[51],"using namespace std;\n",[27,84,82],{"__ignoreMap":25},[10,86,87],{},"表示使用标准命名空间。没有这一句时，要写：",[19,89,92],{"className":90,"code":91,"language":53,"meta":25},[51],"std::cout \u003C\u003C \"Hello\" \u003C\u003C std::endl;\n",[27,93,91],{"__ignoreMap":25},[19,95,98],{"className":96,"code":97,"language":53,"meta":25},[51],"return 0;\n",[27,99,97],{"__ignoreMap":25},[10,101,102],{},"表示程序正常结束，把状态码 0 返回给操作系统。",[10,104,105],{},"考试常见点：",[107,108,109,121,137],"ul",{},[110,111,112,113,116,117,120],"li",{},"标准 C++ 主函数写 ",[27,114,115],{"code":115},"int main()","，不要写 ",[27,118,119],{"code":119},"void main()","。",[110,122,123,124,127,128,71,131,71,134,120],{},"C++ 标准库头文件多数不带 ",[27,125,126],{"code":126},".h","，例如 ",[27,129,130],{"code":130},"\u003Ciostream>",[27,132,133],{"code":133},"\u003Cstring>",[27,135,136],{"code":136},"\u003Cvector>",[110,138,139,140,71,143,146,147,71,150,120],{},"老式 C 头文件在 C++ 中常写成 ",[27,141,142],{"code":142},"\u003Ccstdio>",[27,144,145],{"code":145},"\u003Ccmath>","，而不是 ",[27,148,149],{"code":149},"\u003Cstdio.h>",[27,151,152],{"code":152},"\u003Cmath.h>",[34,154,156,157,159],{"id":155},"_12-cout-输出","1.2 ",[27,158,70],{"code":70}," 输出",[10,161,162,164],{},[27,163,70],{"code":70}," 是 C++ 的标准输出流对象。",[10,166,167],{},"基本语法：",[19,169,172],{"className":170,"code":171,"language":53,"meta":25},[51],"cout \u003C\u003C 输出内容;\n",[27,173,171],{"__ignoreMap":25},[10,175,176],{},"例子：",[19,178,181],{"className":179,"code":180,"language":53,"meta":25},[51],"int x = 10;\ndouble pi = 3.14;\n\ncout \u003C\u003C x \u003C\u003C endl;\ncout \u003C\u003C \"pi = \" \u003C\u003C pi \u003C\u003C endl;\n",[27,182,180],{"__ignoreMap":25},[10,184,185],{},"输出：",[19,187,190],{"className":188,"code":189,"language":24,"meta":25},[22],"10\npi = 3.14\n",[27,191,189],{"__ignoreMap":25},[10,193,194,197],{},[27,195,196],{"code":196},"\u003C\u003C"," 在这里叫插入运算符，含义是把右侧内容插入到输出流中。",[10,199,200],{},"可以连续输出：",[19,202,205],{"className":203,"code":204,"language":53,"meta":25},[51],"cout \u003C\u003C \"a = \" \u003C\u003C a \u003C\u003C \", b = \" \u003C\u003C b \u003C\u003C endl;\n",[27,206,204],{"__ignoreMap":25},[10,208,209,211],{},[27,210,77],{"code":77}," 的作用：",[19,213,216],{"className":214,"code":215,"language":53,"meta":25},[51],"cout \u003C\u003C \"hello\" \u003C\u003C endl;\n",[27,217,215],{"__ignoreMap":25},[10,219,220],{},"它做两件事：",[107,222,223,226],{},[110,224,225],{},"换行。",[110,227,228],{},"刷新输出缓冲区。",[10,230,231,232,235],{},"平时刷题常用 ",[27,233,234],{"code":234},"'\\n'","，因为更快：",[19,237,240],{"className":238,"code":239,"language":53,"meta":25},[51],"cout \u003C\u003C \"hello\\n\";\n",[27,241,239],{"__ignoreMap":25},[10,243,244,245,247],{},"考试中看到 ",[27,246,77],{"code":77},"，按换行处理即可。",[34,249,251,252,254],{"id":250},"_13-cin-输入","1.3 ",[27,253,74],{"code":74}," 输入",[10,256,257,259],{},[27,258,74],{"code":74}," 是 C++ 的标准输入流对象。",[10,261,167],{},[19,263,266],{"className":264,"code":265,"language":53,"meta":25},[51],"cin >> 变量;\n",[27,267,265],{"__ignoreMap":25},[10,269,176],{},[19,271,274],{"className":272,"code":273,"language":53,"meta":25},[51],"int a, b;\ncin >> a >> b;\ncout \u003C\u003C a + b \u003C\u003C endl;\n",[27,275,273],{"__ignoreMap":25},[10,277,278],{},"如果输入：",[19,280,283],{"className":281,"code":282,"language":24,"meta":25},[22],"3 5\n",[27,284,282],{"__ignoreMap":25},[10,286,185],{},[19,288,291],{"className":289,"code":290,"language":24,"meta":25},[22],"8\n",[27,292,290],{"__ignoreMap":25},[10,294,295,298],{},[27,296,297],{"code":297},">>"," 在这里叫提取运算符，含义是从输入流中提取数据放入变量。",[10,300,301],{},"注意：",[107,303,304,310],{},[110,305,306,309],{},[27,307,308],{"code":308},"cin >> s"," 读字符串时，遇到空格、Tab、回车就停止。",[110,311,312,313,120],{},"要读整行字符串，用 ",[27,314,315],{"code":315},"getline(cin, s)",[34,317,319,320],{"id":318},"_14-命名空间-namespace","1.4 命名空间 ",[27,321,322],{"code":322},"namespace",[10,324,325],{},"命名空间用来解决命名冲突。",[10,327,47],{},[19,329,332],{"className":330,"code":331,"language":53,"meta":25},[51],"namespace A\n{\n    int x = 10;\n}\n\nnamespace B\n{\n    int x = 20;\n}\n",[27,333,331],{"__ignoreMap":25},[10,335,336],{},"访问：",[19,338,341],{"className":339,"code":340,"language":53,"meta":25},[51],"cout \u003C\u003C A::x \u003C\u003C endl; \u002F\u002F 10\ncout \u003C\u003C B::x \u003C\u003C endl; \u002F\u002F 20\n",[27,342,340],{"__ignoreMap":25},[10,344,345,348],{},[27,346,347],{"code":347},"::"," 是作用域解析运算符。",[10,350,351,352,355],{},"两种 ",[27,353,354],{"code":354},"using","：",[19,357,360],{"className":358,"code":359,"language":53,"meta":25},[51],"using A::x;\n",[27,361,359],{"__ignoreMap":25},[10,363,364,365,368,369,372],{},"只把 ",[27,366,367],{"code":367},"A"," 里的 ",[27,370,371],{"code":371},"x"," 引入当前作用域。",[19,374,377],{"className":375,"code":376,"language":53,"meta":25},[51],"using namespace A;\n",[27,378,376],{"__ignoreMap":25},[10,380,381,382,384],{},"把 ",[27,383,367],{"code":367}," 里的所有名字都引入当前作用域。",[10,386,387],{},"考试易错：",[107,389,390,396],{},[110,391,392,395],{},[27,393,394],{"code":394},"using namespace std;"," 不是必须，只是方便。",[110,397,398],{},"引入太多命名空间可能导致同名冲突。",[34,400,402],{"id":401},"_15-输出格式控制","1.5 输出格式控制",[10,404,405],{},"C++ 可以控制输出宽度、进制、精度等。",[10,407,408],{},"需要头文件：",[19,410,413],{"className":411,"code":412,"language":53,"meta":25},[51],"#include \u003Ciomanip>\n",[27,414,412],{"__ignoreMap":25},[416,417,419,420],"h4",{"id":418},"_151-setw","1.5.1 ",[27,421,422],{"code":422},"setw",[10,424,425,428],{},[27,426,427],{"code":427},"setw(n)"," 设置下一个输出项的宽度。",[19,430,433],{"className":431,"code":432,"language":53,"meta":25},[51],"cout \u003C\u003C \"(\" \u003C\u003C setw(5) \u003C\u003C 100 \u003C\u003C \")\" \u003C\u003C endl;\n",[27,434,432],{"__ignoreMap":25},[10,436,437],{},"输出类似：",[19,439,442],{"className":440,"code":441,"language":24,"meta":25},[22],"(  100)\n",[27,443,441],{"__ignoreMap":25},[10,445,301,446,448],{},[27,447,422],{"code":422}," 只影响紧跟着的一个输出项。",[19,450,453],{"className":451,"code":452,"language":53,"meta":25},[51],"cout \u003C\u003C setw(5) \u003C\u003C 1 \u003C\u003C 2 \u003C\u003C endl;\n",[27,454,452],{"__ignoreMap":25},[10,456,457,458,461,462,465],{},"只有 ",[27,459,460],{"code":460},"1"," 会占 5 宽度，",[27,463,464],{"code":464},"2"," 不受影响。",[416,467,469,470,473,474],{"id":468},"_152-left-和-right","1.5.2 ",[27,471,472],{"code":472},"left"," 和 ",[27,475,476],{"code":476},"right",[19,478,481],{"className":479,"code":480,"language":53,"meta":25},[51],"cout \u003C\u003C left \u003C\u003C setw(5) \u003C\u003C 100 \u003C\u003C endl;\ncout \u003C\u003C right \u003C\u003C setw(5) \u003C\u003C 100 \u003C\u003C endl;\n",[27,482,480],{"__ignoreMap":25},[10,484,485,487,488,490],{},[27,486,472],{"code":472}," 左对齐，",[27,489,476],{"code":476}," 右对齐。它们会持续生效，直到改回来。",[416,492,494,495],{"id":493},"_153-setprecision","1.5.3 ",[27,496,497],{"code":497},"setprecision",[19,499,502],{"className":500,"code":501,"language":53,"meta":25},[51],"cout \u003C\u003C setprecision(3) \u003C\u003C 3.1415 \u003C\u003C endl;\n",[27,503,501],{"__ignoreMap":25},[10,505,506,507,510],{},"默认情况下，",[27,508,509],{"code":509},"setprecision(3)"," 表示保留 3 位有效数字，不是小数点后 3 位。",[10,512,185],{},[19,514,517],{"className":515,"code":516,"language":24,"meta":25},[22],"3.14\n",[27,518,516],{"__ignoreMap":25},[10,520,521,522,355],{},"如果要固定小数位，通常配合 ",[27,523,524],{"code":524},"fixed",[19,526,529],{"className":527,"code":528,"language":53,"meta":25},[51],"cout \u003C\u003C fixed \u003C\u003C setprecision(3) \u003C\u003C 3.1415 \u003C\u003C endl;\n",[27,530,528],{"__ignoreMap":25},[10,532,185],{},[19,534,537],{"className":535,"code":536,"language":24,"meta":25},[22],"3.142\n",[27,538,536],{"__ignoreMap":25},[416,540,542,543,71,546,71,549],{"id":541},"_154-dechexoct","1.5.4 ",[27,544,545],{"code":545},"dec",[27,547,548],{"code":548},"hex",[27,550,551],{"code":551},"oct",[19,553,556],{"className":554,"code":555,"language":53,"meta":25},[51],"cout \u003C\u003C dec \u003C\u003C 100 \u003C\u003C endl; \u002F\u002F 十进制\ncout \u003C\u003C hex \u003C\u003C 100 \u003C\u003C endl; \u002F\u002F 十六进制\ncout \u003C\u003C oct \u003C\u003C 100 \u003C\u003C endl; \u002F\u002F 八进制\n",[27,557,555],{"__ignoreMap":25},[10,559,560],{},"注意：这些操纵符会持续生效。",[19,562,565],{"className":563,"code":564,"language":53,"meta":25},[51],"cout \u003C\u003C hex \u003C\u003C 100 \u003C\u003C \" \" \u003C\u003C 200 \u003C\u003C endl;\ncout \u003C\u003C dec \u003C\u003C 100 \u003C\u003C endl;\n",[27,566,564],{"__ignoreMap":25},[10,568,569],{},"记忆：",[19,571,574],{"className":572,"code":573,"language":24,"meta":25},[22],"setw 只管下一个\nsetprecision 会持续\nhex\u002Foct\u002Fdec 会持续\nleft\u002Fright 会持续\n",[27,575,573],{"__ignoreMap":25},[34,577,579,580,583],{"id":578},"_16-const-常量","1.6 ",[27,581,582],{"code":582},"const"," 常量",[10,585,586,588],{},[27,587,582],{"code":582}," 用来定义不能被修改的变量。",[10,590,47],{},[19,592,595],{"className":593,"code":594,"language":53,"meta":25},[51],"const 类型 常量名 = 初值;\n",[27,596,594],{"__ignoreMap":25},[10,598,176],{},[19,600,603],{"className":601,"code":602,"language":53,"meta":25},[51],"const double PI = 3.1415926;\n",[27,604,602],{"__ignoreMap":25},[10,606,607],{},"错误写法：",[19,609,612],{"className":610,"code":611,"language":53,"meta":25},[51],"const int N; \u002F\u002F 错，const 必须初始化\nN = 100;     \u002F\u002F 错，const 不能再赋值\n",[27,613,611],{"__ignoreMap":25},[10,615,616,617,619],{},"为什么要用 ",[27,618,582],{"code":582},"？",[107,621,622,625],{},[110,623,624],{},"语义清楚：告诉读代码的人这个值不该改变。",[110,626,627],{},"比宏常量更安全：有类型检查。",[10,629,630],{},"对比：",[19,632,635],{"className":633,"code":634,"language":53,"meta":25},[51],"#define PI 3.14\nconst double PI = 3.14;\n",[27,636,634],{"__ignoreMap":25},[10,638,639,640,120],{},"一般更推荐 ",[27,641,582],{"code":582},[34,643,645],{"id":644},"_17-强制类型转换","1.7 强制类型转换",[10,647,648],{},"C 语言写法：",[19,650,653],{"className":651,"code":652,"language":53,"meta":25},[51],"int x = (int)y;\n",[27,654,652],{"__ignoreMap":25},[10,656,657],{},"C++ 写法：",[19,659,662],{"className":660,"code":661,"language":53,"meta":25},[51],"int x = int(y);\n",[27,663,661],{"__ignoreMap":25},[10,665,666],{},"标准 C++ 类型转换：",[19,668,671],{"className":669,"code":670,"language":53,"meta":25},[51],"static_cast\u003Cint>(y);\n",[27,672,670],{"__ignoreMap":25},[10,674,675],{},"四种类型转换：",[677,678,679,692],"table",{},[680,681,682],"thead",{},[683,684,685,689],"tr",{},[686,687,688],"th",{},"转换",[686,690,691],{},"用途",[693,694,695,713,723,736],"tbody",{},[683,696,697,703],{},[698,699,700],"td",{},[27,701,702],{"code":702},"static_cast",[698,704,705,706,709,710],{},"普通合理转换，如 ",[27,707,708],{"code":708},"double"," 转 ",[27,711,712],{"code":712},"int",[683,714,715,720],{},[698,716,717],{},[27,718,719],{"code":719},"dynamic_cast",[698,721,722],{},"类层次中的安全转换，和多态有关",[683,724,725,730],{},[698,726,727],{},[27,728,729],{"code":729},"const_cast",[698,731,732,733,735],{},"去掉或添加 ",[27,734,582],{"code":582}," 属性",[683,737,738,743],{},[698,739,740],{},[27,741,742],{"code":742},"reinterpret_cast",[698,744,745],{},"非常底层、危险的重新解释",[10,747,748],{},"考试一般重点：",[19,750,753],{"className":751,"code":752,"language":53,"meta":25},[51],"static_cast\u003Cint>(3.14)\n",[27,754,752],{"__ignoreMap":25},[10,756,757],{},"结果是：",[19,759,762],{"className":760,"code":761,"language":24,"meta":25},[22],"3\n",[27,763,761],{"__ignoreMap":25},[10,765,569],{},[19,767,770],{"className":768,"code":769,"language":24,"meta":25},[22],"static_cast：正常转\ndynamic_cast：继承转\nconst_cast：改 const\nreinterpret_cast：危险转\n",[27,771,769],{"__ignoreMap":25},[34,773,775,776],{"id":774},"_18-auto","1.8 ",[27,777,778],{"code":778},"auto",[10,780,781,782,784],{},"C++11 后，",[27,783,778],{"code":778}," 用于根据初值推断变量类型。",[10,786,47],{},[19,788,791],{"className":789,"code":790,"language":53,"meta":25},[51],"auto 变量名 = 初值;\n",[27,792,790],{"__ignoreMap":25},[10,794,176],{},[19,796,799],{"className":797,"code":798,"language":53,"meta":25},[51],"auto x = 1;      \u002F\u002F int\nauto y = 3.14;   \u002F\u002F double\nauto c = 'A';    \u002F\u002F char\n",[27,800,798],{"__ignoreMap":25},[10,802,803],{},"错误：",[19,805,808],{"className":806,"code":807,"language":53,"meta":25},[51],"auto x; \u002F\u002F 错，无法推断类型\nx = 10;\n",[27,809,807],{"__ignoreMap":25},[10,811,812],{},"同一条声明中类型必须一致：",[19,814,817],{"className":815,"code":816,"language":53,"meta":25},[51],"auto a = 1, b = 2;   \u002F\u002F 对，都是 int\nauto x = 1, y = 2.0; \u002F\u002F 错，一个 int 一个 double\n",[27,818,816],{"__ignoreMap":25},[10,820,821],{},"算法竞赛里常见：",[19,823,826],{"className":824,"code":825,"language":53,"meta":25},[51],"for (auto x : v)\n{\n    cout \u003C\u003C x \u003C\u003C endl;\n}\n",[27,827,825],{"__ignoreMap":25},[34,829,831,832],{"id":830},"_19-decltype","1.9 ",[27,833,834],{"code":834},"decltype",[10,836,837,839],{},[27,838,834],{"code":834}," 用来取得表达式的类型。",[10,841,47],{},[19,843,846],{"className":844,"code":845,"language":53,"meta":25},[51],"decltype(表达式) 变量名;\n",[27,847,845],{"__ignoreMap":25},[10,849,176],{},[19,851,854],{"className":852,"code":853,"language":53,"meta":25},[51],"int i = 10;\ndecltype(i) j = 20; \u002F\u002F j 是 int\n",[27,855,853],{"__ignoreMap":25},[10,857,858,473,860,862],{},[27,859,778],{"code":778},[27,861,834],{"code":834}," 的区别：",[19,864,867],{"className":865,"code":866,"language":24,"meta":25},[22],"auto：根据初始化值推断，并定义变量\ndecltype：只分析表达式类型，不执行表达式\n",[27,868,866],{"__ignoreMap":25},[10,870,176],{},[19,872,875],{"className":873,"code":874,"language":53,"meta":25},[51],"int i = 0;\ndecltype(i) x = 1; \u002F\u002F x 是 int\n",[27,876,874],{"__ignoreMap":25},[10,878,569],{},[19,880,883],{"className":881,"code":882,"language":24,"meta":25},[22],"auto 看右边初值\ndecltype 看括号里的表达式类型\n",[27,884,882],{"__ignoreMap":25},[14,886,888],{"id":887},"_2-函数","2. 函数",[34,890,892],{"id":891},"_21-函数参数值传递","2.1 函数参数：值传递",[10,894,895],{},"值传递就是把实参的值复制一份给形参。",[10,897,47],{},[19,899,902],{"className":900,"code":901,"language":53,"meta":25},[51],"void f(int x)\n{\n    x = 10;\n}\n",[27,903,901],{"__ignoreMap":25},[10,905,176],{},[19,907,910],{"className":908,"code":909,"language":53,"meta":25},[51],"void change(int x)\n{\n    x = 100;\n}\n\nint main()\n{\n    int a = 5;\n    change(a);\n    cout \u003C\u003C a \u003C\u003C endl; \u002F\u002F 5\n}\n",[27,911,909],{"__ignoreMap":25},[10,913,914],{},"为什么输出还是 5？",[10,916,917,918,920,921,924],{},"因为 ",[27,919,371],{"code":371}," 是 ",[27,922,923],{"code":923},"a"," 的副本。函数里改的是副本，不是原变量。",[10,926,927],{},"交换函数错误示例：",[19,929,932],{"className":930,"code":931,"language":53,"meta":25},[51],"void swapValue(int a, int b)\n{\n    int t = a;\n    a = b;\n    b = t;\n}\n",[27,933,931],{"__ignoreMap":25},[10,935,936],{},"调用：",[19,938,941],{"className":939,"code":940,"language":53,"meta":25},[51],"int x = 5, y = 10;\nswapValue(x, y);\ncout \u003C\u003C x \u003C\u003C \" \" \u003C\u003C y \u003C\u003C endl; \u002F\u002F 仍然是 5 10\n",[27,942,940],{"__ignoreMap":25},[10,944,569],{},[19,946,949],{"className":947,"code":948,"language":24,"meta":25},[22],"值传递：复制一份，函数内改不到外面\n",[27,950,948],{"__ignoreMap":25},[34,952,954],{"id":953},"_22-函数参数地址传递","2.2 函数参数：地址传递",[10,956,957],{},"地址传递就是把变量地址传给函数，函数通过指针访问原变量。",[10,959,47],{},[19,961,964],{"className":962,"code":963,"language":53,"meta":25},[51],"void f(int *p)\n{\n    *p = 10;\n}\n",[27,965,963],{"__ignoreMap":25},[10,967,176],{},[19,969,972],{"className":970,"code":971,"language":53,"meta":25},[51],"void change(int *p)\n{\n    *p = 100;\n}\n\nint main()\n{\n    int a = 5;\n    change(&a);\n    cout \u003C\u003C a \u003C\u003C endl; \u002F\u002F 100\n}\n",[27,973,971],{"__ignoreMap":25},[10,975,976],{},"交换函数：",[19,978,981],{"className":979,"code":980,"language":53,"meta":25},[51],"void swapPointer(int *a, int *b)\n{\n    int t = *a;\n    *a = *b;\n    *b = t;\n}\n",[27,982,980],{"__ignoreMap":25},[10,984,936],{},[19,986,989],{"className":987,"code":988,"language":53,"meta":25},[51],"swapPointer(&x, &y);\n",[27,990,988],{"__ignoreMap":25},[10,992,387],{},[107,994,995,1005],{},[110,996,997,998,1001,1002,120],{},"函数形参是 ",[27,999,1000],{"code":1000},"int *a","，调用时要传地址 ",[27,1003,1004],{"code":1004},"&x",[110,1006,1007,1008,1011],{},"在函数内部要用 ",[27,1009,1010],{"code":1010},"*a"," 访问原变量。",[10,1013,569],{},[19,1015,1018],{"className":1016,"code":1017,"language":24,"meta":25},[22],"地址传递：传地址，用 * 改原变量\n",[27,1019,1017],{"__ignoreMap":25},[34,1021,1023],{"id":1022},"_23-函数参数引用传递","2.3 函数参数：引用传递",[10,1025,1026],{},"引用传递是 C++ 新增的重要内容。引用可以看成变量的别名。",[10,1028,47],{},[19,1030,1033],{"className":1031,"code":1032,"language":53,"meta":25},[51],"void f(int &x)\n{\n    x = 10;\n}\n",[27,1034,1032],{"__ignoreMap":25},[10,1036,176],{},[19,1038,1041],{"className":1039,"code":1040,"language":53,"meta":25},[51],"void change(int &x)\n{\n    x = 100;\n}\n\nint main()\n{\n    int a = 5;\n    change(a);\n    cout \u003C\u003C a \u003C\u003C endl; \u002F\u002F 100\n}\n",[27,1042,1040],{"__ignoreMap":25},[10,1044,976],{},[19,1046,1049],{"className":1047,"code":1048,"language":53,"meta":25},[51],"void swapRef(int &a, int &b)\n{\n    int t = a;\n    a = b;\n    b = t;\n}\n",[27,1050,1048],{"__ignoreMap":25},[10,1052,936],{},[19,1054,1057],{"className":1055,"code":1056,"language":53,"meta":25},[51],"swapRef(x, y);\n",[27,1058,1056],{"__ignoreMap":25},[10,1060,1061],{},"调用看起来和普通函数一样，所以判断是否引用传递不能看调用处，要看函数声明：",[19,1063,1066],{"className":1064,"code":1065,"language":53,"meta":25},[51],"void swapRef(int &a, int &b);\n",[27,1067,1065],{"__ignoreMap":25},[10,1069,1070],{},"引用的基本规则：",[19,1072,1075],{"className":1073,"code":1074,"language":53,"meta":25},[51],"int a = 10;\nint &r = a;\n",[27,1076,1074],{"__ignoreMap":25},[107,1078,1079,1082,1085,1088],{},[110,1080,1081],{},"引用定义时必须初始化。",[110,1083,1084],{},"引用一旦绑定，不能再改绑。",[110,1086,1087],{},"引用类型必须匹配。",[110,1089,1090],{},"引用不是新对象，是原变量的别名。",[10,1092,803],{},[19,1094,1097],{"className":1095,"code":1096,"language":53,"meta":25},[51],"int &r;       \u002F\u002F 错，未初始化\ndouble &d = a; \u002F\u002F 错，类型不匹配\n",[27,1098,1096],{"__ignoreMap":25},[10,1100,569],{},[19,1102,1105],{"className":1103,"code":1104,"language":24,"meta":25},[22],"引用传递：调用像值传递，效果像指针传递\n",[27,1106,1104],{"__ignoreMap":25},[34,1108,1110],{"id":1109},"_24-内联函数","2.4 内联函数",[10,1112,1113],{},"C++ 里的内联函数用关键字：",[19,1115,1118],{"className":1116,"code":1117,"language":53,"meta":25},[51],"inline\n",[27,1119,1117],{"__ignoreMap":25},[10,1121,47],{},[19,1123,1126],{"className":1124,"code":1125,"language":53,"meta":25},[51],"inline 返回值类型 函数名(参数列表)\n{\n    函数体;\n}\n",[27,1127,1125],{"__ignoreMap":25},[10,1129,176],{},[19,1131,1134],{"className":1132,"code":1133,"language":53,"meta":25},[51],"inline int add(int a, int b)\n{\n    return a + b;\n}\n",[27,1135,1133],{"__ignoreMap":25},[10,1137,936],{},[19,1139,1142],{"className":1140,"code":1141,"language":53,"meta":25},[51],"int x = add(3, 5);\ncout \u003C\u003C x \u003C\u003C endl; \u002F\u002F 8\n",[27,1143,1141],{"__ignoreMap":25},[10,1145,1146],{},"普通函数调用时，大致有：",[19,1148,1151],{"className":1149,"code":1150,"language":24,"meta":25},[22],"调用函数 -> 跳到函数代码处执行 -> 返回原位置\n",[27,1152,1150],{"__ignoreMap":25},[10,1154,1155],{},"这个过程有函数调用开销。",[10,1157,1158],{},"内联函数的想法是：编译器在编译时尽量把函数体展开到调用处。",[10,1160,176],{},[19,1162,1165],{"className":1163,"code":1164,"language":53,"meta":25},[51],"inline int square(int x)\n{\n    return x * x;\n}\n\nint a = square(5);\n",[27,1166,1164],{"__ignoreMap":25},[10,1168,1169],{},"编译器可能把它处理成类似：",[19,1171,1174],{"className":1172,"code":1173,"language":53,"meta":25},[51],"int a = 5 * 5;\n",[27,1175,1173],{"__ignoreMap":25},[10,1177,1178],{},"适合情况：",[107,1180,1181,1184,1187],{},[110,1182,1183],{},"函数短小。",[110,1185,1186],{},"函数简单。",[110,1188,1189],{},"函数调用频繁。",[10,1191,176],{},[19,1193,1196],{"className":1194,"code":1195,"language":53,"meta":25},[51],"inline int maxNum(int a, int b)\n{\n    return a > b ? a : b;\n}\n",[27,1197,1195],{"__ignoreMap":25},[10,1199,1200],{},"类里面直接定义的函数默认具有内联性质：",[19,1202,1205],{"className":1203,"code":1204,"language":53,"meta":25},[51],"class Student\n{\nprivate:\n    int age;\n\npublic:\n    int getAge()\n    {\n        return age;\n    }\n};\n",[27,1206,1204],{"__ignoreMap":25},[10,1208,1209,1210,355],{},"也可以类内声明，类外定义时加 ",[27,1211,1212],{"code":1212},"inline",[19,1214,1217],{"className":1215,"code":1216,"language":53,"meta":25},[51],"class Student\n{\nprivate:\n    int age;\n\npublic:\n    int getAge();\n};\n\ninline int Student::getAge()\n{\n    return age;\n}\n",[27,1218,1216],{"__ignoreMap":25},[10,1220,301],{},[107,1222,1223,1229,1232],{},[110,1224,1225,1226,1228],{},"写了 ",[27,1227,1212],{"code":1212}," 不保证一定内联，最终由编译器决定。",[110,1230,1231],{},"函数太复杂时不适合内联。",[110,1233,1234],{},"内联可能减少调用开销，也可能让代码体积变大。",[10,1236,1237],{},"不要把内联理解成“必然更快”。",[10,1239,569],{},[19,1241,1244],{"className":1242,"code":1243,"language":24,"meta":25},[22],"inline：建议编译器在调用处展开函数体，适合短小频繁调用的函数\n",[27,1245,1243],{"__ignoreMap":25},[34,1247,1249],{"id":1248},"_25-默认参数","2.5 默认参数",[10,1251,1252],{},"默认参数就是在函数声明时给形参一个默认值。",[10,1254,47],{},[19,1256,1259],{"className":1257,"code":1258,"language":53,"meta":25},[51],"返回值类型 函数名(类型 参数1, 类型 参数2 = 默认值);\n",[27,1260,1258],{"__ignoreMap":25},[10,1262,176],{},[19,1264,1267],{"className":1265,"code":1266,"language":53,"meta":25},[51],"int add(int x, int y = 5, int z = 6)\n{\n    return x + y + z;\n}\n",[27,1268,1266],{"__ignoreMap":25},[10,1270,936],{},[19,1272,1275],{"className":1273,"code":1274,"language":53,"meta":25},[51],"cout \u003C\u003C add(10, 20, 30) \u003C\u003C endl; \u002F\u002F 60\ncout \u003C\u003C add(10, 20) \u003C\u003C endl;     \u002F\u002F 36\ncout \u003C\u003C add(10) \u003C\u003C endl;         \u002F\u002F 21\n",[27,1276,1274],{"__ignoreMap":25},[10,1278,1279],{},"默认参数的规则：",[10,1281,1282],{},"默认值必须从右向左连续给出。",[10,1284,1285],{},"正确：",[19,1287,1290],{"className":1288,"code":1289,"language":53,"meta":25},[51],"int f(int x, int y = 1, int z = 2);\n",[27,1291,1289],{"__ignoreMap":25},[10,1293,803],{},[19,1295,1298],{"className":1296,"code":1297,"language":53,"meta":25},[51],"int f(int x = 0, int y, int z = 2);\n",[27,1299,1297],{"__ignoreMap":25},[10,1301,917,1302,1305],{},[27,1303,1304],{"code":1304},"y"," 没默认值，却在有默认值参数的右边。",[10,1307,1308],{},"默认参数通常只在函数声明中写一次：",[19,1310,1313],{"className":1311,"code":1312,"language":53,"meta":25},[51],"int add(int x, int y = 5);\n\nint add(int x, int y)\n{\n    return x + y;\n}\n",[27,1314,1312],{"__ignoreMap":25},[10,1316,1317],{},"考试常考判断：",[19,1319,1322],{"className":1320,"code":1321,"language":53,"meta":25},[51],"int add1(int x, int y = 5, int z = 6); \u002F\u002F 对\nint add2(int x = 1, int y = 5, int z); \u002F\u002F 错\nint add3(int x = 1, int y, int z = 6); \u002F\u002F 错\n",[27,1323,1321],{"__ignoreMap":25},[10,1325,569],{},[19,1327,1330],{"className":1328,"code":1329,"language":24,"meta":25},[22],"默认参数从右往左给，中间不能断\n",[27,1331,1329],{"__ignoreMap":25},[34,1333,1335],{"id":1334},"_26-函数重载","2.6 函数重载",[10,1337,1338],{},"函数重载指多个函数同名，但参数列表不同。",[10,1340,47],{},[19,1342,1345],{"className":1343,"code":1344,"language":53,"meta":25},[51],"int add(int a, int b);\ndouble add(double a, double b);\nint add(int a, int b, int c);\n",[27,1346,1344],{"__ignoreMap":25},[10,1348,176],{},[19,1350,1353],{"className":1351,"code":1352,"language":53,"meta":25},[51],"int add(int a, int b)\n{\n    return a + b;\n}\n\ndouble add(double a, double b)\n{\n    return a + b;\n}\n",[27,1354,1352],{"__ignoreMap":25},[10,1356,936],{},[19,1358,1361],{"className":1359,"code":1360,"language":53,"meta":25},[51],"cout \u003C\u003C add(1, 2) \u003C\u003C endl;       \u002F\u002F 调 int 版本\ncout \u003C\u003C add(1.5, 2.5) \u003C\u003C endl;   \u002F\u002F 调 double 版本\n",[27,1362,1360],{"__ignoreMap":25},[10,1364,1365],{},"什么能构成重载？",[107,1367,1368,1371,1374],{},[110,1369,1370],{},"参数个数不同。",[110,1372,1373],{},"参数类型不同。",[110,1375,1376],{},"参数顺序不同。",[10,1378,1379],{},"什么不能构成重载？",[10,1381,1382],{},"仅返回值不同不行：",[19,1384,1387],{"className":1385,"code":1386,"language":53,"meta":25},[51],"int f(int x);\ndouble f(int x); \u002F\u002F 错，不能只靠返回值区分\n",[27,1388,1386],{"__ignoreMap":25},[10,1390,1391],{},"函数重载属于静态多态，编译时就决定调用哪个函数。",[10,1393,1394],{},"易错：",[10,1396,1397],{},"默认参数和重载一起用可能产生二义性。",[19,1399,1402],{"className":1400,"code":1401,"language":53,"meta":25},[51],"void f(int x);\nvoid f(int x, int y = 0);\n\nf(1); \u002F\u002F 二义性\n",[27,1403,1401],{"__ignoreMap":25},[10,1405,569],{},[19,1407,1410],{"className":1408,"code":1409,"language":24,"meta":25},[22],"重载看参数，不看返回值\n",[27,1411,1409],{"__ignoreMap":25},[14,1413,1415],{"id":1414},"_3-类和对象","3. 类和对象",[34,1417,1419],{"id":1418},"_31-类是什么","3.1 类是什么",[10,1421,1422],{},"类是用户自定义类型，是对数据和操作的封装。",[10,1424,176],{},[19,1426,1429],{"className":1427,"code":1428,"language":53,"meta":25},[51],"class Clock\n{\npublic:\n    void setTime(int h, int m, int s);\n    void showTime();\n\nprivate:\n    int hour;\n    int minute;\n    int second;\n};\n",[27,1430,1428],{"__ignoreMap":25},[10,1432,1433],{},"这里：",[107,1435,1436,1442,1448,1454],{},[110,1437,1438,1441],{},[27,1439,1440],{"code":1440},"hour\u002Fminute\u002Fsecond"," 是数据成员，表示对象状态。",[110,1443,1444,1447],{},[27,1445,1446],{"code":1446},"setTime\u002FshowTime"," 是成员函数，表示对象行为。",[110,1449,1450,1453],{},[27,1451,1452],{"code":1452},"private"," 表示外部不能直接访问。",[110,1455,1456,1459],{},[27,1457,1458],{"code":1458},"public"," 表示对外接口。",[10,1461,1462],{},"类和对象的关系：",[19,1464,1467],{"className":1465,"code":1466,"language":53,"meta":25},[51],"Clock c1;\nClock c2;\n",[27,1468,1466],{"__ignoreMap":25},[10,1470,1471,1474,1475,473,1478,1481],{},[27,1472,1473],{"code":1473},"Clock"," 是类型，",[27,1476,1477],{"code":1477},"c1",[27,1479,1480],{"code":1480},"c2"," 是对象。",[10,1483,1484],{},"类定义本身不分配对象数据空间，创建对象时才分配。",[10,1486,1487],{},"重要点：",[19,1489,1492],{"className":1490,"code":1491,"language":24,"meta":25},[22],"对象占的内存主要存数据成员\n成员函数代码所有对象共享一份\n",[27,1493,1491],{"__ignoreMap":25},[34,1495,1497],{"id":1496},"_32-封装","3.2 封装",[10,1499,1500],{},"封装就是把数据和操作数据的函数放在一起，并隐藏内部实现。",[10,1502,1503],{},"典型写法：",[19,1505,1508],{"className":1506,"code":1507,"language":53,"meta":25},[51],"class Student\n{\nprivate:\n    int score;\n\npublic:\n    void setScore(int s)\n    {\n        score = s;\n    }\n\n    int getScore()\n    {\n        return score;\n    }\n};\n",[27,1509,1507],{"__ignoreMap":25},[10,1511,1512],{},"外部不能直接写：",[19,1514,1517],{"className":1515,"code":1516,"language":53,"meta":25},[51],"Student stu;\nstu.score = 100; \u002F\u002F 错，score 是 private\n",[27,1518,1516],{"__ignoreMap":25},[10,1520,1521],{},"应该写：",[19,1523,1526],{"className":1524,"code":1525,"language":53,"meta":25},[51],"stu.setScore(100);\ncout \u003C\u003C stu.getScore() \u003C\u003C endl;\n",[27,1527,1525],{"__ignoreMap":25},[10,1529,1530],{},"为什么要封装？",[107,1532,1533,1536,1539],{},[110,1534,1535],{},"防止外部随便改数据。",[110,1537,1538],{},"类内部实现可以改变，但接口不变。",[110,1540,1541],{},"代码更安全，更容易维护。",[10,1543,569],{},[19,1545,1548],{"className":1546,"code":1547,"language":24,"meta":25},[22],"private 藏数据\npublic 给接口\n",[27,1549,1547],{"__ignoreMap":25},[34,1551,1553,1554,71,1556,71,1558],{"id":1552},"_33-访问控制publicprivateprotected","3.3 访问控制：",[27,1555,1458],{"code":1458},[27,1557,1452],{"code":1452},[27,1559,1560],{"code":1560},"protected",[10,1562,1563],{},"类成员有三种访问权限。",[19,1565,1568],{"className":1566,"code":1567,"language":53,"meta":25},[51],"class A\n{\npublic:\n    int x;\n\nprotected:\n    int y;\n\nprivate:\n    int z;\n};\n",[27,1569,1567],{"__ignoreMap":25},[677,1571,1572,1588],{},[680,1573,1574],{},[683,1575,1576,1579,1582,1585],{},[686,1577,1578],{},"权限",[686,1580,1581],{},"类内",[686,1583,1584],{},"类外对象",[686,1586,1587],{},"派生类内部",[693,1589,1590,1603,1616],{},[683,1591,1592,1596,1599,1601],{},[698,1593,1594],{},[27,1595,1458],{"code":1458},[698,1597,1598],{},"可访问",[698,1600,1598],{},[698,1602,1598],{},[683,1604,1605,1609,1611,1614],{},[698,1606,1607],{},[27,1608,1560],{"code":1560},[698,1610,1598],{},[698,1612,1613],{},"不可访问",[698,1615,1598],{},[683,1617,1618,1622,1624,1626],{},[698,1619,1620],{},[27,1621,1452],{"code":1452},[698,1623,1598],{},[698,1625,1613],{},[698,1627,1628],{},"不可直接访问",[10,1630,1631],{},"对象访问：",[19,1633,1636],{"className":1634,"code":1635,"language":53,"meta":25},[51],"A a;\na.x = 1; \u002F\u002F 对\na.y = 2; \u002F\u002F 错\na.z = 3; \u002F\u002F 错\n",[27,1637,1635],{"__ignoreMap":25},[10,1639,1640,1642],{},[27,1641,1560],{"code":1560}," 的意义主要在继承中体现：外部对象不能访问，但派生类内部可以访问。",[10,1644,1645],{},"考试常见：",[19,1647,1650],{"className":1648,"code":1649,"language":53,"meta":25},[51],"class A\n{\nprotected:\n    int x;\n};\n\nint main()\n{\n    A a;\n    a.x = 5; \u002F\u002F 错，protected 对对象不可见\n}\n",[27,1651,1649],{"__ignoreMap":25},[34,1653,1655],{"id":1654},"_34-成员函数类外定义","3.4 成员函数类外定义",[10,1657,1658],{},"类内声明：",[19,1660,1663],{"className":1661,"code":1662,"language":53,"meta":25},[51],"class Clock\n{\npublic:\n    void setHour(int h);\n\nprivate:\n    int hour;\n};\n",[27,1664,1662],{"__ignoreMap":25},[10,1666,1667],{},"类外定义：",[19,1669,1672],{"className":1670,"code":1671,"language":53,"meta":25},[51],"void Clock::setHour(int h)\n{\n    hour = h;\n}\n",[27,1673,1671],{"__ignoreMap":25},[10,1675,1676,1677,1680,1681,1684,1685,1687],{},"这里的 ",[27,1678,1679],{"code":1679},"Clock::"," 表示 ",[27,1682,1683],{"code":1683},"setHour"," 属于 ",[27,1686,1473],{"code":1473}," 类。",[10,1689,1690,1692],{},[27,1691,347],{"code":347}," 叫作用域解析运算符。",[10,1694,1695],{},"为什么类外定义仍然能访问私有成员？",[10,1697,1698],{},"因为：",[19,1700,1703],{"className":1701,"code":1702,"language":53,"meta":25},[51],"void Clock::setHour(int h)\n",[27,1704,1702],{"__ignoreMap":25},[10,1706,1707,1708,1710,1711,1713],{},"已经说明这个函数是 ",[27,1709,1473],{"code":1473}," 的成员函数，所以它有访问 ",[27,1712,1473],{"code":1473}," 私有成员的权限。",[34,1715,1717,1718,1721],{"id":1716},"_35-this-指针","3.5 ",[27,1719,1720],{"code":1720},"this"," 指针",[10,1723,1724,1726],{},[27,1725,1720],{"code":1720}," 是每个非静态成员函数中隐含存在的指针，指向当前调用该函数的对象。",[10,1728,176],{},[19,1730,1733],{"className":1731,"code":1732,"language":53,"meta":25},[51],"class Calendar\n{\nprivate:\n    int year;\n    int month;\n    int day;\n\npublic:\n    void SetDay(int year, int month, int day)\n    {\n        this->year = year;\n        this->month = month;\n        this->day = day;\n    }\n};\n",[27,1734,1732],{"__ignoreMap":25},[10,1736,1737,1738,355],{},"如果没有 ",[27,1739,1740],{"code":1740},"this->",[19,1742,1745],{"className":1743,"code":1744,"language":53,"meta":25},[51],"year = year;\n",[27,1746,1744],{"__ignoreMap":25},[10,1748,1749,1750,1753],{},"左边和右边都可能被理解为形参 ",[27,1751,1752],{"code":1752},"year","，达不到给数据成员赋值的目的。",[10,1755,1756,1758],{},[27,1757,1720],{"code":1720}," 的常见用途：",[1760,1761,1762,1765],"ol",{},[110,1763,1764],{},"区分同名形参和数据成员。",[110,1766,1767],{},"返回当前对象：",[19,1769,1772],{"className":1770,"code":1771,"language":53,"meta":25},[51],"return *this;\n",[27,1773,1771],{"__ignoreMap":25},[10,1775,1776],{},"比如赋值运算符常写：",[19,1778,1781],{"className":1779,"code":1780,"language":53,"meta":25},[51],"A& operator=(const A &rhs)\n{\n    ...\n    return *this;\n}\n",[27,1782,1780],{"__ignoreMap":25},[10,1784,569],{},[19,1786,1789],{"className":1787,"code":1788,"language":24,"meta":25},[22],"this 指向当前对象\nthis->x 是当前对象的数据成员 x\n*this 是当前对象本身\n",[27,1790,1788],{"__ignoreMap":25},[34,1792,1794],{"id":1793},"_36-构造函数","3.6 构造函数",[10,1796,1797],{},"构造函数用于对象创建时初始化对象。",[10,1799,1800],{},"语法特点：",[19,1802,1805],{"className":1803,"code":1804,"language":53,"meta":25},[51],"class 类名\n{\npublic:\n    类名(参数列表);\n};\n",[27,1806,1804],{"__ignoreMap":25},[10,1808,176],{},[19,1810,1813],{"className":1811,"code":1812,"language":53,"meta":25},[51],"class Clock\n{\npublic:\n    Clock(int h, int m, int s);\n\nprivate:\n    int hour;\n    int minute;\n    int second;\n};\n\nClock::Clock(int h, int m, int s)\n{\n    hour = h;\n    minute = m;\n    second = s;\n}\n",[27,1814,1812],{"__ignoreMap":25},[10,1816,1817],{},"创建对象：",[19,1819,1822],{"className":1820,"code":1821,"language":53,"meta":25},[51],"Clock c(8, 30, 0);\n",[27,1823,1821],{"__ignoreMap":25},[10,1825,1826],{},"构造函数规则：",[107,1828,1829,1832,1838,1841,1846],{},[110,1830,1831],{},"名字和类名相同。",[110,1833,1834,1835,120],{},"没有返回值，不能写 ",[27,1836,1837],{"code":1837},"void",[110,1839,1840],{},"创建对象时自动调用。",[110,1842,1843,1844,120],{},"通常放在 ",[27,1845,1458],{"code":1458},[110,1847,1848],{},"不能显式调用构造函数。",[10,1850,803],{},[19,1852,1855],{"className":1853,"code":1854,"language":53,"meta":25},[51],"Clock c;\nc.Clock(1, 2, 3); \u002F\u002F 错\n",[27,1856,1854],{"__ignoreMap":25},[10,1858,1859],{},"默认构造函数：",[19,1861,1864],{"className":1862,"code":1863,"language":53,"meta":25},[51],"Clock()\n{\n}\n",[27,1865,1863],{"__ignoreMap":25},[10,1867,1868],{},"如果类中没有声明任何构造函数，编译器会自动生成默认构造函数。",[10,1870,1871],{},"但是如果你写了任意一个构造函数：",[19,1873,1876],{"className":1874,"code":1875,"language":53,"meta":25},[51],"class A\n{\npublic:\n    A(int x);\n};\n",[27,1877,1875],{"__ignoreMap":25},[10,1879,1880],{},"那么：",[19,1882,1885],{"className":1883,"code":1884,"language":53,"meta":25},[51],"A a; \u002F\u002F 错，没有默认构造函数\n",[27,1886,1884],{"__ignoreMap":25},[10,1888,1889],{},"除非你自己补：",[19,1891,1894],{"className":1892,"code":1893,"language":53,"meta":25},[51],"A() {}\n",[27,1895,1893],{"__ignoreMap":25},[10,1897,1898],{},"特别坑：",[19,1900,1903],{"className":1901,"code":1902,"language":53,"meta":25},[51],"Clock c3();\n",[27,1904,1902],{"__ignoreMap":25},[10,1906,1907,1908,1911,1912,120],{},"这不是创建对象，而是声明一个函数 ",[27,1909,1910],{"code":1910},"c3","，返回类型是 ",[27,1913,1473],{"code":1473},[10,1915,569],{},[19,1917,1920],{"className":1918,"code":1919,"language":24,"meta":25},[22],"构造函数：对象出生时自动调用\n有参构造写了之后，默认构造不会自动生成\nClock c(); 是函数声明，不是对象\n",[27,1921,1919],{"__ignoreMap":25},[34,1923,1925],{"id":1924},"_37-构造函数初始化列表","3.7 构造函数初始化列表",[10,1927,1928],{},"初始化列表写在构造函数参数表后、函数体前。",[10,1930,47],{},[19,1932,1935],{"className":1933,"code":1934,"language":53,"meta":25},[51],"类名::类名(参数列表) : 成员1(初值1), 成员2(初值2)\n{\n}\n",[27,1936,1934],{"__ignoreMap":25},[10,1938,176],{},[19,1940,1943],{"className":1941,"code":1942,"language":53,"meta":25},[51],"Clock::Clock(int h, int m, int s)\n    : hour(h), minute(m), second(s)\n{\n}\n",[27,1944,1942],{"__ignoreMap":25},[10,1946,1947],{},"和函数体赋值的区别：",[19,1949,1952],{"className":1950,"code":1951,"language":53,"meta":25},[51],"Clock::Clock(int h, int m, int s)\n{\n    hour = h;\n    minute = m;\n    second = s;\n}\n",[27,1953,1951],{"__ignoreMap":25},[10,1955,1956],{},"这叫先默认初始化，再赋值。",[10,1958,1959],{},"初始化列表是直接初始化，效率更高。",[10,1961,1962],{},"必须使用初始化列表的情况：",[1760,1964,1965,1970,1973],{},[110,1966,1967,1969],{},[27,1968,582],{"code":582}," 数据成员。",[110,1971,1972],{},"引用数据成员。",[110,1974,1975],{},"没有默认构造函数的成员对象。",[10,1977,176],{},[19,1979,1982],{"className":1980,"code":1981,"language":53,"meta":25},[51],"class A\n{\nprivate:\n    const int SIZE;\n    int &ref;\n\npublic:\n    A(int s, int &r) : SIZE(s), ref(r)\n    {\n    }\n};\n",[27,1983,1981],{"__ignoreMap":25},[10,1985,1986],{},"成员初始化顺序：",[19,1988,1991],{"className":1989,"code":1990,"language":53,"meta":25},[51],"class A\n{\nprivate:\n    int x;\n    int y;\n\npublic:\n    A() : y(2), x(1) {}\n};\n",[27,1992,1990],{"__ignoreMap":25},[10,1994,1995,1996,1998,1999,2001,2002,2004,2005,120],{},"虽然初始化列表写的是 ",[27,1997,1304],{"code":1304}," 再 ",[27,2000,371],{"code":371},"，实际初始化顺序仍按成员声明顺序：先 ",[27,2003,371],{"code":371}," 后 ",[27,2006,1304],{"code":1304},[10,2008,569],{},[19,2010,2013],{"className":2011,"code":2012,"language":24,"meta":25},[22],"初始化顺序看类内声明顺序，不看初始化列表书写顺序\nconst、引用、无默认构造成员必须用初始化列表\n",[27,2014,2012],{"__ignoreMap":25},[34,2016,2018],{"id":2017},"_38-委托构造函数","3.8 委托构造函数",[10,2020,2021],{},"委托构造函数是一个构造函数调用同类的另一个构造函数完成初始化。",[10,2023,176],{},[19,2025,2028],{"className":2026,"code":2027,"language":53,"meta":25},[51],"class X\n{\nprivate:\n    string name;\n    int code;\n\npublic:\n    X(string n, int c) : name(n), code(c)\n    {\n    }\n\n    X() : X(\"\", 42)\n    {\n    }\n\n    X(string s) : X(s, 0)\n    {\n    }\n};\n",[27,2029,2027],{"__ignoreMap":25},[10,2031,2032],{},"执行顺序：",[19,2034,2037],{"className":2035,"code":2036,"language":24,"meta":25},[22],"先执行被委托构造函数的初始化列表和函数体\n再回到委托者自己的函数体\n",[27,2038,2036],{"__ignoreMap":25},[10,2040,2041],{},"作用：",[107,2043,2044,2047],{},[110,2045,2046],{},"减少多个构造函数之间重复初始化代码。",[110,2048,2049],{},"让初始化逻辑集中在一个主构造函数里。",[34,2051,2053],{"id":2052},"_39-复制构造函数","3.9 复制构造函数",[10,2055,2056],{},"复制构造函数用于用一个已有对象初始化一个新对象。",[10,2058,47],{},[19,2060,2063],{"className":2061,"code":2062,"language":53,"meta":25},[51],"类名(const 类名 &对象名);\n",[27,2064,2062],{"__ignoreMap":25},[10,2066,176],{},[19,2068,2071],{"className":2069,"code":2070,"language":53,"meta":25},[51],"class Clock\n{\nprivate:\n    int hour, minute, second;\n\npublic:\n    Clock(const Clock &c)\n    {\n        hour = c.hour;\n        minute = c.minute;\n        second = c.second;\n    }\n};\n",[27,2072,2070],{"__ignoreMap":25},[10,2074,2075],{},"触发复制构造的三种情况：",[416,2077,2079],{"id":2078},"情况一用对象初始化新对象","情况一：用对象初始化新对象",[19,2081,2084],{"className":2082,"code":2083,"language":53,"meta":25},[51],"Clock c1(8, 10, 20);\nClock c2(c1);\nClock c3 = c1;\n",[27,2085,2083],{"__ignoreMap":25},[10,2087,2088,71,2090,2092],{},[27,2089,1480],{"code":1480},[27,2091,1910],{"code":1910}," 都调用复制构造。",[416,2094,2096],{"id":2095},"情况二对象作为函数值参数","情况二：对象作为函数值参数",[19,2098,2101],{"className":2099,"code":2100,"language":53,"meta":25},[51],"void fun(Clock c)\n{\n}\n\nfun(c1);\n",[27,2102,2100],{"__ignoreMap":25},[10,2104,917,2105,2108,2109,2111],{},[27,2106,2107],{"code":2107},"c"," 是一个新形参对象，要用 ",[27,2110,1477],{"code":1477}," 初始化它。",[10,2113,2114],{},"如果改成引用：",[19,2116,2119],{"className":2117,"code":2118,"language":53,"meta":25},[51],"void fun(const Clock &c)\n{\n}\n",[27,2120,2118],{"__ignoreMap":25},[10,2122,2123],{},"不会调用复制构造。",[416,2125,2127],{"id":2126},"情况三函数返回对象","情况三：函数返回对象",[19,2129,2132],{"className":2130,"code":2131,"language":53,"meta":25},[51],"Clock makeClock()\n{\n    Clock c(1, 2, 3);\n    return c;\n}\n",[27,2133,2131],{"__ignoreMap":25},[10,2135,2136],{},"理论上可能调用复制构造。但现代编译器常做返回值优化，实际输出未必能看到复制构造调用。",[10,2138,2139,2140,619],{},"为什么参数通常写 ",[27,2141,2142],{"code":2142},"const Clock &c",[107,2144,2145,2148],{},[110,2146,2147],{},"引用避免再次复制。",[110,2149,2150,2152],{},[27,2151,582],{"code":582}," 保证不会修改源对象。",[10,2154,569],{},[19,2156,2159],{"className":2157,"code":2158,"language":24,"meta":25},[22],"复制构造：新对象诞生时，用旧对象初始化\n",[27,2160,2158],{"__ignoreMap":25},[34,2162,2164],{"id":2163},"_310-析构函数","3.10 析构函数",[10,2166,2167],{},"析构函数用于对象销毁前清理资源。",[10,2169,47],{},[19,2171,2174],{"className":2172,"code":2173,"language":53,"meta":25},[51],"~类名()\n{\n}\n",[27,2175,2173],{"__ignoreMap":25},[10,2177,176],{},[19,2179,2182],{"className":2180,"code":2181,"language":53,"meta":25},[51],"class A\n{\npublic:\n    ~A()\n    {\n        cout \u003C\u003C \"析构\" \u003C\u003C endl;\n    }\n};\n",[27,2183,2181],{"__ignoreMap":25},[10,2185,2186],{},"规则：",[107,2188,2189,2195,2198,2201,2204],{},[110,2190,2191,2192,120],{},"名字是 ",[27,2193,2194],{"code":2194},"~类名",[110,2196,2197],{},"没有返回值。",[110,2199,2200],{},"没有参数。",[110,2202,2203],{},"一个类只能有一个析构函数。",[110,2205,2206],{},"对象生命周期结束时自动调用。",[10,2208,2209],{},"何时调用析构：",[19,2211,2214],{"className":2212,"code":2213,"language":53,"meta":25},[51],"void f()\n{\n    A a;\n} \u002F\u002F 离开作用域，a 析构\n",[27,2215,2213],{"__ignoreMap":25},[10,2217,2218],{},"动态对象：",[19,2220,2223],{"className":2221,"code":2222,"language":53,"meta":25},[51],"A *p = new A;\ndelete p; \u002F\u002F delete 时调用析构\n",[27,2224,2222],{"__ignoreMap":25},[10,2226,2227,2228,2231,2232,120],{},"如果类中有 ",[27,2229,2230],{"code":2230},"new"," 分配资源，通常要在析构函数中 ",[27,2233,2234],{"code":2234},"delete",[10,2236,569],{},[19,2238,2241],{"className":2239,"code":2240,"language":24,"meta":25},[22],"构造：出生\n析构：死亡\nnew 出来的对象 delete 时才析构\n",[27,2242,2240],{"__ignoreMap":25},[34,2244,2246],{"id":2245},"_311-类组合","3.11 类组合",[10,2248,2249],{},"类组合就是一个类的数据成员是另一个类的对象。",[10,2251,176],{},[19,2253,2256],{"className":2254,"code":2255,"language":53,"meta":25},[51],"class Point\n{\nprivate:\n    int x, y;\n};\n\nclass Line\n{\nprivate:\n    Point p1;\n    Point p2;\n    double len;\n};\n",[27,2257,2255],{"__ignoreMap":25},[10,2259,2260,2263,2264,2267],{},[27,2261,2262],{"code":2262},"Line"," 包含两个 ",[27,2265,2266],{"code":2266},"Point"," 对象。",[10,2269,2270],{},"构造顺序：",[19,2272,2275],{"className":2273,"code":2274,"language":24,"meta":25},[22],"先构造成员对象\n再执行本类构造函数体\n",[27,2276,2274],{"__ignoreMap":25},[10,2278,176],{},[19,2280,2283],{"className":2281,"code":2282,"language":53,"meta":25},[51],"Line::Line(Point a, Point b) : p1(a), p2(b)\n{\n    \u002F\u002F 这里执行时，p1 和 p2 已经构造好了\n}\n",[27,2284,2282],{"__ignoreMap":25},[10,2286,2287],{},"成员对象构造顺序由成员声明顺序决定：",[19,2289,2292],{"className":2290,"code":2291,"language":53,"meta":25},[51],"class Line\n{\nprivate:\n    Point p1;\n    Point p2;\n};\n",[27,2293,2291],{"__ignoreMap":25},[10,2295,2296,2297,2300,2301,120],{},"先 ",[27,2298,2299],{"code":2299},"p1","，再 ",[27,2302,2303],{"code":2303},"p2",[10,2305,2306],{},"析构顺序反过来：",[19,2308,2311],{"className":2309,"code":2310,"language":24,"meta":25},[22],"先执行 Line 的析构函数体\n再析构 p2\n再析构 p1\n",[27,2312,2310],{"__ignoreMap":25},[10,2314,2315],{},"复制构造中，如果自己写了复制构造，要在初始化列表中初始化成员对象：",[19,2317,2320],{"className":2318,"code":2319,"language":53,"meta":25},[51],"Line::Line(const Line &L) : p1(L.p1), p2(L.p2)\n{\n    len = L.len;\n}\n",[27,2321,2319],{"__ignoreMap":25},[10,2323,569],{},[19,2325,2328],{"className":2326,"code":2327,"language":24,"meta":25},[22],"组合构造：先人后己\n组合析构：先己后人\n",[27,2329,2327],{"__ignoreMap":25},[34,2331,2333],{"id":2332},"_312-前向引用声明","3.12 前向引用声明",[10,2335,2336],{},"如果两个类互相引用，可以先声明类名。",[10,2338,47],{},[19,2340,2343],{"className":2341,"code":2342,"language":53,"meta":25},[51],"class B;\n",[27,2344,2342],{"__ignoreMap":25},[10,2346,176],{},[19,2348,2351],{"className":2349,"code":2350,"language":53,"meta":25},[51],"class B;\n\nclass A\n{\npublic:\n    void f(B *b);\n};\n",[27,2352,2350],{"__ignoreMap":25},[10,2354,2355],{},"前向声明只告诉编译器：“有一个类叫 B”。",[10,2357,2358],{},"在完整定义前可以：",[19,2360,2363],{"className":2361,"code":2362,"language":53,"meta":25},[51],"B *p;\nB &r;\n",[27,2364,2362],{"__ignoreMap":25},[10,2366,2367],{},"不能：",[19,2369,2372],{"className":2370,"code":2371,"language":53,"meta":25},[51],"B obj; \u002F\u002F 错，不知道 B 有多大\n",[27,2373,2371],{"__ignoreMap":25},[10,2375,2376],{},"也不能在类内内联函数里访问 B 的成员：",[19,2378,2381],{"className":2379,"code":2380,"language":53,"meta":25},[51],"class B;\n\nclass A\n{\npublic:\n    void f(B *b)\n    {\n        b->g(); \u002F\u002F 错，还不知道 B 里有没有 g\n    }\n};\n",[27,2382,2380],{"__ignoreMap":25},[10,2384,2385],{},"要在 B 完整定义后再写函数体。",[34,2387,2389,2390,473,2393],{"id":2388},"_313-struct-和-class","3.13 ",[27,2391,2392],{"code":2392},"struct",[27,2394,2395],{"code":2395},"class",[10,2397,2398,2399,473,2401,2403],{},"C++ 中 ",[27,2400,2392],{"code":2392},[27,2402,2395],{"code":2395}," 功能几乎一样。",[10,2405,2406],{},"区别主要是默认访问权限：",[19,2408,2411],{"className":2409,"code":2410,"language":53,"meta":25},[51],"struct S\n{\n    int x; \u002F\u002F 默认 public\n};\n\nclass C\n{\n    int x; \u002F\u002F 默认 private\n};\n",[27,2412,2410],{"__ignoreMap":25},[10,2414,2415],{},"因此：",[19,2417,2420],{"className":2418,"code":2419,"language":53,"meta":25},[51],"S s;\ns.x = 1; \u002F\u002F 对\n\nC c;\nc.x = 1; \u002F\u002F 错\n",[27,2421,2419],{"__ignoreMap":25},[10,2423,569],{},[19,2425,2428],{"className":2426,"code":2427,"language":24,"meta":25},[22],"struct 默认 public\nclass 默认 private\n",[27,2429,2427],{"__ignoreMap":25},[34,2431,2433,2434],{"id":2432},"_314-union","3.14 ",[27,2435,2436],{"code":2436},"union",[10,2438,2439,2441],{},[27,2440,2436],{"code":2436}," 的多个成员共享同一片内存。",[10,2443,176],{},[19,2445,2448],{"className":2446,"code":2447,"language":53,"meta":25},[51],"union Mark\n{\n    char grade;\n    bool pass;\n    int percent;\n};\n",[27,2449,2447],{"__ignoreMap":25},[10,2451,2452,2453,2455,2456,2458],{},"如果 ",[27,2454,712],{"code":712}," 占 4 字节，则整个 ",[27,2457,2436],{"code":2436}," 通常占 4 字节，因为要容纳最大成员。",[10,2460,2461],{},"特点：",[107,2463,2464,2467,2470],{},[110,2465,2466],{},"成员共用内存。",[110,2468,2469],{},"同一时刻一般只有一个成员有效。",[110,2471,2472],{},"给一个成员赋值会覆盖另一个成员的数据。",[10,2474,176],{},[19,2476,2479],{"className":2477,"code":2478,"language":53,"meta":25},[51],"union U\n{\n    int i;\n    float f;\n};\n\nU u;\nu.i = 10;\nu.f = 2.2; \u002F\u002F 此时 i 的值被覆盖\n",[27,2480,2478],{"__ignoreMap":25},[14,2482,2484],{"id":2483},"_4-数据的共享与保护","4. 数据的共享与保护",[34,2486,2488],{"id":2487},"_41-作用域","4.1 作用域",[10,2490,2491],{},"作用域指一个标识符有效的范围。",[10,2493,2494],{},"常见作用域：",[107,2496,2497,2500,2503,2506,2509,2512],{},[110,2498,2499],{},"函数原型作用域。",[110,2501,2502],{},"局部作用域。",[110,2504,2505],{},"类作用域。",[110,2507,2508],{},"文件作用域。",[110,2510,2511],{},"命名空间作用域。",[110,2513,2514],{},"枚举类限定作用域。",[10,2516,176],{},[19,2518,2521],{"className":2519,"code":2520,"language":53,"meta":25},[51],"int x = 1; \u002F\u002F 文件作用域\n\nvoid f()\n{\n    int x = 2; \u002F\u002F 局部作用域\n    cout \u003C\u003C x \u003C\u003C endl; \u002F\u002F 2\n}\n",[27,2522,2520],{"__ignoreMap":25},[10,2524,2525],{},"内层同名变量会隐藏外层变量。",[10,2527,2186],{},[19,2529,2532],{"className":2530,"code":2531,"language":24,"meta":25},[22],"先声明，后使用\n同一作用域不能重复声明同名变量\n内层同名隐藏外层同名\n",[27,2533,2531],{"__ignoreMap":25},[34,2535,2537],{"id":2536},"_42-可见性","4.2 可见性",[10,2539,2540],{},"可见性是从某个位置能不能引用某个标识符。",[10,2542,176],{},[19,2544,2547],{"className":2545,"code":2546,"language":53,"meta":25},[51],"int i = 5;\n\nint main()\n{\n    {\n        int i = 7;\n        cout \u003C\u003C i \u003C\u003C endl; \u002F\u002F 7\n    }\n    cout \u003C\u003C i \u003C\u003C endl; \u002F\u002F 5\n}\n",[27,2548,2546],{"__ignoreMap":25},[10,2550,2551,2552,2555,2556,2558],{},"虽然全局 ",[27,2553,2554],{"code":2554},"i"," 的作用域包含整个文件，但在内层块中被局部 ",[27,2557,2554],{"code":2554}," 隐藏，所以暂时不可见。",[10,2560,2561],{},"作用域和可见性区别：",[19,2563,2566],{"className":2564,"code":2565,"language":24,"meta":25},[22],"作用域：理论上有效的区域\n可见性：当前位置实际能不能看见它\n",[27,2567,2565],{"__ignoreMap":25},[34,2569,2571],{"id":2570},"_43-对象生存期","4.3 对象生存期",[10,2573,2574],{},"生存期指对象从产生到销毁的时间。",[10,2576,2577],{},"静态生存期：",[19,2579,2582],{"className":2580,"code":2581,"language":53,"meta":25},[51],"int g = 1;\n\nvoid f()\n{\n    static int cnt = 0;\n    cnt++;\n}\n",[27,2583,2581],{"__ignoreMap":25},[10,2585,2586,473,2589,2592],{},[27,2587,2588],{"code":2588},"g",[27,2590,2591],{"code":2591},"cnt"," 都有静态生存期，和程序运行期相同。",[10,2594,2595],{},"动态生存期：",[19,2597,2600],{"className":2598,"code":2599,"language":53,"meta":25},[51],"void f()\n{\n    int x = 0;\n} \u002F\u002F x 在这里结束\n",[27,2601,2599],{"__ignoreMap":25},[10,2603,2604,2605,2608],{},"局部非 ",[27,2606,2607],{"code":2607},"static"," 对象从声明处开始，到块结束结束。",[10,2610,569],{},[19,2612,2615],{"className":2613,"code":2614,"language":24,"meta":25},[22],"static 活到程序结束\n普通局部变量活到块结束\n",[27,2616,2614],{"__ignoreMap":25},[34,2618,2620],{"id":2619},"_44-静态数据成员","4.4 静态数据成员",[10,2622,2623],{},"静态数据成员属于类，不属于某个对象。",[10,2625,47],{},[19,2627,2630],{"className":2628,"code":2629,"language":53,"meta":25},[51],"class A\n{\nprivate:\n    static int count;\n};\n\nint A::count = 0;\n",[27,2631,2629],{"__ignoreMap":25},[10,2633,2634],{},"为什么需要静态数据成员？",[10,2636,2637,2638,2641],{},"假设要统计某个类创建了多少对象。如果把 ",[27,2639,2640],{"code":2640},"count"," 放在每个对象里：",[19,2643,2646],{"className":2644,"code":2645,"language":53,"meta":25},[51],"class A\n{\nprivate:\n    int count;\n};\n",[27,2647,2645],{"__ignoreMap":25},[10,2649,2650,2651,2653],{},"每个对象都有一个 ",[27,2652,2640],{"code":2640},"，不能表示全类总数。",[10,2655,2656],{},"所以用：",[19,2658,2661],{"className":2659,"code":2660,"language":53,"meta":25},[51],"static int count;\n",[27,2662,2660],{"__ignoreMap":25},[10,2664,2665],{},"所有对象共享一份。",[10,2667,2668],{},"访问方式：",[19,2670,2673],{"className":2671,"code":2672,"language":53,"meta":25},[51],"A::count;\nobj.count;\np->count;\n",[27,2674,2672],{"__ignoreMap":25},[10,2676,2677,2678,2680],{},"如果是 ",[27,2679,1452],{"code":1452},"，外部不能访问，但类外初始化允许：",[19,2682,2685],{"className":2683,"code":2684,"language":53,"meta":25},[51],"int A::count = 0;\n",[27,2686,2684],{"__ignoreMap":25},[10,2688,2689],{},"这是定义，不是普通访问。",[10,2691,2692],{},"考试重点：",[107,2694,2695,2698,2701,2703],{},[110,2696,2697],{},"静态数据成员类内声明。",[110,2699,2700],{},"一般类外定义并初始化。",[110,2702,2665],{},[110,2704,2705],{},"静态数据成员有静态生存期。",[34,2707,2709],{"id":2708},"_45-静态成员函数","4.5 静态成员函数",[10,2711,2712],{},"静态成员函数属于类，不依赖具体对象。",[10,2714,47],{},[19,2716,2719],{"className":2717,"code":2718,"language":53,"meta":25},[51],"class A\n{\npublic:\n    static void show();\n};\n\nvoid A::show()\n{\n}\n",[27,2720,2718],{"__ignoreMap":25},[10,2722,936],{},[19,2724,2727],{"className":2725,"code":2726,"language":53,"meta":25},[51],"A::show();\n",[27,2728,2726],{"__ignoreMap":25},[10,2730,2731],{},"也可以：",[19,2733,2736],{"className":2734,"code":2735,"language":53,"meta":25},[51],"A a;\na.show();\n",[27,2737,2735],{"__ignoreMap":25},[10,2739,2740],{},"但本质上它不依赖对象。",[10,2742,2743],{},"重要规则：",[10,2745,2746,2747,2749],{},"静态成员函数没有 ",[27,2748,1720],{"code":1720}," 指针。",[10,2751,2752],{},"所以它不能直接访问非静态成员：",[19,2754,2757],{"className":2755,"code":2756,"language":53,"meta":25},[51],"class A\n{\nprivate:\n    int x;\n    static int y;\n\npublic:\n    static void f()\n    {\n        y = 1; \u002F\u002F 对\n        x = 2; \u002F\u002F 错，没有 this，不知道是哪个对象的 x\n    }\n};\n",[27,2758,2756],{"__ignoreMap":25},[10,2760,2761],{},"如果想访问非静态成员，必须通过对象：",[19,2763,2766],{"className":2764,"code":2765,"language":53,"meta":25},[51],"static void f(A a)\n{\n    cout \u003C\u003C a.x \u003C\u003C endl;\n}\n",[27,2767,2765],{"__ignoreMap":25},[10,2769,2770,2771,355],{},"静态成员函数也不能写成 ",[27,2772,582],{"code":582},[19,2774,2777],{"className":2775,"code":2776,"language":53,"meta":25},[51],"static void f() const; \u002F\u002F 错\n",[27,2778,2776],{"__ignoreMap":25},[10,2780,917,2781,2783,2784,2786,2787,120],{},[27,2782,582],{"code":582}," 成员函数修饰的是 ",[27,2785,1720],{"code":1720}," 指向的对象，而静态函数没有 ",[27,2788,1720],{"code":1720},[34,2790,2792],{"id":2791},"_46-友元函数","4.6 友元函数",[10,2794,2795],{},"友元函数是定义在类外的普通函数，但它被某个类授权访问该类私有成员。",[10,2797,2798],{},"声明：",[19,2800,2803],{"className":2801,"code":2802,"language":53,"meta":25},[51],"class Point\n{\nprivate:\n    double x, y;\n\npublic:\n    friend double dist(Point &a, Point &b);\n};\n",[27,2804,2802],{"__ignoreMap":25},[10,2806,2807],{},"定义：",[19,2809,2812],{"className":2810,"code":2811,"language":53,"meta":25},[51],"double dist(Point &a, Point &b)\n{\n    double dx = a.x - b.x;\n    double dy = a.y - b.y;\n    return sqrt(dx * dx + dy * dy);\n}\n",[27,2813,2811],{"__ignoreMap":25},[10,2815,301],{},[107,2817,2818,2824,2829,2832,2839],{},[110,2819,2820,2823],{},[27,2821,2822],{"code":2822},"friend"," 只在类内声明时写。",[110,2825,2826,2827,120],{},"类外定义不要写 ",[27,2828,2822],{"code":2822},[110,2830,2831],{},"友元函数不是成员函数。",[110,2833,2834,2835,2838],{},"不能用 ",[27,2836,2837],{"code":2837},"p.dist()"," 调用。",[110,2840,2841],{},"友元函数可以直接访问私有成员。",[10,2843,2844],{},"为什么要用友元？",[10,2846,2847],{},"有时某个函数逻辑上需要访问两个对象的私有数据，但它又不适合作为其中一个对象的成员函数。",[10,2849,2850],{},"比如求两点距离：",[19,2852,2855],{"className":2853,"code":2854,"language":53,"meta":25},[51],"dist(p1, p2);\n",[27,2856,2854],{"__ignoreMap":25},[10,2858,2859],{},"比写成：",[19,2861,2864],{"className":2862,"code":2863,"language":53,"meta":25},[51],"p1.dist(p2);\n",[27,2865,2863],{"__ignoreMap":25},[10,2867,2868],{},"有时更自然。",[34,2870,2872],{"id":2871},"_47-友元类","4.7 友元类",[10,2874,2875],{},"一个类可以把另一个类声明为友元类。",[10,2877,47],{},[19,2879,2882],{"className":2880,"code":2881,"language":53,"meta":25},[51],"class A\n{\n    friend class B;\n\nprivate:\n    int x;\n};\n",[27,2883,2881],{"__ignoreMap":25},[10,2885,2886,2887,2890,2891,2893],{},"这样 ",[27,2888,2889],{"code":2889},"B"," 的所有成员函数都可以访问 ",[27,2892,367],{"code":367}," 的私有成员。",[10,2895,176],{},[19,2897,2900],{"className":2898,"code":2899,"language":53,"meta":25},[51],"class A\n{\n    friend class B;\nprivate:\n    int x;\n};\n\nclass B\n{\npublic:\n    void set(A &a, int v)\n    {\n        a.x = v;\n    }\n};\n",[27,2901,2899],{"__ignoreMap":25},[10,2903,2904],{},"友元关系的三个规则：",[19,2906,2909],{"className":2907,"code":2908,"language":24,"meta":25},[22],"不传递\n不对称\n不继承\n",[27,2910,2908],{"__ignoreMap":25},[10,2912,2913],{},"解释：",[107,2915,2916,2919,2922],{},[110,2917,2918],{},"A 把 B 当友元，B 把 C 当友元，不代表 C 是 A 的友元。",[110,2920,2921],{},"A 把 B 当友元，不代表 B 也把 A 当友元。",[110,2923,2924],{},"基类的友元关系不会自动传给派生类。",[34,2926,2928],{"id":2927},"_48-常对象","4.8 常对象",[10,2930,2931],{},"常对象是不能被修改的对象。",[10,2933,47],{},[19,2935,2938],{"className":2936,"code":2937,"language":53,"meta":25},[51],"const 类名 对象名(参数);\n",[27,2939,2937],{"__ignoreMap":25},[10,2941,176],{},[19,2943,2946],{"className":2944,"code":2945,"language":53,"meta":25},[51],"const Point p(1, 2);\n",[27,2947,2945],{"__ignoreMap":25},[10,2949,2950],{},"常对象的数据成员不能被修改。",[10,2952,2953],{},"常对象只能调用常成员函数。",[19,2955,2958],{"className":2956,"code":2957,"language":53,"meta":25},[51],"class Point\n{\npublic:\n    int getX() const;\n    void setX(int x);\n};\n\nconst Point p;\np.getX(); \u002F\u002F 对\np.setX(1); \u002F\u002F 错\n",[27,2959,2957],{"__ignoreMap":25},[10,2961,2962],{},"为什么？",[10,2964,2965,2968,2969,2971],{},[27,2966,2967],{"code":2967},"setX"," 可能修改对象，而 ",[27,2970,10],{"code":10}," 是常对象。",[34,2973,2975],{"id":2974},"_49-常成员函数","4.9 常成员函数",[10,2977,2978],{},"常成员函数承诺不修改目的对象。",[10,2980,47],{},[19,2982,2985],{"className":2983,"code":2984,"language":53,"meta":25},[51],"返回类型 函数名(参数列表) const;\n",[27,2986,2984],{"__ignoreMap":25},[10,2988,2989,2990,355],{},"声明和定义都要写 ",[27,2991,582],{"code":582},[19,2993,2996],{"className":2994,"code":2995,"language":53,"meta":25},[51],"class Point\n{\nprivate:\n    int x;\n\npublic:\n    int getX() const;\n};\n\nint Point::getX() const\n{\n    return x;\n}\n",[27,2997,2995],{"__ignoreMap":25},[10,2999,3000],{},"常成员函数内部不能修改普通数据成员：",[19,3002,3005],{"className":3003,"code":3004,"language":53,"meta":25},[51],"int Point::getX() const\n{\n    x++; \u002F\u002F 错\n    return x;\n}\n",[27,3006,3004],{"__ignoreMap":25},[10,3008,3009,3010,3012],{},"也不能调用非 ",[27,3011,582],{"code":582}," 成员函数：",[19,3014,3017],{"className":3015,"code":3016,"language":53,"meta":25},[51],"void setX(int v);\n\nint getX() const\n{\n    setX(1); \u002F\u002F 错\n}\n",[27,3018,3016],{"__ignoreMap":25},[10,3020,3021,3023],{},[27,3022,582],{"code":582}," 可以参与重载：",[19,3025,3028],{"className":3026,"code":3027,"language":53,"meta":25},[51],"void print();\nvoid print() const;\n",[27,3029,3027],{"__ignoreMap":25},[10,3031,3032,3033,120],{},"构造函数和析构函数不能是 ",[27,3034,582],{"code":582},[10,3036,569],{},[19,3038,3041],{"className":3039,"code":3040,"language":24,"meta":25},[22],"常对象只能调常函数\n常函数不能改对象\n声明和定义都写 const\n",[27,3042,3040],{"__ignoreMap":25},[34,3044,3046],{"id":3045},"_410-常数据成员","4.10 常数据成员",[10,3048,3049,3050,1969],{},"常数据成员是类中的 ",[27,3051,582],{"code":582},[10,3053,176],{},[19,3055,3058],{"className":3056,"code":3057,"language":53,"meta":25},[51],"class A\n{\nprivate:\n    const int SIZE;\n\npublic:\n    A(int size) : SIZE(size)\n    {\n    }\n};\n",[27,3059,3057],{"__ignoreMap":25},[10,3061,3062],{},"常数据成员必须在初始化列表中初始化。",[10,3064,803],{},[19,3066,3069],{"className":3067,"code":3068,"language":53,"meta":25},[51],"A::A(int size)\n{\n    SIZE = size; \u002F\u002F 错，函数体里是赋值，不是初始化\n}\n",[27,3070,3068],{"__ignoreMap":25},[10,3072,3073],{},"原因：",[10,3075,3076,3078],{},[27,3077,582],{"code":582}," 成员一旦初始化之后不能再赋值，所以必须在对象构造阶段直接初始化。",[34,3080,3082],{"id":3081},"_411-常引用","4.11 常引用",[10,3084,3085],{},"常引用语法：",[19,3087,3090],{"className":3088,"code":3089,"language":53,"meta":25},[51],"const 类型 &引用名 = 对象;\n",[27,3091,3089],{"__ignoreMap":25},[10,3093,176],{},[19,3095,3098],{"className":3096,"code":3097,"language":53,"meta":25},[51],"void printPoint(const Point &p)\n{\n    cout \u003C\u003C p.getX() \u003C\u003C endl;\n}\n",[27,3099,3097],{"__ignoreMap":25},[10,3101,2041],{},[107,3103,3104,3107],{},[110,3105,3106],{},"避免对象值传递带来的复制开销。",[110,3108,3109],{},"防止函数内部修改实参对象。",[10,3111,3112],{},"常引用可以绑定普通对象：",[19,3114,3117],{"className":3115,"code":3116,"language":53,"meta":25},[51],"Point p;\nconst Point &r = p;\n",[27,3118,3116],{"__ignoreMap":25},[10,3120,3121],{},"也可以绑定常对象：",[19,3123,3126],{"className":3124,"code":3125,"language":53,"meta":25},[51],"const Point cp;\nconst Point &r = cp;\n",[27,3127,3125],{"__ignoreMap":25},[10,3129,3130],{},"普通引用不能绑定常对象：",[19,3132,3135],{"className":3133,"code":3134,"language":53,"meta":25},[51],"Point &r = cp; \u002F\u002F 错\n",[27,3136,3134],{"__ignoreMap":25},[10,3138,3139],{},"通过常引用，只能调用常成员函数。",[10,3141,569],{},[19,3143,3146],{"className":3144,"code":3145,"language":24,"meta":25},[22],"类对象参数优先考虑 const 引用\n",[27,3147,3145],{"__ignoreMap":25},[34,3149,3151],{"id":3150},"_412-多文件结构","4.12 多文件结构",[10,3153,3154],{},"大程序通常拆成多个文件。",[10,3156,3157],{},"常见结构：",[19,3159,3162],{"className":3160,"code":3161,"language":24,"meta":25},[22],"ClassName.h      类声明\nClassName.cpp    类成员函数定义\nmain.cpp         使用类\n",[27,3163,3161],{"__ignoreMap":25},[10,3165,176],{},[10,3167,3168,355],{},[27,3169,3170],{"code":3170},"Point.h",[19,3172,3175],{"className":3173,"code":3174,"language":53,"meta":25},[51],"#ifndef POINT_H\n#define POINT_H\n\nclass Point\n{\nprivate:\n    int x, y;\npublic:\n    Point(int x, int y);\n    int getX() const;\n};\n\n#endif\n",[27,3176,3174],{"__ignoreMap":25},[10,3178,3179,355],{},[27,3180,3181],{"code":3181},"Point.cpp",[19,3183,3186],{"className":3184,"code":3185,"language":53,"meta":25},[51],"#include \"Point.h\"\n\nPoint::Point(int x, int y) : x(x), y(y)\n{\n}\n\nint Point::getX() const\n{\n    return x;\n}\n",[27,3187,3185],{"__ignoreMap":25},[10,3189,3190,355],{},[27,3191,3192],{"code":3192},"main.cpp",[19,3194,3197],{"className":3195,"code":3196,"language":53,"meta":25},[51],"#include \u003Ciostream>\n#include \"Point.h\"\nusing namespace std;\n\nint main()\n{\n    Point p(1, 2);\n    cout \u003C\u003C p.getX() \u003C\u003C endl;\n}\n",[27,3198,3196],{"__ignoreMap":25},[34,3200,3202],{"id":3201},"_413-预处理和头文件保护","4.13 预处理和头文件保护",[10,3204,3205,355],{},[27,3206,3207],{"code":3207},"#include",[19,3209,3212],{"className":3210,"code":3211,"language":53,"meta":25},[51],"#include \u003Ciostream>\n#include \"Point.h\"\n",[27,3213,3211],{"__ignoreMap":25},[10,3215,3216],{},"尖括号一般用于系统头文件，双引号一般用于自定义头文件。",[10,3218,3219],{},"宏定义：",[19,3221,3224],{"className":3222,"code":3223,"language":53,"meta":25},[51],"#define PI 3.14\n",[27,3225,3223],{"__ignoreMap":25},[10,3227,3228],{},"但 C++ 中很多情况更推荐：",[19,3230,3233],{"className":3231,"code":3232,"language":53,"meta":25},[51],"const double PI = 3.14;\n",[27,3234,3232],{"__ignoreMap":25},[10,3236,3237],{},"条件编译：",[19,3239,3242],{"className":3240,"code":3241,"language":53,"meta":25},[51],"#ifdef DEBUG\ncout \u003C\u003C \"debug info\" \u003C\u003C endl;\n#endif\n",[27,3243,3241],{"__ignoreMap":25},[10,3245,3246],{},"头文件保护：",[19,3248,3251],{"className":3249,"code":3250,"language":53,"meta":25},[51],"#ifndef POINT_H\n#define POINT_H\n\n\u002F\u002F 头文件内容\n\n#endif\n",[27,3252,3250],{"__ignoreMap":25},[10,3254,3255],{},"作用：防止同一个头文件被重复包含。",[10,3257,569],{},[19,3259,3262],{"className":3260,"code":3261,"language":24,"meta":25},[22],"#ifndef 没定义才进入\n#define 定义宏\n#endif 结束\n",[27,3263,3261],{"__ignoreMap":25},[14,3265,3267],{"id":3266},"_5-数组指针字符串和动态内存","5. 数组、指针、字符串和动态内存",[34,3269,3271],{"id":3270},"_51-数组作为函数参数","5.1 数组作为函数参数",[10,3273,3274],{},"数组名作为函数参数时，传递的是数组首地址。",[10,3276,176],{},[19,3278,3281],{"className":3279,"code":3280,"language":53,"meta":25},[51],"void change(int a[])\n{\n    a[0] = 100;\n}\n\nint main()\n{\n    int x[3] = {1, 2, 3};\n    change(x);\n    cout \u003C\u003C x[0] \u003C\u003C endl; \u002F\u002F 100\n}\n",[27,3282,3280],{"__ignoreMap":25},[10,3284,3285],{},"所以数组作为参数时，函数内部修改会影响原数组。",[10,3287,3288],{},"二维数组参数：",[19,3290,3293],{"className":3291,"code":3292,"language":53,"meta":25},[51],"void f(int a[][4], int n)\n{\n}\n",[27,3294,3292],{"__ignoreMap":25},[10,3296,3297],{},"第二维通常必须写，因为编译器要知道如何计算下标地址。",[10,3299,569],{},[19,3301,3304],{"className":3302,"code":3303,"language":24,"meta":25},[22],"数组名传参 = 传首地址\n二维数组参数要写后面的维度\n",[27,3305,3303],{"__ignoreMap":25},[34,3307,3309],{"id":3308},"_52-对象数组","5.2 对象数组",[10,3311,3312],{},"对象数组就是数组元素是对象。",[10,3314,47],{},[19,3316,3319],{"className":3317,"code":3318,"language":53,"meta":25},[51],"类名 数组名[大小];\n",[27,3320,3318],{"__ignoreMap":25},[10,3322,176],{},[19,3324,3327],{"className":3325,"code":3326,"language":53,"meta":25},[51],"Clock c[2];\n",[27,3328,3326],{"__ignoreMap":25},[10,3330,3331,3332,2267],{},"每个元素都是一个 ",[27,3333,1473],{"code":1473},[10,3335,3336],{},"初始化：",[19,3338,3341],{"className":3339,"code":3340,"language":53,"meta":25},[51],"Point p[2] = {Point(1, 2), Point(3, 4)};\n",[27,3342,3340],{"__ignoreMap":25},[10,3344,3345],{},"如果只给一部分初值：",[19,3347,3350],{"className":3348,"code":3349,"language":53,"meta":25},[51],"Point p[2] = {Point(1, 2)};\n",[27,3351,3349],{"__ignoreMap":25},[10,3353,3354,3355,3358],{},"第一个元素用 ",[27,3356,3357],{"code":3357},"Point(1,2)"," 构造，第二个元素调用默认构造函数。",[10,3360,301],{},[107,3362,3363,3366],{},[110,3364,3365],{},"对象数组创建时，每个元素都调用构造函数。",[110,3367,3368],{},"对象数组销毁时，每个元素都调用析构函数。",[10,3370,3371],{},"如果类没有默认构造函数：",[19,3373,3376],{"className":3374,"code":3375,"language":53,"meta":25},[51],"class A\n{\npublic:\n    A(int x);\n};\n\nA a[10]; \u002F\u002F 错，每个元素都需要默认构造，但没有\n",[27,3377,3375],{"__ignoreMap":25},[34,3379,3381],{"id":3380},"_53-指针数组和数组指针","5.3 指针数组和数组指针",[10,3383,3384],{},"指针数组：",[19,3386,3389],{"className":3387,"code":3388,"language":53,"meta":25},[51],"int *p[10];\n",[27,3390,3388],{"__ignoreMap":25},[10,3392,3393,3395,3396,120],{},[27,3394,10],{"code":10}," 是数组，数组里每个元素是 ",[27,3397,3398],{"code":3398},"int*",[10,3400,3401],{},"数组指针：",[19,3403,3406],{"className":3404,"code":3405,"language":53,"meta":25},[51],"int (*p)[3];\n",[27,3407,3405],{"__ignoreMap":25},[10,3409,3410,3412,3413,3415],{},[27,3411,10],{"code":10}," 是指针，指向一个含 3 个 ",[27,3414,712],{"code":712}," 的数组。",[10,3417,3418],{},"怎么区分？",[10,3420,3421],{},"看括号。",[19,3423,3426],{"className":3424,"code":3425,"language":53,"meta":25},[51],"int *p[10];   \u002F\u002F [] 优先，p 先和 [] 结合，所以 p 是数组\nint (*p)[10]; \u002F\u002F p 先和 * 结合，所以 p 是指针\n",[27,3427,3425],{"__ignoreMap":25},[10,3429,569],{},[19,3431,3434],{"className":3432,"code":3433,"language":24,"meta":25},[22],"int *p[10]：十个 int 指针\nint (*p)[10]：一个指向十个 int 数组的指针\n",[27,3435,3433],{"__ignoreMap":25},[34,3437,3439],{"id":3438},"_54-对象指针","5.4 对象指针",[10,3441,3442],{},"对象指针存放对象地址。",[10,3444,47],{},[19,3446,3449],{"className":3447,"code":3448,"language":53,"meta":25},[51],"类名 *指针名;\n",[27,3450,3448],{"__ignoreMap":25},[10,3452,176],{},[19,3454,3457],{"className":3455,"code":3456,"language":53,"meta":25},[51],"Point p(1, 2);\nPoint *ptr = &p;\n",[27,3458,3456],{"__ignoreMap":25},[10,3460,3461],{},"通过指针访问成员：",[19,3463,3466],{"className":3464,"code":3465,"language":53,"meta":25},[51],"ptr->getX();\n",[27,3467,3465],{"__ignoreMap":25},[10,3469,3470],{},"等价于：",[19,3472,3475],{"className":3473,"code":3474,"language":53,"meta":25},[51],"(*ptr).getX();\n",[27,3476,3474],{"__ignoreMap":25},[10,3478,569],{},[19,3480,3483],{"className":3481,"code":3482,"language":24,"meta":25},[22],"对象.成员\n对象指针->成员\n",[27,3484,3482],{"__ignoreMap":25},[34,3486,3488],{"id":3487},"_55-成员指针","5.5 成员指针",[10,3490,3491],{},"成员指针不是普通指针，它指向类中的某个成员。",[10,3493,3494],{},"指向数据成员：",[19,3496,3499],{"className":3497,"code":3498,"language":53,"meta":25},[51],"int Point::*p = &Point::x;\n",[27,3500,3498],{"__ignoreMap":25},[10,3502,3503],{},"使用：",[19,3505,3508],{"className":3506,"code":3507,"language":53,"meta":25},[51],"Point a;\na.*p = 10;\n",[27,3509,3507],{"__ignoreMap":25},[10,3511,3512],{},"如果是对象指针：",[19,3514,3517],{"className":3515,"code":3516,"language":53,"meta":25},[51],"Point *pa = &a;\npa->*p = 20;\n",[27,3518,3516],{"__ignoreMap":25},[10,3520,3521],{},"指向成员函数：",[19,3523,3526],{"className":3524,"code":3525,"language":53,"meta":25},[51],"int (Point::*pf)() = &Point::getX;\n",[27,3527,3525],{"__ignoreMap":25},[10,3529,936],{},[19,3531,3534],{"className":3532,"code":3533,"language":53,"meta":25},[51],"(a.*pf)();\n(pa->*pf)();\n",[27,3535,3533],{"__ignoreMap":25},[10,3537,3538],{},"这类语法不常写，但选择题可能考。",[34,3540,3542,3543,473,3545],{"id":3541},"_56-new-和-delete","5.6 ",[27,3544,2230],{"code":2230},[27,3546,2234],{"code":2234},[10,3548,3549,3551,3552,3554],{},[27,3550,2230],{"code":2230}," 在堆区申请内存，",[27,3553,2234],{"code":2234}," 释放内存。",[10,3556,3557],{},"单个变量：",[19,3559,3562],{"className":3560,"code":3561,"language":53,"meta":25},[51],"int *p = new int;\n*p = 10;\ndelete p;\n",[27,3563,3561],{"__ignoreMap":25},[10,3565,3336],{},[19,3567,3570],{"className":3568,"code":3569,"language":53,"meta":25},[51],"int *p1 = new int;    \u002F\u002F 未初始化\nint *p2 = new int();  \u002F\u002F 初始化为 0\nint *p3 = new int(5); \u002F\u002F 初始化为 5\n",[27,3571,3569],{"__ignoreMap":25},[10,3573,3574],{},"数组：",[19,3576,3579],{"className":3577,"code":3578,"language":53,"meta":25},[51],"int *a = new int[10];\ndelete[] a;\n",[27,3580,3578],{"__ignoreMap":25},[10,3582,3583],{},"初始化为 0：",[19,3585,3588],{"className":3586,"code":3587,"language":53,"meta":25},[51],"int *a = new int[10]();\n",[27,3589,3587],{"__ignoreMap":25},[10,3591,3592],{},"配对关系：",[677,3594,3595,3605],{},[680,3596,3597],{},[683,3598,3599,3602],{},[686,3600,3601],{},"申请",[686,3603,3604],{},"释放",[693,3606,3607,3619],{},[683,3608,3609,3614],{},[698,3610,3611],{},[27,3612,3613],{"code":3613},"new T",[698,3615,3616],{},[27,3617,3618],{"code":3618},"delete p",[683,3620,3621,3626],{},[698,3622,3623],{},[27,3624,3625],{"code":3625},"new T[n]",[698,3627,3628],{},[27,3629,3630],{"code":3630},"delete[] p",[10,3632,803],{},[19,3634,3637],{"className":3635,"code":3636,"language":53,"meta":25},[51],"int *p = new int[10];\ndelete p; \u002F\u002F 错，应该 delete[]\n",[27,3638,3636],{"__ignoreMap":25},[10,3640,3641],{},"对象：",[19,3643,3646],{"className":3644,"code":3645,"language":53,"meta":25},[51],"Student *s = new Student;\ndelete s;\n",[27,3647,3645],{"__ignoreMap":25},[10,3649,3650,3652,3653,3655],{},[27,3651,2230],{"code":2230}," 对象会调用构造函数，",[27,3654,2234],{"code":2234}," 对象会调用析构函数。",[10,3657,569],{},[19,3659,3662],{"className":3660,"code":3661,"language":24,"meta":25},[22],"new 和 delete 一对一\nnew[] 和 delete[] 一对一\n",[27,3663,3661],{"__ignoreMap":25},[34,3665,3667,3668],{"id":3666},"_57-vector","5.7 ",[27,3669,3670],{"code":3670},"vector",[10,3672,3673,3675],{},[27,3674,3670],{"code":3670}," 是标准库中的动态数组类模板。",[10,3677,3678],{},"头文件：",[19,3680,3683],{"className":3681,"code":3682,"language":53,"meta":25},[51],"#include \u003Cvector>\n",[27,3684,3682],{"__ignoreMap":25},[10,3686,47],{},[19,3688,3691],{"className":3689,"code":3690,"language":53,"meta":25},[51],"vector\u003C元素类型> 名字(大小);\n",[27,3692,3690],{"__ignoreMap":25},[10,3694,176],{},[19,3696,3699],{"className":3697,"code":3698,"language":53,"meta":25},[51],"vector\u003Cint> a(10);\n",[27,3700,3698],{"__ignoreMap":25},[10,3702,3703,3704,3706],{},"表示 10 个 ",[27,3705,712],{"code":712},"，默认初始化为 0。",[10,3708,3709],{},"指定初值：",[19,3711,3714],{"className":3712,"code":3713,"language":53,"meta":25},[51],"vector\u003Cint> b(10, 1);\n",[27,3715,3713],{"__ignoreMap":25},[10,3717,3718],{},"10 个元素都为 1。",[10,3720,336],{},[19,3722,3725],{"className":3723,"code":3724,"language":53,"meta":25},[51],"a[0] = 5;\ncout \u003C\u003C a.size() \u003C\u003C endl;\n",[27,3726,3724],{"__ignoreMap":25},[10,3728,301],{},[107,3730,3731,3736,3741],{},[110,3732,3733,3735],{},[27,3734,3670],{"code":3670}," 对象名不是数组首地址。",[110,3737,3738,3740],{},[27,3739,3670],{"code":3670}," 是对象，不是普通数组。",[110,3742,3743,3746],{},[27,3744,3745],{"code":3745},"size()"," 返回元素个数。",[10,3748,3749],{},"算法竞赛里你很熟，但考试会强调它是“类模板”和“封装的动态数组”。",[34,3751,3753],{"id":3752},"_58-浅复制","5.8 浅复制",[10,3755,3756],{},"浅复制就是逐个复制数据成员。",[10,3758,3759],{},"如果类中只有普通数据成员，浅复制通常没问题：",[19,3761,3764],{"className":3762,"code":3763,"language":53,"meta":25},[51],"class A\n{\n    int x;\n    double y;\n};\n",[27,3765,3763],{"__ignoreMap":25},[10,3767,3768,3769,473,3771,120],{},"默认复制构造会复制 ",[27,3770,371],{"code":371},[27,3772,1304],{"code":1304},[10,3774,3775],{},"但如果类中有指针成员：",[19,3777,3780],{"className":3778,"code":3779,"language":53,"meta":25},[51],"class Array\n{\nprivate:\n    int *p;\n    int size;\n};\n",[27,3781,3779],{"__ignoreMap":25},[10,3783,3784],{},"默认复制只会复制指针值：",[19,3786,3789],{"className":3787,"code":3788,"language":24,"meta":25},[22],"a.p 和 b.p 指向同一片内存\n",[27,3790,3788],{"__ignoreMap":25},[10,3792,3793],{},"问题：",[107,3795,3796,3799,3802],{},[110,3797,3798],{},"两个对象共享同一内存。",[110,3800,3801],{},"一个对象修改，另一个也受影响。",[110,3803,3804,3805,120],{},"两个对象析构时可能重复 ",[27,3806,2234],{"code":2234},[34,3808,3810],{"id":3809},"_59-深复制","5.9 深复制",[10,3812,3813],{},"深复制就是重新分配一片独立内存，并复制内容。",[10,3815,176],{},[19,3817,3820],{"className":3818,"code":3819,"language":53,"meta":25},[51],"class Array\n{\nprivate:\n    int *p;\n    int size;\n\npublic:\n    Array(const Array &a)\n    {\n        size = a.size;\n        p = new int[size];\n        for (int i = 0; i \u003C size; i++)\n        {\n            p[i] = a.p[i];\n        }\n    }\n};\n",[27,3821,3819],{"__ignoreMap":25},[10,3823,3824],{},"深复制后：",[19,3826,3829],{"className":3827,"code":3828,"language":24,"meta":25},[22],"a.p 指向一片内存\nb.p 指向另一片内存\n内容相同，但空间独立\n",[27,3830,3828],{"__ignoreMap":25},[10,3832,3833],{},"只要类中有动态分配资源，通常要写：",[107,3835,3836,3839,3842],{},[110,3837,3838],{},"析构函数。",[110,3840,3841],{},"复制构造函数。",[110,3843,3844],{},"赋值运算符。",[10,3846,3847],{},"这就是 Big Three。",[34,3849,3851,3852],{"id":3850},"_510-string","5.10 ",[27,3853,3854],{"code":3854},"string",[10,3856,3857,3859],{},[27,3858,3854],{"code":3854}," 是 C++ 标准库字符串类。",[10,3861,3678],{},[19,3863,3866],{"className":3864,"code":3865,"language":53,"meta":25},[51],"#include \u003Cstring>\n",[27,3867,3865],{"__ignoreMap":25},[10,3869,2807],{},[19,3871,3874],{"className":3872,"code":3873,"language":53,"meta":25},[51],"string s1;\nstring s2(\"China\");\nstring s3 = \"Wust\";\nstring s4(s2);\n",[27,3875,3873],{"__ignoreMap":25},[10,3877,3878],{},"赋值：",[19,3880,3883],{"className":3881,"code":3882,"language":53,"meta":25},[51],"s1 = \"hello\";\ns2 = s1;\n",[27,3884,3882],{"__ignoreMap":25},[10,3886,3887],{},"拼接：",[19,3889,3892],{"className":3890,"code":3891,"language":53,"meta":25},[51],"string s = s1 + s2;\ns += \"!\";\n",[27,3893,3891],{"__ignoreMap":25},[10,3895,3896],{},"输入：",[19,3898,3901],{"className":3899,"code":3900,"language":53,"meta":25},[51],"cin >> s; \u002F\u002F 遇到空格停止\n",[27,3902,3900],{"__ignoreMap":25},[10,3904,3905],{},"读整行：",[19,3907,3910],{"className":3908,"code":3909,"language":53,"meta":25},[51],"getline(cin, s);\n",[27,3911,3909],{"__ignoreMap":25},[10,3913,3914],{},"按分隔符读取：",[19,3916,3919],{"className":3917,"code":3918,"language":53,"meta":25},[51],"getline(cin, s, ',');\n",[27,3920,3918],{"__ignoreMap":25},[10,3922,3923],{},"访问字符：",[19,3925,3928],{"className":3926,"code":3927,"language":53,"meta":25},[51],"s[0] = 'H';\ns.at(1) = 'e';\n",[27,3929,3927],{"__ignoreMap":25},[10,3931,3932,3935,3936,3939],{},[27,3933,3934],{"code":3934},"at"," 会做越界检查，",[27,3937,3938],{"code":3938},"[]"," 通常不做。",[14,3941,3943],{"id":3942},"_6-继承与派生","6. 继承与派生",[34,3945,3947],{"id":3946},"_61-继承的基本概念","6.1 继承的基本概念",[10,3949,3950],{},"继承是在已有类基础上定义新类。",[10,3952,47],{},[19,3954,3957],{"className":3955,"code":3956,"language":53,"meta":25},[51],"class 派生类名 : 继承方式 基类名\n{\n};\n",[27,3958,3956],{"__ignoreMap":25},[10,3960,176],{},[19,3962,3965],{"className":3963,"code":3964,"language":53,"meta":25},[51],"class Person\n{\npublic:\n    void eat();\n};\n\nclass Student : public Person\n{\npublic:\n    void study();\n};\n",[27,3966,3964],{"__ignoreMap":25},[10,3968,3969,3972,3973,3976],{},[27,3970,3971],{"code":3971},"Student"," 继承 ",[27,3974,3975],{"code":3975},"Person","，所以：",[19,3978,3981],{"className":3979,"code":3980,"language":53,"meta":25},[51],"Student s;\ns.eat();\ns.study();\n",[27,3982,3980],{"__ignoreMap":25},[10,3984,3985],{},"继承的目的：",[107,3987,3988,3991,3994],{},[110,3989,3990],{},"代码复用。",[110,3992,3993],{},"扩展已有类。",[110,3995,3996],{},"建立类之间的层次关系。",[10,3998,3999],{},"派生类生成过程：",[19,4001,4004],{"className":4002,"code":4003,"language":24,"meta":25},[22],"吸收基类成员\n改造基类成员\n添加新成员\n",[27,4005,4003],{"__ignoreMap":25},[10,4007,4008],{},"构造函数和析构函数不会被继承。",[34,4010,4012],{"id":4011},"_62-继承方式","6.2 继承方式",[10,4014,4015],{},"三种继承方式：",[19,4017,4020],{"className":4018,"code":4019,"language":53,"meta":25},[51],"class B : public A {};\nclass C : protected A {};\nclass D : private A {};\n",[27,4021,4019],{"__ignoreMap":25},[10,4023,4024],{},"继承后访问权限变化：",[677,4026,4027,4047],{},[680,4028,4029],{},[683,4030,4031,4034,4039,4043],{},[686,4032,4033],{},"基类成员",[686,4035,4036,4038],{},[27,4037,1458],{"code":1458}," 继承",[686,4040,4041,4038],{},[27,4042,1560],{"code":1560},[686,4044,4045,4038],{},[27,4046,1452],{"code":1452},[693,4048,4049,4067,4085],{},[683,4050,4051,4055,4059,4063],{},[698,4052,4053],{},[27,4054,1458],{"code":1458},[698,4056,4057],{},[27,4058,1458],{"code":1458},[698,4060,4061],{},[27,4062,1560],{"code":1560},[698,4064,4065],{},[27,4066,1452],{"code":1452},[683,4068,4069,4073,4077,4081],{},[698,4070,4071],{},[27,4072,1560],{"code":1560},[698,4074,4075],{},[27,4076,1560],{"code":1560},[698,4078,4079],{},[27,4080,1560],{"code":1560},[698,4082,4083],{},[27,4084,1452],{"code":1452},[683,4086,4087,4091,4093,4095],{},[698,4088,4089],{},[27,4090,1452],{"code":1452},[698,4092,1613],{},[698,4094,1613],{},[698,4096,1613],{},[10,4098,4099],{},"口诀：",[19,4101,4104],{"className":4102,"code":4103,"language":24,"meta":25},[22],"公保公不变\n私私保保\n私不访\n",[27,4105,4103],{"__ignoreMap":25},[10,4107,2913],{},[107,4109,4110,4113,4116],{},[110,4111,4112],{},"公有继承最常见，表示“派生类是基类的一种”。",[110,4114,4115],{},"保护继承和私有继承主要改变外部访问权限。",[110,4117,4118,4119,4121,4122,4125],{},"基类 ",[27,4120,1452],{"code":1452}," 成员派生类不能直接访问，只能通过基类 ",[27,4123,4124],{"code":4124},"public\u002Fprotected"," 成员函数间接访问。",[34,4127,4129],{"id":4128},"_63-类型兼容规则","6.3 类型兼容规则",[10,4131,4132],{},"公有派生类对象可以当作基类对象使用。",[10,4134,176],{},[19,4136,4139],{"className":4137,"code":4138,"language":53,"meta":25},[51],"class Base {};\nclass Derived : public Base {};\n\nBase b;\nDerived d;\n\nb = d;\nBase &rb = d;\nBase *pb = &d;\n",[27,4140,4138],{"__ignoreMap":25},[10,4142,4143],{},"三种情况：",[1760,4145,4146,4149,4152],{},[110,4147,4148],{},"派生类对象可以赋值给基类对象。",[110,4150,4151],{},"基类引用可以绑定派生类对象。",[110,4153,4154],{},"基类指针可以指向派生类对象。",[10,4156,4157],{},"反过来不行：",[19,4159,4162],{"className":4160,"code":4161,"language":53,"meta":25},[51],"Derived *pd = &b; \u002F\u002F 错\n",[27,4163,4161],{"__ignoreMap":25},[10,4165,4166],{},"替代后，只能使用基类部分。",[19,4168,4171],{"className":4169,"code":4170,"language":53,"meta":25},[51],"pb->baseFunc(); \u002F\u002F 对\npb->derivedFunc(); \u002F\u002F 错，pb 类型是 Base*\n",[27,4172,4170],{"__ignoreMap":25},[10,4174,4175],{},"类型兼容是虚函数和动态多态的基础。",[34,4177,4179],{"id":4178},"_64-对象切片","6.4 对象切片",[10,4181,4182],{},"对象切片指用派生类对象初始化或赋值给基类对象时，只保留基类部分。",[19,4184,4187],{"className":4185,"code":4186,"language":53,"meta":25},[51],"Derived d;\nBase b = d;\n",[27,4188,4186],{"__ignoreMap":25},[10,4190,4191,4192,4195,4196,4199,4200,4203],{},"此时 ",[27,4193,4194],{"code":4194},"b"," 是一个真正的 ",[27,4197,4198],{"code":4198},"Base"," 对象，不再和 ",[27,4201,4202],{"code":4202},"d"," 的派生类部分有关。",[10,4205,4206],{},"即使有虚函数：",[19,4208,4211],{"className":4209,"code":4210,"language":53,"meta":25},[51],"b.display();\n",[27,4212,4210],{"__ignoreMap":25},[10,4214,4215,4216,4219,4220,4222],{},"也调用 ",[27,4217,4218],{"code":4218},"Base::display()","，因为 ",[27,4221,4194],{"code":4194}," 本身就是基类对象。",[10,4224,569],{},[19,4226,4229],{"className":4227,"code":4228,"language":24,"meta":25},[22],"指针\u002F引用保留动态类型\n对象赋值会切片\n",[27,4230,4228],{"__ignoreMap":25},[34,4232,4234],{"id":4233},"_65-派生类构造函数","6.5 派生类构造函数",[10,4236,4237],{},"派生类构造时，要先构造基类部分。",[10,4239,47],{},[19,4241,4244],{"className":4242,"code":4243,"language":53,"meta":25},[51],"Derived::Derived(参数) : Base(基类参数), member(成员参数)\n{\n    \u002F\u002F 派生类新增成员初始化\n}\n",[27,4245,4243],{"__ignoreMap":25},[10,4247,176],{},[19,4249,4252],{"className":4250,"code":4251,"language":53,"meta":25},[51],"class Base\n{\npublic:\n    Base(int x);\n};\n\nclass Derived : public Base\n{\nprivate:\n    int y;\n\npublic:\n    Derived(int x, int y) : Base(x), y(y)\n    {\n    }\n};\n",[27,4253,4251],{"__ignoreMap":25},[10,4255,2270],{},[19,4257,4260],{"className":4258,"code":4259,"language":24,"meta":25},[22],"基类构造函数\n成员对象构造函数\n派生类构造函数体\n",[27,4261,4259],{"__ignoreMap":25},[10,4263,4264],{},"如果有多个基类，按继承列表顺序构造：",[19,4266,4269],{"className":4267,"code":4268,"language":53,"meta":25},[51],"class D : public B1, public B2 {};\n",[27,4270,4268],{"__ignoreMap":25},[10,4272,2296,4273,2300,4276,120],{},[27,4274,4275],{"code":4275},"B1",[27,4277,4278],{"code":4278},"B2",[34,4280,4282],{"id":4281},"_66-派生类析构函数","6.6 派生类析构函数",[10,4284,4285],{},"析构顺序和构造相反：",[19,4287,4290],{"className":4288,"code":4289,"language":24,"meta":25},[22],"派生类析构函数体\n成员对象析构函数\n基类析构函数\n",[27,4291,4289],{"__ignoreMap":25},[10,4293,176],{},[19,4295,4298],{"className":4296,"code":4297,"language":53,"meta":25},[51],"class Base\n{\npublic:\n    ~Base() { cout \u003C\u003C \"Base\" \u003C\u003C endl; }\n};\n\nclass Derived : public Base\n{\npublic:\n    ~Derived() { cout \u003C\u003C \"Derived\" \u003C\u003C endl; }\n};\n",[27,4299,4297],{"__ignoreMap":25},[19,4301,4304],{"className":4302,"code":4303,"language":53,"meta":25},[51],"Derived d;\n",[27,4305,4303],{"__ignoreMap":25},[10,4307,4308],{},"离开作用域时输出：",[19,4310,4313],{"className":4311,"code":4312,"language":24,"meta":25},[22],"Derived\nBase\n",[27,4314,4312],{"__ignoreMap":25},[10,4316,569],{},[19,4318,4321],{"className":4319,"code":4320,"language":24,"meta":25},[22],"构造从上到下\n析构从下到上\n",[27,4322,4320],{"__ignoreMap":25},[34,4324,4326],{"id":4325},"_67-同名隐藏","6.7 同名隐藏",[10,4328,4329],{},"派生类中定义了和基类同名的成员，会隐藏基类同名成员。",[10,4331,176],{},[19,4333,4336],{"className":4334,"code":4335,"language":53,"meta":25},[51],"class Base\n{\npublic:\n    void f(int);\n};\n\nclass Derived : public Base\n{\npublic:\n    void f(double);\n};\n",[27,4337,4335],{"__ignoreMap":25},[10,4339,4340,4343,4344,120],{},[27,4341,4342],{"code":4342},"Derived::f(double)"," 会隐藏 ",[27,4345,4346],{"code":4346},"Base::f(int)",[10,4348,936],{},[19,4350,4353],{"className":4351,"code":4352,"language":53,"meta":25},[51],"Derived d;\nd.f(3.14); \u002F\u002F Derived::f(double)\nd.f(1);    \u002F\u002F 仍可能调用 Derived::f(double)，基类 f 被隐藏\n",[27,4354,4352],{"__ignoreMap":25},[10,4356,4357],{},"如果要调用基类版本：",[19,4359,4362],{"className":4360,"code":4361,"language":53,"meta":25},[51],"d.Base::f(1);\n",[27,4363,4361],{"__ignoreMap":25},[10,4365,4366],{},"重载和隐藏区别：",[19,4368,4371],{"className":4369,"code":4370,"language":24,"meta":25},[22],"重载：同一作用域，函数名相同，参数不同\n隐藏：基类和派生类不同作用域，派生类同名成员挡住基类成员\n",[27,4372,4370],{"__ignoreMap":25},[34,4374,4376],{"id":4375},"_68-多继承二义性","6.8 多继承二义性",[10,4378,4379],{},"多继承时，如果多个基类有同名成员，派生类对象直接访问会二义。",[10,4381,176],{},[19,4383,4386],{"className":4384,"code":4385,"language":53,"meta":25},[51],"class A\n{\npublic:\n    void f();\n};\n\nclass B\n{\npublic:\n    void f();\n};\n\nclass C : public A, public B\n{\n};\n",[27,4387,4385],{"__ignoreMap":25},[10,4389,936],{},[19,4391,4394],{"className":4392,"code":4393,"language":53,"meta":25},[51],"C c;\nc.f(); \u002F\u002F 错，不知道是 A::f 还是 B::f\n",[27,4395,4393],{"__ignoreMap":25},[10,4397,4398],{},"解决：",[19,4400,4403],{"className":4401,"code":4402,"language":53,"meta":25},[51],"c.A::f();\nc.B::f();\n",[27,4404,4402],{"__ignoreMap":25},[10,4406,4407],{},"如果派生类自己定义同名函数：",[19,4409,4412],{"className":4410,"code":4411,"language":53,"meta":25},[51],"class C : public A, public B\n{\npublic:\n    void f();\n};\n",[27,4413,4411],{"__ignoreMap":25},[10,4415,1880],{},[19,4417,4420],{"className":4418,"code":4419,"language":53,"meta":25},[51],"c.f(); \u002F\u002F 调 C::f，无二义\n",[27,4421,4419],{"__ignoreMap":25},[34,4423,4425,4426,4428],{"id":4424},"_69-using-引入基类成员","6.9 ",[27,4427,354],{"code":354}," 引入基类成员",[10,4430,4431,4433],{},[27,4432,354],{"code":354}," 可以把基类成员引入派生类作用域。",[10,4435,176],{},[19,4437,4440],{"className":4438,"code":4439,"language":53,"meta":25},[51],"class D : public B1, public B2\n{\npublic:\n    using B1::fun;\n    using B1::nV;\n};\n",[27,4441,4439],{"__ignoreMap":25},[10,4443,2041],{},[107,4445,4446,4449],{},[110,4447,4448],{},"指定使用某个基类的同名成员。",[110,4450,4451],{},"让基类函数和派生类同名函数形成类似重载的效果。",[10,4453,176],{},[19,4455,4458],{"className":4456,"code":4457,"language":53,"meta":25},[51],"class B\n{\npublic:\n    void fun();\n};\n\nclass D : public B\n{\npublic:\n    using B::fun;\n    void fun(int);\n};\n",[27,4459,4457],{"__ignoreMap":25},[10,4461,4462],{},"这样：",[19,4464,4467],{"className":4465,"code":4466,"language":53,"meta":25},[51],"D d;\nd.fun();  \u002F\u002F B::fun\nd.fun(1); \u002F\u002F D::fun(int)\n",[27,4468,4466],{"__ignoreMap":25},[34,4470,4472],{"id":4471},"_610-虚基类","6.10 虚基类",[10,4474,4475],{},"虚基类用于解决菱形继承中共同基类被继承多份的问题。",[10,4477,4478],{},"普通菱形继承：",[19,4480,4483],{"className":4481,"code":4482,"language":53,"meta":25},[51],"class B0 {};\nclass B1 : public B0 {};\nclass B2 : public B0 {};\nclass D : public B1, public B2 {};\n",[27,4484,4482],{"__ignoreMap":25},[10,4486,4487,4490,4491,120],{},[27,4488,4489],{"code":4489},"D"," 中有两份 ",[27,4492,4493],{"code":4493},"B0",[10,4495,4496,4497,4499],{},"如果访问 ",[27,4498,4493],{"code":4493}," 成员，会二义。",[10,4501,4502],{},"使用虚基类：",[19,4504,4507],{"className":4505,"code":4506,"language":53,"meta":25},[51],"class B0 {};\nclass B1 : virtual public B0 {};\nclass B2 : virtual public B0 {};\nclass D : public B1, public B2 {};\n",[27,4508,4506],{"__ignoreMap":25},[10,4510,4511,4512,4514,4515,120],{},"现在 ",[27,4513,4489],{"code":4489}," 中只有一份 ",[27,4516,4493],{"code":4493},[10,4518,4519],{},"虚基类构造规则：",[107,4521,4522,4525],{},[110,4523,4524],{},"虚基类由最远派生类负责初始化。",[110,4526,4527],{},"中间类初始化虚基类的调用会被忽略。",[10,4529,2270],{},[19,4531,4534],{"className":4532,"code":4533,"language":24,"meta":25},[22],"虚基类\n非虚基类\n成员对象\n派生类自身\n",[27,4535,4533],{"__ignoreMap":25},[10,4537,4538],{},"析构顺序反过来。",[10,4540,569],{},[19,4542,4545],{"className":4543,"code":4544,"language":24,"meta":25},[22],"菱形继承怕多份共同基类\nvirtual 让共同基类只保留一份\n",[27,4546,4544],{"__ignoreMap":25},[14,4548,4550],{"id":4549},"_7-多态与运算符重载","7. 多态与运算符重载",[34,4552,4554],{"id":4553},"_71-多态","7.1 多态",[10,4556,4557],{},"多态是同一消息作用于不同对象，产生不同表现。",[10,4559,4560],{},"C++ 中常见多态：",[107,4562,4563,4566,4569,4572],{},[110,4564,4565],{},"函数重载。",[110,4567,4568],{},"运算符重载。",[110,4570,4571],{},"虚函数。",[110,4573,4574],{},"模板。",[10,4576,4577],{},"按绑定时间分：",[677,4579,4580,4593],{},[680,4581,4582],{},[683,4583,4584,4587,4590],{},[686,4585,4586],{},"类型",[686,4588,4589],{},"决定时间",[686,4591,4592],{},"例子",[693,4594,4595,4606],{},[683,4596,4597,4600,4603],{},[698,4598,4599],{},"静态多态",[698,4601,4602],{},"编译时",[698,4604,4605],{},"函数重载、运算符重载、模板",[683,4607,4608,4611,4614],{},[698,4609,4610],{},"动态多态",[698,4612,4613],{},"运行时",[698,4615,4616],{},"虚函数",[10,4618,569],{},[19,4620,4623],{"className":4621,"code":4622,"language":24,"meta":25},[22],"重载：编译时决定\n虚函数：运行时决定\n",[27,4624,4622],{"__ignoreMap":25},[34,4626,4628],{"id":4627},"_72-运算符重载","7.2 运算符重载",[10,4630,4631],{},"运算符重载就是给已有运算符赋予适用于自定义类型的新含义。",[10,4633,47],{},[19,4635,4638],{"className":4636,"code":4637,"language":53,"meta":25},[51],"返回类型 operator 运算符(参数列表)\n{\n}\n",[27,4639,4637],{"__ignoreMap":25},[10,4641,176],{},[19,4643,4646],{"className":4644,"code":4645,"language":53,"meta":25},[51],"class Complex\n{\nprivate:\n    double real, imag;\n\npublic:\n    Complex operator+(Complex c)\n    {\n        return Complex(real + c.real, imag + c.imag);\n    }\n};\n",[27,4647,4645],{"__ignoreMap":25},[10,4649,936],{},[19,4651,4654],{"className":4652,"code":4653,"language":53,"meta":25},[51],"c3 = c1 + c2;\n",[27,4655,4653],{"__ignoreMap":25},[10,4657,3470],{},[19,4659,4662],{"className":4660,"code":4661,"language":53,"meta":25},[51],"c3 = c1.operator+(c2);\n",[27,4663,4661],{"__ignoreMap":25},[10,4665,4666],{},"限制：",[107,4668,4669,4672,4675,4678,4681],{},[110,4670,4671],{},"不能创造新运算符。",[110,4673,4674],{},"不能改变运算符优先级。",[110,4676,4677],{},"不能改变操作数个数。",[110,4679,4680],{},"至少一个操作数是自定义类型。",[110,4682,4683,4684,71,4687,71,4690,71,4693,71,4695,71,4698,120],{},"不能重载：",[27,4685,4686],{"code":4686},".",[27,4688,4689],{"code":4689},".*",[27,4691,4692],{"code":4692},"->*",[27,4694,347],{"code":347},[27,4696,4697],{"code":4697},"sizeof",[27,4699,4700],{"code":4700},"?:",[10,4702,569],{},[19,4704,4707],{"className":4705,"code":4706,"language":24,"meta":25},[22],"运算符重载本质是函数重载\n",[27,4708,4706],{"__ignoreMap":25},[34,4710,4712],{"id":4711},"_73-成员形式和友元形式","7.3 成员形式和友元形式",[10,4714,4715],{},"成员函数形式：",[19,4717,4720],{"className":4718,"code":4719,"language":53,"meta":25},[51],"Complex Complex::operator+(Complex c)\n{\n    return Complex(real + c.real, imag + c.imag);\n}\n",[27,4721,4719],{"__ignoreMap":25},[10,4723,4724],{},"非成员\u002F友元形式：",[19,4726,4729],{"className":4727,"code":4728,"language":53,"meta":25},[51],"class Complex\n{\n    friend Complex operator+(Complex a, Complex b);\n};\n\nComplex operator+(Complex a, Complex b)\n{\n    return Complex(a.real + b.real, a.imag + b.imag);\n}\n",[27,4730,4728],{"__ignoreMap":25},[10,4732,4733],{},"区别：",[677,4735,4736,4749],{},[680,4737,4738],{},[683,4739,4740,4743,4746],{},[686,4741,4742],{},"形式",[686,4744,4745],{},"左操作数",[686,4747,4748],{},"参数个数",[693,4750,4751,4765],{},[683,4752,4753,4756,4762],{},[698,4754,4755],{},"成员函数",[698,4757,4758,4759],{},"当前对象 ",[27,4760,4761],{"code":4761},"*this",[698,4763,4764],{},"少一个",[683,4766,4767,4770,4773],{},[698,4768,4769],{},"非成员函数",[698,4771,4772],{},"普通参数",[698,4774,4775],{},"和操作数个数相同",[10,4777,4778,473,4780,4782,4783,4786,4787,4790],{},[27,4779,196],{"code":196},[27,4781,297],{"code":297}," 通常必须写成非成员\u002F友元，因为左操作数是 ",[27,4784,4785],{"code":4785},"ostream"," 或 ",[27,4788,4789],{"code":4789},"istream","，不能改标准库类。",[34,4792,4794,4795],{"id":4793},"_74-前置和后置","7.4 前置和后置 ",[27,4796,4797],{"code":4797},"++",[10,4799,4800],{},"前置：",[19,4802,4805],{"className":4803,"code":4804,"language":53,"meta":25},[51],"Clock& operator++()\n{\n    \u002F\u002F 修改自己\n    return *this;\n}\n",[27,4806,4804],{"__ignoreMap":25},[10,4808,4809],{},"后置：",[19,4811,4814],{"className":4812,"code":4813,"language":53,"meta":25},[51],"Clock operator++(int)\n{\n    Clock old = *this;\n    ++(*this);\n    return old;\n}\n",[27,4815,4813],{"__ignoreMap":25},[10,4817,4733],{},[19,4819,4822],{"className":4820,"code":4821,"language":53,"meta":25},[51],"++a; \u002F\u002F 先加，再用\na++; \u002F\u002F 先用，再加\n",[27,4823,4821],{"__ignoreMap":25},[10,4825,4826,4827,4829],{},"后置参数中的 ",[27,4828,712],{"code":712}," 没实际用途，只用来区分前置和后置。",[10,4831,4832],{},"为什么前置返回引用？",[10,4834,4835],{},"因为返回的是修改后的自己。",[10,4837,4838],{},"为什么后置返回对象？",[10,4840,4841],{},"因为要返回修改前的旧值，旧值通常是临时副本。",[34,4843,4845,4846,473,4848,4850],{"id":4844},"_75-和-重载","7.5 ",[27,4847,196],{"code":196},[27,4849,297],{"code":297}," 重载",[10,4852,4853],{},"输出运算符：",[19,4855,4858],{"className":4856,"code":4857,"language":53,"meta":25},[51],"friend ostream& operator\u003C\u003C(ostream &out, const Complex &c);\n",[27,4859,4857],{"__ignoreMap":25},[10,4861,2807],{},[19,4863,4866],{"className":4864,"code":4865,"language":53,"meta":25},[51],"ostream& operator\u003C\u003C(ostream &out, const Complex &c)\n{\n    out \u003C\u003C \"(\" \u003C\u003C c.real \u003C\u003C \",\" \u003C\u003C c.imag \u003C\u003C \")\";\n    return out;\n}\n",[27,4867,4865],{"__ignoreMap":25},[10,4869,4870],{},"输入运算符：",[19,4872,4875],{"className":4873,"code":4874,"language":53,"meta":25},[51],"friend istream& operator>>(istream &in, Complex &c);\n",[27,4876,4874],{"__ignoreMap":25},[10,4878,2807],{},[19,4880,4883],{"className":4881,"code":4882,"language":53,"meta":25},[51],"istream& operator>>(istream &in, Complex &c)\n{\n    in >> c.real >> c.imag;\n    return in;\n}\n",[27,4884,4882],{"__ignoreMap":25},[10,4886,4887],{},"为什么返回引用？",[10,4889,4890],{},"为了支持链式调用：",[19,4892,4895],{"className":4893,"code":4894,"language":53,"meta":25},[51],"cout \u003C\u003C c1 \u003C\u003C c2;\ncin >> c1 >> c2;\n",[27,4896,4894],{"__ignoreMap":25},[10,4898,4899],{},"为什么第一个参数是引用？",[10,4901,4902,473,4904,4906],{},[27,4903,4785],{"code":4785},[27,4905,4789],{"code":4789}," 不能复制，只能引用传递。",[10,4908,4909,4910,619],{},"为什么输出第二个参数常写 ",[27,4911,582],{"code":582},[10,4913,4914],{},"因为输出不应该修改对象。",[10,4916,4917,4918,619],{},"为什么输入第二个参数不能是 ",[27,4919,582],{"code":582},[10,4921,4922],{},"因为输入要修改对象。",[34,4924,4926,4927],{"id":4925},"_76-赋值运算符-operator","7.6 赋值运算符 ",[27,4928,4929],{"code":4929},"operator=",[10,4931,4932],{},"赋值运算符用于已有对象之间赋值。",[10,4934,47],{},[19,4936,4939],{"className":4937,"code":4938,"language":53,"meta":25},[51],"类名& operator=(const 类名 &rhs);\n",[27,4940,4938],{"__ignoreMap":25},[10,4942,176],{},[19,4944,4947],{"className":4945,"code":4946,"language":53,"meta":25},[51],"String& String::operator=(const String &rhs)\n{\n    if (this != &rhs)\n    {\n        delete[] s;\n        s = new char[strlen(rhs.s) + 1];\n        strcpy(s, rhs.s);\n    }\n    return *this;\n}\n",[27,4948,4946],{"__ignoreMap":25},[10,4950,4951],{},"四步：",[1760,4953,4954,4957,4960,4963],{},[110,4955,4956],{},"检查自赋值。",[110,4958,4959],{},"释放旧资源。",[110,4961,4962],{},"分配新资源并复制。",[110,4964,4965,4966,120],{},"返回 ",[27,4967,4761],{"code":4761},[10,4969,4887],{},[10,4971,4972],{},"支持链式赋值：",[19,4974,4977],{"className":4975,"code":4976,"language":53,"meta":25},[51],"a = b = c;\n",[27,4978,4976],{"__ignoreMap":25},[10,4980,4981,4982,619],{},"为什么参数是 ",[27,4983,4984],{"code":4984},"const 引用",[107,4986,4987,4990,4993],{},[110,4988,4989],{},"避免复制。",[110,4991,4992],{},"允许右侧是常对象或临时对象。",[110,4994,4995],{},"保证不修改右侧对象。",[34,4997,4999],{"id":4998},"_77-big-three","7.7 Big Three",[10,5001,5002],{},"如果类中有动态资源，通常要写三个函数：",[19,5004,5007],{"className":5005,"code":5006,"language":24,"meta":25},[22],"析构函数\n复制构造函数\n赋值运算符\n",[27,5008,5006],{"__ignoreMap":25},[10,5010,176],{},[19,5012,5015],{"className":5013,"code":5014,"language":53,"meta":25},[51],"class String\n{\nprivate:\n    char *s;\n\npublic:\n    String(const char *str);\n    String(const String &rhs);\n    String& operator=(const String &rhs);\n    ~String();\n};\n",[27,5016,5014],{"__ignoreMap":25},[10,5018,2962],{},[10,5020,5021],{},"默认复制构造和默认赋值都是浅复制。指针成员会导致多个对象指向同一片内存。",[10,5023,5024],{},"如果只写析构不写复制构造，复制对象后两个对象析构会重复释放。",[10,5026,569],{},[19,5028,5031],{"className":5029,"code":5030,"language":24,"meta":25},[22],"有 new，就想 Big Three\n",[27,5032,5030],{"__ignoreMap":25},[34,5034,5036],{"id":5035},"_78-复制构造和赋值的区别","7.8 复制构造和赋值的区别",[10,5038,5039],{},"复制构造：",[19,5041,5044],{"className":5042,"code":5043,"language":53,"meta":25},[51],"String a(\"hello\");\nString b = a;\nString c(a);\n",[27,5045,5043],{"__ignoreMap":25},[10,5047,4191,5048,71,5050,5052],{},[27,5049,4194],{"code":4194},[27,5051,2107],{"code":2107}," 是新对象。",[10,5054,3878],{},[19,5056,5059],{"className":5057,"code":5058,"language":53,"meta":25},[51],"String a(\"hello\");\nString b(\"world\");\nb = a;\n",[27,5060,5058],{"__ignoreMap":25},[10,5062,4191,5063,5065],{},[27,5064,4194],{"code":4194}," 已经存在。",[10,5067,5068],{},"判断口诀：",[19,5070,5073],{"className":5071,"code":5072,"language":24,"meta":25},[22],"新对象诞生：复制构造\n老对象改值：赋值运算符\n",[27,5074,5072],{"__ignoreMap":25},[34,5076,5078,5079,71,5082,71,5085],{"id":5077},"_79-operatoroperatoroperator","7.9 ",[27,5080,5081],{"code":5081},"operator+",[27,5083,5084],{"code":5084},"operator+=",[27,5086,5087],{"code":5087},"operator[]",[10,5089,5090,5092],{},[27,5091,5081],{"code":5081}," 返回新对象：",[19,5094,5097],{"className":5095,"code":5096,"language":53,"meta":25},[51],"String String::operator+(const String &rhs)\n{\n    ...\n    return ans;\n}\n",[27,5098,5096],{"__ignoreMap":25},[10,5100,5101],{},"不能返回局部对象引用。",[10,5103,5104,5106],{},[27,5105,5084],{"code":5084}," 修改自己：",[19,5108,5111],{"className":5109,"code":5110,"language":53,"meta":25},[51],"String& String::operator+=(const String &rhs)\n{\n    ...\n    return *this;\n}\n",[27,5112,5110],{"__ignoreMap":25},[10,5114,5115],{},"返回引用支持：",[19,5117,5120],{"className":5118,"code":5119,"language":53,"meta":25},[51],"s1 += s2 += s3;\n",[27,5121,5119],{"__ignoreMap":25},[10,5123,5124,5126],{},[27,5125,5087],{"code":5087}," 要返回引用：",[19,5128,5131],{"className":5129,"code":5130,"language":53,"meta":25},[51],"char& String::operator[](int i)\n{\n    return s[i];\n}\n",[27,5132,5130],{"__ignoreMap":25},[10,5134,5135],{},"这样才能：",[19,5137,5140],{"className":5138,"code":5139,"language":53,"meta":25},[51],"s[0] = 'A';\n",[27,5141,5139],{"__ignoreMap":25},[10,5143,5144,5145,5148],{},"如果返回 ",[27,5146,5147],{"code":5147},"char","，就是返回副本，不能作为左值修改。",[34,5150,5152],{"id":5151},"_710-虚函数","7.10 虚函数",[10,5154,5155,5156,120],{},"虚函数用关键字 ",[27,5157,5158],{"code":5158},"virtual",[10,5160,47],{},[19,5162,5165],{"className":5163,"code":5164,"language":53,"meta":25},[51],"class Base\n{\npublic:\n    virtual void display();\n};\n",[27,5166,5164],{"__ignoreMap":25},[10,5168,5169],{},"派生类重写：",[19,5171,5174],{"className":5172,"code":5173,"language":53,"meta":25},[51],"class Derived : public Base\n{\npublic:\n    void display();\n};\n",[27,5175,5173],{"__ignoreMap":25},[10,5177,5178],{},"动态绑定：",[19,5180,5183],{"className":5181,"code":5182,"language":53,"meta":25},[51],"Base *p;\nDerived d;\np = &d;\np->display(); \u002F\u002F 调 Derived::display\n",[27,5184,5182],{"__ignoreMap":25},[10,5186,5187],{},"条件：",[1760,5189,5190,5193,5198],{},[110,5191,5192],{},"公有继承，满足类型兼容。",[110,5194,5195,5196,120],{},"基类中函数声明为 ",[27,5197,5158],{"code":5158},[110,5199,5200],{},"通过基类指针或引用调用。",[10,5202,5203],{},"如果直接对象调用：",[19,5205,5208],{"className":5206,"code":5207,"language":53,"meta":25},[51],"Base b = d;\nb.display();\n",[27,5209,5207],{"__ignoreMap":25},[10,5211,5212,5213,120],{},"发生对象切片，调用 ",[27,5214,4218],{"code":4218},[10,5216,301],{},[107,5218,5219,5224,5229,5232],{},[110,5220,5221,5223],{},[27,5222,5158],{"code":5158}," 写在类内声明处。",[110,5225,5226,5227,120],{},"类外定义时不写 ",[27,5228,5158],{"code":5158},[110,5230,5231],{},"静态成员函数不能是虚函数。",[110,5233,5234],{},"构造函数不能是虚函数。",[10,5236,569],{},[19,5238,5241],{"className":5239,"code":5240,"language":24,"meta":25},[22],"虚函数：基类指针\u002F引用看实际对象类型\n",[27,5242,5240],{"__ignoreMap":25},[34,5244,5246],{"id":5245},"_711-虚析构函数","7.11 虚析构函数",[10,5248,5249],{},"如果可能通过基类指针删除派生类对象，基类析构函数要写成虚析构。",[10,5251,176],{},[19,5253,5256],{"className":5254,"code":5255,"language":53,"meta":25},[51],"class Base\n{\npublic:\n    virtual ~Base()\n    {\n    }\n};\n\nclass Derived : public Base\n{\npublic:\n    ~Derived()\n    {\n    }\n};\n",[27,5257,5255],{"__ignoreMap":25},[10,5259,3503],{},[19,5261,5264],{"className":5262,"code":5263,"language":53,"meta":25},[51],"Base *p = new Derived;\ndelete p;\n",[27,5265,5263],{"__ignoreMap":25},[10,5267,5268,5269,5271,5272,5274,5275,5278],{},"如果基类析构不是虚函数，",[27,5270,3618],{"code":3618}," 可能只调用 ",[27,5273,4198],{"code":4198}," 析构，不调用 ",[27,5276,5277],{"code":5277},"Derived"," 析构，造成资源泄漏。",[10,5280,2186],{},[107,5282,5283,5286,5289],{},[110,5284,5285],{},"构造函数不能虚。",[110,5287,5288],{},"析构函数可以虚。",[110,5290,5291,5292,120],{},"如果一个类打算作为多态基类，析构函数通常应为 ",[27,5293,5158],{"code":5158},[34,5295,5297],{"id":5296},"_712-纯虚函数和抽象类","7.12 纯虚函数和抽象类",[10,5299,5300],{},"纯虚函数语法：",[19,5302,5305],{"className":5303,"code":5304,"language":53,"meta":25},[51],"virtual 返回类型 函数名(参数列表) = 0;\n",[27,5306,5304],{"__ignoreMap":25},[10,5308,176],{},[19,5310,5313],{"className":5311,"code":5312,"language":53,"meta":25},[51],"class Shape\n{\npublic:\n    virtual double area() = 0;\n};\n",[27,5314,5312],{"__ignoreMap":25},[10,5316,5317],{},"含有纯虚函数的类叫抽象类。",[10,5319,5320],{},"抽象类不能创建对象：",[19,5322,5325],{"className":5323,"code":5324,"language":53,"meta":25},[51],"Shape s; \u002F\u002F 错\n",[27,5326,5324],{"__ignoreMap":25},[10,5328,5329],{},"但可以定义指针或引用：",[19,5331,5334],{"className":5332,"code":5333,"language":53,"meta":25},[51],"Shape *p;\nShape &r = circle;\n",[27,5335,5333],{"__ignoreMap":25},[10,5337,5338],{},"派生类必须实现纯虚函数，否则仍然是抽象类：",[19,5340,5343],{"className":5341,"code":5342,"language":53,"meta":25},[51],"class Circle : public Shape\n{\nprivate:\n    double r;\n\npublic:\n    double area()\n    {\n        return 3.14 * r * r;\n    }\n};\n",[27,5344,5342],{"__ignoreMap":25},[10,5346,5347],{},"纯虚析构函数必须有函数体：",[19,5349,5352],{"className":5350,"code":5351,"language":53,"meta":25},[51],"class A\n{\npublic:\n    virtual ~A() = 0;\n};\n\nA::~A()\n{\n}\n",[27,5353,5351],{"__ignoreMap":25},[10,5355,569],{},[19,5357,5360],{"className":5358,"code":5359,"language":24,"meta":25},[22],"= 0 表示纯虚\n有纯虚函数就是抽象类\n抽象类不能实例化，但可以有指针和引用\n",[27,5361,5359],{"__ignoreMap":25},[14,5363,5365],{"id":5364},"_8-模板和群体数据","8. 模板和群体数据",[34,5367,5369],{"id":5368},"_81-函数模板","8.1 函数模板",[10,5371,5372],{},"函数模板让一个函数适用于多种类型。",[10,5374,47],{},[19,5376,5379],{"className":5377,"code":5378,"language":53,"meta":25},[51],"template \u003Ctypename T>\n返回类型 函数名(参数列表)\n{\n}\n",[27,5380,5378],{"__ignoreMap":25},[10,5382,176],{},[19,5384,5387],{"className":5385,"code":5386,"language":53,"meta":25},[51],"template \u003Ctypename T>\nT myAbs(T x)\n{\n    return x \u003C 0 ? -x : x;\n}\n",[27,5388,5386],{"__ignoreMap":25},[10,5390,936],{},[19,5392,5395],{"className":5393,"code":5394,"language":53,"meta":25},[51],"cout \u003C\u003C myAbs(-5) \u003C\u003C endl;     \u002F\u002F T 是 int\ncout \u003C\u003C myAbs(-3.14) \u003C\u003C endl;  \u002F\u002F T 是 double\n",[27,5396,5394],{"__ignoreMap":25},[10,5398,5399,5402,5403,355],{},[27,5400,5401],{"code":5401},"typename"," 也可以写成 ",[27,5404,2395],{"code":2395},[19,5406,5409],{"className":5407,"code":5408,"language":53,"meta":25},[51],"template \u003Cclass T>\n",[27,5410,5408],{"__ignoreMap":25},[10,5412,5413],{},"函数模板本身不生成代码，只有被具体类型使用时才实例化。",[10,5415,301],{},[10,5417,5418,5419,5422],{},"模板定义通常放在头文件中。不能像普通函数那样只把声明放头文件、定义放 ",[27,5420,5421],{"code":5421},".cpp","，否则其他文件实例化时看不到函数体。",[10,5424,569],{},[19,5426,5429],{"className":5427,"code":5428,"language":24,"meta":25},[22],"模板 = 类型参数化\n用到具体类型时才生成具体函数\n",[27,5430,5428],{"__ignoreMap":25},[34,5432,5434],{"id":5433},"_82-多模板参数","8.2 多模板参数",[10,5436,5437],{},"模板可以有多个类型参数。",[10,5439,176],{},[19,5441,5444],{"className":5442,"code":5443,"language":53,"meta":25},[51],"template \u003Ctypename T1, typename T2>\nT1 myMin(const T1 &a, const T2 &b)\n{\n    return a \u003C b ? a : b;\n}\n",[27,5445,5443],{"__ignoreMap":25},[10,5447,936],{},[19,5449,5452],{"className":5450,"code":5451,"language":53,"meta":25},[51],"myMin\u003Cint, double>(3, 5.0);\nmyMin\u003Cint>(3, 5.0);\nmyMin\u003Cdouble>(3, 5.0);\n",[27,5453,5451],{"__ignoreMap":25},[10,5455,5456,5457,5460],{},"返回类型由 ",[27,5458,5459],{"code":5459},"T1"," 决定。",[10,5462,5463],{},"考试要会判断模板参数推断结果。",[34,5465,5467],{"id":5466},"_83-类模板","8.3 类模板",[10,5469,5470],{},"类模板让类中的数据成员或成员函数参数类型可变。",[10,5472,47],{},[19,5474,5477],{"className":5475,"code":5476,"language":53,"meta":25},[51],"template \u003Cclass T>\nclass Store\n{\nprivate:\n    T item;\n\npublic:\n    void PutElem(T x);\n    T GetElem();\n};\n",[27,5478,5476],{"__ignoreMap":25},[10,5480,1667],{},[19,5482,5485],{"className":5483,"code":5484,"language":53,"meta":25},[51],"template \u003Cclass T>\nvoid Store\u003CT>::PutElem(T x)\n{\n    item = x;\n}\n\ntemplate \u003Cclass T>\nT Store\u003CT>::GetElem()\n{\n    return item;\n}\n",[27,5486,5484],{"__ignoreMap":25},[10,5488,3503],{},[19,5490,5493],{"className":5491,"code":5492,"language":53,"meta":25},[51],"Store\u003Cint> s1;\nStore\u003Cdouble> s2;\nStore\u003CStudent> s3;\n",[27,5494,5492],{"__ignoreMap":25},[10,5496,301],{},[107,5498,5499,5505],{},[110,5500,5501,5502,120],{},"类名在类外定义时写 ",[27,5503,5504],{"code":5504},"Store\u003CT>",[110,5506,5507,5508,120],{},"创建对象时要写具体类型，如 ",[27,5509,5510],{"code":5510},"Store\u003Cint>",[34,5512,5514],{"id":5513},"_84-动态数组类模板","8.4 动态数组类模板",[10,5516,5517],{},"动态数组类模板的核心是：用一个指针管理堆上数组。",[10,5519,5520],{},"基本结构：",[19,5522,5525],{"className":5523,"code":5524,"language":53,"meta":25},[51],"template \u003Cclass T>\nclass Array\n{\nprivate:\n    T *list;\n    int size;\n\npublic:\n    Array(int sz = 50);\n    Array(const Array\u003CT> &a);\n    ~Array();\n    Array\u003CT>& operator=(const Array\u003CT> &rhs);\n    T& operator[](int i);\n    int getSize() const;\n    void resize(int sz);\n};\n",[27,5526,5524],{"__ignoreMap":25},[10,5528,5529],{},"构造：",[19,5531,5534],{"className":5532,"code":5533,"language":53,"meta":25},[51],"template \u003Cclass T>\nArray\u003CT>::Array(int sz)\n{\n    size = sz;\n    list = new T[size];\n}\n",[27,5535,5533],{"__ignoreMap":25},[10,5537,5538],{},"析构：",[19,5540,5543],{"className":5541,"code":5542,"language":53,"meta":25},[51],"template \u003Cclass T>\nArray\u003CT>::~Array()\n{\n    delete[] list;\n}\n",[27,5544,5542],{"__ignoreMap":25},[10,5546,5039],{},[19,5548,5551],{"className":5549,"code":5550,"language":53,"meta":25},[51],"template \u003Cclass T>\nArray\u003CT>::Array(const Array\u003CT> &a)\n{\n    size = a.size;\n    list = new T[size];\n    for (int i = 0; i \u003C size; i++)\n    {\n        list[i] = a.list[i];\n    }\n}\n",[27,5552,5550],{"__ignoreMap":25},[10,5554,3878],{},[19,5556,5559],{"className":5557,"code":5558,"language":53,"meta":25},[51],"template \u003Cclass T>\nArray\u003CT>& Array\u003CT>::operator=(const Array\u003CT> &rhs)\n{\n    if (this != &rhs)\n    {\n        delete[] list;\n        size = rhs.size;\n        list = new T[size];\n        for (int i = 0; i \u003C size; i++)\n        {\n            list[i] = rhs.list[i];\n        }\n    }\n    return *this;\n}\n",[27,5560,5558],{"__ignoreMap":25},[10,5562,5563],{},"下标运算符：",[19,5565,5568],{"className":5566,"code":5567,"language":53,"meta":25},[51],"template \u003Cclass T>\nT& Array\u003CT>::operator[](int i)\n{\n    return list[i];\n}\n",[27,5569,5567],{"__ignoreMap":25},[10,5571,5572,5573,619],{},"为什么返回 ",[27,5574,5575],{"code":5575},"T&",[10,5577,5578],{},"因为要支持：",[19,5580,5583],{"className":5581,"code":5582,"language":53,"meta":25},[51],"a[3] = 10;\n",[27,5584,5582],{"__ignoreMap":25},[10,5586,5144,5587,5590],{},[27,5588,5589],{"code":5589},"T","，只是返回副本，不能修改数组元素。",[34,5592,5594],{"id":5593},"_85-类型转换函数","8.5 类型转换函数",[10,5596,5597],{},"类型转换函数可以把类对象转换成某种类型。",[10,5599,47],{},[19,5601,5604],{"className":5602,"code":5603,"language":53,"meta":25},[51],"operator 类型()\n{\n    return 某个该类型的值;\n}\n",[27,5605,5603],{"__ignoreMap":25},[10,5607,176],{},[19,5609,5612],{"className":5610,"code":5611,"language":53,"meta":25},[51],"template \u003Cclass T>\nArray\u003CT>::operator T*()\n{\n    return list;\n}\n",[27,5613,5611],{"__ignoreMap":25},[10,5615,2041],{},[10,5617,5618,5619,5622,5623,5625],{},"让 ",[27,5620,5621],{"code":5621},"Array\u003Cint>"," 对象在需要 ",[27,5624,3398],{"code":3398}," 的地方自动转换为内部数组首地址。",[10,5627,301],{},[107,5629,5630,5633],{},[110,5631,5632],{},"类型转换函数不写返回类型。",[110,5634,5635],{},"函数名里已经包含目标类型。",[10,5637,803],{},[19,5639,5642],{"className":5640,"code":5641,"language":53,"meta":25},[51],"T* operator T*(); \u002F\u002F 错\n",[27,5643,5641],{"__ignoreMap":25},[10,5645,1285],{},[19,5647,5650],{"className":5648,"code":5649,"language":53,"meta":25},[51],"operator T*();\n",[27,5651,5649],{"__ignoreMap":25},[34,5653,5655],{"id":5654},"_86-链表结点","8.6 链表结点",[10,5657,5658],{},"链表由结点组成。",[10,5660,5661],{},"结点通常包含：",[107,5663,5664,5667],{},[110,5665,5666],{},"数据域。",[110,5668,5669],{},"指针域。",[10,5671,5672],{},"模板结点类：",[19,5674,5677],{"className":5675,"code":5676,"language":53,"meta":25},[51],"template \u003Cclass T>\nclass Node\n{\nprivate:\n    Node\u003CT> *next;\n\npublic:\n    T data;\n    void InsertAfter(Node\u003CT> *p);\n    Node\u003CT>* DeleteAfter();\n};\n",[27,5678,5676],{"__ignoreMap":25},[10,5680,5681],{},"插入当前结点之后：",[19,5683,5686],{"className":5684,"code":5685,"language":53,"meta":25},[51],"template \u003Cclass T>\nvoid Node\u003CT>::InsertAfter(Node\u003CT> *p)\n{\n    p->next = next;\n    next = p;\n}\n",[27,5687,5685],{"__ignoreMap":25},[10,5689,5690],{},"删除当前结点之后：",[19,5692,5695],{"className":5693,"code":5694,"language":53,"meta":25},[51],"template \u003Cclass T>\nNode\u003CT>* Node\u003CT>::DeleteAfter()\n{\n    Node\u003CT> *temp = next;\n    if (next == NULL)\n    {\n        return NULL;\n    }\n    next = temp->next;\n    return temp;\n}\n",[27,5696,5694],{"__ignoreMap":25},[10,5698,5699],{},"这里返回被删除结点指针，调用者可以继续处理或释放它。",[34,5701,5703],{"id":5702},"_87-栈","8.7 栈",[10,5705,5706],{},"栈是只能从一端访问的线性结构。",[10,5708,2461],{},[19,5710,5713],{"className":5711,"code":5712,"language":24,"meta":25},[22],"后进先出 LIFO\n",[27,5714,5712],{"__ignoreMap":25},[10,5716,5717],{},"基本操作：",[107,5719,5720,5726,5732,5738,5744],{},[110,5721,5722,5725],{},[27,5723,5724],{"code":5724},"push"," 入栈。",[110,5727,5728,5731],{},[27,5729,5730],{"code":5730},"pop"," 出栈。",[110,5733,5734,5737],{},[27,5735,5736],{"code":5736},"peek"," 看栈顶。",[110,5739,5740,5743],{},[27,5741,5742],{"code":5742},"isEmpty"," 判空。",[110,5745,5746,5749],{},[27,5747,5748],{"code":5748},"isFull"," 判满。",[10,5751,5752,5753,5756],{},"数组实现时可用 ",[27,5754,5755],{"code":5755},"top"," 表示栈顶位置。",[19,5758,5761],{"className":5759,"code":5760,"language":53,"meta":25},[51],"template \u003Cclass T, int SIZE = 50>\nclass Stack\n{\nprivate:\n    T list[SIZE];\n    int top;\n};\n",[27,5762,5760],{"__ignoreMap":25},[34,5764,5766],{"id":5765},"_88-队列","8.8 队列",[10,5768,5769],{},"队列是一端入队、一端出队的线性结构。",[10,5771,2461],{},[19,5773,5776],{"className":5774,"code":5775,"language":24,"meta":25},[22],"先进先出 FIFO\n",[27,5777,5775],{"__ignoreMap":25},[10,5779,5717],{},[107,5781,5782,5785,5788,5791,5794],{},[110,5783,5784],{},"入队。",[110,5786,5787],{},"出队。",[110,5789,5790],{},"访问队首。",[110,5792,5793],{},"判空。",[110,5795,5796],{},"判满。",[10,5798,5799],{},"循环队列核心：",[19,5801,5804],{"className":5802,"code":5803,"language":53,"meta":25},[51],"front = (front + 1) % SIZE;\nrear = (rear + 1) % SIZE;\n",[27,5805,5803],{"__ignoreMap":25},[10,5807,5808],{},"为什么取余？",[10,5810,5811],{},"因为数组末尾之后要回到数组开头。",[14,5813,5815],{"id":5814},"_9-stl","9. STL",[34,5817,5819],{"id":5818},"_91-stl-四大组件","9.1 STL 四大组件",[10,5821,5822],{},"STL 是标准模板库。",[10,5824,5825],{},"四大组件：",[677,5827,5828,5838],{},[680,5829,5830],{},[683,5831,5832,5835],{},[686,5833,5834],{},"组件",[686,5836,5837],{},"含义",[693,5839,5840,5848,5856,5864],{},[683,5841,5842,5845],{},[698,5843,5844],{},"容器",[698,5846,5847],{},"存数据",[683,5849,5850,5853],{},[698,5851,5852],{},"迭代器",[698,5854,5855],{},"像指针一样访问容器",[683,5857,5858,5861],{},[698,5859,5860],{},"算法",[698,5862,5863],{},"通用函数模板",[683,5865,5866,5869],{},[698,5867,5868],{},"函数对象",[698,5870,5871],{},"像函数一样使用的对象",[10,5873,176],{},[19,5875,5878],{"className":5876,"code":5877,"language":53,"meta":25},[51],"#include \u003Cvector>\n#include \u003Calgorithm>\n\nvector\u003Cint> a = {3, 1, 2};\nsort(a.begin(), a.end());\n",[27,5879,5877],{"__ignoreMap":25},[10,5881,5882,5884,5885,473,5888,5891,5892,5895],{},[27,5883,923],{"code":923}," 是容器，",[27,5886,5887],{"code":5887},"a.begin()",[27,5889,5890],{"code":5890},"a.end()"," 是迭代器，",[27,5893,5894],{"code":5894},"sort"," 是算法。",[34,5897,5899],{"id":5898},"_92-容器","9.2 容器",[10,5901,5902],{},"容器用于保存一组元素。",[10,5904,5905],{},"顺序容器：",[107,5907,5908,5912,5917],{},[110,5909,5910],{},[27,5911,3670],{"code":3670},[110,5913,5914],{},[27,5915,5916],{"code":5916},"deque",[110,5918,5919],{},[27,5920,5921],{"code":5921},"list",[10,5923,5924],{},"关联容器：",[107,5926,5927,5932,5937,5942],{},[110,5928,5929],{},[27,5930,5931],{"code":5931},"set",[110,5933,5934],{},[27,5935,5936],{"code":5936},"multiset",[110,5938,5939],{},[27,5940,5941],{"code":5941},"map",[110,5943,5944],{},[27,5945,5946],{"code":5946},"multimap",[10,5948,5949],{},"算法竞赛里最常用：",[19,5951,5954],{"className":5952,"code":5953,"language":53,"meta":25},[51],"vector\u003Cint> v;\nset\u003Cint> s;\nmap\u003Cstring, int> mp;\n",[27,5955,5953],{"__ignoreMap":25},[10,5957,5958],{},"课程考试重点是知道它们都是 STL 容器，使用时要包含对应头文件。",[34,5960,5962],{"id":5961},"_93-迭代器","9.3 迭代器",[10,5964,5965],{},"迭代器是泛化的指针。",[10,5967,176],{},[19,5969,5972],{"className":5970,"code":5971,"language":53,"meta":25},[51],"vector\u003Cint> v = {1, 2, 3};\n\nfor (vector\u003Cint>::iterator it = v.begin(); it != v.end(); ++it)\n{\n    cout \u003C\u003C *it \u003C\u003C endl;\n}\n",[27,5973,5971],{"__ignoreMap":25},[10,5975,5976],{},"现代写法：",[19,5978,5981],{"className":5979,"code":5980,"language":53,"meta":25},[51],"for (auto it = v.begin(); it != v.end(); ++it)\n{\n    cout \u003C\u003C *it \u003C\u003C endl;\n}\n",[27,5982,5980],{"__ignoreMap":25},[10,5984,5985],{},"迭代器作用：",[19,5987,5990],{"className":5988,"code":5989,"language":24,"meta":25},[22],"把容器和算法连接起来\n",[27,5991,5989],{"__ignoreMap":25},[10,5993,5994],{},"算法不需要知道具体容器内部怎么存，只通过迭代器访问。",[34,5996,5998],{"id":5997},"_94-算法和函数对象","9.4 算法和函数对象",[10,6000,6001],{},"算法是函数模板。",[10,6003,176],{},[19,6005,6008],{"className":6006,"code":6007,"language":53,"meta":25},[51],"sort(v.begin(), v.end());\n",[27,6009,6007],{"__ignoreMap":25},[10,6011,6012,6013,6016],{},"函数对象是重载了 ",[27,6014,6015],{"code":6015},"operator()"," 的对象。",[10,6018,176],{},[19,6020,6023],{"className":6021,"code":6022,"language":53,"meta":25},[51],"struct Greater\n{\n    bool operator()(int a, int b)\n    {\n        return a > b;\n    }\n};\n\nsort(v.begin(), v.end(), Greater());\n",[27,6024,6022],{"__ignoreMap":25},[10,6026,6027],{},"标准库也有函数对象：",[19,6029,6032],{"className":6030,"code":6031,"language":53,"meta":25},[51],"#include \u003Cfunctional>\ngreater\u003Cint>()\nless\u003Cint>()\nnegate\u003Cint>()\n",[27,6033,6031],{"__ignoreMap":25},[14,6035,6037],{"id":6036},"_10-流类库与输入输出","10. 流类库与输入输出",[34,6039,6041],{"id":6040},"_101-常用流对象","10.1 常用流对象",[10,6043,3678],{},[19,6045,6047],{"className":6046,"code":62,"language":53,"meta":25},[51],[27,6048,62],{"__ignoreMap":25},[10,6050,3641],{},[677,6052,6053,6062],{},[680,6054,6055],{},[683,6056,6057,6060],{},[686,6058,6059],{},"对象",[686,6061,5837],{},[693,6063,6064,6073,6082,6092],{},[683,6065,6066,6070],{},[698,6067,6068],{},[27,6069,74],{"code":74},[698,6071,6072],{},"标准输入",[683,6074,6075,6079],{},[698,6076,6077],{},[27,6078,70],{"code":70},[698,6080,6081],{},"标准输出",[683,6083,6084,6089],{},[698,6085,6086],{},[27,6087,6088],{"code":6088},"cerr",[698,6090,6091],{},"标准错误，非缓冲",[683,6093,6094,6099],{},[698,6095,6096],{},[27,6097,6098],{"code":6098},"clog",[698,6100,6101],{},"标准错误，缓冲",[10,6103,6104,6106],{},[27,6105,6088],{"code":6088}," 常用于立即输出错误信息。",[10,6108,6109,6111],{},[27,6110,6098],{"code":6098}," 也是错误输出，但有缓冲。",[34,6113,6115],{"id":6114},"_102-文件输出","10.2 文件输出",[10,6117,3678],{},[19,6119,6122],{"className":6120,"code":6121,"language":53,"meta":25},[51],"#include \u003Cfstream>\n",[27,6123,6121],{"__ignoreMap":25},[10,6125,6126],{},"输出文件流：",[19,6128,6131],{"className":6129,"code":6130,"language":53,"meta":25},[51],"ofstream fout;\nfout.open(\"out.txt\");\n",[27,6132,6130],{"__ignoreMap":25},[10,6134,6135],{},"完整步骤：",[19,6137,6140],{"className":6138,"code":6139,"language":53,"meta":25},[51],"#include \u003Cfstream>\n#include \u003Ciostream>\nusing namespace std;\n\nint main()\n{\n    ofstream fout(\"out.txt\");\n    if (!fout)\n    {\n        cout \u003C\u003C \"Error opening file\" \u003C\u003C endl;\n        return -1;\n    }\n\n    fout \u003C\u003C \"hello\" \u003C\u003C endl;\n    fout.close();\n    return 0;\n}\n",[27,6141,6139],{"__ignoreMap":25},[10,6143,6144],{},"六步：",[19,6146,6149],{"className":6147,"code":6148,"language":24,"meta":25},[22],"包含头文件\n定义文件流对象\n打开文件\n检查是否成功\n读写数据\n关闭文件\n",[27,6150,6148],{"__ignoreMap":25},[34,6152,6154],{"id":6153},"_103-文件输入","10.3 文件输入",[10,6156,6157],{},"输入文件流：",[19,6159,6162],{"className":6160,"code":6161,"language":53,"meta":25},[51],"ifstream fin(\"in.txt\");\n",[27,6163,6161],{"__ignoreMap":25},[10,6165,6166],{},"读取：",[19,6168,6171],{"className":6169,"code":6170,"language":53,"meta":25},[51],"string s;\ngetline(fin, s);\n",[27,6172,6170],{"__ignoreMap":25},[10,6174,6175],{},"完整例子：",[19,6177,6180],{"className":6178,"code":6179,"language":53,"meta":25},[51],"#include \u003Cfstream>\n#include \u003Ciostream>\n#include \u003Cstring>\nusing namespace std;\n\nint main()\n{\n    ifstream fin(\"in.txt\");\n    if (!fin)\n    {\n        cout \u003C\u003C \"open failed\" \u003C\u003C endl;\n        return -1;\n    }\n\n    string line;\n    while (getline(fin, line))\n    {\n        cout \u003C\u003C line \u003C\u003C endl;\n    }\n\n    fin.close();\n}\n",[27,6181,6179],{"__ignoreMap":25},[34,6183,6185],{"id":6184},"_104-字符串流","10.4 字符串流",[10,6187,6188],{},"字符串流把字符串当成输入输出流。",[10,6190,3678],{},[19,6192,6195],{"className":6193,"code":6194,"language":53,"meta":25},[51],"#include \u003Csstream>\n",[27,6196,6194],{"__ignoreMap":25},[10,6198,176],{},[19,6200,6203],{"className":6201,"code":6202,"language":53,"meta":25},[51],"istringstream iss(\"1 56.7\");\nint a;\ndouble b;\niss >> a >> b;\n",[27,6204,6202],{"__ignoreMap":25},[10,6206,185],{},[19,6208,6211],{"className":6209,"code":6210,"language":53,"meta":25},[51],"ostringstream oss;\noss \u003C\u003C \"a = \" \u003C\u003C 10;\nstring s = oss.str();\n",[27,6212,6210],{"__ignoreMap":25},[10,6214,2041],{},[107,6216,6217,6220],{},[110,6218,6219],{},"从字符串中解析数字。",[110,6221,6222],{},"把多个值拼成字符串。",[14,6224,6226],{"id":6225},"_11-异常处理","11. 异常处理",[34,6228,6230],{"id":6229},"_111-异常处理思想","11.1 异常处理思想",[10,6232,6233],{},"异常处理用于处理程序运行中的意外情况。",[10,6235,6236],{},"比如：",[107,6238,6239,6242,6245,6248],{},[110,6240,6241],{},"文件打开失败。",[110,6243,6244],{},"内存申请失败。",[110,6246,6247],{},"参数非法。",[110,6249,6250],{},"除数为 0。",[10,6252,6253],{},"异常处理让发现错误和处理错误分离。",[10,6255,6256],{},"底层函数：",[19,6258,6261],{"className":6259,"code":6260,"language":53,"meta":25},[51],"throw 异常;\n",[27,6262,6260],{"__ignoreMap":25},[10,6264,6265],{},"上层代码：",[19,6267,6270],{"className":6268,"code":6269,"language":53,"meta":25},[51],"try\n{\n}\ncatch (...)\n{\n}\n",[27,6271,6269],{"__ignoreMap":25},[34,6273,6275,6276],{"id":6274},"_112-try-throw-catch","11.2 ",[27,6277,6278],{"code":6278},"try-throw-catch",[10,6280,5520],{},[19,6282,6285],{"className":6283,"code":6284,"language":53,"meta":25},[51],"try\n{\n    \u002F\u002F 可能出错的代码\n    throw 表达式;\n}\ncatch (异常类型 变量名)\n{\n    \u002F\u002F 处理异常\n}\n",[27,6286,6284],{"__ignoreMap":25},[10,6288,176],{},[19,6290,6293],{"className":6291,"code":6292,"language":53,"meta":25},[51],"try\n{\n    int milk = 0;\n    int biscuits = 10;\n    if (milk \u003C= 0)\n    {\n        throw biscuits;\n    }\n}\ncatch (int e)\n{\n    cout \u003C\u003C e \u003C\u003C \" biscuits, and no milk\" \u003C\u003C endl;\n}\n",[27,6294,6292],{"__ignoreMap":25},[10,6296,6297],{},"执行过程：",[19,6299,6302],{"className":6300,"code":6301,"language":24,"meta":25},[22],"进入 try\n遇到 throw\n停止 try 中后续语句\n寻找匹配 catch\n执行 catch\n继续 catch 后面的代码\n",[27,6303,6301],{"__ignoreMap":25},[10,6305,6306,6307,6310],{},"如果没有异常，",[27,6308,6309],{"code":6309},"catch"," 会被跳过。",[34,6312,6314,6315],{"id":6313},"_113-多个-catch","11.3 多个 ",[27,6316,6309],{"code":6309},[10,6318,6319,6320,6323,6324,120],{},"一个 ",[27,6321,6322],{"code":6322},"try"," 后可以接多个 ",[27,6325,6309],{"code":6309},[19,6327,6330],{"className":6328,"code":6329,"language":53,"meta":25},[51],"try\n{\n    ...\n}\ncatch (int e)\n{\n}\ncatch (const char *s)\n{\n}\ncatch (...)\n{\n}\n",[27,6331,6329],{"__ignoreMap":25},[10,6333,6334,6337],{},[27,6335,6336],{"code":6336},"catch(...)"," 可以捕获任意异常，但必须放最后。",[10,6339,3073],{},[10,6341,6342,6343,6345],{},"如果放前面，它会把所有异常都拦住，后面的具体 ",[27,6344,6309],{"code":6309}," 永远用不到。",[34,6347,6349],{"id":6348},"_114-栈解旋","11.4 栈解旋",[10,6351,6352],{},"抛出异常后，程序会离开当前作用域。",[10,6354,6355],{},"离开过程中，已经构造好的局部对象会自动析构。",[10,6357,6358],{},"这个过程叫栈解旋。",[10,6360,176],{},[19,6362,6365],{"className":6363,"code":6364,"language":53,"meta":25},[51],"class A\n{\npublic:\n    ~A()\n    {\n        cout \u003C\u003C \"~A\" \u003C\u003C endl;\n    }\n};\n\nvoid f()\n{\n    A a;\n    throw 1;\n}\n",[27,6366,6364],{"__ignoreMap":25},[10,6368,6369,6370,6373,6374,6376],{},"当 ",[27,6371,6372],{"code":6372},"throw 1"," 发生时，",[27,6375,923],{"code":923}," 会被析构。",[10,6378,6379],{},"这也是异常机制重要价值之一：不会因为跳转而忘记析构局部对象。",[34,6381,6383],{"id":6382},"_115-异常接口声明","11.5 异常接口声明",[10,6385,6386],{},"课件里提到旧式异常规格：",[19,6388,6391],{"className":6389,"code":6390,"language":53,"meta":25},[51],"void fun() throw(A, B, C);\nvoid fun() throw();\n",[27,6392,6390],{"__ignoreMap":25},[10,6394,6395],{},"按课件理解：",[107,6397,6398,6404],{},[110,6399,6400,6403],{},[27,6401,6402],{"code":6402},"throw(A, B, C)"," 表示函数只应该抛这些类型。",[110,6405,6406,6409],{},[27,6407,6408],{"code":6408},"throw()"," 表示函数不抛异常。",[10,6411,6412],{},"现代 C++ 中这种写法已经不推荐，但考试如果按课件问，要按课件规则答。",[14,6414,6416],{"id":6415},"_12-程序阅读题套路","12. 程序阅读题套路",[34,6418,6420],{"id":6419},"_121-构造析构输出顺序","12.1 构造析构输出顺序",[10,6422,6423],{},"看到程序输出构造析构，按顺序画：",[19,6425,6428],{"className":6426,"code":6427,"language":24,"meta":25},[22],"基类\n成员对象\n本类\n",[27,6429,6427],{"__ignoreMap":25},[10,6431,6432],{},"析构反过来：",[19,6434,6437],{"className":6435,"code":6436,"language":24,"meta":25},[22],"本类\n成员对象\n基类\n",[27,6438,6436],{"__ignoreMap":25},[10,6440,6441],{},"含虚基类：",[19,6443,6446],{"className":6444,"code":6445,"language":24,"meta":25},[22],"虚基类\n非虚基类\n成员对象\n本类\n",[27,6447,6445],{"__ignoreMap":25},[34,6449,6451],{"id":6450},"_122-复制构造还是赋值","12.2 复制构造还是赋值",[10,6453,6454],{},"看对象是否正在创建。",[19,6456,6459],{"className":6457,"code":6458,"language":53,"meta":25},[51],"A b = a; \u002F\u002F 复制构造\nA b(a);  \u002F\u002F 复制构造\nb = a;   \u002F\u002F 赋值，前提是 b 已存在\n",[27,6460,6458],{"__ignoreMap":25},[10,6462,6463],{},"函数值传参：",[19,6465,6468],{"className":6466,"code":6467,"language":53,"meta":25},[51],"void f(A x);\nf(a); \u002F\u002F 复制构造\n",[27,6469,6467],{"__ignoreMap":25},[10,6471,6472],{},"引用传参：",[19,6474,6477],{"className":6475,"code":6476,"language":53,"meta":25},[51],"void f(const A &x);\nf(a); \u002F\u002F 不复制\n",[27,6478,6476],{"__ignoreMap":25},[34,6480,6482],{"id":6481},"_123-虚函数调用","12.3 虚函数调用",[10,6484,6485],{},"三问：",[1760,6487,6488,6493,6496],{},[110,6489,6490,6491,619],{},"基类函数有没有 ",[27,6492,5158],{"code":5158},[110,6494,6495],{},"是不是通过基类指针或引用调用？",[110,6497,6498],{},"指针或引用实际指向哪个对象？",[10,6500,6501],{},"如果是对象切片：",[19,6503,6506],{"className":6504,"code":6505,"language":53,"meta":25},[51],"Base b = derived;\nb.f();\n",[27,6507,6505],{"__ignoreMap":25},[10,6509,6510,6511,6513,6514,2267],{},"那 ",[27,6512,4194],{"code":4194}," 已经是 ",[27,6515,4198],{"code":4198},[34,6517,6519],{"id":6518},"_124-运算符重载翻译","12.4 运算符重载翻译",[10,6521,6522],{},"把表达式翻译成函数调用。",[19,6524,6527],{"className":6525,"code":6526,"language":53,"meta":25},[51],"a + b       -> a.operator+(b) 或 operator+(a, b)\n++a         -> a.operator++()\na++         -> a.operator++(0)\ncout \u003C\u003C a   -> operator\u003C\u003C(cout, a)\na[i]        -> a.operator[](i)\n",[27,6528,6526],{"__ignoreMap":25},[10,6530,6531],{},"再看返回值是对象还是引用。",[14,6533,6535],{"id":6534},"_13-程序填空模板","13. 程序填空模板",[34,6537,6539,6540,6543],{"id":6538},"_131-string-类-big-three","13.1 ",[27,6541,6542],{"code":6542},"String"," 类 Big Three",[19,6545,6548],{"className":6546,"code":6547,"language":53,"meta":25},[51],"class String\n{\nprivate:\n    char *s;\n\npublic:\n    String()\n    {\n        s = new char[1];\n        s[0] = '\\0';\n    }\n\n    String(const char *str)\n    {\n        s = new char[strlen(str) + 1];\n        strcpy(s, str);\n    }\n\n    String(const String &rhs)\n    {\n        s = new char[strlen(rhs.s) + 1];\n        strcpy(s, rhs.s);\n    }\n\n    ~String()\n    {\n        delete[] s;\n    }\n\n    String& operator=(const String &rhs)\n    {\n        if (this != &rhs)\n        {\n            delete[] s;\n            s = new char[strlen(rhs.s) + 1];\n            strcpy(s, rhs.s);\n        }\n        return *this;\n    }\n};\n",[27,6549,6547],{"__ignoreMap":25},[34,6551,6553,6554],{"id":6552},"_132-operator","13.2 ",[27,6555,5081],{"code":5081},[19,6557,6560],{"className":6558,"code":6559,"language":53,"meta":25},[51],"String String::operator+(const String &rhs)\n{\n    char *tmp = new char[strlen(s) + strlen(rhs.s) + 1];\n    strcpy(tmp, s);\n    strcat(tmp, rhs.s);\n    String ans(tmp);\n    delete[] tmp;\n    return ans;\n}\n",[27,6561,6559],{"__ignoreMap":25},[10,6563,6564],{},"返回对象，不返回引用。",[34,6566,6568,6569],{"id":6567},"_133-operator","13.3 ",[27,6570,5084],{"code":5084},[19,6572,6575],{"className":6573,"code":6574,"language":53,"meta":25},[51],"String& String::operator+=(const String &rhs)\n{\n    char *tmp = new char[strlen(s) + strlen(rhs.s) + 1];\n    strcpy(tmp, s);\n    strcat(tmp, rhs.s);\n    delete[] s;\n    s = tmp;\n    return *this;\n}\n",[27,6576,6574],{"__ignoreMap":25},[10,6578,6579],{},"返回引用。",[34,6581,6583,6584],{"id":6582},"_134-operator","13.4 ",[27,6585,5087],{"code":5087},[19,6587,6589],{"className":6588,"code":5130,"language":53,"meta":25},[51],[27,6590,5130],{"__ignoreMap":25},[10,6592,6593],{},"返回引用，才能作为左值。",[34,6595,6597,6598],{"id":6596},"_135-operator","13.5 ",[27,6599,6600],{"code":6600},"operator\u003C\u003C",[19,6602,6605],{"className":6603,"code":6604,"language":53,"meta":25},[51],"ostream& operator\u003C\u003C(ostream &out, const String &str)\n{\n    out \u003C\u003C str.s;\n    return out;\n}\n",[27,6606,6604],{"__ignoreMap":25},[10,6608,4965,6609,6612],{},[27,6610,6611],{"code":6611},"ostream&","，支持连续输出。",[34,6614,6616,6617,6620],{"id":6615},"_136-arrayt-下标","13.6 ",[27,6618,6619],{"code":6619},"Array\u003CT>"," 下标",[19,6622,6625],{"className":6623,"code":6624,"language":53,"meta":25},[51],"template \u003Cclass T>\nT& Array\u003CT>::operator[](int i)\n{\n    assert(i >= 0 && i \u003C size);\n    return list[i];\n}\n",[27,6626,6624],{"__ignoreMap":25},[10,6628,6629,6631],{},[27,6630,582],{"code":582}," 版本：",[19,6633,6636],{"className":6634,"code":6635,"language":53,"meta":25},[51],"template \u003Cclass T>\nconst T& Array\u003CT>::operator[](int i) const\n{\n    assert(i >= 0 && i \u003C size);\n    return list[i];\n}\n",[27,6637,6635],{"__ignoreMap":25},[14,6639,6641],{"id":6640},"_14-最后一页速记","14. 最后一页速记",[19,6643,6646],{"className":6644,"code":6645,"language":24,"meta":25},[22],"inline：短小频繁函数，建议编译器展开\n默认参数：从右往左给，中间不能断\n函数重载：看参数，不看返回值\n构造函数：对象出生时自动调用\n析构函数：对象死亡时自动调用\n复制构造：新对象用旧对象初始化\n赋值运算符：两个旧对象之间赋值\n初始化列表：const、引用、无默认构造成员必须用\nstatic 数据成员：类内声明，类外定义\nstatic 成员函数：无 this，不能直接访问非 static 成员\nfriend：单向、不传递、不继承\n常对象：只能调用常成员函数\nnew\u002Fdelete 配对，new[]\u002Fdelete[] 配对\n浅复制：复制指针地址\n深复制：重新分配空间复制内容\n继承权限：公保公不变，私私保保，私不访\n对象切片：派生类赋给基类对象，只保留基类部分\n虚函数：通过基类指针\u002F引用调用，看实际对象\n虚析构：多态基类最好写 virtual 析构\n纯虚函数：=0，有纯虚函数就是抽象类\noperator[] 返回引用，才能作为左值\noperator\u003C\u003C 返回 ostream&\n模板：类型参数化，定义通常放头文件\n异常：try -> throw -> catch\n",[27,6647,6645],{"__ignoreMap":25},{"title":25,"searchDepth":6649,"depth":6649,"links":6650},4,[6651,6653,6680,6688,6712,6727,6742,6755,6773,6783,6789,6795,6804,6810,6824],{"id":16,"depth":6652,"text":17},2,{"id":31,"depth":6652,"text":32,"children":6654},[6655,6657,6659,6661,6663,6673,6675,6676,6678],{"id":36,"depth":6656,"text":37},3,{"id":155,"depth":6656,"text":6658},"1.2 cout 输出",{"id":250,"depth":6656,"text":6660},"1.3 cin 输入",{"id":318,"depth":6656,"text":6662},"1.4 命名空间 namespace",{"id":401,"depth":6656,"text":402,"children":6664},[6665,6667,6669,6671],{"id":418,"depth":6649,"text":6666},"1.5.1 setw",{"id":468,"depth":6649,"text":6668},"1.5.2 left 和 right",{"id":493,"depth":6649,"text":6670},"1.5.3 setprecision",{"id":541,"depth":6649,"text":6672},"1.5.4 dec、hex、oct",{"id":578,"depth":6656,"text":6674},"1.6 const 常量",{"id":644,"depth":6656,"text":645},{"id":774,"depth":6656,"text":6677},"1.8 auto",{"id":830,"depth":6656,"text":6679},"1.9 decltype",{"id":887,"depth":6652,"text":888,"children":6681},[6682,6683,6684,6685,6686,6687],{"id":891,"depth":6656,"text":892},{"id":953,"depth":6656,"text":954},{"id":1022,"depth":6656,"text":1023},{"id":1109,"depth":6656,"text":1110},{"id":1248,"depth":6656,"text":1249},{"id":1334,"depth":6656,"text":1335},{"id":1414,"depth":6652,"text":1415,"children":6689},[6690,6691,6692,6694,6695,6697,6698,6699,6700,6705,6706,6707,6708,6710],{"id":1418,"depth":6656,"text":1419},{"id":1496,"depth":6656,"text":1497},{"id":1552,"depth":6656,"text":6693},"3.3 访问控制：public、private、protected",{"id":1654,"depth":6656,"text":1655},{"id":1716,"depth":6656,"text":6696},"3.5 this 指针",{"id":1793,"depth":6656,"text":1794},{"id":1924,"depth":6656,"text":1925},{"id":2017,"depth":6656,"text":2018},{"id":2052,"depth":6656,"text":2053,"children":6701},[6702,6703,6704],{"id":2078,"depth":6649,"text":2079},{"id":2095,"depth":6649,"text":2096},{"id":2126,"depth":6649,"text":2127},{"id":2163,"depth":6656,"text":2164},{"id":2245,"depth":6656,"text":2246},{"id":2332,"depth":6656,"text":2333},{"id":2388,"depth":6656,"text":6709},"3.13 struct 和 class",{"id":2432,"depth":6656,"text":6711},"3.14 union",{"id":2483,"depth":6652,"text":2484,"children":6713},[6714,6715,6716,6717,6718,6719,6720,6721,6722,6723,6724,6725,6726],{"id":2487,"depth":6656,"text":2488},{"id":2536,"depth":6656,"text":2537},{"id":2570,"depth":6656,"text":2571},{"id":2619,"depth":6656,"text":2620},{"id":2708,"depth":6656,"text":2709},{"id":2791,"depth":6656,"text":2792},{"id":2871,"depth":6656,"text":2872},{"id":2927,"depth":6656,"text":2928},{"id":2974,"depth":6656,"text":2975},{"id":3045,"depth":6656,"text":3046},{"id":3081,"depth":6656,"text":3082},{"id":3150,"depth":6656,"text":3151},{"id":3201,"depth":6656,"text":3202},{"id":3266,"depth":6652,"text":3267,"children":6728},[6729,6730,6731,6732,6733,6734,6736,6738,6739,6740],{"id":3270,"depth":6656,"text":3271},{"id":3308,"depth":6656,"text":3309},{"id":3380,"depth":6656,"text":3381},{"id":3438,"depth":6656,"text":3439},{"id":3487,"depth":6656,"text":3488},{"id":3541,"depth":6656,"text":6735},"5.6 new 和 delete",{"id":3666,"depth":6656,"text":6737},"5.7 vector",{"id":3752,"depth":6656,"text":3753},{"id":3809,"depth":6656,"text":3810},{"id":3850,"depth":6656,"text":6741},"5.10 string",{"id":3942,"depth":6652,"text":3943,"children":6743},[6744,6745,6746,6747,6748,6749,6750,6751,6752,6754],{"id":3946,"depth":6656,"text":3947},{"id":4011,"depth":6656,"text":4012},{"id":4128,"depth":6656,"text":4129},{"id":4178,"depth":6656,"text":4179},{"id":4233,"depth":6656,"text":4234},{"id":4281,"depth":6656,"text":4282},{"id":4325,"depth":6656,"text":4326},{"id":4375,"depth":6656,"text":4376},{"id":4424,"depth":6656,"text":6753},"6.9 using 引入基类成员",{"id":4471,"depth":6656,"text":4472},{"id":4549,"depth":6652,"text":4550,"children":6756},[6757,6758,6759,6760,6762,6764,6766,6767,6768,6770,6771,6772],{"id":4553,"depth":6656,"text":4554},{"id":4627,"depth":6656,"text":4628},{"id":4711,"depth":6656,"text":4712},{"id":4793,"depth":6656,"text":6761},"7.4 前置和后置 ++",{"id":4844,"depth":6656,"text":6763},"7.5 \u003C\u003C 和 >> 重载",{"id":4925,"depth":6656,"text":6765},"7.6 赋值运算符 operator=",{"id":4998,"depth":6656,"text":4999},{"id":5035,"depth":6656,"text":5036},{"id":5077,"depth":6656,"text":6769},"7.9 operator+、operator+=、operator[]",{"id":5151,"depth":6656,"text":5152},{"id":5245,"depth":6656,"text":5246},{"id":5296,"depth":6656,"text":5297},{"id":5364,"depth":6652,"text":5365,"children":6774},[6775,6776,6777,6778,6779,6780,6781,6782],{"id":5368,"depth":6656,"text":5369},{"id":5433,"depth":6656,"text":5434},{"id":5466,"depth":6656,"text":5467},{"id":5513,"depth":6656,"text":5514},{"id":5593,"depth":6656,"text":5594},{"id":5654,"depth":6656,"text":5655},{"id":5702,"depth":6656,"text":5703},{"id":5765,"depth":6656,"text":5766},{"id":5814,"depth":6652,"text":5815,"children":6784},[6785,6786,6787,6788],{"id":5818,"depth":6656,"text":5819},{"id":5898,"depth":6656,"text":5899},{"id":5961,"depth":6656,"text":5962},{"id":5997,"depth":6656,"text":5998},{"id":6036,"depth":6652,"text":6037,"children":6790},[6791,6792,6793,6794],{"id":6040,"depth":6656,"text":6041},{"id":6114,"depth":6656,"text":6115},{"id":6153,"depth":6656,"text":6154},{"id":6184,"depth":6656,"text":6185},{"id":6225,"depth":6652,"text":6226,"children":6796},[6797,6798,6800,6802,6803],{"id":6229,"depth":6656,"text":6230},{"id":6274,"depth":6656,"text":6799},"11.2 try-throw-catch",{"id":6313,"depth":6656,"text":6801},"11.3 多个 catch",{"id":6348,"depth":6656,"text":6349},{"id":6382,"depth":6656,"text":6383},{"id":6415,"depth":6652,"text":6416,"children":6805},[6806,6807,6808,6809],{"id":6419,"depth":6656,"text":6420},{"id":6450,"depth":6656,"text":6451},{"id":6481,"depth":6656,"text":6482},{"id":6518,"depth":6656,"text":6519},{"id":6534,"depth":6652,"text":6535,"children":6811},[6812,6814,6816,6818,6820,6822],{"id":6538,"depth":6656,"text":6813},"13.1 String 类 Big Three",{"id":6552,"depth":6656,"text":6815},"13.2 operator+",{"id":6567,"depth":6656,"text":6817},"13.3 operator+=",{"id":6582,"depth":6656,"text":6819},"13.4 operator[]",{"id":6596,"depth":6656,"text":6821},"13.5 operator\u003C\u003C",{"id":6615,"depth":6656,"text":6823},"13.6 Array\u003CT> 下标",{"id":6640,"depth":6652,"text":6641},[6826],"期末复习","2026-06-27 21:19:34","C++ 面向对象程序设计期末复习详细笔记，涉及概念、语法、例子和考点，整理类、构造析构、继承、多态、模板、文件流与异常处理等内容。",false,"md","\u002Fimages\u002Fcpp-oop-final-review-cover.jpg",{"slots":6833},{},true,"\u002F2026\u002Fcpp-oop-final-review",null,{"text":6838,"minutes":6839,"time":6840,"words":6841},"69 min read",68.265,4095900,13653,{"title":5,"description":6828},{"loc":6835},"posts\u002F2026\u002FC++面向对象期末复习资料",[6846,6847,6848,6849],"学习","C++","面向对象","复习","tech","2026-06-27 21:48:27","B_cw8OM6WZ4rnWZI-mKVuc9Me3mhwoHm42rllZFqXnw",[6854,6859],{"title":6855,"path":6856,"stem":6857,"date":6858,"type":6850,"children":-1},"2026 | 思想道德与法治主观题","\u002F2026\u002Fideological-morality-rule-of-law","posts\u002F2026\u002F思想道德与法治主观题","2026-06-09 19:45:46",{"title":6860,"path":6861,"stem":6862,"date":6863,"type":6850,"children":-1},"C++面向对象的程序设计期末考试逃课教程","\u002F2026\u002Fcpp-oop-final-exam-shortcut","posts\u002F2026\u002FC++面向对象期末考试逃课教程","2026-07-08 16:31:30",1786256778265]