[{"data":1,"prerenderedAt":1037},["ShallowReactive",2],{"page-\u002Fcpp\u002Freferences-et-pointeurs":3,"pieces-cpp":994,"autour-\u002Fcpp\u002Freferences-et-pointeurs":1019,"prerequis-\u002Fcpp\u002Freferences-et-pointeurs":1024,"plan-cpp":1026},{"id":4,"title":5,"body":6,"description":965,"extension":966,"ligne":50,"meta":967,"motsCles":968,"navigation":114,"niveau":971,"path":972,"prerequis":973,"ressources":975,"seo":984,"sources":985,"stem":992,"__hash__":993},"docs\u002Fcpp\u002F04.references-et-pointeurs.md","Références et pointeurs",{"type":7,"value":8,"toc":953},"minimark",[9,14,32,36,45,190,196,200,211,304,315,318,322,329,422,425,483,499,503,520,623,637,639,644,707,713,717,720,774,777,781,792,866,875,879,905,909,949],[10,11,13],"h2",{"id":12},"ce-que-tu-vas-apprendre","Ce que tu vas apprendre",[15,16,17,21,29],"ul",{},[18,19,20],"li",{},"Choisir entre passage par valeur, par référence et par référence constante.",[18,22,23,24,28],{},"Lire et écrire un pointeur : adresse, déréférencement, ",[25,26,27],"code",{},"nullptr",".",[18,30,31],{},"Savoir quand préférer une référence à un pointeur.",[10,33,35],{"id":34},"le-problème-de-la-copie","Le problème de la copie",[37,38,39,40,44],"p",{},"Par défaut, une fonction reçoit une ",[41,42,43],"strong",{},"copie"," de ses arguments. Modifier la copie ne change pas l'original :",[46,47,52],"pre",{"className":48,"code":49,"language":50,"meta":51,"style":51},"language-cpp shiki shiki-themes github-light-default github-dark-default github-dark-default","void doubler(int n) {\n    n = n * 2;\n}\n\nint main() {\n    int portions{4};\n    doubler(portions);\n    std::cout \u003C\u003C portions \u003C\u003C \"\\n\";   \u002F\u002F affiche 4\n}\n","cpp","",[25,53,54,81,103,109,116,127,142,151,185],{"__ignoreMap":51},[55,56,59,63,67,71,74,78],"span",{"class":57,"line":58},"line",1,[55,60,62],{"class":61},"sOnC1","void",[55,64,66],{"class":65},"syCW7"," doubler",[55,68,70],{"class":69},"scfrF","(",[55,72,73],{"class":61},"int",[55,75,77],{"class":76},"sIXEE"," n",[55,79,80],{"class":69},") {\n",[55,82,84,87,90,93,96,100],{"class":57,"line":83},2,[55,85,86],{"class":69},"    n ",[55,88,89],{"class":61},"=",[55,91,92],{"class":69}," n ",[55,94,95],{"class":61},"*",[55,97,99],{"class":98},"s5iOY"," 2",[55,101,102],{"class":69},";\n",[55,104,106],{"class":57,"line":105},3,[55,107,108],{"class":69},"}\n",[55,110,112],{"class":57,"line":111},4,[55,113,115],{"emptyLinePlaceholder":114},true,"\n",[55,117,119,121,124],{"class":57,"line":118},5,[55,120,73],{"class":61},[55,122,123],{"class":65}," main",[55,125,126],{"class":69},"() {\n",[55,128,130,133,136,139],{"class":57,"line":129},6,[55,131,132],{"class":61},"    int",[55,134,135],{"class":69}," portions{",[55,137,138],{"class":98},"4",[55,140,141],{"class":69},"};\n",[55,143,145,148],{"class":57,"line":144},7,[55,146,147],{"class":65},"    doubler",[55,149,150],{"class":69},"(portions);\n",[55,152,154,157,160,163,166,168,172,175,178,181],{"class":57,"line":153},8,[55,155,156],{"class":76},"    std",[55,158,159],{"class":69},"::cout ",[55,161,162],{"class":61},"\u003C\u003C",[55,164,165],{"class":69}," portions ",[55,167,162],{"class":61},[55,169,171],{"class":170},"shWOn"," \"",[55,173,174],{"class":61},"\\n",[55,176,177],{"class":170},"\"",[55,179,180],{"class":69},";",[55,182,184],{"class":183},"sd6ml","   \u002F\u002F affiche 4\n",[55,186,188],{"class":57,"line":187},9,[55,189,108],{"class":69},[37,191,192,193,195],{},"Pour un ",[25,194,73],{},", la copie ne coûte rien. Pour un vecteur de milliers d'éléments, elle coûte cher.",[10,197,199],{"id":198},"les-références","Les références",[37,201,202,203,206,207,210],{},"Une ",[41,204,205],{},"référence"," est un second nom pour une variable existante. Elle se déclare avec ",[25,208,209],{},"&"," après le type :",[46,212,214],{"className":48,"code":213,"language":50,"meta":51,"style":51},"void doubler(int& n) {\n    n = n * 2;\n}\n\nint main() {\n    int portions{4};\n    doubler(portions);\n    std::cout \u003C\u003C portions \u003C\u003C \"\\n\";   \u002F\u002F affiche 8\n}\n",[25,215,216,231,245,249,253,261,271,277,300],{"__ignoreMap":51},[55,217,218,220,222,224,227,229],{"class":57,"line":58},[55,219,62],{"class":61},[55,221,66],{"class":65},[55,223,70],{"class":69},[55,225,226],{"class":61},"int&",[55,228,77],{"class":76},[55,230,80],{"class":69},[55,232,233,235,237,239,241,243],{"class":57,"line":83},[55,234,86],{"class":69},[55,236,89],{"class":61},[55,238,92],{"class":69},[55,240,95],{"class":61},[55,242,99],{"class":98},[55,244,102],{"class":69},[55,246,247],{"class":57,"line":105},[55,248,108],{"class":69},[55,250,251],{"class":57,"line":111},[55,252,115],{"emptyLinePlaceholder":114},[55,254,255,257,259],{"class":57,"line":118},[55,256,73],{"class":61},[55,258,123],{"class":65},[55,260,126],{"class":69},[55,262,263,265,267,269],{"class":57,"line":129},[55,264,132],{"class":61},[55,266,135],{"class":69},[55,268,138],{"class":98},[55,270,141],{"class":69},[55,272,273,275],{"class":57,"line":144},[55,274,147],{"class":65},[55,276,150],{"class":69},[55,278,279,281,283,285,287,289,291,293,295,297],{"class":57,"line":153},[55,280,156],{"class":76},[55,282,159],{"class":69},[55,284,162],{"class":61},[55,286,165],{"class":69},[55,288,162],{"class":61},[55,290,171],{"class":170},[55,292,174],{"class":61},[55,294,177],{"class":170},[55,296,180],{"class":69},[55,298,299],{"class":183},"   \u002F\u002F affiche 8\n",[55,301,302],{"class":57,"line":187},[55,303,108],{"class":69},[37,305,306,307,310,311,314],{},"Ici ",[25,308,309],{},"n"," désigne directement ",[25,312,313],{},"portions",". Aucune copie n'est faite, et la fonction peut modifier l'original.",[37,316,317],{},"Une référence doit être initialisée dès sa création et ne peut jamais être réaffectée à une autre variable.",[10,319,321],{"id":320},"la-référence-constante","La référence constante",[37,323,324,325,328],{},"Pour éviter la copie sans autoriser la modification, ajoute ",[25,326,327],{},"const"," :",[46,330,332],{"className":48,"code":331,"language":50,"meta":51,"style":51},"void afficher(const std::vector\u003Cstd::string>& ingredients) {\n    for (const auto& i : ingredients) {\n        std::cout \u003C\u003C i \u003C\u003C \"\\n\";\n    }\n}\n",[25,333,334,375,391,413,418],{"__ignoreMap":51},[55,335,336,338,341,343,345,348,351,354,357,360,362,365,368,370,373],{"class":57,"line":58},[55,337,62],{"class":61},[55,339,340],{"class":65}," afficher",[55,342,70],{"class":69},[55,344,327],{"class":61},[55,346,347],{"class":76}," std",[55,349,350],{"class":69},"::",[55,352,353],{"class":76},"vector",[55,355,356],{"class":69},"\u003C",[55,358,359],{"class":76},"std",[55,361,350],{"class":69},[55,363,364],{"class":76},"string",[55,366,367],{"class":69},">",[55,369,209],{"class":61},[55,371,372],{"class":76}," ingredients",[55,374,80],{"class":69},[55,376,377,380,383,385,388],{"class":57,"line":83},[55,378,379],{"class":61},"    for",[55,381,382],{"class":69}," (",[55,384,327],{"class":61},[55,386,387],{"class":61}," auto&",[55,389,390],{"class":69}," i : ingredients) {\n",[55,392,393,396,398,400,403,405,407,409,411],{"class":57,"line":105},[55,394,395],{"class":76},"        std",[55,397,159],{"class":69},[55,399,162],{"class":61},[55,401,402],{"class":69}," i ",[55,404,162],{"class":61},[55,406,171],{"class":170},[55,408,174],{"class":61},[55,410,177],{"class":170},[55,412,102],{"class":69},[55,414,415],{"class":57,"line":111},[55,416,417],{"class":69},"    }\n",[55,419,420],{"class":57,"line":118},[55,421,108],{"class":69},[37,423,424],{},"C'est la forme la plus courante pour passer des chaînes et des conteneurs en lecture seule.",[426,427,428,444],"table",{},[429,430,431],"thead",{},[432,433,434,438,441],"tr",{},[435,436,437],"th",{},"Paramètre",[435,439,440],{},"Copie ?",[435,442,443],{},"Modifie l'original ?",[445,446,447,461,472],"tbody",{},[432,448,449,455,458],{},[450,451,452],"td",{},[25,453,454],{},"int n",[450,456,457],{},"Oui",[450,459,460],{},"Non",[432,462,463,468,470],{},[450,464,465],{},[25,466,467],{},"int& n",[450,469,460],{},[450,471,457],{},[432,473,474,479,481],{},[450,475,476],{},[25,477,478],{},"const int& n",[450,480,460],{},[450,482,460],{},[37,484,485,486,488,489,488,492,488,495,498],{},"Règle pratique : petits types (",[25,487,73],{},", ",[25,490,491],{},"double",[25,493,494],{},"char",[25,496,497],{},"bool",") par valeur, gros objets par référence constante, et par référence simple seulement pour modifier.",[10,500,502],{"id":501},"adresses-et-pointeurs","Adresses et pointeurs",[37,504,505,506,509,510,513,514,516,517,519],{},"Chaque variable vit à une ",[41,507,508],{},"adresse"," en mémoire. Un ",[41,511,512],{},"pointeur"," est une variable qui stocke une adresse. Le ",[25,515,95],{}," dans la déclaration indique un pointeur, l'opérateur ",[25,518,209],{}," récupère l'adresse :",[46,521,523],{"className":48,"code":522,"language":50,"meta":51,"style":51},"int duree{45};\nint* p = &duree;\n\nstd::cout \u003C\u003C p \u003C\u003C \"\\n\";    \u002F\u002F une adresse, par exemple 0x7ffd...\nstd::cout \u003C\u003C *p \u003C\u003C \"\\n\";   \u002F\u002F 45\n*p = 50;                   \u002F\u002F duree vaut maintenant 50\n",[25,524,525,537,553,557,580,607],{"__ignoreMap":51},[55,526,527,529,532,535],{"class":57,"line":58},[55,528,73],{"class":61},[55,530,531],{"class":69}," duree{",[55,533,534],{"class":98},"45",[55,536,141],{"class":69},[55,538,539,542,545,547,550],{"class":57,"line":83},[55,540,541],{"class":61},"int*",[55,543,544],{"class":69}," p ",[55,546,89],{"class":61},[55,548,549],{"class":61}," &",[55,551,552],{"class":69},"duree;\n",[55,554,555],{"class":57,"line":105},[55,556,115],{"emptyLinePlaceholder":114},[55,558,559,561,563,565,567,569,571,573,575,577],{"class":57,"line":111},[55,560,359],{"class":76},[55,562,159],{"class":69},[55,564,162],{"class":61},[55,566,544],{"class":69},[55,568,162],{"class":61},[55,570,171],{"class":170},[55,572,174],{"class":61},[55,574,177],{"class":170},[55,576,180],{"class":69},[55,578,579],{"class":183},"    \u002F\u002F une adresse, par exemple 0x7ffd...\n",[55,581,582,584,586,588,591,594,596,598,600,602,604],{"class":57,"line":118},[55,583,359],{"class":76},[55,585,159],{"class":69},[55,587,162],{"class":61},[55,589,590],{"class":61}," *",[55,592,593],{"class":69},"p ",[55,595,162],{"class":61},[55,597,171],{"class":170},[55,599,174],{"class":61},[55,601,177],{"class":170},[55,603,180],{"class":69},[55,605,606],{"class":183},"   \u002F\u002F 45\n",[55,608,609,611,613,615,618,620],{"class":57,"line":129},[55,610,95],{"class":61},[55,612,593],{"class":69},[55,614,89],{"class":61},[55,616,617],{"class":98}," 50",[55,619,180],{"class":69},[55,621,622],{"class":183},"                   \u002F\u002F duree vaut maintenant 50\n",[37,624,625,626,629,630,633,634,636],{},"Utiliser ",[25,627,628],{},"*p"," s'appelle le ",[41,631,632],{},"déréférencement"," : on accède à la valeur située à l'adresse. Attention, le symbole ",[25,635,95],{}," a donc deux sens selon l'endroit où il apparaît.",[10,638,27],{"id":27},[37,640,641,642,328],{},"Un pointeur peut ne pointer sur rien. On le déclare alors avec ",[25,643,27],{},[46,645,647],{"className":48,"code":646,"language":50,"meta":51,"style":51},"int* p = nullptr;\n\nif (p != nullptr) {\n    std::cout \u003C\u003C *p \u003C\u003C \"\\n\";\n}\n",[25,648,649,662,666,681,703],{"__ignoreMap":51},[55,650,651,653,655,657,660],{"class":57,"line":58},[55,652,541],{"class":61},[55,654,544],{"class":69},[55,656,89],{"class":61},[55,658,659],{"class":98}," nullptr",[55,661,102],{"class":69},[55,663,664],{"class":57,"line":83},[55,665,115],{"emptyLinePlaceholder":114},[55,667,668,671,674,677,679],{"class":57,"line":105},[55,669,670],{"class":61},"if",[55,672,673],{"class":69}," (p ",[55,675,676],{"class":61},"!=",[55,678,659],{"class":98},[55,680,80],{"class":69},[55,682,683,685,687,689,691,693,695,697,699,701],{"class":57,"line":111},[55,684,156],{"class":76},[55,686,159],{"class":69},[55,688,162],{"class":61},[55,690,590],{"class":61},[55,692,593],{"class":69},[55,694,162],{"class":61},[55,696,171],{"class":170},[55,698,174],{"class":61},[55,700,177],{"class":170},[55,702,102],{"class":69},[55,704,705],{"class":57,"line":118},[55,706,108],{"class":69},[708,709,710],"warning",{},[37,711,712],{},"Déréférencer un pointeur nul ou non initialisé est un comportement indéfini : le programme peut planter ou, pire, continuer avec des données fausses. Initialise toujours tes pointeurs, et vérifie-les avant usage.",[10,714,716],{"id":715},"pointeur-ou-référence","Pointeur ou référence ?",[37,718,719],{},"Les deux désignent un objet sans le copier. Leurs différences :",[426,721,722,734],{},[429,723,724],{},[432,725,726,728,731],{},[435,727],{},[435,729,730],{},"Référence",[435,732,733],{},"Pointeur",[445,735,736,749,758],{},[432,737,738,741,743],{},[450,739,740],{},"Peut être « vide »",[450,742,460],{},[450,744,745,746,748],{},"Oui (",[25,747,27],{},")",[432,750,751,754,756],{},[450,752,753],{},"Peut changer de cible",[450,755,460],{},[450,757,457],{},[432,759,760,763,766],{},[450,761,762],{},"Syntaxe d'accès",[450,764,765],{},"Comme une variable",[450,767,768,770,771],{},[25,769,628],{}," ou ",[25,772,773],{},"p->",[37,775,776],{},"Choisis la référence par défaut. Prends un pointeur seulement quand l'absence de valeur est possible ou que la cible doit changer.",[10,778,780],{"id":779},"pointeur-vers-un-objet","Pointeur vers un objet",[37,782,783,784,787,788,791],{},"Pour accéder à un membre d'un objet via un pointeur, on utilise la flèche ",[25,785,786],{},"->",", raccourci de ",[25,789,790],{},"(*p).",". Exemple avec une chaîne :",[46,793,795],{"className":48,"code":794,"language":50,"meta":51,"style":51},"std::string titre{\"Quiche lorraine\"};\nstd::string* p = &titre;\n\nstd::cout \u003C\u003C p->size() \u003C\u003C \"\\n\";   \u002F\u002F 15\n",[25,796,797,813,832,836],{"__ignoreMap":51},[55,798,799,801,803,805,808,811],{"class":57,"line":58},[55,800,359],{"class":76},[55,802,350],{"class":69},[55,804,364],{"class":76},[55,806,807],{"class":69}," titre{",[55,809,810],{"class":170},"\"Quiche lorraine\"",[55,812,141],{"class":69},[55,814,815,817,819,821,823,825,827,829],{"class":57,"line":83},[55,816,359],{"class":76},[55,818,350],{"class":69},[55,820,364],{"class":69},[55,822,95],{"class":61},[55,824,544],{"class":69},[55,826,89],{"class":61},[55,828,549],{"class":61},[55,830,831],{"class":69},"titre;\n",[55,833,834],{"class":57,"line":105},[55,835,115],{"emptyLinePlaceholder":114},[55,837,838,840,842,844,847,850,853,855,857,859,861,863],{"class":57,"line":111},[55,839,359],{"class":76},[55,841,159],{"class":69},[55,843,162],{"class":61},[55,845,846],{"class":69}," p->",[55,848,849],{"class":65},"size",[55,851,852],{"class":69},"() ",[55,854,162],{"class":61},[55,856,171],{"class":170},[55,858,174],{"class":61},[55,860,177],{"class":170},[55,862,180],{"class":69},[55,864,865],{"class":183},"   \u002F\u002F 15\n",[867,868,869],"note",{},[37,870,871,872,874],{},"Les pointeurs « bruts » comme ",[25,873,541],{}," ne gèrent pas la mémoire eux-mêmes. Pour posséder un objet alloué dynamiquement, on utilise des pointeurs intelligents, vus au cours 06.",[10,876,878],{"id":877},"pièges-classiques","Pièges classiques",[15,880,881,884,891],{},[18,882,883],{},"Retourner une référence vers une variable locale : elle est détruite à la fin de la fonction, la référence devient invalide.",[18,885,886,887,890],{},"Garder un pointeur vers un élément d'un ",[25,888,889],{},"std::vector"," puis ajouter des éléments : le vecteur peut déplacer ses données en mémoire.",[18,892,893,894,897,898,901,902,28],{},"Oublier que ",[25,895,896],{},"int* a, b;"," déclare un pointeur ",[25,899,900],{},"a"," et un entier ",[25,903,904],{},"b",[10,906,908],{"id":907},"à-retenir","À retenir",[15,910,911,918,924,934,940,943],{},[18,912,913,914,917],{},"Par défaut, un argument est copié ; une référence ",[25,915,916],{},"T&"," évite la copie et permet la modification.",[18,919,920,923],{},[25,921,922],{},"const T&"," passe un gros objet en lecture seule, sans copie.",[18,925,926,927,930,931,933],{},"Un pointeur contient une adresse : ",[25,928,929],{},"&x"," la donne, ",[25,932,628],{}," lit la valeur pointée.",[18,935,936,937,939],{},"Initialise un pointeur à ",[25,938,27],{}," et teste-le avant de le déréférencer.",[18,941,942],{},"Une référence ne peut pas être nulle ni changer de cible, c'est le choix par défaut.",[18,944,945,948],{},[25,946,947],{},"p->membre"," accède à un membre d'un objet pointé.",[950,951,952],"style",{},"html pre.shiki code .sOnC1, html code.shiki .sOnC1{--shiki-light:#CF222E;--shiki-default:#FF7B72;--shiki-dark:#FF7B72}html pre.shiki code .syCW7, html code.shiki .syCW7{--shiki-light:#8250DF;--shiki-default:#D2A8FF;--shiki-dark:#D2A8FF}html pre.shiki code .scfrF, html code.shiki .scfrF{--shiki-light:#1F2328;--shiki-default:#E6EDF3;--shiki-dark:#E6EDF3}html pre.shiki code .sIXEE, html code.shiki .sIXEE{--shiki-light:#953800;--shiki-default:#FFA657;--shiki-dark:#FFA657}html pre.shiki code .s5iOY, html code.shiki .s5iOY{--shiki-light:#0550AE;--shiki-default:#79C0FF;--shiki-dark:#79C0FF}html pre.shiki code .shWOn, html code.shiki .shWOn{--shiki-light:#0A3069;--shiki-default:#A5D6FF;--shiki-dark:#A5D6FF}html pre.shiki code .sd6ml, html code.shiki .sd6ml{--shiki-light:#6E7781;--shiki-default:#8B949E;--shiki-dark:#8B949E}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);}",{"title":51,"searchDepth":83,"depth":105,"links":954},[955,956,957,958,959,960,961,962,963,964],{"id":12,"depth":83,"text":13},{"id":34,"depth":83,"text":35},{"id":198,"depth":83,"text":199},{"id":320,"depth":83,"text":321},{"id":501,"depth":83,"text":502},{"id":27,"depth":83,"text":27},{"id":715,"depth":83,"text":716},{"id":779,"depth":83,"text":780},{"id":877,"depth":83,"text":878},{"id":907,"depth":83,"text":908},"Comprendre les adresses mémoire, passer des arguments sans copie avec les références et manipuler des pointeurs en sécurité.","md",{},[205,512,508,27,327,969,970,632],"passage par valeur","passage par référence","intermediaire","\u002Fcpp\u002Freferences-et-pointeurs",[974],"\u002Fcpp\u002Fstring-et-vector",[976,980],{"nom":977,"url":978,"type":979},"OpenClassrooms, Apprenez à programmer en C++","https:\u002F\u002Fopenclassrooms.com\u002Ffr\u002Fcourses\u002F1894236-programmez-avec-le-langage-c","cours",{"nom":981,"url":982,"type":983},"cppreference.com, référence C++ en français","https:\u002F\u002Ffr.cppreference.com\u002Fw\u002Fcpp","doc",{"title":5,"description":965},[986,989],{"nom":987,"url":988},"cppreference.com, références (en anglais)","https:\u002F\u002Fen.cppreference.com\u002Fw\u002Fcpp\u002Flanguage\u002Freference",{"nom":990,"url":991},"cppreference.com, pointeurs (version française partielle)","https:\u002F\u002Ffr.cppreference.com\u002Fw\u002Fcpp\u002Flanguage\u002Fpointer","cpp\u002F04.references-et-pointeurs","mqeGr3nV2c-y0z0chbpztpg9Ge68ICCbO1G_TrsZBuM",[995,999,1003,1006,1007,1011,1015],{"path":996,"title":997,"stem":998},"\u002Fcpp\u002Fpremier-programme","Premier programme","cpp\u002F01.premier-programme",{"path":1000,"title":1001,"stem":1002},"\u002Fcpp\u002Fconditions-boucles-fonctions","Conditions, boucles et fonctions","cpp\u002F02.conditions-boucles-fonctions",{"path":974,"title":1004,"stem":1005},"std::string et std::vector","cpp\u002F03.string-et-vector",{"path":972,"title":5,"stem":992},{"path":1008,"title":1009,"stem":1010},"\u002Fcpp\u002Fclasses-et-raii","Classes, constructeurs et RAII","cpp\u002F05.classes-et-raii",{"path":1012,"title":1013,"stem":1014},"\u002Fcpp\u002Fmemoire-et-bibliotheque","Mémoire, pointeurs intelligents et bibliothèque standard","cpp\u002F06.memoire-et-bibliotheque",{"path":1016,"title":1017,"stem":1018},"\u002Fcpp","C++","cpp\u002Findex",[1020,1022],{"title":1004,"path":974,"stem":1005,"description":1021,"children":-1},"Manipuler du texte avec std::string et des listes d'éléments avec std::vector, les deux outils de base de la bibliothèque standard.",{"title":1009,"path":1008,"stem":1010,"description":1023,"children":-1},"Définir ses propres types avec les classes, initialiser un objet avec un constructeur et libérer ses ressources automatiquement grâce au destructeur (RAII).",[1025],{"path":974,"title":1004,"ligne":50},[1027,1029,1030,1031,1032,1033,1035],{"path":996,"title":997,"niveau":1028,"stem":998},"debutant",{"path":1000,"title":1001,"niveau":1028,"stem":1002},{"path":974,"title":1004,"niveau":1028,"stem":1005},{"path":972,"title":5,"niveau":971,"stem":992},{"path":1008,"title":1009,"niveau":971,"stem":1010},{"path":1012,"title":1013,"niveau":1034,"stem":1014},"avance",{"path":1016,"title":1017,"niveau":1036,"stem":1018},"memo",1794583456486]