C++ റഷ്യ: അത് എങ്ങനെ സംഭവിച്ചു

നാടകത്തിന്റെ തുടക്കത്തിൽ ചുവരിൽ C++ കോഡ് തൂങ്ങിക്കിടക്കുന്നുവെന്ന് നിങ്ങൾ പറഞ്ഞാൽ, അവസാനം അത് നിങ്ങളുടെ കാലിൽ വെടിവയ്ക്കും.

Bjarne Stroustrup

ഒക്ടോബർ 31 മുതൽ നവംബർ 1 വരെ, C++ റഷ്യ പീറ്റർ കോൺഫറൻസ് സെന്റ് പീറ്റേഴ്‌സ്ബർഗിൽ നടന്നു - റഷ്യയിലെ വലിയ തോതിലുള്ള പ്രോഗ്രാമിംഗ് കോൺഫറൻസുകളിലൊന്ന്, JUG Ru ഗ്രൂപ്പ് സംഘടിപ്പിച്ചു. അതിഥി സ്പീക്കറുകളിൽ C++ സ്റ്റാൻഡേർഡ് കമ്മിറ്റി അംഗങ്ങൾ, CppCon സ്പീക്കറുകൾ, O'Reilly പുസ്തക രചയിതാക്കൾ, LLVM, libc++, Boost തുടങ്ങിയ പ്രോജക്റ്റുകളുടെ മെയിന്റനർമാർ എന്നിവരും ഉൾപ്പെടുന്നു. തത്സമയ ആശയവിനിമയത്തിൽ വൈദഗ്ധ്യം വർദ്ധിപ്പിക്കാനും അനുഭവങ്ങൾ കൈമാറാനും ആഗ്രഹിക്കുന്ന പരിചയസമ്പന്നരായ C++ ഡവലപ്പർമാരെയാണ് കോൺഫറൻസ് ലക്ഷ്യമിടുന്നത്. വിദ്യാർത്ഥികൾക്കും ബിരുദ വിദ്യാർത്ഥികൾക്കും യൂണിവേഴ്സിറ്റി അധ്യാപകർക്കും വളരെ നല്ല കിഴിവുകൾ നൽകുന്നു.

കോൺഫറൻസിന്റെ മോസ്കോ പതിപ്പ് അടുത്ത വർഷം ഏപ്രിലിൽ തന്നെ സന്ദർശിക്കാൻ ലഭ്യമാകും, എന്നാൽ അതിനിടയിൽ ഞങ്ങളുടെ വിദ്യാർത്ഥികൾ അവസാന പരിപാടിയിൽ പഠിച്ച രസകരമായ കാര്യങ്ങൾ നിങ്ങളോട് പറയും. 

ഫോട്ടോയിൽ നിന്നുള്ളത് കോൺഫറൻസ് ആൽബം

ഞങ്ങളെ കുറിച്ച്

നാഷണൽ റിസർച്ച് യൂണിവേഴ്സിറ്റി ഹയർ സ്കൂൾ ഓഫ് ഇക്കണോമിക്സിൽ നിന്നുള്ള രണ്ട് വിദ്യാർത്ഥികൾ - സെന്റ് പീറ്റേഴ്സ്ബർഗ് ഈ പോസ്റ്റിൽ പ്രവർത്തിച്ചു:

• അപ്ലൈഡ് മാത്തമാറ്റിക്സ് ആൻഡ് കമ്പ്യൂട്ടർ സയൻസ് പ്രോഗ്രാമിന്റെ ഭാഗമായി പ്രോഗ്രാമിംഗ് ഭാഷകൾ പഠിക്കുന്ന നാലാം വർഷ ബിരുദ വിദ്യാർത്ഥിനിയാണ് ലിസ വാസിലെങ്കോ. സർവ്വകലാശാലയിലെ എന്റെ ആദ്യ വർഷത്തിൽ തന്നെ C++ ഭാഷയുമായി പരിചയത്തിലായ എനിക്ക് പിന്നീട് വ്യവസായത്തിലെ ഇന്റേൺഷിപ്പിലൂടെ അതിനൊപ്പം പ്രവർത്തിച്ച അനുഭവം ലഭിച്ചു. പ്രോഗ്രാമിംഗ് ഭാഷകളോടുള്ള അഭിനിവേശവും പ്രത്യേകിച്ചും ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗും കോൺഫറൻസിലെ റിപ്പോർട്ടുകൾ തിരഞ്ഞെടുക്കുന്നതിൽ അതിന്റെ മുദ്ര പതിപ്പിച്ചു.
• "പ്രോഗ്രാമിംഗ് ആൻഡ് ഡാറ്റ അനാലിസിസ്" എന്ന മാസ്റ്റേഴ്സ് പ്രോഗ്രാമിലെ ഒന്നാം വർഷ വിദ്യാർത്ഥിനിയാണ് ഡാനിയ സ്മിർനോവ്. സ്കൂളിൽ പഠിക്കുമ്പോൾ, ഞാൻ സി ++ ൽ ഒളിമ്പ്യാഡ് പ്രശ്നങ്ങൾ എഴുതി, തുടർന്ന് എങ്ങനെയെങ്കിലും ഭാഷ വിദ്യാഭ്യാസ പ്രവർത്തനങ്ങളിൽ നിരന്തരം ഉയർന്നുവരുകയും ഒടുവിൽ പ്രധാന പ്രവർത്തന ഭാഷയായി മാറുകയും ചെയ്തു. എന്റെ അറിവ് മെച്ചപ്പെടുത്തുന്നതിനും പുതിയ അവസരങ്ങളെക്കുറിച്ച് പഠിക്കുന്നതിനുമായി ഞാൻ കോൺഫറൻസിൽ പങ്കെടുക്കാൻ തീരുമാനിച്ചു.

വാർത്താക്കുറിപ്പിൽ, ഫാക്കൽറ്റി നേതൃത്വം പലപ്പോഴും ഞങ്ങളുടെ സ്പെഷ്യാലിറ്റിയുമായി ബന്ധപ്പെട്ട വിദ്യാഭ്യാസ പരിപാടികളെക്കുറിച്ചുള്ള വിവരങ്ങൾ പങ്കിടുന്നു. സെപ്റ്റംബറിൽ ഞങ്ങൾ C++ റഷ്യയെക്കുറിച്ചുള്ള വിവരങ്ങൾ കാണുകയും ശ്രോതാക്കളായി രജിസ്റ്റർ ചെയ്യാൻ തീരുമാനിക്കുകയും ചെയ്തു. ഇത്തരം സമ്മേളനങ്ങളിൽ പങ്കെടുക്കുന്നത് ഞങ്ങളുടെ ആദ്യ അനുഭവമാണ്.

കോൺഫറൻസ് ഘടന

• റിപ്പോർട്ടുകൾ

രണ്ട് ദിവസത്തിനുള്ളിൽ, വിദഗ്ധർ 30 റിപ്പോർട്ടുകൾ വായിച്ചു, നിരവധി ചർച്ചാ വിഷയങ്ങൾ ഉൾക്കൊള്ളുന്നു: പ്രായോഗിക പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനുള്ള ഭാഷാ സവിശേഷതകളുടെ തന്ത്രപരമായ ഉപയോഗം, പുതിയ സ്റ്റാൻഡേർഡുമായി ബന്ധപ്പെട്ട് വരാനിരിക്കുന്ന ഭാഷാ അപ്‌ഡേറ്റുകൾ, C++ രൂപകൽപ്പനയിലെ വിട്ടുവീഴ്ചകൾ, അവയുടെ അനന്തരഫലങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ മുൻകരുതലുകൾ, ഉദാഹരണങ്ങൾ. രസകരമായ പ്രോജക്റ്റ് ആർക്കിടെക്ചർ, കൂടാതെ ഭാഷാ ഇൻഫ്രാസ്ട്രക്ചറിന്റെ ചില അണ്ടർ-ദി-ഹുഡ് വിശദാംശങ്ങളും. മൂന്ന് പ്രകടനങ്ങൾ ഒരേസമയം നടന്നു, മിക്കപ്പോഴും രണ്ട് റഷ്യൻ ഭാഷയിലും ഒന്ന് ഇംഗ്ലീഷിലും.

• ചർച്ചാ മേഖലകൾ

പ്രസംഗത്തിനുശേഷം, ചോദിക്കാത്ത എല്ലാ ചോദ്യങ്ങളും പൂർത്തിയാകാത്ത ചർച്ചകളും സ്പീക്കറുമായുള്ള ആശയവിനിമയത്തിനായി പ്രത്യേകം നിയുക്ത മേഖലകളിലേക്ക് മാറ്റി, മാർക്കർ ബോർഡുകൾ സജ്ജീകരിച്ചിരിക്കുന്നു. സംഭാഷണങ്ങൾക്കിടയിലുള്ള ഇടവേളയിൽ സന്തോഷകരമായ സംഭാഷണം നടത്താനുള്ള നല്ലൊരു വഴി.

• മിന്നൽ സംസാരങ്ങളും അനൗപചാരിക ചർച്ചകളും

നിങ്ങൾക്ക് ഒരു ചെറിയ റിപ്പോർട്ട് നൽകാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, വൈകുന്നേരത്തെ മിന്നൽ പ്രസംഗത്തിനായി വൈറ്റ്ബോർഡിൽ സൈൻ അപ്പ് ചെയ്യാനും കോൺഫറൻസ് വിഷയത്തെ കുറിച്ച് എന്തും സംസാരിക്കാൻ അഞ്ച് മിനിറ്റ് സമയം നേടാനും കഴിയും. ഉദാഹരണത്തിന്, C++ നായുള്ള സാനിറ്റൈസറുകളെക്കുറിച്ചുള്ള ഒരു ദ്രുത ആമുഖം (ചിലർക്ക് ഇത് പുതിയതായിരുന്നു) അല്ലെങ്കിൽ കേൾക്കാൻ മാത്രം കഴിയുന്ന, എന്നാൽ കാണാത്ത ഒരു ബഗിനെക്കുറിച്ചുള്ള ഒരു കഥ.

മറ്റൊരു ഫോർമാറ്റ് പാനൽ ചർച്ചയാണ് "ഹൃദയത്തോട് ഹൃദയത്തോട് കൂടിയ സമിതി." സ്റ്റേജിൽ സ്റ്റാൻഡേർഡൈസേഷൻ കമ്മിറ്റിയിലെ ചില അംഗങ്ങളുണ്ട്, പ്രൊജക്ടറിൽ ഒരു അടുപ്പ് ഉണ്ട് (ഔദ്യോഗികമായി - ഒരു ആത്മാർത്ഥമായ അന്തരീക്ഷം സൃഷ്ടിക്കാൻ, പക്ഷേ "എല്ലാം തീയിലായതിനാൽ" കാരണം രസകരമാണെന്ന് തോന്നുന്നു), C ++ ന്റെ സ്റ്റാൻഡേർഡിനെയും പൊതുവായ കാഴ്ചപ്പാടിനെയും കുറിച്ചുള്ള ചോദ്യങ്ങൾ , ചൂടേറിയ സാങ്കേതിക ചർച്ചകളും ഹോളിവാറുകളും ഇല്ലാതെ. എന്തെങ്കിലും പൂർണ്ണമായി ഉറപ്പില്ലാത്തതോ എന്തെങ്കിലും അറിയാത്തതോ ആയ ജീവനുള്ള ആളുകളും കമ്മിറ്റിയിൽ ഉണ്ടെന്ന് മനസ്സിലായി.

ഹോളിവാറുകളുടെ ആരാധകർക്കായി, മൂന്നാമത്തെ ഇവന്റ് കേസിൽ തുടർന്നു - BOF സെഷൻ “Go vs. C++”. ഞങ്ങൾ ഒരു ഗോ പ്രേമി, ഒരു C++ കാമുകനെ എടുക്കുന്നു, സെഷൻ ആരംഭിക്കുന്നതിന് മുമ്പ് അവർ ഒരുമിച്ച് ഒരു വിഷയത്തിൽ 100500 സ്ലൈഡുകൾ തയ്യാറാക്കുന്നു (C++ ലെ പാക്കേജുകളിലെ പ്രശ്‌നങ്ങൾ അല്ലെങ്കിൽ Go-യിലെ ജനറിക്‌സിന്റെ അഭാവം പോലെ), തുടർന്ന് അവർ തമ്മിൽ സജീവമായ ചർച്ചയും ഒപ്പം പ്രേക്ഷകരോടൊപ്പം, പ്രേക്ഷകർ ഒരേസമയം രണ്ട് കാഴ്ചപ്പാടുകൾ മനസ്സിലാക്കാൻ ശ്രമിക്കുന്നു. ഒരു ഹോളിവർ സന്ദർഭത്തിന് പുറത്താണ് ആരംഭിക്കുന്നതെങ്കിൽ, മോഡറേറ്റർ ഇടപെട്ട് കക്ഷികളെ അനുരഞ്ജിപ്പിക്കുന്നു. ഈ ഫോർമാറ്റ് ആസക്തി ഉളവാക്കുന്നതാണ്: ആരംഭിച്ച് കുറച്ച് മണിക്കൂറുകൾക്ക് ശേഷം, സ്ലൈഡുകളുടെ പകുതി മാത്രം പൂർത്തിയായി. അവസാനം വളരെ ത്വരിതപ്പെടുത്തേണ്ടതായിരുന്നു.

• പങ്കാളി നിൽക്കുന്നു

കോൺഫറൻസിന്റെ പങ്കാളികളെ ഹാളുകളിൽ പ്രതിനിധീകരിച്ചു - സ്റ്റാൻഡിൽ അവർ നിലവിലെ പ്രോജക്ടുകളെക്കുറിച്ച് സംസാരിച്ചു, ഇന്റേൺഷിപ്പുകളും ജോലിയും വാഗ്ദാനം ചെയ്തു, ക്വിസുകളും ചെറിയ മത്സരങ്ങളും നടത്തി, കൂടാതെ നല്ല സമ്മാനങ്ങൾ നറുക്കെടുപ്പും നടത്തി. അതേസമയം, ചില കമ്പനികൾ അഭിമുഖത്തിന്റെ പ്രാരംഭ ഘട്ടങ്ങളിലൂടെ കടന്നുപോകാൻ പോലും വാഗ്ദാനം ചെയ്തു, ഇത് റിപ്പോർട്ടുകൾ കേൾക്കാൻ മാത്രമല്ല വരുന്നവർക്ക് ഉപയോഗപ്രദമാകും.

റിപ്പോർട്ടുകളുടെ സാങ്കേതിക വിശദാംശങ്ങൾ

രണ്ടുദിവസവും ഞങ്ങൾ റിപ്പോർട്ടുകൾ ശ്രദ്ധിച്ചു. ചില സമയങ്ങളിൽ സമാന്തരമായവയിൽ നിന്ന് ഒരു റിപ്പോർട്ട് തിരഞ്ഞെടുക്കുന്നത് ബുദ്ധിമുട്ടായിരുന്നു - ഇടവേളകളിൽ നേടിയ അറിവ് വിഭജിക്കാനും കൈമാറാനും ഞങ്ങൾ സമ്മതിച്ചു. അങ്ങനെയാണെങ്കിലും, പലതും വിട്ടുപോയതായി തോന്നുന്നു. ഞങ്ങൾക്ക് ഏറ്റവും രസകരമായി തോന്നിയ ചില റിപ്പോർട്ടുകളുടെ ഉള്ളടക്കത്തെക്കുറിച്ച് ഇവിടെ സംസാരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു

കംപൈലർ ഒപ്റ്റിമൈസേഷനുകളുടെ പ്രിസത്തിലൂടെ C++ ലെ ഒഴിവാക്കലുകൾ, റോമൻ റുസയേവ്

നിന്ന് സ്ലൈഡ് ചെയ്യുക അവതരണങ്ങൾ

തലക്കെട്ട് സൂചിപ്പിക്കുന്നത് പോലെ, LLVM ഒരു ഉദാഹരണമായി ഉപയോഗിച്ച് ഒഴിവാക്കലുകളോടെ പ്രവർത്തിക്കാൻ റോമൻ നോക്കി. അതേ സമയം, അവരുടെ ജോലിയിൽ Clang ഉപയോഗിക്കാത്തവർക്ക്, കോഡ് എങ്ങനെ ഒപ്റ്റിമൈസ് ചെയ്യാം എന്നതിനെക്കുറിച്ച് റിപ്പോർട്ടിന് ഇപ്പോഴും ചില ആശയങ്ങൾ നൽകാൻ കഴിയും. കംപൈലറുകളുടെയും അനുബന്ധ സ്റ്റാൻഡേർഡ് ലൈബ്രറികളുടെയും ഡെവലപ്പർമാർ പരസ്പരം ആശയവിനിമയം നടത്തുന്നതിനാലും വിജയകരമായ നിരവധി പരിഹാരങ്ങൾ ഒത്തുചേരുന്നതിനാലും ഇത് സംഭവിക്കുന്നു.

അതിനാൽ, ഒരു അപവാദം കൈകാര്യം ചെയ്യുന്നതിന്, നിങ്ങൾ ഒരുപാട് കാര്യങ്ങൾ ചെയ്യേണ്ടതുണ്ട്: നിലവിലെ തലത്തിൽ ഹാൻഡ്‌ലിംഗ് കോഡ് (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ) അല്ലെങ്കിൽ സൗജന്യ ഉറവിടങ്ങൾ വിളിച്ച് സ്റ്റാക്ക് ഉയർന്നത് സ്പിൻ അപ്പ് ചെയ്യുക. ഒഴിവാക്കലുകൾ വരുത്താൻ സാധ്യതയുള്ള കോളുകൾക്കായി കംപൈലർ അധിക നിർദ്ദേശങ്ങൾ ചേർക്കുന്നു എന്ന വസ്തുതയിലേക്ക് ഇതെല്ലാം നയിക്കുന്നു. അതിനാൽ, ഒഴിവാക്കൽ യഥാർത്ഥത്തിൽ ഉയർത്തിയില്ലെങ്കിൽ, പ്രോഗ്രാം ഇപ്പോഴും അനാവശ്യമായ പ്രവർത്തനങ്ങൾ നടത്തും. ഓവർഹെഡ് എങ്ങനെയെങ്കിലും കുറയ്ക്കുന്നതിന്, ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യുന്നതിനുള്ള കോഡ് ചേർക്കേണ്ടതില്ല അല്ലെങ്കിൽ "അധിക" നിർദ്ദേശങ്ങളുടെ എണ്ണം കുറയ്ക്കാൻ കഴിയുന്ന സാഹചര്യങ്ങൾ നിർണ്ണയിക്കുന്നതിന് LLVM-ന് നിരവധി ഹ്യൂറിസ്റ്റിക്സ് ഉണ്ട്.

സ്പീക്കർ അവയിൽ ഒരു ഡസനോളം പരിശോധിക്കുകയും പ്രോഗ്രാം നിർവ്വഹണം വേഗത്തിലാക്കാൻ സഹായിക്കുന്ന സാഹചര്യങ്ങളും ഈ രീതികൾ ബാധകമല്ലാത്ത സാഹചര്യങ്ങളും കാണിക്കുന്നു.

അങ്ങനെ, റോമൻ റുസയേവ്, ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യുന്ന കോഡ് എല്ലായ്പ്പോഴും പൂജ്യം ഓവർഹെഡിൽ നടപ്പിലാക്കാൻ കഴിയില്ലെന്ന നിഗമനത്തിലേക്ക് വിദ്യാർത്ഥികളെ നയിക്കുന്നു, കൂടാതെ ഇനിപ്പറയുന്ന ഉപദേശം നൽകുന്നു:

• ലൈബ്രറികൾ വികസിപ്പിക്കുമ്പോൾ, തത്വത്തിൽ ഒഴിവാക്കലുകൾ ഉപേക്ഷിക്കുന്നത് മൂല്യവത്താണ്;
• ഒഴിവാക്കലുകൾ ഇപ്പോഴും ആവശ്യമാണെങ്കിൽ, സാധ്യമാകുമ്പോഴെല്ലാം എല്ലായിടത്തും noexcept (ഒപ്പം const) മോഡിഫയറുകൾ ചേർക്കുന്നത് മൂല്യവത്താണ്, അതുവഴി കംപൈലറിന് കഴിയുന്നത്ര ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയും.

പൊതുവേ, ഒഴിവാക്കലുകൾ ഏറ്റവും കുറഞ്ഞത് ഉപയോഗിക്കുന്നതോ പൂർണ്ണമായും ഉപേക്ഷിക്കുന്നതോ ആയ വീക്ഷണം സ്പീക്കർ സ്ഥിരീകരിച്ചു.

റിപ്പോർട്ട് സ്ലൈഡുകൾ ഇനിപ്പറയുന്ന ലിങ്കിൽ ലഭ്യമാണ്: [“LLVM കംപൈലർ ഒപ്റ്റിമൈസേഷനുകളുടെ ലെൻസിലൂടെയുള്ള C++ ഒഴിവാക്കലുകൾ”]

ജനറേറ്ററുകൾ, കൊറൗട്ടിനുകൾ, മറ്റ് മസ്തിഷ്കത്തെ അൺറോൾ ചെയ്യുന്ന മധുരം, ആദി ഷാവിത്ത്

നിന്ന് സ്ലൈഡ് ചെയ്യുക അവതരണങ്ങൾ

C++20-ലെ പുതുമകൾക്കായി സമർപ്പിച്ചിരിക്കുന്ന ഈ കോൺഫറൻസിലെ നിരവധി റിപ്പോർട്ടുകളിലൊന്ന് അതിന്റെ വർണ്ണാഭമായ അവതരണത്തിന് മാത്രമല്ല, ശേഖരണ പ്രോസസ്സിംഗ് ലോജിക്കിലുള്ള (ലൂപ്പ്, കോൾബാക്കുകൾക്ക്) നിലവിലുള്ള പ്രശ്‌നങ്ങൾ വ്യക്തമായി തിരിച്ചറിയുന്നതിനും അവിസ്മരണീയമാണ്.

Adi Shavit ഇനിപ്പറയുന്നവ എടുത്തുകാണിക്കുന്നു: നിലവിൽ ലഭ്യമായ രീതികൾ മുഴുവൻ ശേഖരത്തിലൂടെയും കടന്നുപോകുന്നു, ചില ആന്തരിക ഇന്റർമീഡിയറ്റ് അവസ്ഥകളിലേക്ക് പ്രവേശനം നൽകുന്നില്ല (അല്ലെങ്കിൽ കോൾബാക്കുകളുടെ കാര്യത്തിൽ അവ ചെയ്യുന്നു, പക്ഷേ കോൾബാക്ക് ഹെൽ പോലെയുള്ള അസുഖകരമായ പാർശ്വഫലങ്ങൾ ധാരാളം ഉണ്ട്) . ആവർത്തനങ്ങൾ ഉണ്ടെന്ന് തോന്നുന്നു, പക്ഷേ അവയിൽ പോലും എല്ലാം അത്ര സുഗമമല്ല: പൊതുവായ എൻട്രി, എക്സിറ്റ് പോയിന്റുകളൊന്നുമില്ല (ആരംഭം → അവസാനം വേഴ്സസ് rbegin → റെൻഡും മറ്റും), ഞങ്ങൾ എത്രനേരം ആവർത്തിക്കുമെന്ന് വ്യക്തമല്ല? C++20 മുതൽ, ഈ പ്രശ്നങ്ങൾ പരിഹരിച്ചു!

ആദ്യ ഓപ്ഷൻ: ശ്രേണികൾ. ഇറ്ററേറ്ററുകൾ പൊതിയുന്നതിലൂടെ, ഒരു ആവർത്തനത്തിന്റെ തുടക്കത്തിനും അവസാനത്തിനും ഒരു പൊതു ഇന്റർഫേസ് ലഭിക്കും, കൂടാതെ രചിക്കാനുള്ള കഴിവും നമുക്ക് ലഭിക്കും. ഇതെല്ലാം പൂർണ്ണമായ ഡാറ്റ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ നിർമ്മിക്കുന്നത് എളുപ്പമാക്കുന്നു. എന്നാൽ എല്ലാം അത്ര സുഗമമല്ല: കണക്കുകൂട്ടൽ ലോജിക്കിന്റെ ഒരു ഭാഗം ഒരു നിർദ്ദിഷ്ട ആവർത്തനത്തിന്റെ നിർവ്വഹണത്തിനുള്ളിൽ സ്ഥിതിചെയ്യുന്നു, ഇത് കോഡ് മനസിലാക്കാനും ഡീബഗ് ചെയ്യാനും സങ്കീർണ്ണമാക്കും.

നിന്ന് സ്ലൈഡ് ചെയ്യുക അവതരണങ്ങൾ

ശരി, ഈ സാഹചര്യത്തിൽ, C++20 കോറൂട്ടീനുകൾ ചേർത്തു (പൈത്തണിലെ ജനറേറ്ററുകളോട് സാമ്യമുള്ള പ്രവർത്തനങ്ങൾ): ഒരു ഇന്റർമീഡിയറ്റ് അവസ്ഥ നിലനിർത്തിക്കൊണ്ട് നിലവിലെ ചില മൂല്യങ്ങൾ നൽകിക്കൊണ്ട് നിർവ്വഹണം മാറ്റിവയ്ക്കാം. അതിനാൽ, ദൃശ്യമാകുന്ന ഡാറ്റയിൽ പ്രവർത്തിക്കുക മാത്രമല്ല, ഒരു പ്രത്യേക കോറൂട്ടീനിനുള്ളിലെ എല്ലാ യുക്തികളും ഉൾക്കൊള്ളിക്കുകയും ചെയ്യുന്നു.

എന്നാൽ തൈലത്തിൽ ഒരു ഈച്ചയുണ്ട്: ഇപ്പോൾ അവ നിലവിലുള്ള കംപൈലറുകൾ ഭാഗികമായി മാത്രമേ പിന്തുണയ്ക്കുന്നുള്ളൂ, മാത്രമല്ല ഞങ്ങൾ ആഗ്രഹിക്കുന്നത്ര ഭംഗിയായി നടപ്പിലാക്കുകയും ചെയ്യുന്നില്ല: ഉദാഹരണത്തിന്, റഫറൻസുകളും താൽക്കാലിക വസ്തുക്കളും കൊറൂട്ടീനുകളിൽ ഉപയോഗിക്കുന്നത് ഇതുവരെ വിലമതിക്കുന്നില്ല. കൂടാതെ, coroutines എന്തായിരിക്കാം എന്നതിന് ചില നിയന്ത്രണങ്ങളുണ്ട്, constexpr ഫംഗ്‌ഷനുകൾ, കൺസ്‌ട്രക്‌ടറുകൾ/ഡിസ്ട്രക്റ്ററുകൾ, മെയിൻ എന്നിവ ഈ ലിസ്റ്റിൽ ഉൾപ്പെടുത്തിയിട്ടില്ല.

അതിനാൽ, ഡാറ്റാ പ്രോസസ്സിംഗ് ലോജിക്കിന്റെ ലാളിത്യം കൊണ്ട് കൊറൗട്ടീനുകൾ പ്രശ്നങ്ങളുടെ ഒരു പ്രധാന ഭാഗം പരിഹരിക്കുന്നു, എന്നാൽ അവയുടെ നിലവിലെ നടപ്പാക്കലുകൾ മെച്ചപ്പെടുത്തേണ്ടതുണ്ട്.

മെറ്റീരിയലുകൾ:

• C++ റഷ്യയിൽ നിന്നുള്ള സ്ലൈഡുകൾ - ["ജനറേറ്ററുകൾ, കൊറൂട്ടിനുകൾ, മറ്റ് മസ്തിഷ്കത്തിന്റെ അൺറോൾ ചെയ്യുന്ന മധുരം"]
• CppCon 2019-ൽ നിന്നുള്ള റിപ്പോർട്ടിന്റെ വീഡിയോ റെക്കോർഡിംഗ്

Yandex.Taxi, Anton Polukhin എന്നിവയിൽ നിന്നുള്ള C++ തന്ത്രങ്ങൾ

എന്റെ പ്രൊഫഷണൽ പ്രവർത്തനങ്ങളിൽ, ചിലപ്പോൾ എനിക്ക് പൂർണ്ണമായും സഹായകമായ കാര്യങ്ങൾ നടപ്പിലാക്കേണ്ടി വരും: ചില ലൈബ്രറിയുടെ ആന്തരിക ഇന്റർഫേസിനും API-യ്ക്കും ഇടയിലുള്ള ഒരു റാപ്പർ, ലോഗിംഗ് അല്ലെങ്കിൽ പാഴ്സിംഗ്. ഈ സാഹചര്യത്തിൽ, സാധാരണയായി അധിക ഒപ്റ്റിമൈസേഷൻ ആവശ്യമില്ല. എന്നാൽ RuNet-ലെ ഏറ്റവും ജനപ്രിയമായ ചില സേവനങ്ങളിൽ ഈ ഘടകങ്ങൾ ഉപയോഗിച്ചാലോ? അത്തരമൊരു സാഹചര്യത്തിൽ, നിങ്ങൾക്ക് മണിക്കൂറിൽ ടെറാബൈറ്റുകൾ മാത്രം ലോഗുകൾ പ്രോസസ്സ് ചെയ്യേണ്ടിവരും! അപ്പോൾ ഓരോ മില്ലിസെക്കൻഡും കണക്കാക്കുന്നു, അതിനാൽ നിങ്ങൾ വിവിധ തന്ത്രങ്ങൾ അവലംബിക്കേണ്ടതുണ്ട് - ആന്റൺ പൊലുഖിൻ അവരെക്കുറിച്ച് സംസാരിച്ചു.

ഒരുപക്ഷേ ഏറ്റവും രസകരമായ ഉദാഹരണം പോയിന്റർ-ടു-ഇംപ്ലിമെന്റേഷൻ (pimpl) പാറ്റേൺ നടപ്പിലാക്കിയതാണ്. 

#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_; 
};

ഈ ഉദാഹരണത്തിൽ, ആദ്യം ഞാൻ ബാഹ്യ ലൈബ്രറികളുടെ തലക്കെട്ട് ഫയലുകൾ ഒഴിവാക്കാൻ ആഗ്രഹിക്കുന്നു - ഇത് വേഗത്തിൽ കംപൈൽ ചെയ്യും, കൂടാതെ സാധ്യമായ നാമ വൈരുദ്ധ്യങ്ങളിൽ നിന്നും മറ്റ് സമാന പിശകുകളിൽ നിന്നും നിങ്ങൾക്ക് സ്വയം പരിരക്ഷിക്കാം. 

ശരി, ഞങ്ങൾ .cpp ഫയലിലേക്ക് #include നീക്കി: പൊതിഞ്ഞ 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 ഇതിനകം നിർവചിച്ചിരിക്കുന്നതിനാൽ, ഈ കോഡ് ശരിയായി പാഴ്‌സ് ചെയ്യപ്പെടും, കൂടാതെ കംപൈലേഷൻ ഘട്ടത്തിൽ അത് പിശകുകളായി നൽകേണ്ട ആവശ്യമായ വലുപ്പവും വിന്യാസ മൂല്യങ്ങളും ഔട്ട്പുട്ട് ചെയ്യും. അങ്ങനെ, ഒരു അധിക കംപൈലേഷൻ റണ്ണിന്റെ ചെലവിൽ, പൊതിഞ്ഞ ക്ലാസുകളുടെ ചലനാത്മക അലോക്കേഷനിൽ നിന്ന് ഞങ്ങൾ രക്ഷപ്പെടുന്നു, നടപ്പാക്കലിനൊപ്പം ഒരു .cpp ഫയലിൽ API മറയ്‌ക്കുന്നു, കൂടാതെ പ്രോസസ്സർ കാഷെ ചെയ്യുന്നതിന് കൂടുതൽ അനുയോജ്യമായ ഒരു ഡിസൈൻ നേടുകയും ചെയ്യുന്നു.

ലോഗിംഗും പാഴ്‌സിംഗും അത്ര ആകർഷണീയമല്ല, അതിനാൽ ഈ അവലോകനത്തിൽ പരാമർശിക്കുന്നില്ല.

റിപ്പോർട്ട് സ്ലൈഡുകൾ ഇനിപ്പറയുന്ന ലിങ്കിൽ ലഭ്യമാണ്: ["ടാക്സിയിൽ നിന്നുള്ള 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 ആട്രിബ്യൂട്ടും (C++20) ലാംഡ ഫംഗ്ഷനുകളിലെ ടെംപ്ലേറ്റ് പാരാമീറ്ററുകളും (C++20) ഉപയോഗത്തിന്റെ ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് വിശദീകരിക്കുന്നു. (അതെ, ഇപ്പോൾ ലാംഡ വാക്യഘടന ഓർക്കാൻ വളരെ എളുപ്പമാണ് - ഇവ എല്ലാ തരത്തിലുമുള്ള തുടർച്ചയായ നാല് ജോഡി പരാൻതീസിസുകളാണ്.) കൺസ്ട്രക്‌ടർ വിശദാംശങ്ങളായി ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ചുള്ള അന്തിമ പരിഹാരം എന്റെ ആത്മാവിനെ ശരിക്കും ചൂടാക്കുന്നു, ലാംഡയുടെ മികച്ച പാരമ്പര്യങ്ങളിലെ ട്യൂപ്പിൾ എന്ന പദപ്രയോഗം പരാമർശിക്കേണ്ടതില്ല. കാൽക്കുലസ്.

അവസാനം, അത് മിനുസപ്പെടുത്താൻ മറക്കരുത്:

• ലാംഡകൾ സൗജന്യമായി constexpr ആണെന്ന് ഓർക്കുക; 
• നമുക്ക് തികഞ്ഞ ഫോർവേഡിംഗ് ചേർക്കുകയും ലാംഡ ക്ലോഷറിലെ പാരാമീറ്റർ പായ്ക്കുമായി ബന്ധപ്പെട്ട് അതിന്റെ വൃത്തികെട്ട വാക്യഘടന നോക്കുകയും ചെയ്യാം;
• കംപൈലറിന് സോപാധികമായ നോഎക്സെപ്റ്റ് ഉള്ള ഒപ്റ്റിമൈസേഷനുകൾക്കായി കൂടുതൽ അവസരങ്ങൾ നൽകാം; 
• ലാംഡാസിന്റെ വ്യക്തമായ റിട്ടേൺ മൂല്യങ്ങൾക്ക് നന്ദി, ടെംപ്ലേറ്റുകളിൽ കൂടുതൽ മനസ്സിലാക്കാവുന്ന പിശക് ഔട്ട്പുട്ട് നമുക്ക് ശ്രദ്ധിക്കാം. ഇത് ടെംപ്ലേറ്റ് ഫംഗ്‌ഷനെ യഥാർത്ഥത്തിൽ വിളിക്കുന്നതിന് മുമ്പ് കൂടുതൽ പരിശോധനകൾ നടത്താൻ കംപൈലറിനെ പ്രേരിപ്പിക്കും - ടൈപ്പ് ചെക്കിംഗ് ഘട്ടത്തിൽ. 

വിശദാംശങ്ങൾക്ക്, പ്രഭാഷണ സാമഗ്രികൾ പരിശോധിക്കുക: 

• സ്ലൈഡുകൾ റിപ്പോർട്ട് ചെയ്യുക: [നിങ്ങളുടെ കോഡ് വരണ്ടതാക്കുന്നതിനുള്ള ആധുനിക സാങ്കേതിക വിദ്യകൾ]
• ഗിത്തബിലെ ഉറവിട കോഡ്
• രചയിതാവിന്റെ ബ്ലോഗ് ലേഖനം

ഞങ്ങളുടെ ഇംപ്രഷനുകൾ

C++ റഷ്യയിലെ ഞങ്ങളുടെ ആദ്യ പങ്കാളിത്തം അതിന്റെ തീവ്രതയാൽ അവിസ്മരണീയമായിരുന്നു. പരിശീലനത്തിനും തത്സമയ ആശയവിനിമയത്തിനും ഇടയിലുള്ള ലൈൻ ഏതാണ്ട് അദൃശ്യമായ ഒരു ആത്മാർത്ഥ സംഭവമായി എനിക്ക് C++ റഷ്യയുടെ മതിപ്പ് ലഭിച്ചു. പ്രസംഗകരുടെ മൂഡ് മുതൽ ഇവന്റ് പാർട്ണർമാരിൽ നിന്നുള്ള മത്സരങ്ങൾ വരെ എല്ലാം ചൂടേറിയ ചർച്ചകൾക്ക് സഹായകമാണ്. റിപ്പോർട്ടുകൾ അടങ്ങുന്ന കോൺഫറൻസിന്റെ ഉള്ളടക്കം, C++ കണ്ടുപിടുത്തങ്ങൾ, വലിയ പ്രോജക്റ്റുകളുടെ കേസ് പഠനങ്ങൾ, പ്രത്യയശാസ്ത്രപരമായ വാസ്തുവിദ്യാ പരിഗണനകൾ എന്നിവയുൾപ്പെടെ വിപുലമായ വിഷയങ്ങൾ ഉൾക്കൊള്ളുന്നു. എന്നാൽ ഇവന്റിന്റെ സാമൂഹിക ഘടകത്തെ അവഗണിക്കുന്നത് അന്യായമായിരിക്കും, ഇത് C++ ന് മാത്രമല്ല, ഭാഷാ തടസ്സങ്ങളെ മറികടക്കാൻ സഹായിക്കുന്നു.

ഇത്തരമൊരു പരിപാടിയിൽ പങ്കെടുക്കാൻ അവസരം നൽകിയതിന് കോൺഫറൻസ് സംഘാടകർക്ക് ഞങ്ങൾ നന്ദി പറയുന്നു!
C++ റഷ്യയുടെ ഭൂതകാലത്തെയും വർത്തമാനത്തെയും ഭാവിയെയും കുറിച്ചുള്ള സംഘാടകരുടെ പോസ്റ്റ് നിങ്ങൾ കണ്ടിരിക്കാം JUG Ru ബ്ലോഗിൽ.

വായിച്ചതിന് നന്ദി, ഞങ്ങളുടെ സംഭവങ്ങളുടെ പുനരാഖ്യാനം സഹായകരമാണെന്ന് ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു!

അവലംബം: www.habr.com