C++ రష్యా: ఇది ఎలా జరిగింది

నాటకం ప్రారంభంలో మీరు గోడపై C++ కోడ్ వేలాడుతున్నట్లు చెబితే, చివరికి అది మిమ్మల్ని పాదాలకు కాల్చేస్తుంది.

Bjarne Stroustrup

అక్టోబర్ 31 నుండి నవంబర్ 1 వరకు, C++ రష్యా పీటర్ కాన్ఫరెన్స్ సెయింట్ పీటర్స్‌బర్గ్‌లో జరిగింది - రష్యాలో పెద్ద ఎత్తున ప్రోగ్రామింగ్ కాన్ఫరెన్స్‌లలో ఒకటి, దీనిని JUG Ru గ్రూప్ నిర్వహించింది. అతిథి స్పీకర్‌లలో C++ స్టాండర్డ్స్ కమిటీ సభ్యులు, CppCon స్పీకర్లు, O'Reilly పుస్తక రచయితలు మరియు LLVM, libc++ మరియు Boost వంటి ప్రాజెక్ట్‌ల నిర్వహణదారులు ఉన్నారు. ఈ సమావేశం అనుభవజ్ఞులైన C++ డెవలపర్‌ల కోసం ఉద్దేశించబడింది, వారు లైవ్ కమ్యూనికేషన్‌లో తమ నైపుణ్యాన్ని మరియు అనుభవాలను మార్పిడి చేసుకోవాలనుకునేవారు. విద్యార్థులు, గ్రాడ్యుయేట్ విద్యార్థులు మరియు విశ్వవిద్యాలయ ఉపాధ్యాయులకు చాలా మంచి తగ్గింపులు అందించబడతాయి.

కాన్ఫరెన్స్ యొక్క మాస్కో ఎడిషన్ వచ్చే ఏడాది ఏప్రిల్‌లో సందర్శించడానికి అందుబాటులో ఉంటుంది, అయితే ఈలోగా మా విద్యార్థులు చివరి ఈవెంట్‌లో నేర్చుకున్న ఆసక్తికరమైన విషయాలను మీకు తెలియజేస్తారు. 

నుండి ఫోటో కాన్ఫరెన్స్ ఆల్బమ్

О нас

నేషనల్ రీసెర్చ్ యూనివర్శిటీ హయ్యర్ స్కూల్ ఆఫ్ ఎకనామిక్స్ నుండి ఇద్దరు విద్యార్థులు - సెయింట్ పీటర్స్‌బర్గ్ ఈ పోస్ట్‌లో పనిచేశారు:

• లిజా వాసిలెంకో అప్లైడ్ మ్యాథమెటిక్స్ మరియు కంప్యూటర్ సైన్స్ ప్రోగ్రామ్‌లో భాగంగా ప్రోగ్రామింగ్ లాంగ్వేజెస్ చదువుతున్న 4వ సంవత్సరం అండర్ గ్రాడ్యుయేట్ విద్యార్థి. యూనివర్శిటీలో నా మొదటి సంవత్సరంలో C++ లాంగ్వేజ్‌తో పరిచయం ఏర్పడిన తర్వాత, నేను పరిశ్రమలో ఇంటర్న్‌షిప్‌ల ద్వారా దానితో పనిచేసిన అనుభవాన్ని పొందాను. సాధారణంగా ప్రోగ్రామింగ్ లాంగ్వేజెస్ మరియు ముఖ్యంగా ఫంక్షనల్ ప్రోగ్రామింగ్ పట్ల ఉన్న మక్కువ సమావేశంలో నివేదికల ఎంపికపై తనదైన ముద్ర వేసింది.
• డాన్యా స్మిర్నోవ్ మాస్టర్స్ ప్రోగ్రామ్ “ప్రోగ్రామింగ్ అండ్ డేటా అనాలిసిస్” 1వ సంవత్సరం విద్యార్థి. పాఠశాలలో ఉన్నప్పుడు, నేను ఒలింపియాడ్ సమస్యలను C ++ లో వ్రాసాను, ఆపై ఏదో ఒకవిధంగా విద్యా కార్యకలాపాలలో భాష నిరంతరం ముందుకు వచ్చింది మరియు చివరికి ప్రధాన పని భాషగా మారింది. నా పరిజ్ఞానాన్ని మెరుగుపరచుకోవడానికి మరియు కొత్త అవకాశాల గురించి తెలుసుకోవడానికి నేను సమావేశంలో పాల్గొనాలని నిర్ణయించుకున్నాను.

వార్తాలేఖలో, ఫ్యాకల్టీ నాయకత్వం తరచుగా మా ప్రత్యేకతకు సంబంధించిన విద్యా కార్యక్రమాల గురించి సమాచారాన్ని పంచుకుంటుంది. సెప్టెంబరులో మేము C++ రష్యా గురించి సమాచారాన్ని చూశాము మరియు శ్రోతలుగా నమోదు చేసుకోవాలని నిర్ణయించుకున్నాము. ఇలాంటి సదస్సుల్లో పాల్గొనడం మాకు ఇదే మొదటి అనుభవం.

కాన్ఫరెన్స్ నిర్మాణం

• డోక్లాడి

రెండు రోజుల వ్యవధిలో, నిపుణులు అనేక హాట్ టాపిక్‌లను కవర్ చేస్తూ 30 నివేదికలను చదివారు: అనువర్తిత సమస్యలను పరిష్కరించడానికి భాషా లక్షణాల యొక్క తెలివిగల ఉపయోగాలు, కొత్త ప్రమాణానికి సంబంధించి రాబోయే భాషా నవీకరణలు, C++ డిజైన్‌లో రాజీలు మరియు వాటి పరిణామాలతో పనిచేసేటప్పుడు జాగ్రత్తలు, ఉదాహరణలు ఆసక్తికరమైన ప్రాజెక్ట్ ఆర్కిటెక్చర్, అలాగే భాషా అవస్థాపనకు సంబంధించిన కొన్ని అండర్-ది-హుడ్ వివరాలు. ఒక సమయంలో 3 ప్రదర్శనలు ఉన్నాయి, చాలా తరచుగా రష్యన్ భాషలో రెండు మరియు ఆంగ్లంలో ఒకటి.

• చర్చా మండలాలు

ప్రసంగం తర్వాత, అన్ని అడగని ప్రశ్నలు మరియు అసంపూర్తి చర్చలు మార్కర్ బోర్డులతో అమర్చబడిన స్పీకర్లతో కమ్యూనికేషన్ కోసం ప్రత్యేకంగా నియమించబడిన ప్రాంతాలకు బదిలీ చేయబడ్డాయి. ఆహ్లాదకరమైన సంభాషణతో ప్రసంగాల మధ్య విరామానికి దూరంగా ఉన్నప్పుడు మంచి మార్గం.

• మెరుపు చర్చలు మరియు అనధికారిక చర్చలు

మీరు ఒక చిన్న నివేదిక ఇవ్వాలనుకుంటే, సాయంత్రం మెరుపు చర్చ కోసం మీరు వైట్‌బోర్డ్‌లో సైన్ అప్ చేయవచ్చు మరియు కాన్ఫరెన్స్ అంశంపై ఏదైనా మాట్లాడటానికి ఐదు నిమిషాల సమయాన్ని పొందవచ్చు. ఉదాహరణకు, C++ కోసం శానిటైజర్‌లకు త్వరిత పరిచయం (కొందరికి ఇది కొత్తది) లేదా సైన్ వేవ్ జనరేషన్‌లోని బగ్ గురించిన కథనం మాత్రమే వినవచ్చు, కానీ చూడలేరు.

మరొక ఆకృతి "విత్ ఎ హార్ట్ టు హార్ట్ కమిటీ" ప్యానెల్ చర్చ. వేదికపై స్టాండర్డైజేషన్ కమిటీలోని కొంతమంది సభ్యులు ఉన్నారు, ప్రొజెక్టర్‌లో ఒక పొయ్యి ఉంది (అధికారికంగా - హృదయపూర్వక వాతావరణాన్ని సృష్టించడానికి, కానీ “అంతా మంటల్లో ఉంది” అనే కారణం హాస్యాస్పదంగా అనిపిస్తుంది), C++ యొక్క ప్రమాణం మరియు సాధారణ దృష్టి గురించి ప్రశ్నలు , వేడి సాంకేతిక చర్చలు మరియు హోలీవార్‌లు లేకుండా. కమిటీలో సజీవంగా ఉన్న వ్యక్తులు కూడా ఉన్నారని తేలింది, వారు ఏదో ఒకదానిపై పూర్తిగా నిశ్చయించుకోలేరు లేదా ఏదైనా తెలియదు.

హోలివర్స్ అభిమానుల కోసం, మూడవ ఈవెంట్ కేసులో మిగిలిపోయింది - BOF సెషన్ “Go vs. C++”. మేము ఒక గో ప్రేమికుడిని, C++ ప్రేమికుడిని తీసుకుంటాము, సెషన్ ప్రారంభానికి ముందు వారు కలిసి ఒక టాపిక్‌పై 100500 స్లయిడ్‌లను సిద్ధం చేస్తారు (C++లో ప్యాకేజీల సమస్యలు లేదా గోలో జెనరిక్స్ లేకపోవడం వంటివి), ఆపై వారు తమలో తాము ఉల్లాసంగా చర్చించుకుంటారు మరియు ప్రేక్షకులతో, మరియు ప్రేక్షకులు ఒకేసారి రెండు దృక్కోణాలను అర్థం చేసుకోవడానికి ప్రయత్నిస్తారు. హోలివర్ సందర్భం నుండి ప్రారంభమైతే, మోడరేటర్ జోక్యం చేసుకుని పార్టీలను సయోధ్య చేస్తాడు. ఈ ఫార్మాట్ వ్యసనపరుడైనది: ప్రారంభమైన అనేక గంటల తర్వాత, స్లయిడ్‌లలో సగం మాత్రమే పూర్తయ్యాయి. ముగింపు చాలా వేగవంతం చేయాల్సి వచ్చింది.

• భాగస్వామి నిలుస్తుంది

కాన్ఫరెన్స్ భాగస్వాములు హాళ్లలో ప్రాతినిధ్యం వహించారు - స్టాండ్లలో వారు ప్రస్తుత ప్రాజెక్ట్‌ల గురించి మాట్లాడారు, ఇంటర్న్‌షిప్‌లు మరియు ఉపాధిని అందించారు, క్విజ్‌లు మరియు చిన్న పోటీలను నిర్వహించారు మరియు మంచి బహుమతులను కూడా గెలుచుకున్నారు. అదే సమయంలో, కొన్ని కంపెనీలు ఇంటర్వ్యూల ప్రారంభ దశల ద్వారా వెళ్ళడానికి కూడా ఆఫర్ చేశాయి, ఇది నివేదికలను వినడానికి మాత్రమే కాకుండా వచ్చిన వారికి ఉపయోగపడుతుంది.

నివేదికల సాంకేతిక వివరాలు

మేము రెండు రోజులు నివేదికలు విన్నాము. కొన్ని సమయాల్లో సమాంతరంగా ఉన్న వాటి నుండి ఒక నివేదికను ఎంచుకోవడం కష్టం - మేము విడిపోవడానికి మరియు విరామ సమయంలో పొందిన జ్ఞానాన్ని మార్పిడి చేసుకోవడానికి అంగీకరించాము. మరియు అయినప్పటికీ, చాలా వదిలివేయబడినట్లు అనిపిస్తుంది. ఇక్కడ మేము చాలా ఆసక్తికరంగా అనిపించిన కొన్ని నివేదికల విషయాల గురించి మాట్లాడాలనుకుంటున్నాము

కంపైలర్ ఆప్టిమైజేషన్ల ప్రిజం ద్వారా C++లో మినహాయింపులు, రోమన్ రస్యావ్

నుండి స్లయిడ్ చేయండి ప్రదర్శనలు

టైటిల్ సూచించినట్లుగా, రోమన్ LLVMని ఉదాహరణగా ఉపయోగించి మినహాయింపులతో పనిచేయడం చూశాడు. అదే సమయంలో, వారి పనిలో గణగణమని ద్వని చేయు ఉపయోగించని వారికి, నివేదిక ఇప్పటికీ కోడ్‌ను ఎలా ఆప్టిమైజ్ చేయవచ్చనే దాని గురించి కొంత ఆలోచనను ఇస్తుంది. కంపైలర్‌లు మరియు సంబంధిత ప్రామాణిక లైబ్రరీల డెవలపర్‌లు ఒకరితో ఒకరు సంభాషించుకోవడం మరియు అనేక విజయవంతమైన పరిష్కారాలు ఏకకాలంలో ఉండటమే దీనికి కారణం.

కాబట్టి, మినహాయింపును నిర్వహించడానికి, మీరు చాలా పనులు చేయాల్సి ఉంటుంది: ప్రస్తుత స్థాయిలో హ్యాండ్లింగ్ కోడ్ (ఏదైనా ఉంటే) లేదా ఉచిత వనరులను కాల్ చేయండి మరియు స్టాక్‌ను ఎక్కువ స్పిన్ అప్ చేయండి. మినహాయింపులను సంభావ్యంగా విసిరే కాల్‌ల కోసం కంపైలర్ అదనపు సూచనలను జోడిస్తుందనే వాస్తవానికి ఇవన్నీ దారితీస్తాయి. అందువల్ల, మినహాయింపు వాస్తవానికి పెంచబడకపోతే, ప్రోగ్రామ్ ఇప్పటికీ అనవసరమైన చర్యలను చేస్తుంది. ఓవర్‌హెడ్‌ని ఎలాగైనా తగ్గించడానికి, మినహాయింపు హ్యాండ్లింగ్ కోడ్‌ని జోడించాల్సిన అవసరం లేని లేదా "అదనపు" సూచనల సంఖ్యను తగ్గించగల పరిస్థితులను నిర్ణయించడానికి LLVM అనేక హ్యూరిస్టిక్‌లను కలిగి ఉంది.

స్పీకర్ వాటిలో డజను గురించి పరిశీలిస్తాడు మరియు ప్రోగ్రామ్ అమలును వేగవంతం చేయడంలో సహాయపడే రెండు పరిస్థితులను చూపుతుంది మరియు ఈ పద్ధతులు వర్తించనివి.

అందువల్ల, రోమన్ రస్యేవ్ విద్యార్థులను మినహాయింపు నిర్వహణను కలిగి ఉన్న కోడ్‌ని ఎల్లప్పుడూ సున్నా ఓవర్‌హెడ్‌తో అమలు చేయడం సాధ్యం కాదని నిర్ధారణకు దారి తీస్తుంది మరియు ఈ క్రింది సలహాను ఇస్తుంది:

• లైబ్రరీలను అభివృద్ధి చేసేటప్పుడు, సూత్రప్రాయంగా మినహాయింపులను వదిలివేయడం విలువ;
• మినహాయింపులు ఇంకా అవసరమైతే, సాధ్యమైనప్పుడల్లా ప్రతిచోటా noexcept (మరియు const) మాడిఫైయర్‌లను జోడించడం విలువైనదే, తద్వారా కంపైలర్ వీలైనంత వరకు ఆప్టిమైజ్ చేయవచ్చు.

సాధారణంగా, మినహాయింపులు కనిష్టంగా ఉపయోగించబడతాయి లేదా పూర్తిగా వదిలివేయబడతాయి అనే అభిప్రాయాన్ని స్పీకర్ ధృవీకరించారు.

నివేదిక స్లయిడ్‌లు క్రింది లింక్‌లో అందుబాటులో ఉన్నాయి: [“LLVM కంపైలర్ ఆప్టిమైజేషన్ల లెన్స్ ద్వారా C++ మినహాయింపులు”]

జనరేటర్‌లు, కొరౌటిన్‌లు మరియు ఇతర మెదడు-అన్‌రోలింగ్ స్వీట్‌నెస్, ఆది శవిత్

నుండి స్లయిడ్ చేయండి ప్రదర్శనలు

C++20లో ఆవిష్కరణలకు అంకితం చేయబడిన ఈ కాన్ఫరెన్స్‌లోని అనేక నివేదికలలో ఒకటి దాని రంగుల ప్రదర్శన కోసం మాత్రమే కాకుండా, సేకరణ ప్రాసెసింగ్ లాజిక్‌తో (లూప్, కాల్‌బ్యాక్‌ల కోసం) ఇప్పటికే ఉన్న సమస్యలను స్పష్టంగా గుర్తించడం కోసం కూడా గుర్తుంచుకోదగినది.

ఆది శవిత్ కిందివాటిని హైలైట్ చేస్తుంది: ప్రస్తుతం అందుబాటులో ఉన్న పద్ధతులు మొత్తం సేకరణ ద్వారా వెళ్తాయి మరియు కొన్ని అంతర్గత ఇంటర్మీడియట్ స్థితికి యాక్సెస్‌ను అందించవు (లేదా అవి కాల్‌బ్యాక్‌ల విషయంలో చేస్తాయి, కానీ కాల్‌బ్యాక్ హెల్ వంటి పెద్ద సంఖ్యలో అసహ్యకరమైన దుష్ప్రభావాలతో) . ఇటరేటర్లు ఉన్నట్లు అనిపించవచ్చు, కానీ వాటితో కూడా ప్రతిదీ అంత సజావుగా లేదు: సాధారణ ప్రవేశ మరియు నిష్క్రమణ పాయింట్లు లేవు (ప్రారంభం → ముగింపు వర్సెస్ rbegin → రెండ్ మరియు మొదలైనవి), మనం ఎంతకాలం పునరావృతం చేస్తామో స్పష్టంగా తెలియదా? C++20తో ప్రారంభించి, ఈ సమస్యలు పరిష్కరించబడతాయి!

మొదటి ఎంపిక: పరిధులు. ఇటరేటర్‌లను చుట్టడం ద్వారా, పునరావృతం యొక్క ప్రారంభం మరియు ముగింపు కోసం మేము సాధారణ ఇంటర్‌ఫేస్‌ను పొందుతాము మరియు మేము కంపోజ్ చేయగల సామర్థ్యాన్ని కూడా పొందుతాము. ఇవన్నీ పూర్తి స్థాయి డేటా ప్రాసెసింగ్ పైప్‌లైన్‌లను నిర్మించడాన్ని సులభతరం చేస్తాయి. కానీ ప్రతిదీ చాలా మృదువైనది కాదు: గణన తర్కం యొక్క భాగం నిర్దిష్ట పునరావృత్తి అమలులో ఉంది, ఇది కోడ్‌ను అర్థం చేసుకోవడానికి మరియు డీబగ్ చేయడానికి క్లిష్టతరం చేస్తుంది.

నుండి స్లయిడ్ చేయండి ప్రదర్శనలు

సరే, ఈ సందర్భంలో, C++20 జోడించిన కొరోటిన్‌లు (పైథాన్‌లోని జనరేటర్‌ల మాదిరిగానే ఉండే విధులు): ఇంటర్మీడియట్ స్థితిని సంరక్షించేటప్పుడు కొంత ప్రస్తుత విలువను తిరిగి ఇవ్వడం ద్వారా అమలును వాయిదా వేయవచ్చు. అందువల్ల, మేము డేటా కనిపించే విధంగా పని చేయడం మాత్రమే కాకుండా, నిర్దిష్ట కొరౌటిన్‌లోని అన్ని లాజిక్‌లను కూడా కలుపుతాము.

కానీ లేపనంలో ఒక ఫ్లై ఉంది: ప్రస్తుతానికి అవి ఇప్పటికే ఉన్న కంపైలర్లచే పాక్షికంగా మాత్రమే మద్దతిస్తాయి మరియు మనం కోరుకున్నంత చక్కగా అమలు చేయబడవు: ఉదాహరణకు, కొరౌటిన్‌లలో సూచనలు మరియు తాత్కాలిక వస్తువులను ఉపయోగించడం ఇంకా విలువైనది కాదు. అదనంగా, కొరౌటిన్‌లు ఏవి కావాలనే దానిపై కొన్ని పరిమితులు ఉన్నాయి మరియు constexpr ఫంక్షన్‌లు, కన్‌స్ట్రక్టర్‌లు/డిస్ట్రక్టర్‌లు మరియు మెయిన్‌లు ఈ జాబితాలో చేర్చబడలేదు.

అందువల్ల, డేటా ప్రాసెసింగ్ లాజిక్ యొక్క సరళతతో కొరౌటిన్లు సమస్యలలో గణనీయమైన భాగాన్ని పరిష్కరిస్తాయి, అయితే వాటి ప్రస్తుత అమలులకు మెరుగుదల అవసరం.

పదార్థాలు:

• C++ రష్యా నుండి స్లయిడ్‌లు - ["జనరేటర్లు, కొరౌటిన్లు మరియు ఇతర మెదడు-అన్ రోలింగ్ స్వీట్‌నెస్"]
• CppCon 2019 నుండి నివేదిక యొక్క వీడియో రికార్డింగ్

Yandex.Taxi, Anton Polukhin నుండి C++ ట్రిక్స్

నా వృత్తిపరమైన కార్యకలాపాలలో, కొన్నిసార్లు నేను పూర్తిగా సహాయక అంశాలను అమలు చేయాల్సి ఉంటుంది: అంతర్గత ఇంటర్‌ఫేస్ మరియు కొన్ని లైబ్రరీ యొక్క API మధ్య ర్యాపర్, లాగింగ్ లేదా పార్సింగ్. ఈ సందర్భంలో, సాధారణంగా అదనపు ఆప్టిమైజేషన్ అవసరం లేదు. అయితే ఈ భాగాలు RuNetలో అత్యంత ప్రజాదరణ పొందిన కొన్ని సేవలలో ఉపయోగించినట్లయితే? అటువంటి పరిస్థితిలో, మీరు ఒంటరిగా గంటకు టెరాబైట్లను ప్రాసెస్ చేయాలి! అప్పుడు ప్రతి మిల్లీసెకన్ లెక్కించబడుతుంది మరియు అందువల్ల మీరు వివిధ ఉపాయాలను ఆశ్రయించవలసి ఉంటుంది - అంటోన్ పొలుఖిన్ వారి గురించి మాట్లాడారు.

పాయింటర్-టు-ఇంప్లిమెంటేషన్ (పింప్ల్) నమూనాను అమలు చేయడం బహుశా అత్యంత ఆసక్తికరమైన ఉదాహరణ. 

#include <third_party/json.hpp> //PROBLEMS! 
struct Value { 
    Value() = default; 
    Value(Value&& other) = default; 
    Value& operator=(Value&& other) = default; 
    ~Value() = default; 

    std::size_t Size() const { return data_.size(); } 

private: 
    third_party::Json data_; 
};

ఈ ఉదాహరణలో, మొదట నేను బాహ్య లైబ్రరీల హెడర్ ఫైల్‌లను వదిలించుకోవాలనుకుంటున్నాను - ఇది వేగంగా కంపైల్ చేస్తుంది మరియు మీరు సాధ్యమయ్యే పేరు వైరుధ్యాలు మరియు ఇతర సారూప్య లోపాల నుండి మిమ్మల్ని మీరు రక్షించుకోవచ్చు. 

సరే, మేము #includeని .cpp ఫైల్‌కి తరలించాము: మాకు చుట్టబడిన API యొక్క ఫార్వర్డ్-డిక్లరేషన్ అలాగే std::unique_ptr అవసరం. ఇప్పుడు మనకు డైనమిక్ కేటాయింపులు మరియు డేటా సమూహంలో చెల్లాచెదురుగా ఉన్న డేటా మరియు తగ్గిన హామీలు వంటి ఇతర అసహ్యకరమైన విషయాలు ఉన్నాయి. std::aligned_storage వీటన్నింటికీ సహాయపడుతుంది. 

struct Value { 
// ... 
private: 
    using JsonNative = third_party::Json; 
    const JsonNative* Ptr() const noexcept; 
    JsonNative* Ptr() noexcept; 

    constexpr std::size_t kImplSize = 32; 
    constexpr std::size_t kImplAlign = 8; 
    std::aligned_storage_t<kImplSize, kImplAlign> data_; 
};

ఒకే సమస్య: మేము ప్రతి రేపర్ కోసం పరిమాణం మరియు అమరికను పేర్కొనాలి - పారామితులతో మన pimpl టెంప్లేట్‌ను తయారు చేద్దాం, కొన్ని ఏకపక్ష విలువలను ఉపయోగించండి మరియు మేము ప్రతిదీ సరిగ్గా అంచనా వేసినట్లు డిస్ట్రక్టర్‌కు చెక్‌ను జోడించండి. : 

~FastPimpl() noexcept { 
    validate<sizeof(T), alignof(T)>(); 
    Ptr()->~T(); 
}

template <std::size_t ActualSize, std::size_t ActualAlignment>
static void validate() noexcept { 
    static_assert(
        Size == ActualSize, 
        "Size and sizeof(T) mismatch"
    ); 
    static_assert(
        Alignment == ActualAlignment, 
        "Alignment and alignof(T) mismatch"
    ); 
}

డిస్ట్రక్టర్‌ను ప్రాసెస్ చేస్తున్నప్పుడు T ఇప్పటికే నిర్వచించబడినందున, ఈ కోడ్ సరిగ్గా అన్వయించబడుతుంది మరియు సంకలన దశలో ఇది లోపాలుగా నమోదు చేయవలసిన అవసరమైన పరిమాణం మరియు అమరిక విలువలను అవుట్‌పుట్ చేస్తుంది. అందువలన, ఒక అదనపు సంకలన రన్ ఖర్చుతో, మేము చుట్టబడిన తరగతుల యొక్క డైనమిక్ కేటాయింపును వదిలించుకుంటాము, అమలుతో APIని .cpp ఫైల్‌లో దాచిపెడతాము మరియు ప్రాసెసర్ ద్వారా కాషింగ్ చేయడానికి మరింత అనుకూలమైన డిజైన్‌ను కూడా పొందుతాము.

లాగింగ్ మరియు అన్వయించడం అంతగా ఆకట్టుకోలేదు కాబట్టి ఈ సమీక్షలో ప్రస్తావించబడదు.

నివేదిక స్లయిడ్‌లు క్రింది లింక్‌లో అందుబాటులో ఉన్నాయి: ["టాక్సీ నుండి C++ ట్రిక్స్"]

మీ కోడ్ డ్రైగా ఉంచడానికి ఆధునిక పద్ధతులు, Björn Fahller

ఈ చర్చలో, Björn Fahller పునరావృతమయ్యే స్థితి తనిఖీల యొక్క శైలీకృత లోపాన్ని ఎదుర్కోవడానికి అనేక విభిన్న మార్గాలను చూపుతుంది:

assert(a == IDLE || a == CONNECTED || a == DISCONNECTED);

తెలిసిన కదూ? ఇటీవలి ప్రమాణాలలో ప్రవేశపెట్టబడిన అనేక శక్తివంతమైన C++ టెక్నిక్‌లను ఉపయోగించడం ద్వారా, మీరు ఎలాంటి పనితీరు పెనాల్టీ లేకుండా అదే కార్యాచరణను చక్కగా అమలు చేయవచ్చు. సరిపోల్చండి:   

assert(a == any_of(IDLE, CONNECTED, DISCONNECTED));

స్థిరపరచని సంఖ్యలో తనిఖీలను నిర్వహించడానికి, మీరు వెంటనే వైవిధ్యమైన టెంప్లేట్‌లు మరియు ఫోల్డ్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగించాలి. మేము enum యొక్క state_type మూలకానికి అనేక వేరియబుల్స్ యొక్క సమానత్వాన్ని తనిఖీ చేయాలనుకుంటున్నామని అనుకుందాం. సహాయక ఫంక్షన్‌ని వ్రాయడం అనేది ముందుగా గుర్తుకు వచ్చేది_ఏదైనా_:

enum state_type { IDLE, CONNECTED, DISCONNECTED };

template <typename ... Ts>
bool is_any_of(state_type s, const Ts& ... ts) { 
    return ((s == ts) || ...); 
}

ఈ ఇంటర్మీడియట్ ఫలితం నిరాశపరిచింది. ఇప్పటివరకు కోడ్ మరింత చదవగలిగేలా లేదు:

assert(is_any_of(state, IDLE, DISCONNECTING, DISCONNECTED)); 

నాన్-టైప్ టెంప్లేట్ పారామితులు పరిస్థితిని కొద్దిగా మెరుగుపరచడంలో సహాయపడతాయి. వారి సహాయంతో, మేము enum యొక్క లెక్కించదగిన అంశాలను టెంప్లేట్ పారామితుల జాబితాకు బదిలీ చేస్తాము: 

template <state_type ... states>
bool is_any_of(state_type t) { 
    return ((t == states) | ...); 
}
	
assert(is_any_of<IDLE, DISCONNECTING, DISCONNECTED>(state)); 

నాన్-టైప్ టెంప్లేట్ పరామితి (C++17)లో స్వయంచాలకంగా ఉపయోగించడం ద్వారా, విధానం కేవలం స్టేట్_టైప్ మూలకాలతో మాత్రమే కాకుండా, నాన్-టైప్ టెంప్లేట్ పారామీటర్‌లుగా ఉపయోగించబడే ఆదిమ రకాలతో పోలికలను సాధారణీకరిస్తుంది:

template <auto ... alternatives, typename T>
bool is_any_of(const T& t) {
    return ((t == alternatives) | ...);
}

ఈ వరుస మెరుగుదలల ద్వారా, తనిఖీల కోసం కావలసిన సరళమైన వాక్యనిర్మాణం సాధించబడుతుంది:

template <class ... Ts>
struct any_of : private std::tuple<Ts ...> { 
// поленимся и унаследуем конструкторы от tuple 
        using std::tuple<Ts ...>::tuple;
        template <typename T>
        bool operator ==(const T& t) const {
                return std::apply(
                        [&t](const auto& ... ts) {
                                return ((ts == t) || ...);
                        },
                        static_cast<const std::tuple<Ts ...>&>(*this));
        }
};

template <class ... Ts>
any_of(Ts ...) -> any_of<Ts ... >;
 
assert(any_of(IDLE, DISCONNECTING, DISCONNECTED) == state);

ఈ ఉదాహరణలో, తగ్గింపు గైడ్ కంపైలర్‌కు కావలసిన స్ట్రక్చర్ టెంప్లేట్ పారామితులను సూచించడానికి ఉపయోగపడుతుంది, ఇది కన్స్ట్రక్టర్ ఆర్గ్యుమెంట్‌ల రకాలను తెలుసు. 

మరింత - మరింత ఆసక్తికరంగా. Bjorn == మించి పోలిక ఆపరేటర్‌ల కోసం ఫలిత కోడ్‌ను ఎలా సాధారణీకరించాలో నేర్పుతుంది, ఆపై ఏకపక్ష కార్యకలాపాల కోసం. అలాగే, no_unique_address attribute (C++20) మరియు లాంబ్డా ఫంక్షన్‌లలో టెంప్లేట్ పారామితులు (C++20) వంటి ఫీచర్లు ఉపయోగ ఉదాహరణలను ఉపయోగించి వివరించబడ్డాయి. (అవును, ఇప్పుడు లాంబ్డా సింటాక్స్ గుర్తుంచుకోవడం మరింత సులభం - ఇవి అన్ని రకాల కుండలీకరణాల యొక్క నాలుగు వరుస జంటలు.) కన్స్ట్రక్టర్ వివరాల వలె ఫంక్షన్‌లను ఉపయోగించి తుది పరిష్కారం నిజంగా నా ఆత్మను వేడి చేస్తుంది, లాంబ్డా యొక్క ఉత్తమ సంప్రదాయాలలో వ్యక్తీకరణ టుపుల్ గురించి ప్రత్యేకంగా చెప్పనక్కర్లేదు. కాలిక్యులస్.

ముగింపులో, దానిని మెరుగుపర్చడం మర్చిపోవద్దు:

• లాంబ్డాస్ ఉచితంగా constexpr అని గుర్తుంచుకోండి; 
• లాంబ్డా మూసివేతలో పారామీటర్ ప్యాక్‌కి సంబంధించి ఖచ్చితమైన ఫార్వార్డింగ్‌ని జోడించి, దాని అగ్లీ సింటాక్స్‌ని చూద్దాం;
• కంపైలర్‌కు షరతులతో కూడిన noexcept ఆప్టిమైజేషన్‌ల కోసం మరిన్ని అవకాశాలను అందజేద్దాం; 
• లాంబ్డాస్ యొక్క స్పష్టమైన రిటర్న్ విలువలకు ధన్యవాదాలు టెంప్లేట్‌లలో మరింత అర్థమయ్యే ఎర్రర్ అవుట్‌పుట్‌ను జాగ్రత్తగా చూసుకుందాం. టైప్ చెకింగ్ దశలో - టెంప్లేట్ ఫంక్షన్‌ని వాస్తవంగా పిలవడానికి ముందు ఇది కంపైలర్‌ను మరిన్ని తనిఖీలను చేయమని బలవంతం చేస్తుంది. 

వివరాల కోసం, దయచేసి లెక్చర్ మెటీరియల్‌లను చూడండి: 

• స్లయిడ్‌లను నివేదించండి: [మీ కోడ్ పొడిగా ఉంచడానికి ఆధునిక పద్ధతులు]
• గితుబ్‌లో సోర్స్ కోడ్
• రచయిత యొక్క బ్లాగ్ వ్యాసం

మా ముద్రలు

C++ రష్యాలో మా మొదటి భాగస్వామ్యం దాని తీవ్రతకు చిరస్మరణీయమైనది. శిక్షణ మరియు లైవ్ కమ్యూనికేషన్ మధ్య లైన్ దాదాపుగా కనిపించని ఒక హృదయపూర్వక సంఘటనగా నేను C++ రష్యా యొక్క అభిప్రాయాన్ని పొందాను. వక్తల మానసిక స్థితి నుండి ఈవెంట్ భాగస్వాముల నుండి పోటీల వరకు ప్రతిదీ వేడి చర్చలకు అనుకూలంగా ఉంటుంది. కాన్ఫరెన్స్ యొక్క కంటెంట్, నివేదికలతో కూడినది, C++ ఆవిష్కరణలు, పెద్ద ప్రాజెక్ట్‌ల కేస్ స్టడీస్ మరియు సైద్ధాంతిక నిర్మాణ పరిశీలనలతో సహా చాలా విస్తృతమైన అంశాలను కవర్ చేస్తుంది. కానీ ఈవెంట్ యొక్క సామాజిక భాగాన్ని విస్మరించడం అన్యాయం, ఇది C++కి మాత్రమే కాకుండా భాషా అడ్డంకులను అధిగమించడంలో సహాయపడుతుంది.

ఇలాంటి కార్యక్రమంలో పాల్గొనే అవకాశం కల్పించినందుకు కాన్ఫరెన్స్ నిర్వాహకులకు ధన్యవాదాలు!
మీరు C++ రష్యా గతం, వర్తమానం మరియు భవిష్యత్తు గురించి నిర్వాహకుల పోస్ట్‌ని చూసి ఉండవచ్చు JUG Ru బ్లాగ్‌లో.

చదివినందుకు ధన్యవాదాలు, మరియు మేము ఈవెంట్‌లను తిరిగి చెప్పడం ఉపయోగకరంగా ఉందని మేము ఆశిస్తున్నాము!

మూలం: www.habr.com