كيفية جعل SFINAE أنيق وموثوق

مرحبا مرة اخرى إننا نشاركك مقالة مثيرة للاهتمام ، تم إعداد ترجمة لها خصيصًا لطلاب الدورة التدريبية "C ++ Developer" .

---

اليوم لدينا منشور ضيف من قبل MADdám Balázs. آدم هو مهندس برمجيات في Verizon Smart Communities Hungary ويطور تحليلات الفيديو للأنظمة المدمجة. أحد شغفه هو تحسين وقت التجميع ، لذلك وافق على الفور على كتابة منشور ضيف حول هذا الموضوع. يمكنك أن تجد آدم على الإنترنت على LinkedIn .

في سلسلة من المقالات حول كيفية جعل SFINAE أنيقة ، شاهدنا كيفية جعل قالب SFINAE خاص بنا موجزا ومعبرا.

مجرد إلقاء نظرة على شكله الأصلي:

template<typename T> class MyClass { public: void MyClass(T const& x){} template<typename T_ = T> void f(T&& x, typename std::enable_if<!std::is_reference<T_>::value, std::nullptr_t>::type = nullptr){} }; 

ومقارنتها مع هذا الشكل الأكثر تعبيرا:

 template<typename T> using IsNotReference = std::enable_if_t<!std::is_reference_v<T>>; template<typename T> class MyClass { public: void f(T const& x){} template<typename T_ = T, typename = IsNotReference <T_>> void f(T&& x){} }; 

يمكننا أن نعتقد بشكل معقول أنه من الممكن بالفعل الاسترخاء والبدء في استخدامه في الإنتاج. يمكننا ذلك ، إنه يعمل في معظم الحالات ، لكن - كما نتحدث عن الواجهات - يجب أن يكون كودنا آمنًا وموثوقًا به. هل هذا صحيح؟ دعونا نحاول اختراقه!

العيب رقم 1: يمكن تجاوز SFINAE

عادة ، يتم استخدام SFINAE لتعطيل جزء من الكود حسب الحالة. يمكن أن يكون هذا مفيدًا للغاية إذا احتجنا إلى تنفيذ ، على سبيل المثال ، وظيفة abs المعرفة من قبل المستخدم لسبب ما (فئة الحساب المعرفة من قبل المستخدم ، والتحسين لمعدات معينة ، لأغراض التدريب ، وما إلى ذلك):

 template< typename T > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } int main() { int a{ std::numeric_limits< int >::max() }; std::cout << "a: " << a << " myAbs( a ): " << myAbs( a ) << std::endl; } 

يعرض هذا البرنامج ما يلي ، والذي يبدو طبيعياً تمامًا:

 a: 2147483647 myAbs( a ): 2147483647 

ولكن يمكننا استدعاء دالة abs بنا باستخدام الوسائط غير الموقعة T ، وسيكون التأثير كارثيًا:

 nt main() { unsigned int a{ std::numeric_limits< unsigned int >::max() }; std::cout << "a: " << a << " myAbs( a ): " << myAbs( a ) << std::endl; } 

في الواقع ، يعرض البرنامج الآن:

a: 4294967295 myAbs( a ): 1

لم يتم تصميم وظيفتنا للعمل مع الوسائط غير الموقعة ، لذلك يجب علينا تقييد المجموعة المحتملة من T مع SFINAE:

 template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T > >; template< typename T, typename = IsSigned< T > > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } 

يعمل الرمز كما هو متوقع: يؤدي استدعاء myAbs بنوع غير موقّع إلى حدوث خطأ وقت الترجمة:

candidate template ignored: requirement 'std::is_signed_v< unsigned int>' was not satisfied [with T = unsigned int]

القرصنة SFINAE الدولة

ثم ما هو الخطأ في هذه الوظيفة؟ للإجابة على هذا السؤال ، نحتاج إلى التحقق من كيفية قيام myAbs بتنفيذ SFINAE.

 template< typename T, typename = IsSigned<T> > T myAbs( T val ); 

myAbs هو قالب وظيفة مع نوعين من معلمات قالب الإدخال. الأول هو النوع الفعلي للوسيطة الدالة ، والثاني هو IsSigned < T > الافتراضي (وإلا std::enable_if_t < std::is_signed_v < T > > أو std::enable_if < std::is_signed_v < T>, void>::type ، وهو بديل void أو فاشل).

كيف يمكن أن نسمي myAbs ؟ هناك 3 طرق:

 int a{ myAbs( -5 ) }; int b{ myAbs< int >( -5 ) }; int c{ myAbs< int, void >( -5 ) }; 

المكالمات الأولى والثانية واضحة ومباشرة ، ولكن الثالثة مثيرة للاهتمام: ما هي حجة القالب void ؟

معلمة القالب الثاني هي مجهولة ، ولها نوع افتراضي ، لكنها لا تزال معلمة قالب ، لذلك يمكنك تحديدها بشكل صريح. هل هذه مشكلة؟ في هذه الحالة ، هذه مشكلة كبيرة حقًا. يمكننا استخدام النموذج الثالث للتجول في سيفينا

 unsigned int d{ myAbs< unsigned int, void >( 5u ) }; unsigned int e{ myAbs< unsigned int, void >( std::numeric_limits< unsigned int >::max() ) }; 

يجمع هذا الرمز بشكل جيد ، ولكنه يؤدي إلى نتائج كارثية ، لتجنب ما استخدمناه SFINAE:

 a: 4294967295 myAbs( a ): 1 

سنحل هذه المشكلة - لكن أولاً: هل هناك أي عيوب أخرى؟ حسنا ...

العيب رقم 2: لا يمكننا تنفيذ تطبيقات محددة

الاستخدام الشائع الآخر لـ SFINAE هو توفير تطبيقات محددة لظروف وقت الترجمة المحددة. ماذا لو كنا لا نريد حظر دعوة myAbs بقيم myAbs وتقديم تطبيق تافه لهذه الحالات؟ يمكننا استخدام if constexpr في C ++ 17 (سنناقش هذا لاحقًا) ، أو يمكننا:

  template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T > >; template< typename T > using IsUnsigned = std::enable_if_t< std::is_unsigned_v< T > >; template< typename T, typename = IsSigned< T > > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } template< typename T, typename = IsUnsigned< T > > T myAbs( T val ) { return val; } 

لكن ما هذا؟

 error: template parameter redefines default argument template< typename T, typename = IsUnsigned< T > > note: previous default template argument defined here template< typename T, typename = IsSigned< T > > 

أوه ، ينص معيار C ++ (C ++ 17 ؛ § 17.1.16) على ما يلي :

"لا ينبغي تقديم الوسائط الافتراضية لمعلمة القالب بواسطة إعلانين مختلفين في نفس النطاق."

عفوًا ، هذا بالضبط ما فعلناه ...

لماذا لا تستخدم العادية إذا؟

يمكن أن نستخدمها فقط في وقت التشغيل:

 template< typename T > T myAbs( T val ) { if( std::is_signed_v< T > ) { return ( ( val <= -1 ) ? -val : val ); } else { return val; } } 

سيقوم المحول البرمجي بتحسين الشرط لأنه if (std::is_signed_v < T>) if (true) أو if (false) بعد إنشاء القالب. نعم ، مع تطبيقنا الحالي ل myAbs هذا سوف ينجح. لكن بشكل عام ، يفرض هذا قيودًا هائلة: يجب أن تكون else if و else صالحة لكل T ماذا لو قمنا بتغيير تطبيقنا قليلاً:

 template< typename T > T myAbs( T val ) { if( std::is_signed_v< T > ) { return std::abs( val ); } else { return val; } } int main() { unsigned int a{ myAbs( 5u ) }; } 

سوف يتعطل كودنا على الفور:

 error: call of overloaded 'abs(unsigned int&)' is ambiguous 

هذا التقييد هو ما يحذفه SFINAE: يمكننا كتابة رمز صالح فقط لمجموعة فرعية من T (في myAbs ، يكون صالحًا للأنواع غير الموقعة فقط أو صالحًا للأنواع الموقعة فقط).

الحل: نموذج آخر لـ SFINAE

ماذا يمكننا أن نفعل للتغلب على هذه العيوب؟ بالنسبة للمشكلة الأولى ، يجب علينا فرض اختبار SFINAE الخاص بنا بغض النظر عن كيفية استدعاء المستخدمين لوظائفنا. حاليًا ، يمكن التحايل على اختبارنا عندما لا يحتاج المترجم إلى النوع الافتراضي لمعلمة القالب الثاني.

ماذا لو استخدمنا كود SFINAE للإعلان عن نوع معلمة قالب بدلاً من تقديم نوع افتراضي؟ لنجرب:

 template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T >, bool >; template< typename T, IsSigned< T > = true > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } int main() { //int a{ myAbs( 5u ) }; int b{ myAbs< int >( 5u ) }; //int c{ myAbs< unsigned int, true >( 5u ) }; } 

نحتاج إلى أن يكون IsSigned نوعًا آخر غير الفراغ في الحالات الصحيحة ، لأننا نريد تقديم قيمة افتراضية لهذا النوع. لا توجد قيمة للنوع الفارغ ، لذلك يجب علينا استخدام شيء آخر: bool ، int ، enum ، nullptr_t ، إلخ. عادةً ما أستخدم bool - في هذه الحالة ، تبدو التعبيرات ذات معنى:

 template< typename T, IsSigned< T > = true > 

إنه يعمل! بالنسبة إلى myAbs (5u) يلقي المترجم خطأ ، كما كان من قبل:

 candidate template ignored: requirement 'std::is_signed_v<unsigned int>' was not satisfied [with T = unsigned int 

المكالمة الثانية ، myAbs < int> (5u) لا تزال صالحة ، فنحن نقول لنوع المحول البرمجي T صراحة ، لذلك يحول 5u إلى int .

أخيرًا ، لم يعد بإمكاننا تتبع myAbs حول الإصبع: myAbs < unsigned int, true> (5u) يلقي خطأ. لا يهم إذا قدمنا ​​قيمة افتراضية في المكالمة أم لا ، يتم تقييم جزء من تعبير SFINAE على أي حال ، لأن المترجم يحتاج إلى نوع وسيطة من قيمة قالب مجهولة.

يمكننا الانتقال إلى المشكلة التالية - لكن انتظر لحظة! أعتقد أننا لم نعد نتجاوز الوسيطة الافتراضية لمعلمة القالب نفسها ، فما هو الموقف الأصلي؟

 template< typename T, typename = IsUnsigned< T > > T myAbs( T val ); template< typename T, typename = IsSigned< T > > T myAbs( T val ); 

ولكن الآن مع الكود الحالي:

 template< typename T, IsUnsigned< T > = true > T myAbs( T val ); template< typename T, IsSigned< T > = true > T myAbs( T val ); 

يبدو مشابهاً للغاية للرمز السابق ، لذلك قد نعتقد أن هذا لن ينجح أيضًا ، ولكن في الحقيقة هذا الرمز لا يواجه نفس المشكلة. ما هو IsUnsigned < T> ؟ منطقي أو فشل البحث. وما هو IsSigned < T> ؟ نفس الشيء ، ولكن إذا كان أحدهم Bool ، فإن الآخر هو عملية بحث فاشلة.

هذا يعني أننا لا نتجاوز الوسيطات الافتراضية ، نظرًا لوجود دالة واحدة فقط مع bool وسيطة القالب ، والآخر بديل فاشل ، لذلك لا وجود له.

السكر النحوي

UPD. تم حذف هذه الفقرة من قبل المؤلف بسبب وجود أخطاء فيها.

الإصدارات القديمة من C ++

كل ما سبق يعمل مع الإصدار C ++ 11 ، والفرق الوحيد هو لفظ تعريفات القيود بين الإصدارات القياسية:

 //C++11 template< typename T > using IsSigned = typename std::enable_if< std::is_signed< T >::value, bool >::type; //C++14 - std::enable_if_t template< typename T > using IsSigned = std::enable_if_t< std::is_signed< T >::value, bool >; //C++17 - std::is_signed_v template< typename T > using IsSigned = std::enable_if_t< std::is_signed_v< T >, bool >; 

ولكن القالب لا يزال هو نفسه:

 template< typename T, IsSigned< T > = true > 

في C ++ 98 القديم الجيد ، لا توجد أسماء مستعارة للقالب ، بالإضافة إلى ذلك ، لا يمكن أن تحتوي قوالب الوظائف على أنواع أو قيم افتراضية. يمكننا إدراج كود SFINAE الخاص بنا في نوع النتيجة أو فقط في قائمة معلمات الوظيفة. يوصى بالخيار الثاني لأن المنشئات لا تحتوي على أنواع النتائج. أفضل ما يمكننا فعله هو شيء مثل هذا:

 template< typename T > T myAbs( T val, typename my_enable_if< my_is_signed< T >::value, bool >::type = true ) { return( ( val <= -1 ) ? -val : val ); } 

فقط للمقارنة - النسخة الحديثة من C ++:

 template< typename T, IsSigned< T > = true > T myAbs( T val ) { return( ( val <= -1 ) ? -val : val ); } 

إصدار C ++ 98 قبيح ، يقدم معلمة لا معنى لها ، لكنه يعمل - يمكنك استخدامها إذا كانت ضرورية للغاية. ونعم: يجب تطبيق my_enable_if و my_is_signed ( std :: enable_if std :: is_signed كانت جديدة في std :: enable_if std :: is_signed C ++ 11).

الحالة الحالية

C ++ 17 المقدمة if constexpr ، طريقة if constexpr من التعليمات البرمجية استنادًا إلى الظروف في وقت الترجمة. يجب أن تكون عبارات if وخلافها صحيحة بناءً ، لكن سيتم تقييم الشرط في وقت الترجمة.

 template< typename T > T myAbs( T val ) { if constexpr( std::is_signed_v< T > ) { return( ( val <= -1 ) ? -val : val ); } else { if constexpr( std::is_unsigned_v< T > ) { return val; } /*else { static_assert( false, "T must be signed or unsigned arithmetic type." ); }*/ } } 

كما نرى ، أصبحت وظيفة القيمة المطلقة لدينا أكثر إحكاما وسهولة في القراءة. ومع ذلك ، فإن التعامل مع الأنواع غير المطابقة ليس سهلاً. إن static_assert غير المشروط يجعل هذا البيان ثابتًا إلى حد ما ، وهو أمر محظور بموجب المعيار ، بصرف النظر عما إذا كان يتم تجاهله أم لا.

لحسن الحظ ، هناك ثغرة: في كائنات القوالب ، لا يتم إنشاء عوامل التشغيل المسقطة إذا كانت الحالة مستقلة عن القيمة. ! ممتاز

وبالتالي فإن المشكلة الوحيدة في الكود هي أنها تتعطل أثناء تعريف القالب. إذا استطعنا إرجاء تقييم static_assert حتى وقت إنشاء القالب ، فسيتم حل المشكلة: سيتم إنشاؤه إذا كانت جميع شروطنا خاطئة وفقط. ولكن كيف يمكننا تأجيل static_assert حتى يتم إنشاء القالب؟ جعل حالتها تعتمد على نوع!

 template< typename > inline constexpr bool dependent_false_v{ false }; template< typename T > T myAbs( T val ) { if constexpr( std::is_signed_v< T > ) { return( ( val <= -1 ) ? -val : val ); } else { if constexpr( std::is_unsigned_v< T > ) { return val; } else { static_assert( dependent_false_v< T >, "Unsupported type" ); } } } 

عن المستقبل

نحن بالفعل قريبون بالفعل ، لكننا بحاجة إلى الانتظار بعض الوقت حتى يأتي C ++ 20 بالحل النهائي: المفاهيم! سيؤدي هذا إلى تغيير طريقة استخدام القوالب (و SFINAE) تمامًا.

باختصار: يمكن استخدام المفاهيم للحد من مجموعة الوسائط التي يتم قبولها لمعلمات القالب. بالنسبة لوظيفة القيمة المطلقة لدينا ، يمكننا استخدام المفهوم التالي:

 template< typename T > concept bool Arithmetic() { return std::is_arithmetic_v< T >; } 

وكيف يمكننا استخدام المفاهيم؟ هناك ثلاث طرق:

 //   template< typename T > requires Arithmetic< T >() T myAbs( T val ); //   template< Arithmetic T > T myAbs( T val ); //  Arithmetic myAbs( Arithmetic val ); 

لاحظ أن النموذج الثالث لا يزال يعلن عن وظيفة القالب! فيما يلي التنفيذ الكامل لـ myAbs في الإصدار C ++ 20:

 template< typename T > concept bool Arithmetic() { return std::is_arithmetic_v< T >; } Arithmetic myAbs( Arithmetic val ) { if constexpr( std::is_signed_v< decltype( val ) > ) { return( ( val <= -1 ) ? -val : val ); } else { return val; } } int main() { unsigned int a{ myAbs( 5u ) }; int b{ myAbs< int >( 5u ) }; //std::string c{ myAbs( "d" ) }; } 

مكالمة تم التعليق عليها تعطي الخطأ التالي:

 error: cannot call function 'auto myAbs(auto:1) [with auto:1 = const char*]' constraints not satisfied within 'template<class T> concept bool Arithmetic() [with T = const char*]' concept bool Arithmetic(){ ^~~~~~~~~~ 'std::is_arithmetic_v' evaluated to false 

أحث الجميع على استخدام هذه الأساليب بجرأة في شفرة الإنتاج ؛ وقت التجميع أرخص من وقت التشغيل. SFINAEing سعيد!