C++26 ધોરણ મંજૂર

ISO C++ ભાષા માનકીકરણ સમિતિએ સ્પષ્ટીકરણના અંતિમ સંસ્કરણને મંજૂરી આપી છે જે આંતરરાષ્ટ્રીય ધોરણ "C++26" બનાવે છે. સ્પષ્ટીકરણમાં રજૂ કરાયેલ સુવિધાઓ પહેલાથી જ GCC, Clang અને Microsoft Visual C++ કમ્પાઇલર્સમાં આંશિક રીતે સમર્થિત છે. C++26 ને સપોર્ટ કરતી માનક લાઇબ્રેરીઓ બુસ્ટ પ્રોજેક્ટમાં લાગુ કરવામાં આવી છે.

આગામી બે મહિનામાં, મંજૂર થયેલ સ્પષ્ટીકરણ દસ્તાવેજ તૈયારીના તબક્કામાંથી પસાર થશે, જે દરમિયાન જોડણીની ભૂલો અને ટાઇપોને સુધારવા માટે સંપાદકીય સુધારા કરવામાં આવશે. નવેમ્બરની શરૂઆતમાં, દસ્તાવેજનું અંતિમ સંસ્કરણ ઔપચારિક નામ ISO/IEC 14882:2026 હેઠળ પ્રકાશન માટે ISO ને સબમિટ કરવામાં આવશે.

C++26 ની મુખ્ય વિશેષતાઓ:

• કોન્ટ્રેક્ટ પ્રોગ્રામિંગ તત્વો (કોન્ટ્રાક્ટ્સ) અમલમાં મૂકવામાં આવ્યા છે, જે તમને ત્રણ નવા ઓપરેટરોનો ઉપયોગ કરીને ઔપચારિક ઇન્ટરફેસ સ્પષ્ટીકરણો વ્યાખ્યાયિત કરવાની મંજૂરી આપે છે: પૂર્વ (પૂર્વશરત), પોસ્ટ (પોસ્ટશરત), અને કરાર_એસેર્ટ (એસેર્શન ચેક). "પૂર્વ" ઓપરેટર પૂર્વશરતો વ્યાખ્યાયિત કરે છે જે કોલ પહેલાં પૂર્ણ થવી આવશ્યક છે (ઇનપુટ માન્યતા); "પોસ્ટ" એવી શરતો વ્યાખ્યાયિત કરે છે જે અમલ પછી પૂર્ણ થવી આવશ્યક છે (આઉટપુટ આવશ્યકતાઓ); કરાર_એસેર્ટ અપવાદો વધારવા માટેની શરતો વ્યાખ્યાયિત કરે છે. આ સુવિધા GCC 16 માં ઉપલબ્ધ હશે. int f(const int x) pre (x != 1) // ઇનપુટ આવશ્યકતાઓ પોસ્ટ (r : r == x && r != 2) // પરિણામ આવશ્યકતાઓ; r એ પરિણામ સાથેનું મૂલ્ય છે { contract_assert (x != 3); return x; }
• રિફ્લેક્શન સપોર્ટ ઉમેરવામાં આવ્યો છે, જે કમ્પાઇલ સમયે પ્રોગ્રામ તત્વોનું નિરીક્ષણ અને સંશોધિત કરવાની મંજૂરી આપે છે. વ્યાકરણ રચના વિશે મેટામાહિતી મેળવવા માટે નવા ઓપરેટરો "^^" અને વ્યસ્ત પરિવર્તન કરવા માટે "[:…:]" ઉમેરવામાં આવ્યા છે. નિરીક્ષણ દરમિયાન મેળવેલી માહિતીને રૂપાંતરિત કરવા અને પ્રક્રિયા કરવા માટે std::meta લાઇબ્રેરી પ્રસ્તાવિત છે, અને સ્થિરાંકો સાથે ગણતરીઓ જેવી ક્ષમતાઓ ઉપલબ્ધ છે. GCC 16 માં રિફ્લેક્શન સપોર્ટ ઉમેરવામાં આવશે. constexpr int i = 42, j = 42; constexpr std::meta::info r = ^^i, s = ^^i; static_assert(r == r && r == s); static_assert(^^i != ^^j); // 'i' અને 'j' ના મૂલ્યો અલગ અલગ છે. static_assert(constant_of(^^i) == constant_of(^^j)); // 'i' અને 'j' એક જ છે static_assert(^^i != std::meta::reflect_constant(42)); // મૂલ્ય 42 થી અલગ
• રેગ્યુલર ફોર લૂપની શૈલીમાં કમ્પાઇલ સમયે પેરામીટર પેક, ટ્યુપલ જેવા ઑબ્જેક્ટ્સ અને રિફ્લેક્શન રિઝલ્ટ્સ (મેટાઓબ્જેક્ટ્સ) જેવા તત્વો પર પુનરાવર્તિત થવા માટે 'ટેમ્પલેટ ફોર' ઉમેર્યું. 'ટેમ્પલેટ ફોર' ચલાવતી વખતે, દરેક એલિમેન્ટ માટે લૂપ બોડી વિસ્તૃત થાય છે, અને દરેક પુનરાવૃત્તિ એક અલગ સ્કોપમાં પ્રક્રિયા કરવામાં આવે છે જેમાં લૂપમાં બદલાતું ચલ સતત હોય છે. પ્રતિબિંબના સંદર્ભમાં, 'ટેમ્પલેટ ફોર' નો ઉપયોગ વર્ગો અથવા એનમ્સના ગુણધર્મો પર પુનરાવર્તિત થવા માટે થઈ શકે છે. આ સુવિધા GCC 16 માં ઉપલબ્ધ હશે. void f() { template for (constexpr int I : std::array{1, 2, 3}) { static_assert(I < 4); } } આમાં વિસ્તૃત થશે: void f() { { constexpr auto&& __range = std::array{1, 2, 3}; constexpr auto __begin = __range.begin(); constexpr ઓટો __expansion-size = __range.end() — __begin; // 3 { constexpr int I = *(__begin + 0); static_assert(I < 4); } { constexpr int I = *(__begin + 1); static_assert(I < 4); } { constexpr int I = *(__begin + 2); static_assert(I < 4); } } }
• અસુમેળ અને સમાંતર કોડ એક્ઝેક્યુશન માટે std::એક્ઝેક્યુશન ફ્રેમવર્ક ઉમેર્યું. તે શેડ્યૂલર ઑબ્જેક્ટ્સ પૂરા પાડે છે, જે વર્ક શેડ્યૂલર (થ્રેડ, થ્રેડ પૂલ, GPU, ઇવેન્ટ લૂપ) ને વ્યાખ્યાયિત કરે છે, સેન્ડર ઑબ્જેક્ટ્સ, જે એક્ઝેક્યુટ કરવાના કાર્યને વ્યાખ્યાયિત કરે છે, અને રીસીવર ઑબ્જેક્ટ્સ, જે પરિણામને હેન્ડલ કરે છે. namespace નો ઉપયોગ કરીને std::execution; scheduler auto sch = thread_pool.scheduler(); sender auto begin = schedule(sch); sender auto hi = then(begin, []{ std::cout < "હેલો વર્લ્ડ! ઇન્ટ રાખો."; રીટર્ન 13; }); sender auto add_42 = then(hi, [](int arg) { return arg + 42; }); auto [i] = this_thread::sync_wait(add_42).value();
• સ્ટાન્ડર્ડ C++ ટાઇપ સિસ્ટમનો ઉપયોગ કરીને AVX-512 અને NEON જેવા SIMD સૂચના સેટનો ઉપયોગ કરીને ડેટા ઓપરેશન્સને સમાંતર બનાવવા માટે std::simd લાઇબ્રેરી ઉમેરવામાં આવી છે. a = {૧.૦f, ૨.૦f, ૩.૦f, ૪.૦f}; std::simd b = {5.0f, 6.0f, 7.0f, 8.0f}; std::simd પરિણામ = a + b;
• ચલ-કદના વેક્ટર (એરે) std::inplace_vector નું અમલીકરણ પ્રસ્તાવિત છે. તે સ્ટેક પર ફાળવવામાં આવે છે, જેનું કદ કમ્પાઇલ સમયે નક્કી થાય છે. API std::vector જેવું જ છે, પરંતુ એરે તત્વો આંતરિક રીતે સંગ્રહિત થાય છે, હીપ પર નહીં. inplace_vector a(10); inplace_vector b(std::move(a)); assert(a.size() == 10);
• કોડમાં બાઈનરી સંસાધનોને એમ્બેડ કરવા માટે "#embed" ડાયરેક્ટિવ ઉમેરવામાં આવ્યો છે. const unsigned char icon_display_data[] = { #embed "art.png" };
• જ્યારે constexpr સંદર્ભમાં ભૂલો થાય છે ત્યારે કમ્પાઇલ સમયે અપવાદો જનરેટ કરવા અને હેન્ડલ કરવા માટે ઉમેરાયેલ સપોર્ટ. constexpr std::optional checked_divide(unsigned n, unsigned d) { try { return divide(n, d); } catch (...) { return std::nullopt; } } constexpr date parse_date(std::string_view input) { auto [correct, year, month, day] = ctre::match<“([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})”>(input); જો (!correct) { throw incorrect_date{input}; } return build_date(year, month, day); }
• std::hive ડેટા સ્ટ્રક્ચર અનઓર્ડર્ડ ડેટા સ્ટોરેજ અને ડિલીટ કરેલા એલિમેન્ટ્સ દ્વારા મુક્ત થયેલ મેમરીના પુનઃઉપયોગ માટે અમલમાં મૂકવામાં આવ્યું છે. આ સ્ટ્રક્ચરને હાઇ-ઇન્ટેન્સિટી એડિશન અને ડિલીટેશન સાથે વર્કલોડ માટે ઑપ્ટિમાઇઝ કરવામાં આવ્યું છે જેમાં એલિમેન્ટ્સ મનસ્વી ક્રમમાં હોય છે. એરેથી વિપરીત, std::hive માં એલિમેન્ટ ડિલીટ કરવાથી અન્ય એલિમેન્ટ્સ બદલાતા નથી, પરંતુ ડિલીટ કરેલા એલિમેન્ટને ખાલી તરીકે ચિહ્નિત કરે છે, અને પછી જ્યારે નવું એલિમેન્ટ ઉમેરવામાં આવે છે ત્યારે ખાલી સ્થાન ભરે છે.
• રેખીય બીજગણિત માટે BLAS-આધારિત API સાથે std::linalg લાઇબ્રેરી ઉમેરી.
• હેઝાર્ડ પોઈન્ટર સિંક્રનાઇઝેશન મિકેનિઝમ માટે ઉમેરાયેલ સપોર્ટ, જે લોકીંગ વિના અન્ય થ્રેડો દ્વારા ઍક્સેસ કરવામાં આવતી વસ્તુઓ માટે મેમરી રિલીઝ થવાથી અટકાવે છે. જ્યારે કોઈ ઑબ્જેક્ટ ડિલીટ કરવામાં આવે છે, ત્યારે તેને ફક્ત ડિલીટ તરીકે ચિહ્નિત કરવામાં આવે છે, પરંતુ ઑબ્જેક્ટ દ્વારા કબજે કરેલી મેમરી ફક્ત ત્યારે જ રિલીઝ થાય છે જ્યારે બધા થ્રેડો ઑબ્જેક્ટની ઍક્સેસ દરમિયાન હેઝાર્ડ પોઈન્ટર સેટ રિલીઝ કરે છે.
• RCU (રીડ-કોપી અપડેટ) સિંક્રનાઇઝેશન મિકેનિઝમ માટે ઉમેરાયેલ સપોર્ટ. રાઇટ ઓપરેશન્સ ઑબ્જેક્ટનું નવું ઇન્સ્ટન્સ બનાવે છે, જ્યારે રીડ ઓપરેશન્સ બ્લોક કરતા નથી, પરંતુ જૂના ઇન્સ્ટન્સ સાથે કામ કરવાનું ચાલુ રાખે છે. ફેરફાર પૂર્ણ થયા પછી, નવું ઇન્સ્ટન્સ સક્રિય બને છે, અને તેના પર નવા રીડ ઓપરેશન્સ કરવામાં આવે છે, જ્યારે જૂના ઇન્સ્ટન્સને થ્રેડો વાંચ્યા પછી કાઢી નાખવામાં આવે છે.
• માનક લાઇબ્રેરીની સલામતીને મજબૂત બનાવવા માટે ફેરફારો કરવામાં આવ્યા છે, જેમ કે માન્ય મૂલ્યો અને બફર ઓવરરન્સ માટે તપાસ કરવી. ઉદાહરણ તરીકે, "constexpr સંદર્ભ ઓપરેટર[](size_type idx) const;" તત્વને ઍક્સેસ કરતી વખતે, "idx <size()" સ્થિતિ માટે ચેક ઉમેરવામાં આવે છે.
• કમ્પાઇલ સમયે પૂર્વ-ફાળવેલ મેમરીમાં ઑબ્જેક્ટ મૂકવા માટે નવા ઓપરેટર (પ્લેસમેન્ટ ન્યૂ) ના વેરિઅન્ટ સાથે constexpr કીવર્ડનો ઉપયોગ કરવાની ક્ષમતા પ્રદાન કરવામાં આવી છે.
• "constexpr" સંદર્ભમાં સ્ટ્રક્ચર્ડ બાઈન્ડિંગ્સ માટે સપોર્ટ ઉમેર્યો, જેનો અર્થ એ થયો કે કોન્સ્ટન્ટ એક્સપ્રેશનના સંદર્ભો હવે પોતે કોન્સ્ટન્ટ એક્સપ્રેશન હોઈ શકે છે. સપોર્ટ એરે અને સરળ સ્ટ્રક્ચર્સ માટે લાગુ કરવામાં આવ્યો છે. constexpr int arr[] = {1, 2}; constexpr auto [x, y] = arr;
• સ્ટ્રક્ચર્ડ બાઈન્ડિંગ્સ હવે "..." વાક્યરચનાને સપોર્ટ કરે છે જે પેકને સ્પષ્ટ કરે છે જે સોંપણી ક્રમમાં બાકીના તત્વોને કેપ્ચર કરે છે. auto [x,y,z] = f(); // ચલ x, y, z માં f() દ્વારા પરત કરાયેલા ત્રણ ઘટકો હશે. auto [...xs] = f(); // પેકેજ xs માં f() દ્વારા પરત કરાયેલા બધા ઘટકો હશે. auto [x, ...rest] = f(); // x માં પહેલું તત્વ હશે, અને બાકીનામાં બાકીનું હશે. auto [x, y, ...rest] = f(); // x માં પહેલું તત્વ હશે, y માં બીજું હશે, અને બાકીનામાં ત્રીજું હશે. auto [x, ...rest, z] = f(); // x માં પહેલું તત્વ હશે, બાકીનામાં બીજું હશે, અને z માં ત્રીજું હશે.
• "ટ્રિવિયલ રિલોકેટેબિલિટી" પ્રકારના માટે ઉમેરાયેલ સપોર્ટ, જે કન્સ્ટ્રક્ટર અથવા ડિસ્ટ્રક્ટરને બોલાવ્યા વિના મેમરીમાં ક્લોન કરીને આપેલ પ્રકારના ઑબ્જેક્ટ્સની હિલચાલને ઑપ્ટિમાઇઝ કરવાની મંજૂરી આપે છે. મેમ્બરવાઇઝ_ટ્રિવિયલલી_રિલોકેટેબલ અને મેમ્બરવાઇઝ_રિપ્લેસેબલ પ્રોપર્ટીઝ વર્ગો માટે લાગુ કરવામાં આવે છે, અને એક અથવા વધુ ઑબ્જેક્ટ્સની નીચી-સ્તરની હિલચાલ માટે trivially_relocate_at અને trivially_relocate ફંક્શન ઉમેરવામાં આવે છે.
• ગ્લોબલ મોડ્યુલ સાથે main() ફંક્શન જોડવા અને નામાંકિત મોડ્યુલોમાં main() ફંક્શન વ્યાખ્યાયિત કરવા માટે સપોર્ટ લાગુ કરવામાં આવ્યો છે.
• ચલ ઓપરેટર "મિત્ર" ("મિત્ર Ts...") ઉમેર્યું.
• સ્ટ્રક્ચર્ડ બાઈન્ડિંગ્સ માટે અમલમાં મૂકાયેલ વિશેષતાઓ;
• '= delete("reason")' વાક્યરચના ઉમેરી.
• મૂળભૂત અક્ષર સમૂહમાં "@", "$", અને "`" શામેલ છે.
• if અને switch સ્ટેટમેન્ટમાં શરત તરીકે સ્ટ્રક્ચર્ડ બાઇન્ડિંગનો ઉપયોગ કરવાની ક્ષમતા પૂરી પાડવામાં આવી છે.
• એક અવકાશમાં "_" નામ સાથે અનેક પ્લેસહોલ્ડર ચલોનો ઉપયોગ કરવાની ક્ષમતા ઉમેરાઈ, ઉદાહરણ તરીકે, નીચેના બાંધકામો હવે યોગ્ય છે: struct S { int _, _; }; void func() { int _, _; } void other() { int _; // અગાઉ એક ચેતવણી -Wunused મોડમાં પ્રદર્શિત કરવામાં આવી હતી }
• એવા સંદર્ભમાં સ્ટ્રિંગ લિટરલનો ઉપયોગ કરવો શક્ય છે જેમાં તેઓ અક્ષર એરેને પ્રારંભ કરવા માટે ઉપયોગમાં લેવાતા નથી અને પરિણામી કોડમાં સમાપ્ત થતા નથી, પરંતુ ડાયગ્નોસ્ટિક સંદેશાઓ અને પ્રીપ્રોસેસિંગ માટે કમ્પાઇલ સમયે જ ઉપયોગમાં લેવાય છે, ઉદાહરણ તરીકે, પરિમાણો તરીકે નિર્દેશો અને વિશેષતાઓ _Pragma, asm, extern, static_asssert, [[નાપસંદ કરેલ]] અને [[nodiscard]].
• બિલ્ટ-ઇન ફંક્શન ઉમેર્યા: યુનિયનમાં કોઈ વિકલ્પ સક્રિય છે કે નહીં તે તપાસવા માટે "__builtin_is_within_lifetime" અને બેઝ ક્લાસ વર્ચ્યુઅલ છે કે નહીં તે તપાસવા માટે "__builtin_is_virtual_base_of".
• અવ્યાખ્યાયિત વર્તન વિના તુચ્છ અનંત લૂપ્સ અમલમાં મૂક્યા.
• અપૂર્ણ પ્રકારના પોઇન્ટરને કાઢી નાખતી વખતે ભૂલ પ્રદર્શિત થાય છે તેની ખાતરી કરી.
• પૂર્વવર્તી અલ્પવિરામ વિના એલિપ્સિસ સાથે વેરિયેડિક પરિમાણોને વ્યાખ્યાયિત કરવા માટેનો વાક્યરચના (ઉદાહરણ તરીકે, જ્યારે "void e(int, …)" ને બદલે "void e(int…)" સ્પષ્ટ કરવામાં આવે છે) દૂર કરવામાં આવ્યો છે.
• મોડ્યુલો જાહેર કરવા માટે મેક્રોનો ઉપયોગ પ્રતિબંધિત છે.
• અંકગણિત ગણતરીઓમાં ગણતરી કરેલ મૂલ્યોના ગર્ભિત રૂપાંતરણોને દૂર કરવામાં આવ્યા છે. int main() { enum E1 { e }; enum E2 { f }; bool b = e <= 3.7; // નાપસંદ થયેલ int k = f - e; // નાપસંદ થયેલ int x = +f - e; // ઠીક છે }
• ડાયરેક્ટ એરે સરખામણી સપોર્ટ બંધ કરવામાં આવ્યો છે. int arr1[5]; int arr2[5]; bool same = arr1 == arr2;
• is_trivial ટેમ્પલેટ ક્લાસને નાપસંદ કરવામાં આવ્યો છે.
  
  સોર્સ: opennet.ru