سی‌پلاس‌پلاس مدرن قابلیت‌های ممتاز و پیشرفتهٔ ++C در استاندارد‌های جدید

کامبیز اسدزاده · خرداد 97

اگر شما توسعه دهنده‌ٔ ++C هستید، توصیه می‌کنم این سری از مقالات را دنبال کنید زیرا در این تاپیک قصد دارم به چکیده‌ای از آخرین تغییرات مرتبط با سی‌پلاس‌پلاس پیشرفته اشاره کنم. بنابراین در بخش اول، مهم‌ترین موارد منسوخ شده، اشکلات رفع شده و ویژگی‌های جدید در استاندارد‌های اخیر را پوشش خواهیم داد‌ که به صورت جزئی خواهد بود و سپس نسبت به هر کدام در مقالات جداگانه به کاربرد‌های پیشرفته‌تر و جزئیات بیشتری اشاره خواهیم کرد.

نقل قول

این مقاله شامل توضیحات مربوط به هستهٔ زبان است، درواقع به ویژگی‌های خودِ زبان اشاره می‌شود نه به اضافات و امکانات جدید از کتابخانهٔ STL. بنابراین در یک مقالهٔ جداگانه به ویژگی‌های جدید کتابخانه‌ٔ استاندارد اشاره خواهد شد که به زودی در این مکان لینک می‌شود.

قبل از شروع، اگر می‌خواهید به لیستی از تغییرات و ویژگی‌های کامل در استاندارد‌ها دسترسی داشته باشید به مقالهٔ زیر مراجعه کنید. در مقالهٔ فوق به لیست ویژگی‌های جدید در استاندارد ۱۱، ۱۴، ۱۷ و ۲۰ اشاره شده است.

در نظر داشته باشید که بزرگترین به‌روز رسانی سی++ در ده سالِ اخیر مربوط به استاندارد ۲۰ است. این نسخه از زبان تقریباً 2.5 برابر بزرگتر از سی++ ۱۰ سال پیش است! این در حالی است که استاندارد ۱۷ تقریباً ۸۰٪ بزرگتر از استاندارد ۰۳ است.

به عنوان مثال، طبق مستندات رسمی پیش‌نویسه‌ها تغییرات استاندارد از ۸۷۹ صفحه به ۱۸۳۴ صفحه در این استاندارد رسیده است! چیزی حدود ۱۰۰۰ صفحه بیشتر از نسخه‌های قبلی

تمامی این بهبود‌ها خبر از بهتر شدن و در عین حال پیچیده شدن زبان اما همراه با ساده‌تر و سریع‌تر شدن آن می‌دهد. اما مشکلی که می‌تواند رخ دهد در این است که یادگیری آن و به‌روز‌رسانی کد‌ها نیز می‌تواند دردسر ساز باشد.

بنابراین، برای پوشش دادن جزئیات و به‌روز‌رسانی‌های بیشتر در این مقاله سعی خواهم کرد که مهم‌ترین موارد را معرفی کنم.

جزئیات ++C نسخه ۱۷ (بهبود‌ها و تغییرات)

بیایید به آرامی شروع کنیم، امروز ما به عناصر حذف شده و یا به موارد بهبود یافتهٔ کتابخانه استاندارد بپردازیم.

معرفی به صورت سلسله مراتبی

عناصر حذف شده و توسعه یافته (در این بحث)
شفاف سازی در زبان
قالب‌ها
ویژگی‌ها
تغییرات اول کتابخانه
تغییرات دوم کتابخانه

مستندات و لینک‌ها

قبل از هر چیز، اگر شما خودتان می‌خواهید استاندارد جدید را کاوش کنید آخرین پیش نویسه را در این بخش مطالعه کنید.
در صورتی که می‌خواهید بدانید کدام کامپایلر از ویژگی‌های جدید پشتیبانی می‌کند، در این بخش آن را پیگیری کنید.
علاوه بر این، لیستی از توصیف‌های مختصر از تمامی ویژگی‌های زبان سی‌پلاس‌پلاس ۱۷ تهیه شده است که در این بخش می‌توانید آن را ببینید که در قالب PDF از طرف مرجع رسمی می‌باشد.

مواردی که ترجیح داده شده است که حذف شوند

حذف تریگراف
تریگراف‌ها کاراکترهای ویژه ترتیبی هستند که در موقع عدم پشتیبانی سیستم از نوع ۷ بیتی اَسکی (ASCII) همانند ایزو 646 استفاه شوند. برای مثال =?? کاراکتر ویژه‌ای مانند # تولید شده را در قالب -?? تولید می‌کند. تمامی مجموعه کاراکترهای اصلی سی‌پلاس‌پلاس در قالب 7 بیتی اسکی قرار دارند. موضوع فوق به ندرت مورد استفاده قرار می‌گیرد، بنابراین حذف آن ممکن است به ترجمه ساده کد کمک کند.

اگر شما می‌خواهید اطلاعات بیشتری در رابطه با کارآیی تیرگراف‌ها در سی++ کسب کنید به این لینک مراجعه کنید.

----------------------------------------------------------------------------
| trigraph | replacement | trigraph | replacement | trigraph | replacement |
----------------------------------------------------------------------------
| ??=      | #           | ??(      | [           | ??<      | {           |
| ??/      | \           | ??)      | ]           | ??>      | }           |
| ??’      | ˆ           | ??!      | |           | ??-      | ˜           |
----------------------------------------------------------------------------

شما جزئیات بیشتر را می‌توانید در سند N4086 بیابید.

اگر شما واقعاً به هر نحوی به گراف‌ها در ویژوال استودیو نیاز دارید، نگاهی به مشخصه /Zc:trigraphs در بخش پیکربندی داشته باشید. همچنین، کامپایلرهای دیگر ممکن است مواردی را پشتیبانی نکنند. وضعیت انجام شده کنونی در کامپایلر های GCC:5.1 و Clang:3.5 می‌باشد.

حذف کلمه کلیدی register
کلمه کلیدی register در استاندارد 2011 سی‌پلاس‌پلاس منسوخ شده است و دیگر استفاده از آن معنایی ندارد. این کلمه کلیدی در حال حاضر حذف شده است. این کلمه کلیدی محفوظ است و ممکن است در نسخه های بعدی باز نویسی شود (مثلا autokeyword به عنوان یک چیز قدرتمند مجددا مورد استفاده قرار گرفته است).

جزئیات بیشتر در رابطه با این مورد در P0001R1 قابل مشاهده است. البته فعلا در MSVC انجام نشده است اما در کامپایلر‌های GCC 7.0 و Clang 3.8 انجام شده است.

حذف Operator++ bool
این اپراتور برای زمان بسیار زیادی است که منسوخ شده است! در سی پلاس پلاس ۹۸ تصمیم بر آن گرفته بودند که از آن استفاده کنند اما در نسخه ۱۷ سی‌پلاس‌پلاس کمیته موافقت خود را جهت حذف آن از زبان اعلام کرده است.

جزئیات بیشتر در رابطه با این مورد در P0002R1 قابل مشاهده است. البته فعلا در MSVC انجام نشده است اما در کامپایلر‌های GCC 7.0 و Clang 3.8 انجام شده است.

حذف مشخصات استثنایی از استاندارد ۱۷
در سی پلاس پلاس ۱۷، مشخصات استثنایی بخشی از نوع سیستمی خواهند بود (به P0012R1 نگاه کنید). با این حال، استاندارد شامل مشخصات استثنایی قدیمی و منسوخ شده اند که به نظر غیرعلمی و غیرقابل استفاده است.

void fooThrowsInt(int a) throw(int) { 
  printf_s("can throw ints\n"); 
  if (a == 0) 
    throw 1; 
}

کد بالا در سی‌پلاس‌پلاس ۱۱ رد (منسوخ شده است). تنها اعلامیه استثنایی علمی throw() است، به این معنی است که این کد چیزی را در قالب throw انجام نخواهد داد. اما از سی‌پلاس‌پلاس ۱۱ به اینور، برنامه نویسان توصیه کرده اند که کسی از آن استفاده نکند.

برای مثال در کامپایلر Clang 4.0 شما باید خطای زیر را دریافت کنید:

error: ISO C++1z does not allow dynamic exception specifications [-Wdynamic-exception-spec]
note: use 'noexcept(false)' instead

جزئیات بیشتر در رابطه با این مورد در P0003R5 قابل مشاهده است. البته فعلا در MSVC انجام نشده است اما در کامپایلر‌های GCC 7.0 و Clang 3.8 انجام شده است.

حذف auto_ptr
این یکی از به روز رسانی‌های خوبی است که در سی‌پلاس‌پلاس ۱۱، ما اشاره گرهای هوشمند را دریافت کردیم : unique_ptr,shared_ptr و weak_ptr. با تشکر از این حرکتی که کمیته انجام داده بود، معنای واقعی این به روز رسانی در این بود که زبان می‌تواند پشتیبانی مناسبی از انتقال منابع منحصربفرد را داشته باشد. در این میان auto_ptr یک چیز قدیمی و نادرست در زبان بود به نا به دلایلی auto_ptr در این جا منسوخ شده است و باید به صورت خودکار به unique_ptr تبدیل شود.

توجه داشته باشیم که auto_ptr مدت کوتاهی است که از سی‌پلاس‌پلاس ۱۱ به اینور منسوخ شده است و بسیاری از کامپایلر ها منسوخ شدن آن را گزارش می‌دهند که به صورت زیر خواهد بود:

warning: 'template<class> class std::auto_ptr' is deprecated

در حال حاضر آن به وضعیت نامناسب تبدیل شده است، و اساساً کد شما کامپایل نخواهد شد. در اینجا خطا از طرف MSVC 2017 زمانی که از گزینه /std::c++latest استفاده کنید اعلام خواهد شد.

error C2039: 'auto_ptr': is not a member of 'std'

اگر شما نیاز به کمک از تبدیل از auto_ptr به unique_ptr دارید، می‌توانید Clang Tidy را بررسی کنید، زیرا آن عمل تبدیل خودکار را انجام خواهد داد. اطلاعات بیشتر در سند N4190 موجود است.

همچنین موارد مرتبط دیگری با سند N4190 وجود دارند که در کتابخانه خذف شده اند مانند:

unary_function/binary_function
ptr_fun()
mem_fun()/mem_fun_ref()
bind1st()/bind2nd()
random_shuffle

قوانین جدید خودکار برای Direct-List-Initialization از سی پلاس پلاس ۱۱ به اینور که ما یک مشکل بزرگی در این رابطه داشتیم:

auto x { 1 };

از initializer_list اینطور نتیجه‌گیری شده است. با استاندارد جدید، ما می‌توانیم این مشکل را حل کنیم. بنابراین آن می‌تواند به عنوان نوع int که اکثر مردم تصور می‌کنند شناسایی شود. برای اینکه این اتفاق بیافتد، ما نیاز داریم که دو روش تخصیص مقدار اولیه را درک کنیم: کپی و مستقیم.

auto x = foo(); // copy-initialization
auto x{foo}; // direct-initialization, initializes an
// initializer_list (until C++17)
int x = foo(); // copy-initialization
int x{foo}; // direct-initialization

برای مقدار دهی اولیه، سی‌پلاس‌پلاس ۱۷ قوانین جدیدی را معرفی می‌کند:

For a braced-init-list with only a single element, auto
deduction will deduce from that entry;
For a braced-init-list with more than one element, auto
deduction will be ill-formed.

برای مثال:

auto x1 = { 1, 2 };   // decltype(x1) is std::initializer_list<int>
auto x2 = { 1, 2.0 }; // error: cannot deduce element type
auto x3{ 1, 2 };      // error: not a single element
auto x4 = { 3 };      // decltype(x4) is std::initializer_list<int>
auto x5{ 3 };         // decltype(x5) is int

جزئیات بیشتر را در سند N3922 می‌توانید مشاهده کنید. همچنین جزئیات در رابطه با فهرست خودکار موجود هستند که توسط جناب آقای Ville Voutilainen اشاره شده است. این اضافات در سی‌پلاس‌پلاس از زمان MSVC 14.0، GCC 5.0 و Clang 3.8 کار می‌کنند.

گزینه static_assert بدون هیچ نوع پیغامی
این واضح است که، این به شما این امکان را می دهد که فقط بدون داشتن گذراندن پیام، نسخه دارای پیغام در دسترس خواهد بود. این سازگاری با سایر موارد مانند BOOST_STATIC_ASSERT وجود دارد.

static_assert(std::is_arithmetic_v<T>, "T must be arithmetic");
static_assert(std::is_arithmetic_v<T>); // no message needed since C++17

جزئیات بیشتر در سند N3928 در دسترس است. پشتیبانی شده در MSVC 2017 ٬ GCC 6.0 و Clang 2.5.

انواع مختلف شروع و پایان در محدوده حلقه
از سی‌پلاس‌پلاس ۱۱ به بعد، محدوده مبتنی بر حلقه ها به صورت داخلی تعریف شده است:

{
auto && __range = for-range-initializer;
for ( auto __begin = begin-expr,
__end = end-expr;
__begin != __end;
++__begin ) {
  for-range-declaration = *__begin;
  statement
}
}

همانطور که می‌بینید، __begin و __end دارای نوع مشابه هستند. این ممکن است باعث مشکلاتی شود. برای مثال زمانی که شما چیزی شبیه یک نگهبان (محافظ) که از نوع داده دیگری است را داشته باشید مشکل ساز خواهد بود.

در سی‌پلاس‌پلاس ۱۷ آن به صورت زیر تغییر کرده است:

{
auto && __range = for-range-initializer;
auto __begin = begin-expr;
auto __end = end-expr;
for ( ; __begin != __end; ++__begin ) {
  for-range-declaration = *__begin;
  statement
}
}

انواع __begin و __end ممکن است متفاوت باشد چرا که فقط اپراتور مقایسه مورد نیاز است. این تغییر کلی باعث می‌شود که این ویژگی تجربه بیشتری را در این زمینه برای کاربران ارائه دهند. جزئیات بیشتر در P0184R0، پشتیبانی شده در MSVC 2017 ،GCC 6.0 و Clang 3.6.

کامبیز اسدزاده · خرداد 97

جزئیات در ++C ویرایش ۱۷: کد نویسی ساده

با توجه به مشخصاتی که در استاندارد ISO/IEC 14882:2017 که ارائه شده است، ویژگی‌های جدید برای این معرفی می‌شوند تا کد شما تمیز تر و بهتر و در کل رَسا‌تر اعمال شوند. این مقاله را برای مطلع شدن از جزئیات بیشتر بخوانید. سی‌پلاس‌پلاس ۱۷ چندین ویژگی بزرگ زبان را ارائه می‌دهد که باعث می‌شود کد ما زیباتر و بهتر شود. بنابراین بیایید باهم یک نگاهی به این ویژگی‌ها داشته باشیم.

ممکن است شما بگویید که بیشترین ویژگی‌های جدید زبان (به جز پیشرفت های کتابخانه استاندارد - STL) برای نوشتن کد ساده تر و پاکتر می‌باشند. با توجه به مجموعه جزئیات سی‌پلاس‌پلاس ۱۷ که بسیاری از چیزهای بزرگ را مورد بررسی قرار داده است، ما امروز تنها برای بعضی از ویژگی ها که از داخل این مجموعه عظیم بیرون کشیده‌ایم اشاره خواهیم داشت که باعث می‌شود کد شما فشرده‌تر و بهینه تر شود.

پیوند‌های ساخت یافته / اعلان‌های تجزیه
عبارت Init-statement برای if/switch
متغیرهای درون خطی (inline)
شرط constexpr if
و چند موارد دیگر

پیوند‌های ساخت یافته، آیا اغلب با tuple ها کار کرده‌اید؟

اگر نه، پس احتمالاً باید به آن نگاهی کنید. tuple ها تنها برای بازگشت مقادیر چند گانه از یک تابع پیشنهاد نمی‌شوند، آنها پشتیبانی ویژگی‌ای از زبان را داشتند. به طوری که باعث می‌شود کد ساده تر و پاکتر شود.

برای مثال (std::tie که از مرجع اصلی سی‌پلاس‌پلاس به دست آمده است) به صورت زیر است:

std::set<S> mySet; 
S value{42, "Test", 3.14}; 
std::set<S>::iterator iter; 
bool inserted; // unpacks the return val of insert into iter and inserted 
std::tie(iter, inserted) = mySet.insert(value); 
if (inserted) 
std::cout << "Value was inserted\n";

توجه داشته باشید که باید iter و inserted را ابتدا وارد کرده باشید. سپس شما می‌‌توانید از std::tie استفاده کنید. با این حال این بخش کوچکی از کد نمونه است:

std::set<S> mySet; 
S value{42, "Test", 3.14}; 
auto [iter, inserted] = mySet.insert(value);

اینجا توجه داشته باشید که یک خط به جای سه خط جایگزین شده است! این کد ساده‌تر و خوانا‌تر و درعین حال ایمن‌ تر است، اینطور نیست؟ همچنین، شما هم اکنون می‌‌توانید از const استفاده کنید و آن را به صورت const auto [iter inserted] بنویسید که صحیح است.

پیوند ساختاری تنها به tuple ها ختم نمی‌شود، چرا که ما سه مورد دیگر را داریم:

اگر مقدار دهی اولیه یک آرایه باشد:

// works with arrays: 
double myArray[3] = { 1.0, 2.0, 3.0 }; 
auto [a, b, c] = myArray;

اگر مقدار دهی اولیه std::tuple_size<> را پشتیبانی کند و تابع get را فراهم کند که شایع ترین مورد است.

auto [a, b] = myPair; // binds myPair.first/second

به عبارت دیگر، شما می‌‌توانید کلاس‌های خود را پشتیبانی کنید، با فرض این که شما تابع get را در پیاده سازی رابط کلاس خود اضافه کرده باشید.

اگر مقدار دهی اولیه فقط شامل اعضای عمومی شود در این صورت:

struct S { 
 int x1 : 2; 
 volatile double y1; 
}; 
S f(); 
const auto [ x, y ] = f();

در حال حاضر این روش برای دریافت یک مرجع از یک عضو tuple آسان است.

auto& [ refA, refB, refC, refD ] = myTuple;

و یکی از جالب‌ترین استفاده‌‌ها (پشتیبانی از حلقه‌ها است):

  std::map myMap; 
  for (const auto & [k,v] : myMap) 
  { // k - key 
   // v - value 
  }

پیوند ساختاری یا تقسیم بندی اعلان‌ها
برای این ویژگی، ممکن است شما نام های دیگری را دیده باشید، "اعلان تجزیه". همانطور که می‌‌بینیم، این دو نام در نظر گرفته شده است، اما فعلاً استاندارد سازی در حالت پیش‌نویسه است و با نام "پیوند‌های ساختاری" می‌‌باشند.

جزئیات بیشتر در رابطه با این مورد در اسناد P0217R3، P0144R0 و P0615R0 موجود هستند. همچنین این مورد با کامپایلر‌‌های GCC 7.0،MSVC2017 و Clang 4.0 سازگار است.

عبارت Init-statement برای if/switch
نسخه جدید عبارت شرطی if و switch در سی‌پلاس‌پلاس جدید به صورت زیر است:

if (init; condition) , switch (init; condition)

قبلاً باید به صورت زیر می‌نوشتیم:

{ 
 auto val = GetValue(); 
 if (condition(val)) 
 // on success 
 else 
 // on false... 
}

در اینجا val یک دامنه جدا کننده بدون دارد که باعث "نشت - فقدان" در خاتمه دهنده دامنه خواهد شد. در حالی که شما در نسخه جدید می‌‌‌توانید به صورت زیر بنویسید:

if (auto val = GetValue(); condition(val)) 
  // on success 
 else 
  // on false...

متغیر val تنها در داخل عبارات if و else قابل رویت است، بنابراین آن یک "نَشت" نخواهد داشت. condition ممکن است چندین عبارت باشد نه تنها if بنابراین متغیر val یکی از دو مقدار true/false را خواهد داشت.

چرا این ویژگی کاربرد دارد؟
اجازه دهید تا به شما بگوییم زمانی که می‌خواهید چندین چیز را در یک رشته را جستجو کنید به صورت زیر خواهید داشت:

const std::string myString = "My Hello World Wow"; 
const auto it = myString.find("Hello"); 
if (it != std::string::npos) 
 std::cout << it << " Hello\n" 
const auto it2 = myString.find("World"); 
if (it2 != std::string::npos) 
 std::cout << it2 << " World\n"

ما باید از نام‌‌های مختلفی برای it استفاده کنیم و یا اینکه آن را با دامنه خاتمه دهنده جدا سازیم.

{ 
 const auto it = myString.find("Hello"); 
 if (it != std::string::npos) 
 std::cout << it << " Hello\n" 
} 
{ 
 const auto it = myString.find("World"); 
 if (it != std::string::npos) 
 std::cout << it << " World\n" 
}

عبارت جدید شرطی if در نسخه جدید یک دامنه اضافه را در یک خط ایجاد می‌‌کند.

if (const auto it = myString.find("Hello"); it != std::string::npos) 
 std::cout << it << " Hello\n"; 
if (const auto it = myString.find("World"); it != std::string::npos) 
 std::cout << it << " World\n";

همانطور که قبلاً اشاره شده است، متغیر تعریف شده در عبارت شرطی if در بلوک دیگری قابل مشاهده است. بنابراین شما می‌‌تواین به صورت زیر بنویسید:

if (const auto it = myString.find("World"); it != std::string::npos) 
 std::cout << it << " World\n"; 
else 
 std::cout << it << " not found!!\n";

به علاوه، شما می‌‌توانید آن را با پیوند ساختاری بر اساس کد نمونه از جانب (Herb Sutter) استفاده کنید:

// better together: structured bindings + if initializer 
if (auto [iter, succeeded] = mymap.insert(value); succeeded) { 
 use(iter); // ok 
 // ... 
} // iter and succeeded are destroyed here

جزئیات بیشتر در اسناد زیر آمده است:

سند P0305R1
ویدیو موجود در یوتیوب با عنوان (C++ Weekly - Ep 21 C++17’s if and switch Init Statements)
این مورد با کامپایلر‌های GCC 7.0،MSVC-2017.3 و Clang 3.9 سازگار است.

متغیرهای درون خطی (inline)
با شروع مقدار دهی داده‌های غیر استاتیک، اکنون می‌‌توانیم یک متغیر عضو را دی یک مکان اعلام کنیم. با این حال، با متغیر‌های استاتیک یا const static، معمولاً باید آن را در برخی از فایل‌های cpp تعریف کنید. در سی‌پلاس‌پلاس ۱۱ و کلید واژه constexpr که مارا قادر می‌سازد تا در یک مکان اعلان و تعریف متغیر‌های استاتیک را انجام دهیم، اما این امکان تنها به constexpr محدود می‌‌شود.

قبلاً فقط روشها/توابع می‌‌توانستند به عنوان inline تعریف شوند، حالا شما می‌‌توانید این کار را با متغیر ها در داخل فایل هدر انجام دهید. یک متغیر اعلام شده درون خطی معنای مشاهبی دارد بنابراین همانند یک تابع inline تعریف می‌‌شود. آن را می‌‌توان به واحد‌های ترجمه چند گانه نیز تعریف کرد. مثال‌‌های زیر را ببینید:

struct MyClass { 
 static const int sValue; 
}; 
inline int const MyClass::sValue = 777;

و حتی

struct MyClass { 
 inline static const int sValue = 777; 
};

همچنین توجه داشته باشید که متغیر‌های constexpr به طور ضمنی inline هستند، بنابراین نیازی به استفاده به صورت constepr inline myVar = 10; نمی‌‌باشد.

این ویژگی چرا کد را ساده تر می‌‌کند؟

برای مثال، تعداد زیادی از هدرها در کتابخانه تنها تعدادی از روش های (هک‌) را محدود می‌‌کنند (مانند استفاده توابع درون خطیinline و یا قالب ها) و در نهایت مزیت constexpr این است که مقدار دهی اولیه شما نباید constexpr باشد.

جزئیات بیشتر در رابطه با این ویژگی در سند زیر موجود است:

سند P0386R2

این مورد با کامپایلر‌های GCC 7.0 و Clang 3.9 سازگار است اما فعلاً با MSVC سازگاری ندارد.

ویژگی مربوط به constexpr if
ممکن است در بعضی جاها به قابلیت std::enable_if در سی‌پلاس‌پلاس ۱۴ نگاه کنید که آن به راحتی با constexpr if جایگزین می‌شود.

بنابراین، در اکثر موارد، ما اکنون می‌‌توانیم تنها با نوشتن عبارت یک constexpr if این کار را بهتر و تمیز تر انجام دهیم. این ویژگی برای برنامه نویسی metaprogramming/template بسیار مهم است که احتمالاً طبیعت آن بسیار پیچیده خواهد بود.

یک مثال ساده با تابع Fibonacci:

template<int N> 
constexpr int fibonacci() {
 return fibonacci<N-1>() + fibonacci<N-2>(); 
} 
template<>
constexpr int fibonacci<1>() { 
 return 1; 
} 
template<> 
constexpr int fibonacci<0>() { 
 return 0; 
}

حال می‌‌توان آن را تقریباً در یک حالت نرمال (نسخه بدون کامپایل) نوشت:

template<int N> 
constexpr int fibonacci() { 
 if constexpr (N>=2) 
 return fibonacci<N-1>() + fibonacci<N-2>(); 
 else 
 return N; 
}

در رویداد ۱۸ هم جلسات هفتگی سی‌پلاس‌پلاس در جیسون ترنر نمونه‌‌ای را می‌‌توان یافت که در آن عبارت constexpr if هیچ منطق اتصال کوتاهی را در زمان کامپایل انجام نمی‌‌‌دهد، بنابراین این کد باید کامپایل شود:

if constexpr (std::is_integral<T>::value && 
 std::numeric_limits<T>::min() < 10)
{ 
}

در کد فوق برای T شما در std::strin‌g خطایی کامپایل را دریافت خواهید کرد زیرا numeric_limits برای رشته ها تعریف نشده اند.

در جلسات C++NOW 2017 آقای Bryce Leblbach با عنوان جلسه خود C++17 Features در ۱۶ دقیقه مثال بسیار زیبایی را در رابطه باconstexpr if زد که می‌‌تواند برای تابع get استفاده شود که آن برای پیوند ساختاری مورد استفاده قرار می‌‌گیرد.

struct S { 
 int n; 
 std::string s;
 float d; 
}; 
template <std::size_t I> 
auto& get(S& s) { 
 if constexpr (I == 0) 
 return s.n; 
 else if constexpr (I == 1) 
 return s.s; 
 else if constexpr (I == 2) 
 return s.d; 
}

قبلاً ما باید به صورت زیر می‌‌نوشتیم:

template <> 
 auto& get<0>(S &s) { 
  return s.n; 
 } 
 template <> 
 auto& get<1>(S &s) { 
  return s.s; 
 } 
 template <> 
 auto& get<2>(S &s) { 
  return s.d;
 }

همانطور که می‌‌بینید، مشکل سوال برانگیز اینجاست که کد در این جا ساده تر است. اگر چه در این مورد فقط از یک ساختار ساده استفاده شده است، با برخی از نمونه های واقعی دنیا، کد نهایی باید بسیار پیچیده تر از این باشد بنابراین باید constexpr if کد تمیز تری نسبت به این مورد باشد.

این مورد با کامپایلر‌های GCC 7.0،MSVC-2017.3 و Clang 3.9 سازگار است.

ویژگی‌های دیگر
ما می‌‌توانیم در رابطه با بسیاری از ویژگی های جدید سی‌پلاس‌پلاس صحبت کنیم اما در این پست ما بیشتر در رابطه با قطعات بزرگتر تمرکز کرده‌‌ایم. با این حال، فقط برای یادآوری، ممکن است بخواهید ویژگی‌‌های زیر را در نظر بگیرید که آنها نیز کد ها را ساده تر می‌کنند:

الگو یا قالب‌ها‌ (templates)
عبارت Fold
الگو برای کلاس ها

بنابراین برای ذکر ویژگی‌‌های بیشتر در رابطه با نسخه جدید در پستهای آن ها را پوشش خواهیم داد. شک نکنید که، سی‌پلاس‌پلاس ۱۷ پیشرفت واقعی را در برابر کد های جمع و جور و آسان فراهم گرده است. یکی از بهترین چیزها constexpr است که آن به ما اجازه می‌دهد کد template/metaprogramming را به روش کد استاندارد شده بنویسیم. این یک مزیت بسیار بزرگی است.

ویژگی دوم: پیوند ساخت یافته (که حتی برای حلقه ها کار می‌‌کند) مانند حسی را القا می‌‌کند که در زبان‌های پویایی مثل Python وجود دارد.

همانطور که می‌‌بینید، تمام ویژگی‌های ذکر شده در حال حاضر در Clang، MSVC و GCC قابل اجرا هستند. اگر شما با نسخه‌های اخیر این کامپایلر ها کار می‌کنید می‌تواین بلافاصله با سی‌++ ۱۷ کار کرده و آن را تجربه کنید.

کامبیز اسدزاده · شهریور 99

جزئیات در ۱۱ ++C و برخی بهبود‌ها در ویرایش ۱۷

جدا کننده رقم ^{استاندارد ۱۱}

تا قبل از استاندارد ۱۴ شما مجبور بودید تعداد رقم‌ها و یا صفر‌ها را بشمارید. از استاندارد ۱۴ به بعد دیگر نیازی به این کار نیست. این کار در زمان محاسبهٔ آدرس در کلمه، مرز‌های رقمی یا نیم کاراکتر‌ها مفید خواهد بود. در واقع با گروه‌بندی ارقام کد شما رسا‌تر خواهد شد.

int no = 1'000'000;
long addr = 0xA000'EFFF;
uint32_t binary = 0b0001'0010'0111'1111;

تعریف نام مستعار (Type aliases) ^{استاندارد ۱۱}

از لحاظ معنایی مشابه typedef است، هرچند نام‌های مستعار تعریف شده به این شیوه ساده‌تر بوده و تحت انواع الگو‌ها سازگار‌تر هستند. به مثال‌های زیر توجه کنید:

template <typename T>
using dynamicArray = std::vector<T>;
dynamicArray<int> nums; // equivalent to std::vector<int>
using func_ptr = int (*)(int);

و یا اگر بخواهید نام مستعاری از یک نوع std::map با کلید و مقدار از نوع رشته تعریف کنید، آنگاه به صورت زیر خواهد بود:

using mapString  = std::map<std::string, std::string>;

این روش برای موارد متنوعی مورد استفاده قرار که قبل و بعد از وجود آن را در مثال زیر می‌بینیم:

// C++11
using counter = long;

// C++03 equivalent:
// typedef long counter;

// C++11
using fmtfl = std::ios_base::fmtflags;

// C++03 equivalent:
// typedef std::ios_base::fmtflags fmtfl;

fmtfl fl_orig = std::cout.flags();
fmtfl fl_hex = (fl_orig & ~std::cout.basefield) | std::cout.showbase | std::cout.hex;
// ...
std::cout.flags(fl_hex);

// C++11
using func = void(*)(int);

// C++03 equivalent:
// typedef void (*func)(int);

// func can be assigned to a function pointer value
void actual_function(int arg) { /* some code */ }
func fptr = &actual_function;

template<typename T> using ptr = T*;

// the name 'ptr<T>' is now an alias for pointer to T
ptr<int> ptr_int;

الفاظ رشته‌ای تعریف شده توسط کاربر (User-defined literals) ^{استاندارد ۱۱}

در مواقع نیاز شما مجبورید با اصطلاحات واضحی مثل MB, KB, GB یا km، cm و یا واحد‌های دیگری جهت تبدیلات در زمان اجرا کار‌ی انجام دهید. اکنون به عنوان کاربر می‌توانید اصلاح مورد نیاز خود را همانند انواع pt (انواع ابتدائی) دیگر انجام دهید.
این شیوه برای واحد‌ها و اندازه‌گیری بسیار مناسب است.
اضافه کردن constexpr اثر هزینهٔ صفر از کارایی را در زمان اجرا فراهم می‌کند.

using ull = unsigned long long;

constexpr ull operator"" _KB(ull no)
{
    return no * 1024;
}
constexpr ull operator"" _MB(ull no)
{
    return no * (1024_KB);
}

int main()
{
  
  std::cout << 1_KB << std::endl;
  std::cout << 1_MB << std::endl;
  
  return 0;
}

ویژگی مقداردهی لیست اولیه (std::initializer_list) ^{استاندارد ۱۱}

std::pair<int, int> p = {1, 2};
std::tuple<int, int> t = {1, 2};
std::vector<int> v = {1, 2, 3, 4, 5};
std::set<int> s = {1, 2, 3, 4, 5};
std::list<int> l = {1, 2, 3, 4, 5};
std::deque<int> d = {1, 2, 3, 4, 5};
std::array<int, 5> a = {1, 2, 3, 4, 5};

این شیوه مشابه آرایه‌ها به سبک C مقادیر را مستقیماً با لیست مقدار دهندهٔ اولیه «std::initializer_list» اختصاص می‌دهد. همچنین به لطف استاندارد ۱۱ این مورد در مورد نگه‌دارنده‌های تو در تو هم صدق می‌کند.

ویژگی auto و decltype ^{استاندارد ۱۱، بهبود و اضافات در استاندارد ۲۰}

متغیر‌های تعریف شده به وسیلهٔ کلمهٔ کلیدی auto بر اساس نوع مقدار توسط کامپایلر استنباط می‌شوند.
متغیر‌های تعرف شده به کمک کلمهٔ کلیدی decltype بر اساس بررسی موجودیت یا نوع و مقادیر عبارت تعیین می‌شوند.
این ویژگی‌ها به شدت برای خواندن، به ویژه انواع پیچیده مفید است.

auto a = 3.14; // double

اجازه دهید یک مثال با ترکیب auto و decltype داشته باشیم.

به عنوان مثال، توابع می‌توانند به وسیلهٔ کلمهٔ کلیدی auto نیز نوع بازگشتی خود را استنباط کنند. در استاندارد ۱۱ نوع بازگشتی باید به طور صریح یا با استفاده از نوع decltype رمزگشایی شود، به مثال‌های عادی و الگو (template) مانند زیر توجه کنید:

auto getResult(std::string var) -> decltype (var) {
  return var;
}

template <typename X, typename Y>
auto add(X x, Y y) -> decltype(x + y)
{
    return x + y;
}
add(1, 2);     // == 3
add(1, 2.0);   // == 3.0
add(1.5, 1.5); // == 3.0

ویژگی Range-based for-loops ^{استاندارد ۱۱ به علاوهٔ اضافات و بهبود‌ها در استاندارد ۱۷ و ۲۰}

یک نحوِ شیرین برای تکرار عناصر در یک نگه‌دارنده یا ظرف (container)

std::vector<int> v = {0, 1, 2, 3, 4, 5};
for (const int& i : v) // access by const reference
  std::cout << i << ' ';
  std::cout << '\n';

برای بررسی برخی از ویژگی‌های مرتبط با این موضوع به مقالات زیر مراجعه کنید:

اشاره‌گر‌های هوشمند ^{استاندارد ۱۱، بهبود‌ها در استاندارد ۱۷}

استاندارد ۱۱ با خود اشاره‌گر‌های هوشمند را معرفی کرده است مانند std::unique_ptr، std::shared_ptr و std::weak_ptr که سپس std::auto_ptr در استاندارد ۱۷ به عنوان منسوخ شده معرفی و حذف شده است.

std::unique_ptr<int> p = std::make_unique<int>(128);

برای آشنایی با این ویژگی، لازم است در رابطه با اصطلاح RAII آشنا شوید، برای این منظور مقالهٔ زیر را برای مطالعه پیشنهاد می‌کنم.

صفت‌های استاندارد جدید مانند، [[fallthrough]]، [[maybe_unused]] و [[nodiscard]]^{استاندارد ۱۷}

این بحث به خودی خود بسیار جذاب است، بنابراین برای آن یک مقالهٔ ویژه در نظر گرفته‌ام که در ادامه می‌توانید به آن مراجعه کنید.

ویژگی فضاهای نام تو در تو (Nested namespace)^{استاندارد ۱۷}

فضاهای نام یکی از کاربردی‌ترین ویژگی‌های سی++ از زمان استاندارد ۱۱ به بعد می‌باشد که نحوهٔ تعریف آن به صورت زیر است:

namespace Base {
  namespace Person {
    class PersonInfo {
    public:
      std::string name = {"Kambiz"};
    };
  }
}

در ادامهٔ استاندارد ۱۷ بهبود آن به شیوهٔ تو در تو صورت گرفته است و می‌تواند به صورت زیر تعریف شود:

namespace Base::Person {
    class PersonInfo {
    public:
      std::string name = {"Kambiz"};
    };
}

در نهایت دسترسی به فضای نام و اعضای آن به همان شیوهٔ ساده ممکن است:

Base::Person::PersonInfo pInfo;
  std::cout << pInfo.name << std::endl;

یک کاراکتر u8 لفظی^{استاندارد ۱۷}

این ویژگی برای ترجمهٔ صحیح کاراکتر‌ها به اسکی (ASCII) در پلتفرم‌های مختلف استفاده می‌شود.

auto c = {u8'C'};

و یا به صورت یک رشتهٔ کامل:

auto str = u8"سلام";
  std::cout << str << "/n";

امکان استفاده از auto در template ^{استاندارد ۱۷}

این ویژگی امکان این را می‌دهد تا نوع پارامتر‌ها را در الگو‌ها تعریف کنیم، در استاندارد ۱۴ این ویژگی به صورت زیر ممکن است:

template<typename Type, Type x> constexpr auto value = x;
int main()
{   
   auto x = value<int,3>;
   return 0;
}

و اینک به لطف استاندارد ۱۷ استفاده از کلمهٔ کلیدی auto نیز فراهم شده است که به طور زیر تعریف می‌شود:

template<auto x> constexpr auto value = x;
 
int main()
{   
   auto x = value<3>;
 
   return 0;
}

نوع متغیر x توسط کامپایلر استنباط می‌شود، البته باید در نظر داشت این ویژگی در استفاده از variadic templates هم کاربرد دارد. به مثال زیر توجه کنید:

template<auto ... values> struct A {};
 
int main()
{   
   auto k = A<1, 2, 'c'>();
   return 0;
}

الفاظ رشته‌ای (لیترال) با ممیز شناور‌ (Floating point) در مبنای هگزادسیمال^{استاندارد ۱۷}

در استاندارد ۱۷ ممیز شناور در مبنای هگزادسیمال اضافه شده است. اگر یک حرف شناور لفظی، آغازش با دنبالهٔ کاراکتر‌های 0x یا 0X باشد، آن در مبنای هگزا دسیمال شناور محسوب می‌شود. در غیر این صورت در مبنای شناور دسیمال (مبنای ۱۰) تعریف می‌شود.

0x | 0X hex-digit-sequence exponent suffix

double d = 0x1.2p3; // hex fraction 1.2 (decimal 1.125) scaled by 2^3, that is 9.0

به مثال زیر توجه کنید:

#include <iostream>
int main()
{
  std::cout << 58.         << '\n'
            << 4e2         << '\n'
            << 123.456e-67 << '\n'
            << .1E4f       << '\n'
            << 0x10.1p0    << '\n';
}

نتیجهٔ تحت این ویژگی به این صورت است:

58
400
1.23456e-65
1000
16.0625

کامبیز اسدزاده · فروردین 2

جزئیات، به‌روز رسانی‌ها و ویژگی‌های C++20

معرفی و نمونه کد‌های کلاس std::span

کلاس std::span یک کلاس در C++20 است که برای نشان دادن (نمایش ظاهری) یک محدوده دنباله‌ای از اشیاء پیوسته بکار می‌رود. الگوی کلاس span یک شیء را توصیف می‌کند که می‌تواند به یک دنباله متوالی از اشیاء با اولین عنصر دنباله در موقعیت صفر ارجاع دهد. یک span می‌تواند دارای دامنه‌ی استاتیک باشد، در این صورت تعداد عناصر در دنباله در زمان کامپایل مشخص است و در نوع خودشان رمزگذاری شده‌اند و یا دامنه‌ی داینامیک دارد. اگر یک span دارای دامنه‌ٔ داینامیک باشد، به طور معمول، پیاده‌سازی آن شامل دو عضو است: یک اشاره‌گر به T و یک اندازه است. یک span با دامنه‌ٔ استاتیک ممکن است فقط یک عضو داشته باشد: یک اشاره‌گر به T.

template<
    class T,
    std::size_t Extent = std::dynamic_extent
> class span;

برای استفاده از کلاس std::span، باید ابتدا کتابخانه <span> را به کدتان اضافه کنید. سپس برای ایجاد یک شیء از این کلاس، می‌توانید از یک اشاره‌گر به شروع دنباله و طول آن استفاده کنید. برای مثال:

#include <span>
#include <iostream>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    std::span<int> mySpan(arr, 5);
    
    for (int i : mySpan) {
        std::cout << i << " ";
    }
    
    return 0;
}

در این مثال، یک آرایه از نوع int با ۵ عضو تعریف شده و سپس یک شیء از کلاس std::span با استفاده از این آرایه و طول آن ایجاد می‌شود. سپس با استفاده از حلقه for، اعضای دنباله در خروجی چاپ می‌شوند.

استفاده از std::span می‌تواند در کدهایی که بر روی داده‌های چند بعدی یا برای داده‌هایی که آن‌ها نمی‌توانند با طول ثابت در داخل یک آرایه شبیه‌سازی شوند، مفید باشد. همچنین، با استفاده از std::span می‌توان با مراجعه به همه اعضای یک آرایه به صورت پویا از زمان اجرا، از یک پیاده‌سازی معمولی با تراکم حافظه کمتر استفاده کرد. همچنین استفاده از std::span برای پشتیبانی از روش‌های پیشرفته‌تر و بازبینی کدها مفید است.

اینجا یک نمونه از استفاده از std::span در یک کد C++20 آورده شده است:

#include <iostream>
#include <span>

int main() {
    int arr[] = {1, 2, 3, 4, 5};

    std::span<int, 5> s(arr); // s refers to the whole array

    for (auto& elem : s) { // range-based for loop
        std::cout << elem << ' ';
    }
    std::cout << '\n';
    
    std::span<int, 3> s2(arr + 1, 3); // s2 refers to {2, 3, 4}

    for (auto& elem : s2) {
        std::cout << elem << ' ';
    }
    std::cout << '\n';
}

در این کد، یک آرایه از 5 عدد تعریف شده است. سپس با استفاده از std::span، دو نمونه برای این آرایه تعریف شده است. پس از آن ، با استفاده از حلقه for ، مقادیر در هر دو نمونه std::span به ترتیب چاپ شده و تفاوت بین آن‌ها نیز نشان داده شده است.

برخی از مزایای این کلاس به صورت زیر است:

کد مطمئن‌تر: به دلیل استفاده از نمای مناسبی از ارث‌بری، این کلاس امکان بازنویسی کد و تجدید نظر در طراحی را فراهم می‌کند.
کاربردهای متعدد: توانایی نشان دادن داده‌های پیوسته با هر نوع، دنباله‌های داخلی و خارجی، بردارها، ماتریس‌ها و موارد دیگر، std::span را به یک وسیله کارآمد در برنامه‌نویسی ترکیب‌شدها و هم‌زمان‌سازی داده‌ها تبدیل کرده است.
عملکرد بهتر: به دلیل این که std::span یک کلاس ساده به همراه تعریف مجددی از iterator (https://en.cppreference.com/w/cpp/iterator) هاست، عملیاتی مانند خواندن، نوشتن و مرتب سازی داده‌ها، بسیار سریعتر از زیربرنامه‌های برنامه سازی بهینه شده است.
پشتیبانی از تشخیص خطا: با استفاده از std::span، می‌توان یک شیء معتبری ایجاد کرد که در آن تغییرات اندیس باید در محدوده معتبر واقع شود که باعث بهبود تشخیص خطا در کد می‌شود.

اینجا یک نمونه کد ورودی با std::span برای محاسبه میانگین اعداد یک محدوده از داده هاست که توضیحات کد نیز در کد ذکر شده است:

#include <iostream>
#include <span>
#include <algorithm>

double average(std::span<int> ns)
{
    if (ns.empty())
        throw std::invalid_argument("empty span");
    if (ns.size() > static_cast<size_t>(std::numeric_limits<int>::max()))
        throw std::invalid_argument("span size exceeds int max");
    if (std::any_of(ns.begin(), ns.end(), [](const int& n) { return n < 0; }))
        throw std::invalid_argument("span contains negative values");
    return static_cast<double>(std::accumulate(ns.begin(), ns.end(), 0)) / ns.size();
}

int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    std::span<int> span_arr(arr, 5);
    try {
        std::cout << average(span_arr) << '\n';
    } catch(const std::exception& ex) {
        std::cerr << "Error: " << ex.what() << '\n';
    }
    return 0;
}

در کد زیر، یک std::span از یک آرایه از اعداد پشت سر هم ایجاد شده است و سپس به عنوان ورودی به تابع calculate_mean() منتقل شده است. تابع calculate_mean() به صورت یک حلقه که به ازای عنصری که به عنوان ورودی دریافت می کند، محدوده داده ها را پیمایش می کند و میانگین اعداد را محاسبه می کند. با استفاده این تابع و تعریف یک آرایه از اعداد، برنامه قادر است میانگین اعداد را محاسبه کند.

#include <iostream>
#include <span>

double calculate_mean(std::span<double> nums)
{
    double sum = 0.0;
    for (auto num : nums) {
        sum += num;
    }
    return sum / static_cast<double>(nums.size());
}

int main()
{
    double nums[] = {2.0, 3.0, 5.0, 7.0, 11.0, 13.0};
    std::span<double> nums_span(nums, std::size(nums));
    double mean = calculate_mean(nums_span);
    std::cout << "mean = " << mean << std::endl;

    return 0;
}

کاربرد std::span در ورودی توابع

یکی از استفاده های مهم std::span ، به عنوان ورودی تابع است. با استفاده از std::span به عنوان ورودی، می توان به سادگی یک محدوده از داده ها را به یک تابع انتقال داد و از انتقال داده های اضافی و همچنین رعایت روشن بودن کد استفاده کرد.

با استفاده از std::span به عنوان ورودی تابع، عملیات از هر نوع می تواند مستقل از نوع داده های کانتینر باشد و به همین دلیل کد تمیز تر و بیشتر چند منظوره خواهد بود.

#include <iostream>
#include <span>

double calculateAverage(std::span<double> nums) {
    double sum = 0;
    for (auto num : nums) {
        sum += num;
    }
    return (nums.size() > 0) ? sum / nums.size() : 0;
}

int main() {
    double data[] = {2.5, 3.8, 4.2, 1.7, 6.5};
    double average = calculateAverage(data);

    std::cout << "Average: " << average << std::endl;

    return 0;
}

در این کد، تابع calculateAverage یک std::span از نوع double به عنوان ورودی دریافت می کند و با استفاده از آن، میانگین عناصر را محاسبه می کند. سپس در تابع main یک آرایه از اعداد اولیه تعریف شده است که به عنوان ورودی به تابع calculateAverage ارسال می شود و سپس میانگین محاسبه شده چاپ می شود.

استفاده از std::span به خصوص زمانی مناسب است که به دنبال ارسال یک محدوده از داده ها به تابع هستیم، بدون آنکه نیاز به کپی کردن داده ها باشد. در این حالت، استفاده از std::span به جای استفاده از نشانگر به عنوان ورودی تابع، توصیه می شود. با استفاده از std::span، می توان محدوده ای از داده ها را مستقیماً به تابع انتقال داد و از کپی نشانگر آندونه و داده های مربوط به آن جلوگیری کرد و در عین حال، کد را شفاف تر و آسان تر قابل فهم نیز می کند.

کاربرد std::span در کلاس‌ها

استفاده از std::span در کلاس ها، می تواند در طراحی کلاس هایی که بر روی داده هایی فیکس‌شده کار می کنند، مفید باشد. این کار به تشخیص و جلوگیری از خطرات مربوط به ارجاع به اشاره یا نشانگر اشاره که به محدوده ای خارج از داده های کلاس مستقر شده اند، کمک می کند.

#include <span>

class DataProcessor {
private:
  std::span<const int> data;
public:
  explicit DataProcessor(std::span<const int> d) : data(d) {}
  double calculateMean() const {
    double sum = 0.0;
    for (auto num : data) {
      sum += num;
    }
    return sum / static_cast<double>(data.size());
  }
};

همچنین، می‌توان با تعریف تابع‌هایی که با std::span کار می کنند، از صرفه جویی در حجم کدها خود لذت برد.

اینجا یک نمونه کد با استفاده از std::span در طراحی یک کلاس برای مدیریت یک آرایه با سایز ثابت است:

#include <array>
#include <span>

template <typename T, std::size_t N>
class FixedArray {
public:
    FixedArray(std::array<T, N>& arr) : data(arr), memory(data) { }

    std::span<T, N> memory;

private:
    std::array<T, N>& data;
};

در این کد، FixedArray یک کلاس است که یک آرایه با سایز ثابت را مدیریت می‌کند. با استفاده از std::span، ما می‌توانیم برای نگهداری داده‌ها از حافظه‌ای استفاده کنیم که قبل تر allocated شده است (در اینجا داده‌ها از آرایه data استخراج شده و به صورت پویایی در memory نگهداری می‌شوند). به این ترتیب، ما از خطرات ارجاع به اشاره به محدوده‌های خارج از داده ها به دلیل دستکاری در آرایه، محافظت می‌کنیم.

کامبیز اسدزاده · بهمن 2

جزئیات، به‌روز رسانی‌ها و ویژگی‌های C++23

همانطور که می دانیم، مدیریت خطا در سی‌پلاس‌پلاس به وسیلهٔ بیانیه‌های try، catch و throw انجام می‌شود. این ویژگی به برنامه‌نویس این امکان را می‌دهد که خطاها را شناسایی کرده و به دسته‌بندی کرده و سپس به شکل مناسبی برخورد کند.

همچنین کلاس‌هایی مانند std::exception یک کلاس پایه در سی‌پلاس‌پلاس است که برای نمایش استثناء‌ها (خطاها) در هنگام اجرای برنامه استفاده می‌شود. این کلاس یک رابط عمومی به نام what دارد که متنی که توضیح خطا را حاوی می‌شود، به عنوان یک رشته C-style (const char*) باز می‌گرداند.

مدیریت خطای جدید std::expected معرفی شده در استاندارد ۲۳

در استاندارد جدید ۲۳ گزینهٔ std::expected معرفی شده‌است که اجازه می‌دهد خطاها را بهتر مدیریت کنیم.

این نوع داده به شما این امکان را می‌دهد که یک عدد بازگشتی معمولی (نتیجه موفقیت‌آمیز) یا یک کد خطا (نتیجه ناموفق) را با هم در یک متغیر ذخیره کنید.
برای برنامه نویسانی که از این نوع داده استفاده می‌کنند، کد برنامه خواناتر و قابل‌فهم‌تر است.
استفاده از std::expected معمولاً در جاهایی مناسب است که خطاها قابل پیش‌بینی و مدیریت شوند.

در زیر یک نمونه کد در قالب مثال بر پایهٔ سی‌پلاس‌پلاس جدید آورده شده است:

import <print>;
import <expected>;

enum class ErrorType { InvalidName, NotFound, OtherError };

auto getName(std::string name) -> std::expected<std::string, ErrorType>
{
    if (name != "Kambiz") {
        return std::unexpected(ErrorType::InvalidName);
    }
    return name;
}

auto main() -> int {

    auto result = getName("Compez");

    if (result.has_value()) {
        std::println("Result: {}", result.value());
    } else {
        ErrorType error = result.error();
        switch (error) {
        case ErrorType::InvalidName:
            std::println("Error: Invalid Name!");
            break;
        case ErrorType::NotFound:
            std::println("Error: Not Found!");
            break;
        case ErrorType::OtherError:
            std::println("Error: Other Error!");
            break;
        }
    }

    return 0;
}

در اینجا، یک تابع به نام getName تعریف شده است که یک نام به عنوان ورودی دریافت می‌کند و یک std::expected را باز می‌گرداند. اگر نام "Kambiz" نباشد، یک std::unexpected با ErrorType::InvalidName ایجاد می‌شود و اگر نام معتبر باشد، خود نام به عنوان مقدار بازگشتی استفاده می‌شود.

سپس در تابع main، ما از تابع getName برای دریافت نتیجه استفاده می‌کنیم. اگر نتیجه دارای مقدار باشد (با فراخوانیhas_value())، آن مقدار با استفاده از value() چاپ می‌شود. اگر نتیجه دارای خطا باشد، ما با استفاده از error() نوع خطا را دریافت کرده و با استفاده از یک switch به تصمیمات مرتبط با نوع خطا می‌رسیم و پیام مناسب چاپ می‌شود. توجه داشته باشید که در دسترسی بهerror()، ممکن است بعضی از پیاده‌سازی‌های expected به جای error() از value() برای دسترسی به خطا استفاده کنند.

به نظر می‌رسد این ویژگی می‌تواند به صورت چشم‌گیری روش مدیریت خطاها را بهبود سازد.

ماژول‌ها و وارد کردن کتابخانه‌های استاندارد به پروژه به صورت ساده و بهینه توسطimport std; و import std.compat; در استاندارد ۲۳

قبلاً من توی پروژهٔ سل و حتی قالب PT یه بخشی برای بهبود و بهینه‌سازی فایل‌های کتابخانهٔ استاندارد (هدر فایل‌ها) به عنوان pch گذاشته بودم. این کار باعث می‌شد که پروژه در سرتاسرش هر جا اس کتابخانهٔ STL استفاده می‌شد رو نیازی به وارد کردن فایل‌ها نباشه. این کار موجب بهینگی کامپایل می‌شه. حالا توی استاندارد ۲۳ چیزی مشابه این موضوع رو به صورت استاندارد شده تعبیه کردن که از شلوغی و اضافات لازم به شدت جلو گیری می‌کنه و سرعت کامپایل هم افزایش پیدا می‌کنه. ️

بهتر بخوام توضیح بدم دیگه نیازی نیست کدی مثل زیر داشته باشید:

#include <algorithm>
#include <array>
#include <print>

auto main() -> int
{
    std::array<int, 10> s {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    std::sort(s.begin(), s.end());
    for(auto el : s)
    {
        std::println("Sorted Index: {}", el);
    }
}

کافیه به شیوهٔ زیر بنویسید:

import std;

auto main() -> int
{
    std::array<int, 10> s {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    std::sort(s.begin(), s.end());
    for(auto el : s)
    {
        std::println("Sorted Index: {}", el);
    }
}

در واقع استفاده از ;import std تمامی کتابخانه‌های استاندارد رو وارد می‌کنه و استفاده از ;import std.compat مثل همون هست اما با تفاوت این ‌که کتابخانه‌های عمومی C رو هم وارد خواهد کرد. فکرشو بکن ده‌ها و صد‌ها کتابخانه STL رو وارد فایل‌ها می‌کنی! اما الآن کافیه همین یه خط رو بنویسی دنیای ماژول‌ها در سی‌پلاس‌پلاس جدید خیلی تمیزه!

ویرایش شده در بهمن 2 توسط کامبیز اسدزاده
به‌روز رسانی استاندارد ۲۳.

ورود

سی‌پلاس‌پلاس مدرن قابلیت‌های ممتاز و پیشرفتهٔ ++C در استاندارد‌های جدید

پست های پیشنهاد شده

کامبیز اسدزاده 618

به اشتراک گذاری این ارسال

لینک به ارسال

به اشتراک گذاری در سایت های دیگر

کامبیز اسدزاده 618

به اشتراک گذاری این ارسال

لینک به ارسال

به اشتراک گذاری در سایت های دیگر

کامبیز اسدزاده 618

جدا کننده رقم استاندارد ۱۱

تعریف نام مستعار (Type aliases) استاندارد ۱۱

الفاظ رشته‌ای تعریف شده توسط کاربر (User-defined literals) استاندارد ۱۱

ویژگی مقداردهی لیست اولیه (std::initializer_list) استاندارد ۱۱

ویژگی auto و decltype استاندارد ۱۱، بهبود و اضافات در استاندارد ۲۰

ویژگی Range-based for-loops استاندارد ۱۱ به علاوهٔ اضافات و بهبود‌ها در استاندارد ۱۷ و ۲۰

اشاره‌گر‌های هوشمند استاندارد ۱۱، بهبود‌ها در استاندارد ۱۷

صفت‌های استاندارد جدید مانند، [[fallthrough]]، [[maybe_unused]] و [[nodiscard]] استاندارد ۱۷

ویژگی فضاهای نام تو در تو (Nested namespace) استاندارد ۱۷

یک کاراکتر u8 لفظی استاندارد ۱۷

امکان استفاده از auto در template استاندارد ۱۷

الفاظ رشته‌ای (لیترال) با ممیز شناور‌ (Floating point) در مبنای هگزادسیمال استاندارد ۱۷

به اشتراک گذاری این ارسال

لینک به ارسال

به اشتراک گذاری در سایت های دیگر

کامبیز اسدزاده 618

جزئیات، به‌روز رسانی‌ها و ویژگی‌های C++20

برخی از مزایای این کلاس به صورت زیر است:

کاربرد std::span در ورودی توابع

کاربرد std::span در کلاس‌ها

به اشتراک گذاری این ارسال

لینک به ارسال

به اشتراک گذاری در سایت های دیگر

کامبیز اسدزاده 618

جزئیات، به‌روز رسانی‌ها و ویژگی‌های C++23

مدیریت خطای جدید std::expected معرفی شده در استاندارد ۲۳

به اشتراک گذاری این ارسال

لینک به ارسال

به اشتراک گذاری در سایت های دیگر

کاربران آنلاین در این صفحه 0 کاربر

فهرست بخش ها

تالارهای گفتگو

بخش دریافت

وبلاگ ها

فعالیت ها

پشتیبانی

اطلاعات مهم

جدا کننده رقم ^{استاندارد ۱۱}

تعریف نام مستعار (Type aliases) ^{استاندارد ۱۱}

الفاظ رشته‌ای تعریف شده توسط کاربر (User-defined literals) ^{استاندارد ۱۱}

ویژگی مقداردهی لیست اولیه (std::initializer_list) ^{استاندارد ۱۱}

ویژگی auto و decltype ^{استاندارد ۱۱، بهبود و اضافات در استاندارد ۲۰}

ویژگی Range-based for-loops ^{استاندارد ۱۱ به علاوهٔ اضافات و بهبود‌ها در استاندارد ۱۷ و ۲۰}

اشاره‌گر‌های هوشمند ^{استاندارد ۱۱، بهبود‌ها در استاندارد ۱۷}

صفت‌های استاندارد جدید مانند، [[fallthrough]]، [[maybe_unused]] و [[nodiscard]]^{استاندارد ۱۷}

ویژگی فضاهای نام تو در تو (Nested namespace)^{استاندارد ۱۷}

یک کاراکتر u8 لفظی^{استاندارد ۱۷}

امکان استفاده از auto در template ^{استاندارد ۱۷}

الفاظ رشته‌ای (لیترال) با ممیز شناور‌ (Floating point) در مبنای هگزادسیمال^{استاندارد ۱۷}