قالب متغير

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

تدعم لغة C++ (منذ معيار C++11 ) ولغة البرمجة D القوالب ذات الوسائط المتغيرة . بينما توفر لغات أخرى، مثل Java أو C#، دعمًا للدوال ذات الوسائط المتغيرة الآمنة من حيث النوع ، إلا أنها لا توفر دعمًا للأنواع العامة ذات الوسائط المتغيرة كما هو الحال في C++ وD.

قبل إدخال القوالب المتغيرة الوسائط إلى لغة C++، كان بالإمكان تنفيذ الدوال المتغيرة الوسائط فقط باستخدام va_listوحدات الماكرو المتغيرة الوسائط من لغة C ، والتي تفتقر إلى أمان النوع . صُممت ميزة القوالب المتغيرة الوسائط في C++ بواسطة دوغلاس غريغور وجاكو يارفي ^{[ 1 ] [ 2 ]} ، وتم توحيدها لاحقًا في C++11. قبل C++11، كانت القوالب (الفئات والدوال) تقبل عددًا ثابتًا من الوسائط، والذي كان يجب تحديده عند تعريف القالب لأول مرة. يسمح C++11 بتعريف القوالب بقبول أي عدد من الوسائط من أي نوع. وبالتالي، فإن الطريقة الوحيدة للحصول على دوال متغيرة الوسائط آمنة النوع هي من خلال القوالب المتغيرة الوسائط، حيث تفتقر C++ إلى دوال متغيرة الوسائط غير المعتمدة على القوالب مثل تلك الموجودة في Java وC#.

// يأخذ صفرًا أو أكثر من الوسائط template < typename ... Ts > class Tuple ;

يأخذ قالب الفئة المذكور أعلاه Tuple<Ts...>(الذي يمثل نوع منتج أو مجموعة) أي عدد من أسماء الأنواع كمعاملات للقالب . هنا، يتم إنشاء نسخة من قالب الفئة المذكور أعلاه بثلاثة وسائط من النوع:

باستخدام String = std :: string ؛ قالب < typename T > باستخدام Vector = std :: vector <T> ؛ قالب < typename K , typename V > باستخدام TreeMap = std :: map < K , V > ؛​​Tuple < int , Vector <int> , TreeMap < String , Vector <int> >> t ;​​​

يمكن أن يكون عدد الوسائط صفرًا، لذا سيعمل أيضًا.Tuple<>t;

إذا كان القالب المتغير لا يسمح إلا بعدد موجب من الوسائط، فيمكن استخدام هذا التعريف:

// يأخذ وسيطًا واحدًا أو أكثر template < typename First , typename ... Rest > class Tuple ;

يستخدم أحد التطبيقات الشائعة للزوج المرتب (tuple) التفكيك المتكرر على النحو التالي:

// قالب التصريح المسبق < typename ... Ts > class Tuple ;// قالب الحالة الفارغة <> فئة Tuple <> {};// قالب الحالة التكرارية < typename Head , typename ... Tail > class Tuple < Head , Tail ... > { private : Head head ; Tuple < Tail ... > tail ; public : Tuple () = default ; explicit Tuple ( const Head & head , const Tail & ... tail ) : head { head }, tail { tail ...} {}// ... };

قد تنطبق القوالب المتغيرة أيضًا على الدوال، وبالتالي لا توفر فقط إضافة آمنة من حيث النوع للدوال المتغيرة (مثل printf() )، ولكنها تسمح أيضًا للدالة التي يتم استدعاؤها باستخدام printfبناء جملة مشابه بمعالجة الكائنات غير التافهة.

باستخدام std :: string_view ؛template < typename ... Args > void myPrintf ( string_view fmt , Args ... parameters );

يؤدي عامل الحذف ( ... ) وظيفتين. فعندما يظهر على يسار اسم مُعامل، يُعلن عن حزمة مُعاملات. وباستخدام حزمة المُعاملات، يُمكن للمستخدم ربط صفر أو أكثر من الوسائط بمعاملات القوالب المتغيرة. كما يُمكن استخدام حزم المُعاملات للمعاملات غير النوعية. في المقابل، عندما يظهر عامل الحذف على يمين وسيط قالب أو وسيط استدعاء دالة ، فإنه يفك حزم المُعاملات إلى وسائط منفصلة، ​​كما هو موضح في متن المثال أدناه. عمليًا، يؤدي استخدام عامل الحذف في الكود إلى تكرار التعبير الكامل الذي يسبق الحذف لكل وسيط لاحق يتم فكه من حزمة الوسائط، مع فصل التعبيرات بفواصل.args...printf()

غالبًا ما يتم تنفيذ مُركِّب النقطة الثابتة باستخدام وسائط القالب المتغيرة (لاحظ أن هذا يُعادل ) :[](auto&&...args)[]<template...Args>(Args&&...args)

auto fix = []( auto f ) { return [ f ]( auto && ... args ) -> decltype ( auto ) { return f ( f , std :: forward < decltype ( args ) > ( args )...); }; };auto factorial = fix ([]( auto self , long n ) -> long { return n == 0 ? 1 : n * self ( self , n - 1 ); });std :: println ( "5! = {}" , factorial ( 5 )); // يطبع 120

لتقييد المعامل ليكون من نوع معين فقط T(على غرار T... args) في جافا، يمكن استخدام المفهوم [ std::same_as<T, U>^{3 ] أو} ( std::convertible_to<From, To>للأنواع التي قد يُراد تحويلها). ^{[ 4 ]}

باستخدام std :: same_as ;// مكافئ لتصريح جافا // <T> void fn(T... args) template < typename T > void fn ( same_as < T > auto ... args ) { // ... }

ويمكن حصر ذلك بشكل أكبر في أي نوع محدد:

باستخدام std :: convertible_to ؛ باستخدام std :: same_as ؛ باستخدام std :: string ؛// مكافئ لتصريح جافا // void foo(int... args) void foo ( same_as < int > auto ... args ) { // ... }// مكافئ لتصريح جافا // void bar(String... args) void bar ( convertible_to < string > auto ... args ) { // ... }

غالبًا ما يكون استخدام القوالب ذات المعاملات المتغيرة متكررًا. ولا تكون المعاملات المتغيرة نفسها متاحة بسهولة لتنفيذ دالة أو فئة. لذلك، فإن الآلية النموذجية لتعريف printf()بديل للمعاملات المتغيرة في C++11 ستكون كما يلي:

باستخدام std :: runtime_error ؛// الحالة الأساسية void myPrintf ( const char s []) { while ( * s ) { if ( * s == '%' ) { if ( * ( s + 1 ) == '%' ) { ++ s ; } else { throw runtime_error ( "سلسلة تنسيق غير صالحة: وسائط مفقودة" ); } } std :: println ( "{}" , * s ++ ); } }// قالب تكراري < typename T , typename ... Args > void myPrintf ( const char s [], T value , Args ... args ) { while ( * s ) { if ( * s == '%' ) { if ( * ( s + 1 ) != '%' ) { // التظاهر بتحليل التنسيق: يعمل فقط على سلاسل التنسيق المكونة من حرفين ( %d, %f, إلخ ); يفشل مع %5.4f s += 2 ; // طباعة القيمة std :: println ( "{}" , value ); // يتم استدعاؤه حتى عندما يكون *s يساوي 0 ولكنه لا يفعل شيئًا في هذه الحالة (ويتجاهل الوسائط الإضافية) myPrintf ( s , args ...); return ; } ++ s ; } std :: println ( "{}" , * s ++ ); } }

هذا قالب تكراري. لاحظ أن نسخة القالب المتغيرة myPrintf()تستدعي نفسها، أو (في حالة كونها args...فارغة) تستدعي الحالة الأساسية.

لا توجد آلية بسيطة للتكرار على قيم القالب المتغير. مع ذلك، توجد عدة طرق لتحويل حزمة الوسائط إلى وسيط واحد يمكن تقييمه بشكل منفصل لكل مُعامل. عادةً ما يعتمد هذا على تحميل الدوال الزائد ، أو - إذا كانت الدالة قادرة على اختيار وسيط واحد في كل مرة - باستخدام مُحدِّد توسيع بسيط.

template < typename ... Args > inline void pass ( Args && ... args ) { // ... }

والتي يمكن استخدامها على النحو التالي:

template < typename ... Args > inline void expand ( Args && ... args ) { pass ( foo ( args )...); }توسيع ( 42 ، "إجابة" ، صحيح );

والذي سيتوسع إلى شيء مثل:

pass ( foo ( arg1 ), foo ( arg2 ), foo ( arg3 ) /* إلخ... */ );

يُعدّ استخدام دالة "pass" ضروريًا، لأنّ توسيع حزمة الوسائط يتمّ بفصل وسائط استدعاء الدالة بفواصل، وهي ليست مكافئة لمعامل الفاصلة . لذلك، لن تعمل هذه الطريقة أبدًا. علاوة على ذلك، لن يعمل الحلّ المذكور أعلاه إلا إذا لم يكن نوع الإرجاع للدالة `true` . بالإضافة إلى ذلك، سيتمّ تنفيذ الاستدعاءات بترتيب غير مُحدّد، لأنّ ترتيب تقييم وسائط الدالة غير مُعرّف. لتجنّب هذا الترتيب غير المُحدّد، يُمكن استخدام قوائم التهيئة المُحاطة بأقواس معقوفة، والتي تضمن ترتيبًا صارمًا للتقييم من اليسار إلى اليمين. تتطلّب قائمة التهيئة نوع إرجاع غير `true`، ولكن يُمكن استخدام معامل الفاصلة لإرجاع قيمة لكلّ عنصر توسيع.foo(args)...;foo()voidfoo()void1

struct Pass { template < typename ... T > explicit Pass ( T ... args ) { // ... } };مرر {( foo ( args ), 1 )...};

بدلاً من تنفيذ دالة، يمكن تحديد تعبير لامدا وتنفيذه في مكانه، مما يسمح بتنفيذ تسلسلات عشوائية من العبارات في مكانها.

Pass {([ & ]() -> void { std :: println ( "{}" , args ); }(), 1 )...};

لكن في هذا المثال تحديدًا، لا حاجة لدالة لامدا. يمكن استخدام تعبير أكثر بساطة بدلاً منها:

مرر {( std :: println ( "{}" , args ), 1 )...};

في لغة C++17 ، يمكن إعادة كتابة هذه باستخدام تعبيرات الطي على عامل الفاصلة:

([ & ]() -> void { std :: println ( "{}" , args ); }(), ...); (( std :: println ( "{}" , args )), ...);

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

void foo () { // نسخة الإنهاء }template < typename First , typename ... Args > void foo ( const First & first , const Args && ... args ) { process ( first ); foo ( args ...); // ملاحظة: first غير موجود هنا! }

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

يمكن أيضًا استخدام القوالب المتغيرة في مواصفات الاستثناءات، أو قائمة الفئات الأساسية، أو قائمة تهيئة المُنشئ. على سبيل المثال، يمكن للفئة تحديد ما يلي:

template < typename ... Bases > class Foo : public Bases ... { public : explicit Foo ( Bases && ... bases ) : Bases ( bases )... {} };

سيقوم عامل فك التغليف بتكرار أنواع الفئات الأساسية لـ Foo، بحيث يتم اشتقاق هذه الفئة من كل نوع من الأنواع التي تم تمريرها. كما يجب أن يأخذ المُنشئ مرجعًا لكل فئة أساسية، وذلك لتهيئة الفئات الأساسية لـ Foo.

فيما يتعلق بقوالب الدوال، يمكن تمرير المعاملات المتغيرة. وعند دمجها مع المراجع العامة (انظر أعلاه)، يتيح ذلك تمريرًا مثاليًا، كما في مثال المؤشر الذكي هذا :

template < typename T > using SharedPtr = std :: shared_ptr < T > ;template < typename T > struct SharedPtrAllocator { template < typename ... Args > SharedPtr < T > construct ( Args && ... params ) { return SharedPtr < T > ( new T ( std :: forward < Args > ( params )...)); } };

يقوم هذا بفك قائمة الوسائط إلى مُنشئ الكائن T. يُمرر بناء الجملة الوسائط بشكل صحيح، حتى فيما يتعلق بكونها قيمًا يمينية، إلى المُنشئ. سينقل عامل فك التعبئة بناء جملة التمرير إلى كل مُعامل. تقوم دالة المصنع هذه بتغليف الذاكرة المُخصصة تلقائيًا في غلاف برمجي لتوفير درجة من الأمان فيما يتعلق بتسرب الذاكرة.std::forward<Args...>(params)std::shared_ptr<T>

بالإضافة إلى ذلك، يمكن تحديد عدد الوسائط في حزمة معلمات القالب على النحو التالي:

template < typename ... Args > struct SizeCarrier { static constexpr size_t SIZE = sizeof ...( Args ); };

سيعطي التعبير قيمة ، بينما سيعطي .SizeCarrier<T,U>::SIZE2SizeCarrier<>::SIZE0

استيراد std ؛template < typename ... Friends > class WithFriends { private : int secretValue ;صديق الأصدقاء ...؛ عام : صريح WithFriends ( int secret ) : secretValue { secret } {} };class A { public : void readSecret ( const class WithFriends < A , B >& instance ) const { std :: println ( "فحص القيمة السرية من A: {}" , instance . secretValue ); } };class B { public : void readSecret ( const class WithFriends < A , B >& instance ) const { std :: println ( "فحص القيمة السرية من B: {}" , instance . secretValue ); } };int main ( int argc , char * argv []) { WithFriends < A , B > secretHolder ( 135 ); A a ; B b ; a . readSecret ( secretHolder ); b . readSecret ( secretHolder ); }

استيراد std ؛باستخدام std :: index_sequence ؛ باستخدام std :: index_sequence_for ؛ باستخدام std :: tuple ؛// تأخذ هذه الدالة، reversed()، أي عدد من الوسائط وتعيد // tuple<Ts...> تحتوي على نفس الوسائط بترتيب معكوس، حيث يتم تقليص كل // T في Ts... إلى decay_t<T>. template < typename ... Ts > requires ( sizeof ...( Ts ) > 0 ) constexpr auto reversed ( Ts && ... args ) noexcept { constexpr size_t MAX_INDEX_SIZE = sizeof ...( args ) - 1 ; auto reverser = [ & args ...] < size_t ... Is > ( index_sequence < Is ... > ) { auto reverseForOneIndex = [ & args ...] < size_t I > { return args ...[ MAX_INDEX_SIZE - I ] ; }; return std :: make_tuple ( reverseForOneIndex . template operator () < Is > ()...); }; return reverser ( index_sequence_for < Ts ... > {}); }int main () { // نوع النتيجة: // tuple<char, long double, double, float, const char*, int> constexpr tuple result = reversed ( 13 , "hello" , 2.718f , 3.14 , 9.9375L , 'X' ); static_assert ( std :: get < 0 > ( result ) == 'X' ); }

استيراد std ؛void printAllObjects ( auto && ... args ) { template for ( auto && arg : { args ...}) { std :: print ( "{}" , arg ); } }int main () { printAllObjects ( "13 + 31 = " , 44 , " \n Hello, world! \n " , 3.14 , '\n' , 2.718f , '\n' , 735.9572L , false ); return 0 ; }

استيراد std ؛باستخدام std :: index_sequence ؛ باستخدام std :: index_sequence_for ؛template < typename ... Ts > constexpr bool areEvenIndicesEven ( Ts && ... args ) noexcept { auto checkEvenIndices = [ & args ...] < size_t ... Is > ([[ maybe_unused ]] index_sequence < Is ... > s ) -> bool { template for ( constexpr size_t I : { Is ...}) { if constexpr ( I % 2 != 0 ) { continue ; } if ( args ...[ I ] % 2 != 0 ) { return false ; } } return true ; }; return checkEvenIndices ( index_sequence_for < Ts ... > {}); }int main () { static_assert ( areEvenIndicesEven ( 0 , 1 , 2 , 3 )); }

توفر لغة Carbon ، المصممة مع مراعاة التوافق مع لغة C++، إمكانية استخدام المتغيرات، وخاصة توسيعات الحزم. ^{[ 7 ]}

// تأخذ عددًا غير محدد من المتجهات بأنواع عناصر غير محددة، // وتعيد متجهًا من الأزواج حيث يكون العنصر رقم i من المتجه // زوجًا من العناصر رقم i من متجهات الإدخال. fn Zip [ ... eachElementType :! type ] ( ... eachvector : Vector ( eachElementType ) ) -> Vector (( ... eachElementType ) ) { ... var eachiter : auto = eachvector.Begin ( ); var result : Vector ( ( ... eachElementType ) ) ; while ( ... andeachiter ! = eachvector.End ( ) ) { result.push_back ( ( ... eachiter ) ) ; ... eachiter ++ ; } return result ; }

في لغة C# / .NET ، تحتوي الفئة System.Tupleعلى نسخ محددة من 1 إلى 8 عناصر. ولإنشاء مجموعة من تسعة عناصر أو أكثر، يتم توفير المعامل الأخير TRestكمجموعة Tuple<T1, T2, T3, T4, T5, T6, T7, TRest>أخرى، لأن لغة C# تفتقر إلى معلمات القوالب المتغيرة. ^{[ 8 ]}

في لغة جافا ، يمكن محاكاة المعاملات المتغيرة باستخدام النوع الأعلى java.lang.Object(وبالمثل في C#/.NET، مع System.Object)، إلا أن هذا يفتقر إلى أمان النوع للمعاملات المتغيرة على نمط C++.

استيراد java.util.List ;void printAllObjects ( Object ... args ) { for ( Object arg : args ) { System . out . println ( arg ); } }void main () { printAllObjects ( "Hello, world!" , 42 , 3.14159f , true , List . of ( 1 , 2 , 3 )); }

توجد مقترحات للأنواع العامة المتغيرة في لغة Rust منذ عام 2013 ^{[ 9 ]} ، ولكنها لم تُضَف إلى اللغة حتى الآن. مع ذلك، يمكن محاكاتها بشكل مشابه باستخدام وحدات الماكرو المتغيرة ، والتي يمكن استخدامها لتوليد التعليمات البرمجية. ^{[ 10 ]}

للاطلاع على المقالات المتعلقة بالبنى المتغيرة بخلاف القوالب

• دالة متغيرة
• ماكرو متغير في معالج C المسبق

• مسودة عمل للغة C++، 16 يناير 2012
• القوالب المتغيرة في لغة D