[{"data":1,"prerenderedAt":1876},["ShallowReactive",2],{"navigation":3,"\u002Fch10\u002Fsmart_pointer":909,"\u002Fch10\u002Fsmart_pointer-surround":1871},[4,36,56,96,230,270,414,457,508,583,649,685,767,864,900,904],{"title":5,"icon":6,"path":7,"stem":8,"children":9},"附录","i-lucide-bookmark","\u002Fappendix","appendix",[10,12,16,20,24,28,32],{"title":5,"path":7,"stem":11,"icon":6},"appendix\u002Findex",{"title":13,"path":14,"stem":15,"icon":6},"命令行界面","\u002Fappendix\u002Fcli","appendix\u002Fcli",{"title":17,"path":18,"stem":19,"icon":6},"代码风格","\u002Fappendix\u002Fcoding_style","appendix\u002Fcoding_style",{"title":21,"path":22,"stem":23,"icon":6},"关键字列表","\u002Fappendix\u002Fkeyword","appendix\u002Fkeyword",{"title":25,"path":26,"stem":27,"icon":6},"运算符优先级和结合方向","\u002Fappendix\u002Foperator","appendix\u002Foperator",{"title":29,"path":30,"stem":31,"icon":6},"预处理指令","\u002Fappendix\u002Fpreprocessor","appendix\u002Fpreprocessor",{"title":33,"path":34,"stem":35,"icon":6},"值类别","\u002Fappendix\u002Fvalue_category","appendix\u002Fvalue_category",{"title":37,"icon":38,"path":39,"stem":40,"children":41},"第〇章 基本概念","i-lucide-monitor","\u002Fch00","ch00",[42,44,48,52],{"title":37,"path":39,"stem":43,"icon":38},"ch00\u002Findex",{"title":45,"path":46,"stem":47,"icon":38},"计算机","\u002Fch00\u002Fcomputer","ch00\u002Fcomputer",{"title":49,"path":50,"stem":51,"icon":38},"编程","\u002Fch00\u002Fprogramming","ch00\u002Fprogramming",{"title":53,"path":54,"stem":55,"icon":38},"编程语言","\u002Fch00\u002Fprogramming_language","ch00\u002Fprogramming_language",{"title":57,"icon":58,"path":59,"stem":60,"children":61},"第一章 感性认识 C++ 程序","i-lucide-book-open","\u002Fch01","ch01",[62,64,68,72,76,80,84,88,92],{"title":57,"path":59,"stem":63,"icon":58},"ch01\u002Findex",{"title":65,"path":66,"stem":67,"icon":58},"赋值和分支","\u002Fch01\u002Fassignment_and_if","ch01\u002Fassignment_and_if",{"title":69,"path":70,"stem":71,"icon":58},"最麻烦的门槛","\u002Fch01\u002Fenvironment","ch01\u002Fenvironment",{"title":73,"path":74,"stem":75,"icon":58},"第一个 C++ 程序","\u002Fch01\u002Ffirst_program","ch01\u002Ffirst_program",{"title":77,"path":78,"stem":79,"icon":58},"输入","\u002Fch01\u002Finput","ch01\u002Finput",{"title":81,"path":82,"stem":83,"icon":58},"综合运用","\u002Fch01\u002Fintegrated_use","ch01\u002Fintegrated_use",{"title":85,"path":86,"stem":87,"icon":58},"循环","\u002Fch01\u002Floop","ch01\u002Floop",{"title":89,"path":90,"stem":91,"icon":58},"更多的输出","\u002Fch01\u002Fmore_output","ch01\u002Fmore_output",{"title":93,"path":94,"stem":95,"icon":58},"总结","\u002Fch01\u002Fsummary","ch01\u002Fsummary",{"title":97,"path":98,"stem":99,"children":100,"icon":102},"第二章 理性认识 C++ 程序","\u002Fch02","ch02\u002Findex",[101,103,149,188,227],{"title":97,"path":98,"stem":99,"icon":102},"i-lucide-code",{"title":104,"icon":105,"path":106,"stem":107,"children":108},"第 1 部分 数据成分","i-lucide-database","\u002Fch02\u002Fpart1","ch02\u002Fpart1\u002Findex",[109,110,114,118,122,126],{"title":104,"path":106,"stem":107,"icon":105},{"title":111,"path":112,"stem":113,"icon":105},"初识数组","\u002Fch02\u002Fpart1\u002Farray_glance","ch02\u002Fpart1\u002Farray_glance",{"title":115,"path":116,"stem":117,"icon":105},"常量","\u002Fch02\u002Fpart1\u002Fconstant","ch02\u002Fpart1\u002Fconstant",{"title":119,"path":120,"stem":121,"icon":105},"声明语句","\u002Fch02\u002Fpart1\u002Fdeclaration_statement","ch02\u002Fpart1\u002Fdeclaration_statement",{"title":123,"path":124,"stem":125,"icon":105},"只读变量","\u002Fch02\u002Fpart1\u002Freadonly_variable","ch02\u002Fpart1\u002Freadonly_variable",{"title":127,"icon":128,"path":129,"stem":130,"children":131},"类型系统","i-lucide-dna","\u002Fch02\u002Fpart1\u002Ftype_system","ch02\u002Fpart1\u002Ftype_system\u002Findex",[132,133,137,141,145],{"title":127,"path":129,"stem":130,"icon":128},{"title":134,"path":135,"stem":136,"icon":128},"布尔类型","\u002Fch02\u002Fpart1\u002Ftype_system\u002Fboolean_type","ch02\u002Fpart1\u002Ftype_system\u002Fboolean_type",{"title":138,"path":139,"stem":140,"icon":128},"字符类型","\u002Fch02\u002Fpart1\u002Ftype_system\u002Fcharacter_type","ch02\u002Fpart1\u002Ftype_system\u002Fcharacter_type",{"title":142,"path":143,"stem":144,"icon":128},"浮点类型","\u002Fch02\u002Fpart1\u002Ftype_system\u002Ffloat_type","ch02\u002Fpart1\u002Ftype_system\u002Ffloat_type",{"title":146,"path":147,"stem":148,"icon":128},"整型","\u002Fch02\u002Fpart1\u002Ftype_system\u002Finteger_type","ch02\u002Fpart1\u002Ftype_system\u002Finteger_type",{"title":150,"icon":151,"path":152,"stem":153,"children":154},"第 2 部分 运算成分","i-lucide-calculator","\u002Fch02\u002Fpart2","ch02\u002Fpart2\u002Findex",[155,156,160,164,168,172,176,180,184],{"title":150,"path":152,"stem":153,"icon":151},{"title":157,"path":158,"stem":159,"icon":151},"算术运算符","\u002Fch02\u002Fpart2\u002Farithmetic_operator","ch02\u002Fpart2\u002Farithmetic_operator",{"title":161,"path":162,"stem":163,"icon":151},"赋值运算符","\u002Fch02\u002Fpart2\u002Fassignment_operator","ch02\u002Fpart2\u002Fassignment_operator",{"title":165,"path":166,"stem":167,"icon":151},"位运算符（选读）","\u002Fch02\u002Fpart2\u002Fbit_operator","ch02\u002Fpart2\u002Fbit_operator",{"title":169,"path":170,"stem":171,"icon":151},"关系运算符","\u002Fch02\u002Fpart2\u002Fcomparison_operator","ch02\u002Fpart2\u002Fcomparison_operator",{"title":173,"path":174,"stem":175,"icon":151},"算术类型隐式转换","\u002Fch02\u002Fpart2\u002Fimplicit_conversion","ch02\u002Fpart2\u002Fimplicit_conversion",{"title":177,"path":178,"stem":179,"icon":151},"自增减运算符","\u002Fch02\u002Fpart2\u002Fincdec_operator","ch02\u002Fpart2\u002Fincdec_operator",{"title":181,"path":182,"stem":183,"icon":151},"逻辑运算符","\u002Fch02\u002Fpart2\u002Flogical_operator","ch02\u002Fpart2\u002Flogical_operator",{"title":185,"path":186,"stem":187,"icon":151},"其它常用运算符","\u002Fch02\u002Fpart2\u002Fother_operator","ch02\u002Fpart2\u002Fother_operator",{"title":189,"icon":190,"path":191,"stem":192,"children":193},"第 3 部分 控制成分","i-lucide-git-branch","\u002Fch02\u002Fpart3","ch02\u002Fpart3\u002Findex",[194,195,199,203,207,211,215,219,223],{"title":189,"path":191,"stem":192,"icon":190},{"title":196,"path":197,"stem":198,"icon":190},"复合语句","\u002Fch02\u002Fpart3\u002Fcompound_statement","ch02\u002Fpart3\u002Fcompound_statement",{"title":200,"path":201,"stem":202,"icon":190},"for 语句","\u002Fch02\u002Fpart3\u002Ffor_statement","ch02\u002Fpart3\u002Ffor_statement",{"title":204,"path":205,"stem":206,"icon":190},"if 语句","\u002Fch02\u002Fpart3\u002Fif_statement","ch02\u002Fpart3\u002Fif_statement",{"title":208,"path":209,"stem":210,"icon":190},"跳转语句","\u002Fch02\u002Fpart3\u002Fjump_statement","ch02\u002Fpart3\u002Fjump_statement",{"title":212,"path":213,"stem":214,"icon":190},"空语句","\u002Fch02\u002Fpart3\u002Fnull_statement","ch02\u002Fpart3\u002Fnull_statement",{"title":216,"path":217,"stem":218,"icon":190},"作用域","\u002Fch02\u002Fpart3\u002Fscope","ch02\u002Fpart3\u002Fscope",{"title":220,"path":221,"stem":222,"icon":190},"switch 语句","\u002Fch02\u002Fpart3\u002Fswitch_statement","ch02\u002Fpart3\u002Fswitch_statement",{"title":224,"path":225,"stem":226,"icon":190},"while 语句","\u002Fch02\u002Fpart3\u002Fwhile_statement","ch02\u002Fpart3\u002Fwhile_statement",{"title":93,"path":228,"stem":229,"icon":102},"\u002Fch02\u002Fsummary","ch02\u002Fsummary",{"title":231,"icon":232,"path":233,"stem":234,"children":235},"第三章 过程式编程","i-lucide-function-square","\u002Fch03","ch03",[236,239,243,247,251,255,259,263,267],{"title":231,"path":233,"stem":237,"icon":238},"ch03\u002Findex","i-lucide-square-function",{"title":240,"path":241,"stem":242,"icon":232},"函数","\u002Fch03\u002Ffunction","ch03\u002Ffunction",{"title":244,"path":245,"stem":246,"icon":232},"函数的定义、声明和调用","\u002Fch03\u002Ffunction_definition","ch03\u002Ffunction_definition",{"title":248,"path":249,"stem":250,"icon":232},"函数的执行","\u002Fch03\u002Ffunction_execution","ch03\u002Ffunction_execution",{"title":252,"path":253,"stem":254,"icon":232},"初识函数","\u002Fch03\u002Ffunction_glance","ch03\u002Ffunction_glance",{"title":256,"path":257,"stem":258,"icon":232},"递归","\u002Fch03\u002Frecursion","ch03\u002Frecursion",{"title":260,"path":261,"stem":262,"icon":232},"重新认识 C++ 程序","\u002Fch03\u002Freview_cpp","ch03\u002Freview_cpp",{"title":264,"path":265,"stem":266,"icon":232},"再谈作用域","\u002Fch03\u002Fscope_again","ch03\u002Fscope_again",{"title":93,"path":268,"stem":269,"icon":232},"\u002Fch03\u002Fsummary","ch03\u002Fsummary",{"title":271,"icon":272,"path":273,"stem":274,"children":275},"第四章 POD 类型与结构","i-lucide-layers","\u002Fch04","ch04",[276,278,301,316,320,338,365,392,407,410],{"title":271,"path":273,"stem":277,"icon":272},"ch04\u002Findex",{"title":279,"icon":280,"path":281,"stem":282,"children":283},"数组","i-lucide-grid","\u002Fch04\u002Farray","ch04\u002Farray\u002Findex",[284,285,289,293,297],{"title":279,"path":281,"stem":282,"icon":280},{"title":286,"path":287,"stem":288,"icon":280},"二维数组","\u002Fch04\u002Farray\u002F2d_array","ch04\u002Farray\u002F2d_array",{"title":290,"path":291,"stem":292,"icon":280},"数组的定义和初始化","\u002Fch04\u002Farray\u002Farray_init","ch04\u002Farray\u002Farray_init",{"title":294,"path":295,"stem":296,"icon":280},"数组的用途","\u002Fch04\u002Farray\u002Farray_usage","ch04\u002Farray\u002Farray_usage",{"title":298,"path":299,"stem":300,"icon":280},"C 风格字符串","\u002Fch04\u002Farray\u002Fc_string","ch04\u002Farray\u002Fc_string",{"title":302,"icon":303,"path":304,"stem":305,"children":306},"迁移到 C 语言","i-lucide-arrow-right-left","\u002Fch04\u002Fcompare_with_c","ch04\u002Fcompare_with_c\u002Findex",[307,308,312],{"title":302,"path":304,"stem":305,"icon":303},{"title":309,"path":310,"stem":311,"icon":303},"需要注意的 C 特性","\u002Fch04\u002Fcompare_with_c\u002Fc_feature","ch04\u002Fcompare_with_c\u002Fc_feature",{"title":313,"path":314,"stem":315,"icon":303},"C 输入输出","\u002Fch04\u002Fcompare_with_c\u002Fc_io","ch04\u002Fcompare_with_c\u002Fc_io",{"title":317,"path":318,"stem":319,"icon":272},"枚举","\u002Fch04\u002Fenum","ch04\u002Fenum",{"title":321,"path":322,"stem":323,"children":324,"icon":326},"输入输出成分","\u002Fch04\u002Fio","ch04\u002Fio\u002Findex",[325,327,330,334],{"title":321,"path":322,"stem":323,"icon":326},"i-lucide-terminal",{"title":77,"path":328,"stem":329,"icon":326},"\u002Fch04\u002Fio\u002Finput","ch04\u002Fio\u002Finput",{"title":331,"path":332,"stem":333,"icon":326},"输入失败状态","\u002Fch04\u002Fio\u002Finput_fail","ch04\u002Fio\u002Finput_fail",{"title":335,"path":336,"stem":337,"icon":326},"输出","\u002Fch04\u002Fio\u002Foutput","ch04\u002Fio\u002Foutput",{"title":339,"icon":340,"path":341,"stem":342,"children":343},"链表","i-lucide-list","\u002Fch04\u002Flist","ch04\u002Flist\u002Findex",[344,345,349,353,357,361],{"title":339,"path":341,"stem":342,"icon":340},{"title":346,"path":347,"stem":348,"icon":340},"new[] 和 delete[]","\u002Fch04\u002Flist\u002Farr_new_del","ch04\u002Flist\u002Farr_new_del",{"title":350,"path":351,"stem":352,"icon":340},"链表的增删","\u002Fch04\u002Flist\u002Flist_add_del","ch04\u002Flist\u002Flist_add_del",{"title":354,"path":355,"stem":356,"icon":340},"链表的构建","\u002Fch04\u002Flist\u002Flist_construct","ch04\u002Flist\u002Flist_construct",{"title":358,"path":359,"stem":360,"icon":340},"安全性","\u002Fch04\u002Flist\u002Fsafety","ch04\u002Flist\u002Fsafety",{"title":362,"path":363,"stem":364,"icon":340},"存储期","\u002Fch04\u002Flist\u002Fstorage_duration","ch04\u002Flist\u002Fstorage_duration",{"title":366,"path":367,"stem":368,"children":369,"icon":371},"指针","\u002Fch04\u002Fpointer","ch04\u002Fpointer\u002Findex",[370,372,376,380,384,388],{"title":366,"path":367,"stem":368,"icon":371},"i-lucide-dot",{"title":373,"path":374,"stem":375,"icon":371},"何为指针","\u002Fch04\u002Fpointer\u002Fpointer","ch04\u002Fpointer\u002Fpointer",{"title":377,"path":378,"stem":379,"icon":371},"指针和数组","\u002Fch04\u002Fpointer\u002Fpointer_and_array","ch04\u002Fpointer\u002Fpointer_and_array",{"title":381,"path":382,"stem":383,"icon":371},"指针的定义 Ⅰ","\u002Fch04\u002Fpointer\u002Fpointer_def","ch04\u002Fpointer\u002Fpointer_def",{"title":385,"path":386,"stem":387,"icon":371},"指针的定义 Ⅱ","\u002Fch04\u002Fpointer\u002Fpointer_def_2","ch04\u002Fpointer\u002Fpointer_def_2",{"title":389,"path":390,"stem":391,"icon":371},"指针的简单使用","\u002Fch04\u002Fpointer\u002Fpointer_usage","ch04\u002Fpointer\u002Fpointer_usage",{"title":393,"path":394,"stem":395,"children":396,"icon":398},"结构体","\u002Fch04\u002Fstruct","ch04\u002Fstruct\u002Findex",[397,399,403],{"title":393,"path":394,"stem":395,"icon":398},"i-lucide-box",{"title":400,"path":401,"stem":402,"icon":398},"结构体的定义","\u002Fch04\u002Fstruct\u002Fstruct_def","ch04\u002Fstruct\u002Fstruct_def",{"title":404,"path":405,"stem":406,"icon":398},"结构体的使用","\u002Fch04\u002Fstruct\u002Fstruct_usage","ch04\u002Fstruct\u002Fstruct_usage",{"title":93,"path":408,"stem":409,"icon":272},"\u002Fch04\u002Fsummary","ch04\u002Fsummary",{"title":411,"path":412,"stem":413,"icon":272},"联合体","\u002Fch04\u002Funion","ch04\u002Funion",{"title":415,"icon":416,"path":417,"stem":418,"children":419},"第五章 初探面向对象","i-lucide-copy","\u002Fch05","ch05",[420,422,426,430,434,438,442,446,450,454],{"title":415,"path":417,"stem":421,"icon":416},"ch05\u002Findex",{"title":423,"path":424,"stem":425,"icon":416},"构造函数","\u002Fch05\u002Fconstructor","ch05\u002Fconstructor",{"title":427,"path":428,"stem":429,"icon":416},"复制构造函数","\u002Fch05\u002Fcopy_constructor","ch05\u002Fcopy_constructor",{"title":431,"path":432,"stem":433,"icon":416},"预置构造函数","\u002Fch05\u002Fdefaulted_constructor","ch05\u002Fdefaulted_constructor",{"title":435,"path":436,"stem":437,"icon":416},"例子：简单的字符串","\u002Fch05\u002Feasy_string","ch05\u002Feasy_string",{"title":439,"path":440,"stem":441,"icon":416},"收尾工作","\u002Fch05\u002Fmisc","ch05\u002Fmisc",{"title":443,"path":444,"stem":445,"icon":416},"重载","\u002Fch05\u002Foverload","ch05\u002Foverload",{"title":447,"path":448,"stem":449,"icon":416},"引用","\u002Fch05\u002Freference","ch05\u002Freference",{"title":451,"path":452,"stem":453,"icon":416},"浅复制与深复制","\u002Fch05\u002Fshallow_deep_copy","ch05\u002Fshallow_deep_copy",{"title":93,"path":455,"stem":456,"icon":416},"\u002Fch05\u002Fsummary","ch05\u002Fsummary",{"title":458,"icon":459,"path":460,"stem":461,"children":462},"第六章 运算符重载","i-lucide-component","\u002Fch06","ch06",[463,465,469,473,477,481,485,489,493,497,501,504],{"title":458,"path":460,"stem":464,"icon":459},"ch06\u002Findex",{"title":466,"path":467,"stem":468,"icon":459},"赋值运算符重载","\u002Fch06\u002Fassignment_overload","ch06\u002Fassignment_overload",{"title":470,"path":471,"stem":472,"icon":459},"赋值与初始化","\u002Fch06\u002Fassignment_vs_construct","ch06\u002Fassignment_vs_construct",{"title":474,"path":475,"stem":476,"icon":459},"类型转换重载","\u002Fch06\u002Fcast_overload","ch06\u002Fcast_overload",{"title":478,"path":479,"stem":480,"icon":459},"只读成员函数","\u002Fch06\u002Fconst_member_function","ch06\u002Fconst_member_function",{"title":482,"path":483,"stem":484,"icon":459},"友元","\u002Fch06\u002Ffriend","ch06\u002Ffriend",{"title":486,"path":487,"stem":488,"icon":459},"类外定义成员函数","\u002Fch06\u002Fnoninline_member_function","ch06\u002Fnoninline_member_function",{"title":490,"path":491,"stem":492,"icon":459},"非成员的运算符重载","\u002Fch06\u002Fnonmember_operator","ch06\u002Fnonmember_operator",{"title":494,"path":495,"stem":496,"icon":459},"特殊运算符重载","\u002Fch06\u002Fspecial_operator_overload","ch06\u002Fspecial_operator_overload",{"title":498,"path":499,"stem":500,"icon":459},"静态成员","\u002Fch06\u002Fstatic_member","ch06\u002Fstatic_member",{"title":93,"path":502,"stem":503,"icon":459},"\u002Fch06\u002Fsummary","ch06\u002Fsummary",{"title":505,"path":506,"stem":507,"icon":459},"`this` 指针","\u002Fch06\u002Fthis","ch06\u002Fthis",{"title":509,"path":510,"stem":511,"children":512,"icon":190},"第七章 继承与多态","\u002Fch07","ch07\u002Findex",[513,514,541,545,549,580],{"title":509,"path":510,"stem":511,"icon":190},{"title":515,"icon":516,"path":517,"stem":518,"children":519},"继承关系","i-lucide-share","\u002Fch07\u002Finheritance","ch07\u002Finheritance\u002Findex",[520,521,525,529,533,537],{"title":515,"path":517,"stem":518,"icon":516},{"title":522,"path":523,"stem":524,"icon":516},"关于成员名","\u002Fch07\u002Finheritance\u002Fabout_member_name","ch07\u002Finheritance\u002Fabout_member_name",{"title":526,"path":527,"stem":528,"icon":516},"派生类的构造","\u002Fch07\u002Finheritance\u002Fderived_constructor","ch07\u002Finheritance\u002Fderived_constructor",{"title":530,"path":531,"stem":532,"icon":516},"继承中的隐式转换","\u002Fch07\u002Finheritance\u002Fimplicit_cast_in_inheritance","ch07\u002Finheritance\u002Fimplicit_cast_in_inheritance",{"title":534,"path":535,"stem":536,"icon":516},"其它小问题","\u002Fch07\u002Finheritance\u002Fmisc","ch07\u002Finheritance\u002Fmisc",{"title":538,"path":539,"stem":540,"icon":516},"保护成员","\u002Fch07\u002Finheritance\u002Fprotected_member","ch07\u002Finheritance\u002Fprotected_member",{"title":542,"path":543,"stem":544,"icon":190},"多重继承","\u002Fch07\u002Fmi","ch07\u002Fmi",{"title":546,"path":547,"stem":548,"icon":190},"简单的对象关系","\u002Fch07\u002Fobject_relationships","ch07\u002Fobject_relationships",{"title":550,"icon":551,"path":552,"stem":553,"children":554},"多态","i-lucide-refresh","\u002Fch07\u002Fpolymorphism","ch07\u002Fpolymorphism\u002Findex",[555,556,560,564,568,572,576],{"title":550,"path":552,"stem":553,"icon":551},{"title":557,"path":558,"stem":559,"icon":551},"抽象类","\u002Fch07\u002Fpolymorphism\u002Fabstract_class","ch07\u002Fpolymorphism\u002Fabstract_class",{"title":561,"path":562,"stem":563,"icon":551},"C++ 风格类型转换","\u002Fch07\u002Fpolymorphism\u002Fcpp_cast","ch07\u002Fpolymorphism\u002Fcpp_cast",{"title":565,"path":566,"stem":567,"icon":551},"`override` 与 `final`","\u002Fch07\u002Fpolymorphism\u002Foverride_and_final","ch07\u002Fpolymorphism\u002Foverride_and_final",{"title":569,"path":570,"stem":571,"icon":551},"RTTI","\u002Fch07\u002Fpolymorphism\u002Frtti","ch07\u002Fpolymorphism\u002Frtti",{"title":573,"path":574,"stem":575,"icon":551},"虚析构函数","\u002Fch07\u002Fpolymorphism\u002Fvirtual_destructor","ch07\u002Fpolymorphism\u002Fvirtual_destructor",{"title":577,"path":578,"stem":579,"icon":551},"虚函数","\u002Fch07\u002Fpolymorphism\u002Fvirtual_function","ch07\u002Fpolymorphism\u002Fvirtual_function",{"title":93,"path":581,"stem":582,"icon":190},"\u002Fch07\u002Fsummary","ch07\u002Fsummary",{"title":584,"icon":585,"path":586,"stem":587,"children":588},"第八章 模板基础","i-lucide-layout-template","\u002Fch08","ch08",[589,591,595,599,603,607,646],{"title":584,"path":586,"stem":590,"icon":585},"ch08\u002Findex",{"title":592,"path":593,"stem":594,"icon":585},"类模板","\u002Fch08\u002Fclass_template","ch08\u002Fclass_template",{"title":596,"path":597,"stem":598,"icon":585},"默认实参","\u002Fch08\u002Fdefault_argument","ch08\u002Fdefault_argument",{"title":600,"path":601,"stem":602,"icon":585},"函数模板","\u002Fch08\u002Ffunction_template","ch08\u002Ffunction_template",{"title":604,"path":605,"stem":606,"icon":585},"非类型模板参数","\u002Fch08\u002Fnontype_template_param","ch08\u002Fnontype_template_param",{"title":608,"icon":609,"path":610,"stem":611,"children":612},"STL 容器和迭代器","i-lucide-container","\u002Fch08\u002Fstl_containers","ch08\u002Fstl_containers\u002Findex",[613,614,618,622,626,630,634,638,642],{"title":608,"path":610,"stem":611,"icon":609},{"title":615,"path":616,"stem":617,"icon":609},"容器适配器","\u002Fch08\u002Fstl_containers\u002Fadaptors","ch08\u002Fstl_containers\u002Fadaptors",{"title":619,"path":620,"stem":621,"icon":609},"迭代器的概念","\u002Fch08\u002Fstl_containers\u002Fiterator_concept","ch08\u002Fstl_containers\u002Fiterator_concept",{"title":623,"path":624,"stem":625,"icon":609},"初识迭代器","\u002Fch08\u002Fstl_containers\u002Fiterator_glance","ch08\u002Fstl_containers\u002Fiterator_glance",{"title":627,"path":628,"stem":629,"icon":609},"迭代器的用途","\u002Fch08\u002Fstl_containers\u002Fiterator_usage","ch08\u002Fstl_containers\u002Fiterator_usage",{"title":631,"path":632,"stem":633,"icon":609},"`std::map`","\u002Fch08\u002Fstl_containers\u002Fmap","ch08\u002Fstl_containers\u002Fmap",{"title":635,"path":636,"stem":637,"icon":609},"其它顺序容器","\u002Fch08\u002Fstl_containers\u002Fother_sequence","ch08\u002Fstl_containers\u002Fother_sequence",{"title":639,"path":640,"stem":641,"icon":609},"`std::set`","\u002Fch08\u002Fstl_containers\u002Fset","ch08\u002Fstl_containers\u002Fset",{"title":643,"path":644,"stem":645,"icon":609},"`std::vector`","\u002Fch08\u002Fstl_containers\u002Fvector","ch08\u002Fstl_containers\u002Fvector",{"title":93,"path":647,"stem":648,"icon":585},"\u002Fch08\u002Fsummary","ch08\u002Fsummary",{"title":650,"icon":651,"path":652,"stem":653,"children":654},"第九章 链接","i-lucide-link","\u002Fch09","ch09",[655,657,661,665,669,673,677,681],{"title":650,"path":652,"stem":656,"icon":651},"ch09\u002Findex",{"title":658,"path":659,"stem":660,"icon":651},"C 中的链接","\u002Fch09\u002Fc_linking","ch09\u002Fc_linking",{"title":662,"path":663,"stem":664,"icon":651},"多文件编译实践","\u002Fch09\u002Fcompile_multiple_files","ch09\u002Fcompile_multiple_files",{"title":666,"path":667,"stem":668,"icon":651},"模板中的友元","\u002Fch09\u002Ffriend_in_template","ch09\u002Ffriend_in_template",{"title":670,"path":671,"stem":672,"icon":651},"内联","\u002Fch09\u002Finline","ch09\u002Finline",{"title":674,"path":675,"stem":676,"icon":651},"单一定义原则","\u002Fch09\u002Fodr","ch09\u002Fodr",{"title":678,"path":679,"stem":680,"icon":651},"符号和连接","\u002Fch09\u002Fsymbol_and_linkage","ch09\u002Fsymbol_and_linkage",{"title":682,"path":683,"stem":684,"icon":651},"模板的链接","\u002Fch09\u002Ftemplate_linking","ch09\u002Ftemplate_linking",{"title":686,"icon":687,"path":688,"stem":689,"children":690},"第十章 常用库介绍 \u003CBadge type=\"warning\" text=\"TBC\" \u002F>","i-lucide-hard-drive","\u002Fch10","ch10",[691,694,717,732,736,740],{"title":692,"path":688,"stem":693,"icon":687},"第十章 常用库介绍","ch10\u002Findex",{"title":695,"icon":696,"path":697,"stem":698,"children":699},"代数数据类型","i-lucide-shapes","\u002Fch10\u002Fadt","ch10\u002Fadt\u002Findex",[700,701,705,709,713],{"title":695,"path":697,"stem":698,"icon":696},{"title":702,"path":703,"stem":704,"icon":696},"顶类型 `std::any`","\u002Fch10\u002Fadt\u002Fany","ch10\u002Fadt\u002Fany",{"title":706,"path":707,"stem":708,"icon":696},"底类型","\u002Fch10\u002Fadt\u002Fnoreturn","ch10\u002Fadt\u002Fnoreturn",{"title":710,"path":711,"stem":712,"icon":696},"通用积类型 `std::tuple`","\u002Fch10\u002Fadt\u002Ftuple","ch10\u002Fadt\u002Ftuple",{"title":714,"path":715,"stem":716,"icon":696},"通用和类型 `std::variant`","\u002Fch10\u002Fadt\u002Fvariant","ch10\u002Fadt\u002Fvariant",{"title":718,"icon":719,"path":720,"stem":721,"children":722},"文件读写","i-lucide-file-text","\u002Fch10\u002Ffile_io","ch10\u002Ffile_io\u002Findex",[723,724,728],{"title":718,"path":720,"stem":721,"icon":719},{"title":725,"path":726,"stem":727,"icon":719},"C 风格输入输出","\u002Fch10\u002Ffile_io\u002Fc_io","ch10\u002Ffile_io\u002Fc_io",{"title":729,"path":730,"stem":731,"icon":719},"流式输入输出","\u002Fch10\u002Ffile_io\u002Fstream","ch10\u002Ffile_io\u002Fstream",{"title":733,"path":734,"stem":735,"icon":687},"文件系统","\u002Fch10\u002Ffilesystem","ch10\u002Ffilesystem",{"title":737,"path":738,"stem":739,"icon":687},"伪随机数生成","\u002Fch10\u002Frandom","ch10\u002Frandom",{"title":741,"path":742,"stem":743,"children":744,"icon":746},"移动语义与智能指针","\u002Fch10\u002Fsmart_pointer","ch10\u002Fsmart_pointer\u002Findex",[745,747,751,755,759,763],{"title":741,"path":742,"stem":743,"icon":746},"i-lucide-pointer",{"title":748,"path":749,"stem":750,"icon":746},"`std::move` 与转发引用","\u002Fch10\u002Fsmart_pointer\u002Fmove_and_forward","ch10\u002Fsmart_pointer\u002Fmove_and_forward",{"title":752,"path":753,"stem":754,"icon":746},"所有权","\u002Fch10\u002Fsmart_pointer\u002Fownership","ch10\u002Fsmart_pointer\u002Fownership",{"title":756,"path":757,"stem":758,"icon":746},"右值引用","\u002Fch10\u002Fsmart_pointer\u002Frvalue_reference","ch10\u002Fsmart_pointer\u002Frvalue_reference",{"title":760,"path":761,"stem":762,"icon":746},"`std::shared_ptr`","\u002Fch10\u002Fsmart_pointer\u002Fshared_ptr","ch10\u002Fsmart_pointer\u002Fshared_ptr",{"title":764,"path":765,"stem":766,"icon":746},"特殊成员函数","\u002Fch10\u002Fsmart_pointer\u002Fspecial_member_function","ch10\u002Fsmart_pointer\u002Fspecial_member_function",{"title":768,"icon":769,"path":770,"stem":771,"children":772},"第十一章 函数式编程","i-lucide-sparkles","\u002Fch11","ch11",[773,775,794,821,825],{"title":768,"path":770,"stem":774,"icon":769},"ch11\u002Findex",{"title":776,"icon":777,"path":778,"stem":779,"children":780},"语法进阶","i-lucide-graduation-cap","\u002Fch11\u002Fadvanced","ch11\u002Fadvanced\u002Findex",[781,782,786,790],{"title":776,"path":778,"stem":779,"icon":777},{"title":783,"path":784,"stem":785,"icon":777},"实参依赖查找","\u002Fch11\u002Fadvanced\u002Fadl","ch11\u002Fadvanced\u002Fadl",{"title":787,"path":788,"stem":789,"icon":777},"可调用","\u002Fch11\u002Fadvanced\u002Fcallable","ch11\u002Fadvanced\u002Fcallable",{"title":791,"path":792,"stem":793,"icon":777},"预置比较","\u002Fch11\u002Fadvanced\u002Fdefaulted_compare","ch11\u002Fadvanced\u002Fdefaulted_compare",{"title":795,"icon":796,"path":797,"stem":798,"children":799},"语法基础","i-lucide-book-text","\u002Fch11\u002Fgrammar","ch11\u002Fgrammar\u002Findex",[800,801,805,809,813,817],{"title":795,"path":797,"stem":798,"icon":796},{"title":802,"path":803,"stem":804,"icon":796},"闭包","\u002Fch11\u002Fgrammar\u002Fclosure","ch11\u002Fgrammar\u002Fclosure",{"title":806,"path":807,"stem":808,"icon":796},"函数也即对象","\u002Fch11\u002Fgrammar\u002Ffunction_as_object","ch11\u002Fgrammar\u002Ffunction_as_object",{"title":810,"path":811,"stem":812,"icon":796},"高阶函数","\u002Fch11\u002Fgrammar\u002Fhigher_order_function","ch11\u002Fgrammar\u002Fhigher_order_function",{"title":814,"path":815,"stem":816,"icon":796},"Lambda 表达式","\u002Fch11\u002Fgrammar\u002Flambda","ch11\u002Fgrammar\u002Flambda",{"title":818,"path":819,"stem":820,"icon":796},"Lambda 表达式捕获","\u002Fch11\u002Fgrammar\u002Flambda_capture","ch11\u002Fgrammar\u002Flambda_capture",{"title":822,"path":823,"stem":824,"icon":769},"`std::sort`","\u002Fch11\u002Fstd_sort","ch11\u002Fstd_sort",{"title":826,"icon":827,"path":828,"stem":829,"children":830},"STL 算法","i-lucide-sort-asc","\u002Fch11\u002Fstl_algorithms","ch11\u002Fstl_algorithms\u002Findex",[831,832,836,840,844,848,852,856,860],{"title":826,"path":828,"stem":829,"icon":827},{"title":833,"path":834,"stem":835,"icon":827},"迁移到 STLv1","\u002Fch11\u002Fstl_algorithms\u002Fcompare_with_legacy","ch11\u002Fstl_algorithms\u002Fcompare_with_legacy",{"title":837,"path":838,"stem":839,"icon":827},"复制","\u002Fch11\u002Fstl_algorithms\u002Fcopy","ch11\u002Fstl_algorithms\u002Fcopy",{"title":841,"path":842,"stem":843,"icon":827},"筛选","\u002Fch11\u002Fstl_algorithms\u002Ffilter","ch11\u002Fstl_algorithms\u002Ffilter",{"title":845,"path":846,"stem":847,"icon":827},"其它算法","\u002Fch11\u002Fstl_algorithms\u002Fothers","ch11\u002Fstl_algorithms\u002Fothers",{"title":849,"path":850,"stem":851,"icon":827},"初识范围","\u002Fch11\u002Fstl_algorithms\u002Frange","ch11\u002Fstl_algorithms\u002Frange",{"title":853,"path":854,"stem":855,"icon":827},"归约","\u002Fch11\u002Fstl_algorithms\u002Freduce","ch11\u002Fstl_algorithms\u002Freduce",{"title":857,"path":858,"stem":859,"icon":827},"排序","\u002Fch11\u002Fstl_algorithms\u002Fsort","ch11\u002Fstl_algorithms\u002Fsort",{"title":861,"path":862,"stem":863,"icon":827},"变换","\u002Fch11\u002Fstl_algorithms\u002Ftransform","ch11\u002Fstl_algorithms\u002Ftransform",{"title":865,"icon":866,"path":867,"stem":868,"children":869},"第十二章 模板","i-lucide-git-fork","\u002Fch12","ch12",[870,873,877,881,885],{"title":871,"path":867,"stem":872,"icon":866},"第十二章 模板进阶","ch12\u002Findex",{"title":874,"path":875,"stem":876},"C++20 概念","\u002Fch12\u002Fconcepts","ch12\u002Fconcepts",{"title":878,"path":879,"stem":880},"模板元编程","\u002Fch12\u002Fmetaprogramming","ch12\u002Fmetaprogramming",{"title":882,"path":883,"stem":884},"模板特化与偏特化","\u002Fch12\u002Fspecialization","ch12\u002Fspecialization",{"title":886,"icon":887,"path":888,"stem":889,"children":890},"静态派发","i-lucide-route","\u002Fch12\u002Fstatic_dispatch","ch12\u002Fstatic_dispatch\u002Findex",[891,892,896],{"title":886,"path":888,"stem":889},{"title":893,"path":894,"stem":895},"定制点","\u002Fch12\u002Fstatic_dispatch\u002Fcustomize_point","ch12\u002Fstatic_dispatch\u002Fcustomize_point",{"title":897,"path":898,"stem":899},"类型擦除","\u002Fch12\u002Fstatic_dispatch\u002Ftype_erasure","ch12\u002Fstatic_dispatch\u002Ftype_erasure",{"title":901,"path":902,"stem":903,"icon":6},"后记","\u002Fpostscript","postscript",{"title":905,"path":906,"stem":907,"icon":908},"技术信息","\u002Ftechnical_info","technical_info","i-lucide-info",{"id":910,"title":741,"body":911,"description":741,"extension":1865,"links":1866,"meta":1867,"navigation":1868,"path":742,"seo":1869,"stem":743,"__hash__":1870},"docs\u002Fch10\u002Fsmart_pointer\u002Findex.md",{"type":912,"value":913,"toc":1860},"minimark",[914,917,921,929,935,940,943,958,961,1055,1078,1121,1134,1137,1147,1161,1164,1167,1174,1176,1179,1282,1315,1320,1323,1392,1425,1441,1447,1450,1453,1456,1543,1582,1585,1727,1744,1818,1843,1856],[915,916,741],"h1",{"id":741},[918,919,920],"p",{},"接下来这一部分内容，是现代 C++ 中非常重要的一环，但也是非常难以理解的部分。我会尽量把它讲明白，但也有可能讲不明白。",[918,922,923,924,928],{},"C++11 引入了",[925,926,927],"strong",{},"移动语义","（Move semantic）。这里的“移动”是相对于“复制”的意思。在第五、六章中我很详细地讲解了复制构造函数和复制赋值运算符重载；这两个函数的作用都是将一个对象复制成两个，类似于文本编辑里的“复制”-“粘贴”。而这里的移动语义则是“剪切”-“粘贴”：当调用“移动构造函数”或者“移动赋值运算符重载”时，原有的对象被“剪切”，“粘贴”到新的对象。",[918,930,931,932,934],{},"刚刚我尽量形象地描述了移动语义的含义，但实现移动语义则需要很多前置知识，所以我要在后面几节一点点展开。首先要重申的第一个概念是",[925,933,33],{},"。",[936,937,939],"h2",{"id":938},"值类别泛左值与纯右值","值类别：泛左值与纯右值",[918,941,942],{},"任何表达式都有一个值类别；换而言之，一个表达式要么是左值，要么是右值。之前我是这样介绍的，可以取地址的表达式为左值，反之为右值；这样说是有失偏颇的，因为标准文本是反过来定义的：左值可以取地址，右值不可以取地址。换而言之，可否取地址不是左右值的定义，而是它的性质。那么左右值的定义到底是什么呢？",[918,944,945,946,949,950,953,954,957],{},"这个问题目前我无法给出答案，但我可以给出答案的是两个不同的概念：",[925,947,948],{},"泛左值","（glvalue）和",[925,951,952],{},"纯右值","（prvalue）。泛左值是指，",[925,955,956],{},"具有身份","（Has identity）的表达式。反之，纯右值是没有身份（No identity）的表达式。",[918,959,960],{},"这个定义是 C++ 之父 Stroustrup 提出的，是我认为最好理解的一种描述方式——但还是略抽象。什么叫“身份”？我把它翻译为“可识别为独一无二实体”的性质。比如中国居民，每个居民都持有独一无二的身份证，我可以通过身份证确定两个称呼是否指代同一个人，因此中国居民是有身份的。回到编程的话题上，下面的代码中",[962,963,968],"pre",{"className":964,"code":965,"language":966,"meta":967,"style":967},"language-cpp shiki shiki-themes material-theme-lighter material-theme material-theme-palenight","int main() {\n    int x{42};\n    int y{42};\n    x; \u002F\u002F 表达式 1\n    y; \u002F\u002F 表达式 2\n}\n","cpp","",[969,970,971,991,1011,1025,1038,1049],"code",{"__ignoreMap":967},[972,973,976,980,984,988],"span",{"class":974,"line":975},"line",1,[972,977,979],{"class":978},"spNyl","int",[972,981,983],{"class":982},"s2Zo4"," main",[972,985,987],{"class":986},"sMK4o","()",[972,989,990],{"class":986}," {\n",[972,992,994,997,1001,1004,1008],{"class":974,"line":993},2,[972,995,996],{"class":978},"    int",[972,998,1000],{"class":999},"sTEyZ"," x",[972,1002,1003],{"class":986},"{",[972,1005,1007],{"class":1006},"sbssI","42",[972,1009,1010],{"class":986},"};\n",[972,1012,1014,1016,1019,1021,1023],{"class":974,"line":1013},3,[972,1015,996],{"class":978},[972,1017,1018],{"class":999}," y",[972,1020,1003],{"class":986},[972,1022,1007],{"class":1006},[972,1024,1010],{"class":986},[972,1026,1028,1031,1034],{"class":974,"line":1027},4,[972,1029,1030],{"class":999},"    x",[972,1032,1033],{"class":986},";",[972,1035,1037],{"class":1036},"sHwdD"," \u002F\u002F 表达式 1\n",[972,1039,1041,1044,1046],{"class":974,"line":1040},5,[972,1042,1043],{"class":999},"    y",[972,1045,1033],{"class":986},[972,1047,1048],{"class":1036}," \u002F\u002F 表达式 2\n",[972,1050,1052],{"class":974,"line":1051},6,[972,1053,1054],{"class":986},"}\n",[918,1056,1057,1058,1061,1062,1065,1066,1068,1069,1071,1072,1074,1075,1077],{},"的这两个表达式都是有身份的，也就是泛左值表达式。因为，",[969,1059,1060],{},"x"," 这个表达式和 ",[969,1063,1064],{},"y"," 这个表达式指代的并不是同一实体：一个指代变量 ",[969,1067,1060],{},"，另一个指代变量 ",[969,1070,1064],{},"。尽管它们类型相同，甚至在运行时具有相同的值，但由于身份不同，我不可能认为对 ",[969,1073,1060],{}," 表达式操作和对 ",[969,1076,1064],{}," 表达式操作是等价行为。反之，下面这段代码",[962,1079,1081],{"className":964,"code":1080,"language":966,"meta":967,"style":967},"int main() {\n    42; \u002F\u002F 表达式 1\n    40 + 2; \u002F\u002F 表达式 2\n}\n",[969,1082,1083,1093,1102,1117],{"__ignoreMap":967},[972,1084,1085,1087,1089,1091],{"class":974,"line":975},[972,1086,979],{"class":978},[972,1088,983],{"class":982},[972,1090,987],{"class":986},[972,1092,990],{"class":986},[972,1094,1095,1098,1100],{"class":974,"line":993},[972,1096,1097],{"class":1006},"    42",[972,1099,1033],{"class":986},[972,1101,1037],{"class":1036},[972,1103,1104,1107,1110,1113,1115],{"class":974,"line":1013},[972,1105,1106],{"class":1006},"    40",[972,1108,1109],{"class":986}," +",[972,1111,1112],{"class":1006}," 2",[972,1114,1033],{"class":986},[972,1116,1048],{"class":1036},[972,1118,1119],{"class":974,"line":1027},[972,1120,1054],{"class":986},[918,1122,1123,1124,1126,1127,1130,1131,934],{},"这里的两个表达式都不具有身份，因此它们都是纯右值表达式。为什么说它们没有身份？因为 ",[969,1125,1007],{}," 和 ",[969,1128,1129],{},"40 + 2"," 的值相同，它们用来初始化变量，或者作为操作数的效果都是相同的。总结下来，",[925,1132,1133],{},"两个值相同的纯右值表达式无法区分彼此，但两个值相同的泛左值表达式可以明确地通过其所指代的实体来区分",[918,1135,1136],{},"我们换一个角度讨论这个问题。从泛左值和纯右值的作用来看：",[1138,1139,1140,1144],"ul",{},[1141,1142,1143],"li",{},"泛左值表达式总是指代一个“实体”，可能是对象（变量）或函数等等；",[1141,1145,1146],{},"纯右值表达式就是一个“裸”的表达式，它本身没有任何意义。只有当纯右值用作初始化器，或者作为运算符的操作数时，它才发挥作用。",[1148,1149,1150],"blockquote",{},[918,1151,1152,1153,1160],{},"这个定义是 C++17 “通过简化值类别以实现可靠的复制消除”提案（",[1154,1155,1159],"a",{"href":1156,"rel":1157},"https:\u002F\u002Fwg21.link\u002Fp0135",[1158],"nofollow","P0135","）提出的，接近现行 C++ 标准中的描述。",[918,1162,1163],{},"由于泛左值表达式指代实体，而每个实体都具有身份（以表明它们是否是相同或不同实体）。而纯右值就像没有求值的数学公式一样，只有在被求值（也就是初始化别人\u002F用作操作数）的那一刻才有用。对于它们来说是否是相同身份不重要，因此没有必要具有身份。",[918,1165,1166],{},"::: tip\n[TODO] 例子\n:::",[918,1168,1169,1170,1173],{},"泛左值、纯右值这一对概念和之前提到的左值、右值概念非常接近。大部分泛左值就是左值，而纯右值表达式必然是右值。两者之间的差异在于",[925,1171,1172],{},"亡值","（xvalue）：亡值是泛左值，但它是右值。",[936,1175,1172],{"id":1172},[918,1177,1178],{},"亡值是一个十分诡异的概念。先直接看下面的代码：",[962,1180,1182],{"className":964,"code":1181,"language":966,"meta":967,"style":967},"struct Coord {\n    int x, y;\n};\n\nint main() {\n    Coord{4, 4}.x; \u002F\u002F 表达式 1\n    Coord{4, 4}.y; \u002F\u002F 表达式 2\n}\n",[969,1183,1184,1195,1210,1214,1220,1230,1255,1277],{"__ignoreMap":967},[972,1185,1186,1189,1193],{"class":974,"line":975},[972,1187,1188],{"class":978},"struct",[972,1190,1192],{"class":1191},"sBMFI"," Coord",[972,1194,990],{"class":986},[972,1196,1197,1199,1202,1205,1207],{"class":974,"line":993},[972,1198,996],{"class":978},[972,1200,1000],{"class":1201},"swJcz",[972,1203,1204],{"class":986},",",[972,1206,1018],{"class":1201},[972,1208,1209],{"class":986},";\n",[972,1211,1212],{"class":974,"line":1013},[972,1213,1010],{"class":986},[972,1215,1216],{"class":974,"line":1027},[972,1217,1219],{"emptyLinePlaceholder":1218},true,"\n",[972,1221,1222,1224,1226,1228],{"class":974,"line":1040},[972,1223,979],{"class":978},[972,1225,983],{"class":982},[972,1227,987],{"class":986},[972,1229,990],{"class":986},[972,1231,1232,1235,1237,1240,1242,1245,1248,1251,1253],{"class":974,"line":1051},[972,1233,1234],{"class":999},"    Coord",[972,1236,1003],{"class":986},[972,1238,1239],{"class":1006},"4",[972,1241,1204],{"class":986},[972,1243,1244],{"class":1006}," 4",[972,1246,1247],{"class":986},"}",[972,1249,1250],{"class":999},".x",[972,1252,1033],{"class":986},[972,1254,1037],{"class":1036},[972,1256,1258,1260,1262,1264,1266,1268,1270,1273,1275],{"class":974,"line":1257},7,[972,1259,1234],{"class":999},[972,1261,1003],{"class":986},[972,1263,1239],{"class":1006},[972,1265,1204],{"class":986},[972,1267,1244],{"class":1006},[972,1269,1247],{"class":986},[972,1271,1272],{"class":999},".y",[972,1274,1033],{"class":986},[972,1276,1048],{"class":1036},[972,1278,1280],{"class":974,"line":1279},8,[972,1281,1054],{"class":986},[918,1283,1284,1285,1288,1289,1291,1292,1294,1295,1299,1300,1303,1304,1307,1308,1303,1311,1314],{},"这里的两个表达式就是亡值了。亡值是泛左值的一部分，也就是说它们是有身份的。比如，表达式 1 所代表的实体是临时变量 ",[969,1286,1287],{},"Coord{4, 4}"," 的 ",[969,1290,1060],{}," 成员，而表达式 2 则是同样的一个变量的 ",[969,1293,1064],{}," 成员。由于它们有关联的实体，所以在定义上它们属于泛左值。",[1296,1297,1298],"em",{},"假如","我们可以对亡值赋值，则 ",[969,1301,1302],{},"Coord{4, 4}.x += 1"," 会让临时变量变成 ",[969,1305,1306],{},"{5, 4}","，而 ",[969,1309,1310],{},"Coord{4, 4}.y += 1",[969,1312,1313],{},"{4, 5}","。因此尽管这两个表达式的值相同，但某种意义上它们是可以区分的。",[1148,1316,1317],{},[918,1318,1319],{},"但亡值作为右值又不能出现在赋值运算符左侧，也不能取地址。也正因为亡值和纯右值都具有这样的性质，因此合称它们为右值。",[918,1321,1322],{},"此外，亡值是纯右值能够被使用的唯一途径。因为纯右值本身没有其所代表的实体对象，但亡值拥有。比如：",[962,1324,1326],{"className":964,"code":1325,"language":966,"meta":967,"style":967},"struct S {\n    int x;\n};\n\nint main() {\n    S{}; \u002F\u002F 纯右值\n    S{}.x; \u002F\u002F ...见下文\n}\n",[969,1327,1328,1337,1345,1349,1353,1363,1374,1388],{"__ignoreMap":967},[972,1329,1330,1332,1335],{"class":974,"line":975},[972,1331,1188],{"class":978},[972,1333,1334],{"class":1191}," S",[972,1336,990],{"class":986},[972,1338,1339,1341,1343],{"class":974,"line":993},[972,1340,996],{"class":978},[972,1342,1000],{"class":1201},[972,1344,1209],{"class":986},[972,1346,1347],{"class":974,"line":1013},[972,1348,1010],{"class":986},[972,1350,1351],{"class":974,"line":1027},[972,1352,1219],{"emptyLinePlaceholder":1218},[972,1354,1355,1357,1359,1361],{"class":974,"line":1040},[972,1356,979],{"class":978},[972,1358,983],{"class":982},[972,1360,987],{"class":986},[972,1362,990],{"class":986},[972,1364,1365,1368,1371],{"class":974,"line":1051},[972,1366,1367],{"class":999},"    S",[972,1369,1370],{"class":986},"{};",[972,1372,1373],{"class":1036}," \u002F\u002F 纯右值\n",[972,1375,1376,1378,1381,1383,1385],{"class":974,"line":1257},[972,1377,1367],{"class":999},[972,1379,1380],{"class":986},"{}",[972,1382,1250],{"class":999},[972,1384,1033],{"class":986},[972,1386,1387],{"class":1036}," \u002F\u002F ...见下文\n",[972,1389,1390],{"class":974,"line":1279},[972,1391,1054],{"class":986},[918,1393,1394,1395,1398,1399,1401,1402,1405,1406,1408,1409,1412,1413,1415,1416,1418,1419,1421,1422,1424],{},"这个例子中，",[969,1396,1397],{},"S{}"," 是纯右值：它就是一个表达式，两个 ",[969,1400,1397],{}," 无法区分。此外，仅仅这个表达式不会让世界上诞生一个 ",[969,1403,1404],{},"S"," 类型对象，",[969,1407,1397],{}," 就静静地摆在那里，直到一个瞬间——“临时量实质化”（Temporary materialization）发生。临时量实质化的全称应该叫“右值到亡值转换”，比如第二个表达式 ",[969,1410,1411],{},"S{}.x"," 中试图使用纯右值 ",[969,1414,1397],{}," 的成员，但纯右值仅仅作为表达式没有与之关联的对象，所以必须将这个关联的对象“实质化”出来。当这个实质化发生后，",[969,1417,1397],{}," 就成为了亡值；一旦成为了亡值，就可以从它所指代的实体（这里就是实质化出了 ",[969,1420,1404],{}," 类型的临时对象）中访问成员 ",[969,1423,1060],{}," 了。",[918,1426,1427,1428,1431,1432,1434,1435,1437,1438,1440],{},"临时量实质化发生在几乎所有可能使用纯右值的地方。比如表达式 ",[969,1429,1430],{},"a = 42"," 中的 ",[969,1433,1007],{}," 虽然是纯右值，但它在实质化之前仅仅停留在 ",[969,1436,1007],{}," 这两个字符的形式化意义上，只有实质化后，计算机才会构造出一个值为 42 的 ",[969,1439,979],{}," 类型变量，随后再用这个变量去做赋值。",[918,1442,1443],{},[1444,1445],"img",{"alt":33,"src":1446},"https:\u002F\u002Fdocs.microsoft.com\u002Fen-us\u002Fwindows\u002Fuwp\u002Fcpp-and-winrt-apis\u002Fimages\u002Fvalue-categories.png",[918,1448,1449],{},"亡值和左值又有什么区别呢？本质上来说，它们没有区别。之后马上就会讲到，你甚至可以手动指定一个泛左值到底作为左值来使用还是亡值来使用。",[936,1451,1452],{"id":1452},"复制消除",[918,1454,1455],{},"临时量实质化的设计可以避免冗余的复制操作。",[962,1457,1459],{"className":964,"code":1458,"language":966,"meta":967,"style":967},"struct S {\n    S() = default;\n    S(const S&) = delete; \u002F\u002F 不允许复制\n};\nint main() {\n    S a(S{});\n}\n",[969,1460,1461,1469,1483,1511,1515,1525,1539],{"__ignoreMap":967},[972,1462,1463,1465,1467],{"class":974,"line":975},[972,1464,1188],{"class":978},[972,1466,1334],{"class":1191},[972,1468,990],{"class":986},[972,1470,1471,1473,1475,1478,1481],{"class":974,"line":993},[972,1472,1367],{"class":982},[972,1474,987],{"class":986},[972,1476,1477],{"class":986}," =",[972,1479,1480],{"class":1006}," default",[972,1482,1209],{"class":986},[972,1484,1485,1487,1490,1493,1495,1498,1501,1503,1506,1508],{"class":974,"line":1013},[972,1486,1367],{"class":982},[972,1488,1489],{"class":986},"(",[972,1491,1492],{"class":978},"const",[972,1494,1334],{"class":1191},[972,1496,1497],{"class":978},"&",[972,1499,1500],{"class":986},")",[972,1502,1477],{"class":986},[972,1504,1505],{"class":1006}," delete",[972,1507,1033],{"class":986},[972,1509,1510],{"class":1036}," \u002F\u002F 不允许复制\n",[972,1512,1513],{"class":974,"line":1027},[972,1514,1010],{"class":986},[972,1516,1517,1519,1521,1523],{"class":974,"line":1040},[972,1518,979],{"class":978},[972,1520,983],{"class":982},[972,1522,987],{"class":986},[972,1524,990],{"class":986},[972,1526,1527,1530,1532,1534,1536],{"class":974,"line":1051},[972,1528,1529],{"class":999},"    S ",[972,1531,1154],{"class":982},[972,1533,1489],{"class":986},[972,1535,1397],{"class":999},[972,1537,1538],{"class":986},");\n",[972,1540,1541],{"class":974,"line":1257},[972,1542,1054],{"class":986},[918,1544,1545,1546,1548,1549,1551,1552,1554,1555,1557,1558,1560,1561,1563,1564,1567,1568,1570,1571,1573,1574,1576,1577,1579,1580,934],{},"如果考虑字面意思的话，这段代码首先通过 ",[969,1547,1397],{}," 构造一个 ",[969,1550,1404],{}," 类型的临时对象，然后再从这个对象复制构造 ",[969,1553,1154],{},"。但这里 S 的复制构造函数被删除了，",[969,1556,1154],{}," 却仍然可以从 ",[969,1559,1397],{}," 初始化。原因就是， ",[969,1562,1397],{}," 纯右值用来初始化变量时",[925,1565,1566],{},"不发生","临时量实质化，所谓的“",[969,1569,1404],{}," 类型临时对象”并不会存在。当临时量实质化被跳过后，",[969,1572,1397],{}," 就直接“原地”构造 ",[969,1575,1154],{},"，即用 ",[969,1578,1380],{}," 初始化 ",[969,1581,1154],{},[918,1583,1584],{},"下面的例子也很常见：",[962,1586,1588],{"className":964,"code":1587,"language":966,"meta":967,"style":967},"struct S {\n    S() = default;\n    S(const S&) = delete; \u002F\u002F 不允许复制\n    S& operator=(const S&) = default;\n};\nS getS() {\n    return S{};\n}\nint main() {\n    S a;\n    a = getS();\n}\n",[969,1589,1590,1598,1610,1632,1660,1664,1675,1686,1690,1701,1709,1722],{"__ignoreMap":967},[972,1591,1592,1594,1596],{"class":974,"line":975},[972,1593,1188],{"class":978},[972,1595,1334],{"class":1191},[972,1597,990],{"class":986},[972,1599,1600,1602,1604,1606,1608],{"class":974,"line":993},[972,1601,1367],{"class":982},[972,1603,987],{"class":986},[972,1605,1477],{"class":986},[972,1607,1480],{"class":1006},[972,1609,1209],{"class":986},[972,1611,1612,1614,1616,1618,1620,1622,1624,1626,1628,1630],{"class":974,"line":1013},[972,1613,1367],{"class":982},[972,1615,1489],{"class":986},[972,1617,1492],{"class":978},[972,1619,1334],{"class":1191},[972,1621,1497],{"class":978},[972,1623,1500],{"class":986},[972,1625,1477],{"class":986},[972,1627,1505],{"class":1006},[972,1629,1033],{"class":986},[972,1631,1510],{"class":1036},[972,1633,1634,1636,1638,1641,1644,1646,1648,1650,1652,1654,1656,1658],{"class":974,"line":1027},[972,1635,1367],{"class":1191},[972,1637,1497],{"class":978},[972,1639,1640],{"class":1006}," operator",[972,1642,1643],{"class":1191},"=",[972,1645,1489],{"class":986},[972,1647,1492],{"class":978},[972,1649,1334],{"class":1191},[972,1651,1497],{"class":978},[972,1653,1500],{"class":986},[972,1655,1477],{"class":986},[972,1657,1480],{"class":1006},[972,1659,1209],{"class":986},[972,1661,1662],{"class":974,"line":1040},[972,1663,1010],{"class":986},[972,1665,1666,1668,1671,1673],{"class":974,"line":1051},[972,1667,1404],{"class":1191},[972,1669,1670],{"class":982}," getS",[972,1672,987],{"class":986},[972,1674,990],{"class":986},[972,1676,1677,1681,1683],{"class":974,"line":1257},[972,1678,1680],{"class":1679},"s7zQu","    return",[972,1682,1334],{"class":999},[972,1684,1685],{"class":986},"{};\n",[972,1687,1688],{"class":974,"line":1279},[972,1689,1054],{"class":986},[972,1691,1693,1695,1697,1699],{"class":974,"line":1692},9,[972,1694,979],{"class":978},[972,1696,983],{"class":982},[972,1698,987],{"class":986},[972,1700,990],{"class":986},[972,1702,1704,1707],{"class":974,"line":1703},10,[972,1705,1706],{"class":999},"    S a",[972,1708,1209],{"class":986},[972,1710,1712,1715,1717,1719],{"class":974,"line":1711},11,[972,1713,1714],{"class":999},"    a ",[972,1716,1643],{"class":986},[972,1718,1670],{"class":982},[972,1720,1721],{"class":986},"();\n",[972,1723,1725],{"class":974,"line":1724},12,[972,1726,1054],{"class":986},[918,1728,1729,1730,1733,1734,1737,1738,1740,1741,1743],{},"当函数的 return 语句中是纯右值时，函数",[925,1731,1732],{},"不进行","临时量实质化而返回纯右值本身。也就是说，",[969,1735,1736],{},"getS()"," 的值是 ",[969,1739,1397],{}," 这个“裸”表达式，而非一个实打实存在的 ",[969,1742,1404],{}," 类型对象。比较正常的返回过程：",[962,1745,1747],{"className":964,"code":1746,"language":966,"meta":967,"style":967},"struct S {};\nS getS() {\n    S s;\n    return s;\n}\nint main() {\n    S a;\n    a = getS();\n}\n",[969,1748,1749,1758,1768,1775,1784,1788,1798,1804,1814],{"__ignoreMap":967},[972,1750,1751,1753,1755],{"class":974,"line":975},[972,1752,1188],{"class":978},[972,1754,1334],{"class":1191},[972,1756,1757],{"class":986}," {};\n",[972,1759,1760,1762,1764,1766],{"class":974,"line":993},[972,1761,1404],{"class":1191},[972,1763,1670],{"class":982},[972,1765,987],{"class":986},[972,1767,990],{"class":986},[972,1769,1770,1773],{"class":974,"line":1013},[972,1771,1772],{"class":999},"    S s",[972,1774,1209],{"class":986},[972,1776,1777,1779,1782],{"class":974,"line":1027},[972,1778,1680],{"class":1679},[972,1780,1781],{"class":999}," s",[972,1783,1209],{"class":986},[972,1785,1786],{"class":974,"line":1040},[972,1787,1054],{"class":986},[972,1789,1790,1792,1794,1796],{"class":974,"line":1051},[972,1791,979],{"class":978},[972,1793,983],{"class":982},[972,1795,987],{"class":986},[972,1797,990],{"class":986},[972,1799,1800,1802],{"class":974,"line":1257},[972,1801,1706],{"class":999},[972,1803,1209],{"class":986},[972,1805,1806,1808,1810,1812],{"class":974,"line":1279},[972,1807,1714],{"class":999},[972,1809,1643],{"class":986},[972,1811,1670],{"class":982},[972,1813,1721],{"class":986},[972,1815,1816],{"class":974,"line":1692},[972,1817,1054],{"class":986},[918,1819,1820,1821,1823,1824,1826,1827,1830,1831,1833,1834,1836,1837,1839,1840,1842],{},"这里 return 语句中已经是一个左值了，所以 ",[969,1822,1736],{}," 返回的是一个已经存在的 ",[969,1825,1404],{}," 类型对象 ",[969,1828,1829],{},"s","。当返回发生时，",[969,1832,1829],{}," 复制初始化了 ",[969,1835,1736],{}," 的值，也就是一次对象的复制。但上一个例子返回 ",[969,1838,1397],{}," 这个“裸”表达式的时候复制的是“‘裸’表达式的形式”，形象地说就是把 ",[969,1841,1397],{}," 从 return 语句“搬”到了调用处，并没有实际的复制发生。因此那个例子中复制构造函数可以被删除。",[1148,1844,1845],{},[918,1846,1847,1848,1850,1851,1853,1854,934],{},"这本质上也是用纯右值初始化变量，只不过这里初始化的是 ",[969,1849,1736],{}," 的值。在初始化时临时量实质化被跳过，因此 ",[969,1852,1397],{}," 直接“原地”替换了 ",[969,1855,1736],{},[1857,1858,1859],"style",{},"html pre.shiki code .spNyl, html code.shiki .spNyl{--shiki-light:#9C3EDA;--shiki-default:#C792EA;--shiki-dark:#C792EA}html pre.shiki code .s2Zo4, html code.shiki .s2Zo4{--shiki-light:#6182B8;--shiki-default:#82AAFF;--shiki-dark:#82AAFF}html pre.shiki code .sMK4o, html code.shiki .sMK4o{--shiki-light:#39ADB5;--shiki-default:#89DDFF;--shiki-dark:#89DDFF}html pre.shiki code .sTEyZ, html code.shiki .sTEyZ{--shiki-light:#90A4AE;--shiki-default:#EEFFFF;--shiki-dark:#BABED8}html pre.shiki code .sbssI, html code.shiki .sbssI{--shiki-light:#F76D47;--shiki-default:#F78C6C;--shiki-dark:#F78C6C}html pre.shiki code .sHwdD, html code.shiki .sHwdD{--shiki-light:#90A4AE;--shiki-light-font-style:italic;--shiki-default:#546E7A;--shiki-default-font-style:italic;--shiki-dark:#676E95;--shiki-dark-font-style:italic}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sBMFI, html code.shiki .sBMFI{--shiki-light:#E2931D;--shiki-default:#FFCB6B;--shiki-dark:#FFCB6B}html pre.shiki code .swJcz, html code.shiki .swJcz{--shiki-light:#E53935;--shiki-default:#F07178;--shiki-dark:#F07178}html pre.shiki code .s7zQu, html code.shiki .s7zQu{--shiki-light:#39ADB5;--shiki-light-font-style:italic;--shiki-default:#89DDFF;--shiki-default-font-style:italic;--shiki-dark:#89DDFF;--shiki-dark-font-style:italic}",{"title":967,"searchDepth":975,"depth":993,"links":1861},[1862,1863,1864],{"id":938,"depth":993,"text":939},{"id":1172,"depth":993,"text":1172},{"id":1452,"depth":993,"text":1452},"md",null,{},{"icon":746},{"title":741,"description":741},"m3r2xaPP85jWI9GqiF3ys_hwSfrqGmS3LoXxVv1DBYc",[1872,1874],{"title":737,"path":738,"stem":739,"description":1873,"icon":687,"children":-1},"伪随机数（Pseudo-random number）是指用确定性算法生成的一系列数。",{"title":748,"path":749,"stem":750,"description":1875,"icon":746,"children":-1},"有的时候，我们知道某个变量已经“快死了”，比如",1784618137980]