most vexing parse

most vexing parse (tsz. most vexing parses)

1. (informatika) A most vexing parse (szó szerint: „legbosszantóbb elemzés”) egy hírhedt szintaktikai „csapda” a C++ nyelvben. Olyan helyzetről van szó, amikor a fordító egy változókonstrukciót félreértelmez, és függvénydeklarációnak tekint valamit, amit a programozó objektumként szánt.

Ez a furcsa viselkedés a C++ nyelvtani szabályai miatt történik, és hibátlan szintaxis mellett is teljesen mást jelent, mint amit várnánk.

• Nem ad szintaktikai hibát.
• Nem csinálja azt, amit a programozó várna.
• A kód tökéletesen legális C++ szintaxis – csak nem az történik, amit hiszel.
• Gyakran nehéz észrevenni, és komoly logikai hibát okozhat.

class Widget {
public:
    Widget(int) {}
};

int main() {
    Widget w(Widget(5)); // ← Most vexing parse!
}

Szeretnénk létrehozni egy Widget nevű objektumot, amelyet egy másik Widget(5) példány alapján konstruálunk.

A fordító nem objektumot lát, hanem:

Egy függvénydeklarációt w nevű függvényről, amely egy Widget típusú paramétert fogad, és visszatérési típusa Widget.

Tehát a fenti kód NEM hoz létre objektumot. Ez a most vexing parse.

A C++ nyelv erősen ambivalens a deklarációkkal kapcsolatban. Egy Type name(params) forma lehet:

• objektumdefiníció (ha params konstruktorparaméter)
• vagy függvénydeklaráció (ha params paraméterlista)

A fordító a legszűkebb értelmezést választja: ha valami lehetséges függvényként, akkor annak fogja tekinteni.

std::vector<int> v(std::vector<int>(10)); // ⚠️ most vexing parse

A programozó azt szeretné:

Hozz létre egy std::vector<int> nevű v nevű változót, amely egy 10 elemű vektorból jön létre.

A fordító így látja:

Függvény v, amely egy std::vector<int> típusú paramétert vesz, és visszatér std::vector<int> típussal.

Nincs objektum, nincs konstrukció.

Widget w{Widget(5)};

Ez biztosan konstrukció, nem függvénydeklaráció. C++11-től kezdve ajánlott.

Widget temp(5);
Widget w(temp);

Külön lépésként elkerülhető a félreértelmezés.

auto w = Widget(5);

Itt egyértelmű, hogy w egy objektum lesz.

std::vector v{std::vector<int>(10)};

A C++ nyelv visszafelé kompatibilis a C-vel, ahol a deklarációs szintaxis hasonló (pl. int f(int);). A type name(args) forma deklarációnak is jelenthető, így a szintaxis kétértelmű, és a szabvány az elemzést a deklaráció felé tolja el, ha lehetséges.

Ezért nem szintaktikai hiba – ez a szabványos viselkedés.

• Sablonos típusok esetén (std::vector, std::map)
• Belső típusokkal történő példányosításkor
• Öröklés és CRTP minták esetén
• STL kódolásban, ha példányosítás történik más típusra

• Ha nem derül ki, hogy nem történt objektumkonstrukció
• Ha a kód később futás közben másképp viselkedik
• Ha a compiler nem ad warningot (pl. g++ -Wall alatt sem mindig)

A most vexing parse tipikusan az a „C++-csapda”, amibe még tapasztalt programozók is beleesnek. Az egyetlen biztos módszer ellene a tudatosság és modern C++-szintaxis használata (uniform initialization, auto, std::make_ típusú segédfüggvények).

• most vexing parse - Szótár.net (en-hu)
• most vexing parse - Sztaki (en-hu)
• most vexing parse - Merriam–Webster
• most vexing parse - Cambridge
• most vexing parse - WordNet
• most vexing parse - Яндекс (en-ru)
• most vexing parse - Google (en-hu)
• most vexing parse - Wikidata
• most vexing parse - Wikipédia (angol)