ടെംപ്ലേറ്റ് ഫംഗ്ഷൻ അംഗങ്ങൾ സി ++ ലെ ടെംപ്ലേറ്റ് പാരാമീറ്ററുകളായി ഉപയോഗിക്കുന്നു

സി ++ ലെ ടെംപ്ലേറ്റ് ഫംഗ്ഷൻ കോളുകൾ സ്ട്രീംലൈനിംഗ് ചെയ്യുക

ആധുനിക സി ++ പ്രോഗ്രാമിംഗിന്റെ ഒരു മൂലക്കല്ലാണ് ടെംപ്ലേറ്റുകൾ, ഇൻസൈഡ് ചെയ്യാവുന്നതും പുനരുപയോഗിക്കാവുന്നതുമായ കോഡ് എഴുതാൻ ഡവലപ്പർമാരെ പ്രാപ്തരാക്കുന്നു. എന്നിരുന്നാലും, ടെംപ്ലേറ്റ് ഫംഗ്ഷൻ അംഗങ്ങൾ പലപ്പോഴും ആവർത്തിച്ചുള്ള ബോയിലർപ്ലേറ്റ് അവതരിപ്പിക്കുന്നു, ഇത് കോഡ്ബേസ് അലങ്കോലപ്പെടുത്താനും വായനാക്ഷമത കുറയ്ക്കാനും കഴിയും. ഇത് ചോദ്യം ഉയർത്തുന്നു: നമുക്ക് അത്തരം പാറ്റേണുകൾ ലളിതമാക്കാമോ?

ഒരു ക്ലാസ്സിൽ നിങ്ങൾക്ക് ഒന്നിലധികം ടെംപ്ലേറ്റഡ് അംഗ ഫംഗ്ഷനുകൾ ഉള്ള ഒരു സാഹചര്യം സങ്കൽപ്പിക്കുക, ഓരോന്നും `ചാർ`,`, `,`, `,`, `,`, `,`, `,`, `,`, `,`, `എന്നിവ പോലെ പ്രവർത്തിക്കുന്നു. ഓരോ തരത്തിലും സ്വമേധയാ ഓരോ ഫംഗ്ഷനും വിളിക്കുന്നതിനുപകരം, വൃത്തിയുള്ളതും ഗംഭീരവുമായ ഡിസ്പാച്ചർ പ്രവർത്തനത്തിൽ യുക്തിയെ കേന്ദ്രീകരിക്കുന്നത് മികച്ചതാകുന്നില്ലേ? ഇത് ആവർത്തനത്തെ ഗണ്യമായി കുറയ്ക്കുകയും പരിപാലനത്തെ മെച്ചപ്പെടുത്തുകയും ചെയ്യും. പതനം

ടെംപ്ലേറ്റ് പാരാമീറ്ററുകൾ ഒരു പ്രകൃതി പരിഹാരമായി തോന്നാം എന്ന് ടെംപ്ലേറ്റ് പാരാമീറ്ററായി കടന്നുപോകാൻ ശ്രമിക്കുന്നു. എന്നിരുന്നാലും, സി ++ ന്റെ തരം സിസ്റ്റത്തിന്റെയും ടെംപ്ലേറ്റ് സിന്റാക്സിന്റെയും സങ്കീർണ്ണതകൾ കാരണം ഇത് നേടാൻ കഴിയില്ല. അത്തരമൊരു പാറ്റേൺ നടപ്പിലാക്കാൻ ശ്രമിക്കുമ്പോൾ ഡവലപ്പർമാർ പലപ്പോഴും കംപൈലർ പിശകുകളിലേക്ക് ഓടുന്നു.

ഈ ലേഖനത്തിൽ, തരത്തിലുള്ള ഒരു ശ്രേണിയിൽ ആവർത്തിക്കാൻ കഴിയുന്ന ഒരു ഡിസ്പാച്ചർ ഫംഗ്ഷൻ രൂപകൽപ്പന ചെയ്യാൻ കഴിയുമോ എന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. വെല്ലുവിളികളും സാധ്യതയുള്ള പരിഹാരങ്ങളും പ്രകടിപ്പിക്കുന്നതിനുള്ള പ്രായോഗിക ഉദാഹരണങ്ങളിലൂടെയും ഞങ്ങൾ നടക്കും. നമുക്ക് അകത്തേക്ക് കടക്കാം! പതനം

സി ++ ലെ ടെംപ്ലേറ്റ് ഫംഗ്ഷൻ ഡിസ്പാച്ചറുകൾ മാസ്റ്ററിംഗ്

മുകളിൽ നൽകിയിരിക്കുന്ന സ്ക്രിപ്റ്റുകൾ സി ++ ൽ ഒരു നിർദ്ദിഷ്ട വെല്ലുവിളി നേരിടുന്നു: ഇൻപുട്ട് തരത്തിന്റെ അതേ ക്രമത്തിൽ വ്യത്യസ്തവും പുനരുപയോഗിക്കാവുന്നതുമായ രീതിയിൽ എന്ന് വിളിക്കുന്നു. ഒരു കേന്ദ്ര ഡിസ്പാച്ചർ പ്രവർത്തനം സൃഷ്ടിച്ച് ബോയിലർ ടെംപ്ലേറ്റ് കോഡ് കുറയ്ക്കുക എന്നതാണ് പ്രാഥമിക ലക്ഷ്യം. ഉപയോഗിക്കുന്നു ടെംപ്ലേറ്റ് മെറ്റാപ്രോഗ്രാമിംഗ്, `for_ty_type` ഫംഗ്ഷൻ ഓട്ടോമേറ്റ് ചെയ്യുന്നു` എ`, `,` `b``, `,` `,`, `,`, `,`, `,`, `എന്നിവ (ഫ്ലോട്ട്`). `Std :: ടുപ്പിൾ, വേരിയഡിക് ടെംപ്ലേറ്റുകൾ, ഒപ്പം മടക്ക പദപ്രയോഗങ്ങളും പോലുള്ള നൂതന ഉപകരണങ്ങൾ സ്വാധീനിക്കുന്നതിലൂടെ ഇത് പൂർത്തിയാക്കുന്നു. പതനം

ആദ്യത്തെ സമീപനം `std :: ഒരു ശ്രേണി കൈവശം വയ്ക്കുന്നതിന് '` std :: tuplet' ഉപയോഗിക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. `Std :: tuplet_elyme` സംയോജിപ്പിക്കുന്നതിലൂടെ 'std :: സൂചിക_ സൂചിക' ഓരോ തരത്തിലും ചലനാത്മകമായി ശരിയായ ടെംപ്ലേറ്റഡ് അംഗ പ്രവർത്തനം അഭ്യർത്ഥിക്കുന്നതിന് ഇത് `_each_type` നടപ്പിലാക്കാൻ ഇത് അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, സ്ക്രിപ്റ്റ് ഉറപ്പാക്കുന്നു() `,` a() `,` a() ഓരോ കോളും സ്വമേധയാ വ്യക്തമാക്കാതെ ഒരു ലൂപ്പിന് സമാനമായ രീതിയിൽ പരിധികളില്ലാതെ വിളിക്കപ്പെടുന്നു. ആവർത്തിച്ചുള്ള കോഡ് കുറയ്ക്കുന്നതിന് നിരവധി തരങ്ങളുള്ള സാഹചര്യങ്ങളിൽ ഈ രീതി പ്രത്യേകിച്ചും വിലപ്പെട്ടതാണ്. പതനം

രണ്ടാമത്തെ സമീപനം കൂടുതൽ സംക്ഷിപ്തമായി സമാനമായ പ്രവർത്തനം നേടുന്നതിന് വേരിയടിക് ടെംപ്ലേറ്റുകൾ ഉപയോഗിച്ച് ലാംഡ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു. ഇവിടെ, ഒരു ലാംഡ `ഫോർ_അജ്_റ്റിപിലേക്ക് 'എന്നതിലേക്ക് കൈമാറുകയും, അത് ടൈപ്പ് പായ്ക്കിന് മുകളിലൂടെ ആവർത്തിക്കുകയും ഓരോ തരത്തിനും ഉചിതമായ പ്രവർത്തനം അഭ്യർത്ഥിക്കുകയും ചെയ്യുന്നു. ആധുനിക സി ++ പ്രോഗ്രാമിംഗിലാണ് ലാംഡ സമീപനം ഉദാഹരണത്തിന്, ഈ സമീപനം ഒരു `എ പകരം, പോലുള്ള ഫംഗ്ഷൻ കോളുകൾ വിപുലീകരിക്കുന്നതിനോ പരിഷ്ക്കരിക്കുന്നതിനോ എളുപ്പമാക്കുന്നു() `ഒരു ഇഷ്ടാനുസൃത പ്രവർത്തനത്തോടെ. വലിയ പ്രോജക്റ്റുകളിൽ വീണ്ടും ഉപയോഗിക്കാവുന്നതും പരിപാലനമുള്ളതുമായ കോഡ് രൂപകൽപ്പന ചെയ്യുമ്പോൾ ഈ വഴക്കം ഒരു പ്രധാന നേട്ടമാണ്.

രണ്ട് രീതികളും ഫ്രണ്ട് എക്സ്പ്രഷനുകൾ പോലുള്ള സി ++ 17 സവിശേഷതകൾ പ്രയോജനപ്പെടുത്തുന്നു, `std :: back_index_thra '. ഈ സവിശേഷതകൾ പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിലൂടെ മെച്ചപ്പെടുത്താം, ഇത് റൺടൈം ഓവർഹെഡ് ഇല്ലാതാക്കുന്നു. കൂടാതെ, റൺടൈം തരം വിവരങ്ങൾ ഉപയോഗിച്ച് `ടൈപ്പ് 'ഉപയോഗിച്ച് വ്യക്തത ചേർക്കുന്നു, പ്രത്യേകിച്ച് ഡീബഗ്ഗിംഗ് അല്ലെങ്കിൽ വിദ്യാഭ്യാസ ആവശ്യങ്ങൾക്കായി. ഡിസ്പാച്ചറിൽ ഏത് തരം പ്രോസസ്സ് ചെയ്യുന്നുവെന്ന് ദൃശ്യവൽക്കരിക്കുമ്പോൾ ഇത് സഹായകമാകും. മൊത്തത്തിൽ, അതിന്റെ ശക്തി എങ്ങനെയെന്ന് നൽകിയ പരിഹാരങ്ങൾ തെളിയിക്കുന്നു സി ++ ടെംപ്ലേറ്റുകൾ ക്ലീനറും കൂടുതൽ പരിപാലനവും എഴുതാൻ. ആവർത്തിച്ചുള്ള യുക്തി അമൂർത്തത്തിലൂടെ ഡവലപ്പർമാർക്ക് കരുത്തുറ്റതും സ്കേലബിൾ ആപ്ലിക്കേഷനുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ കഴിയും. പതനം

#include <iostream>
#include <tuple>
#include <utility>
template <typename... Types>
struct A {
    template <typename T>
    void a() {
        std::cout << "Function a with type: " << typeid(T).name() << std::endl;
    }
    template <typename T>
    void b() {
        std::cout << "Function b with type: " << typeid(T).name() << std::endl;
    }
    template <template <typename> class Fn, typename Tuple, std::size_t... Is>
    void for_each_type_impl(std::index_sequence<Is...>) {
        (Fn<std::tuple_element_t<Is, Tuple>>::invoke(*this), ...);
    }
    template <template <typename> class Fn>
    void for_each_type() {
        using Tuple = std::tuple<Types...>;
        for_each_type_impl<Fn, Tuple>(std::make_index_sequence<sizeof...(Types)>{});
    }
};
template <typename T>
struct FnA {
    static void invoke(A<char, int, float> &obj) {
        obj.a<T>();
    }
};
template <typename T>
struct FnB {
    static void invoke(A<char, int, float> &obj) {
        obj.b<T>();
    }
};
int main() {
    A<char, int, float> obj;
    obj.for_each_type<FnA>();
    obj.for_each_type<FnB>();
    return 0;
}

#include <iostream>
#include <tuple>
template <typename... Types>
struct A {
    template <typename T>
    void a() {
        std::cout << "Function a with type: " << typeid(T).name() << std::endl;
    }
    template <typename T>
    void b() {
        std::cout << "Function b with type: " << typeid(T).name() << std::endl;
    }
    template <typename Fn>
    void for_each_type(Fn fn) {
        (fn.template operator()<Types>(*this), ...);
    }
};
int main() {
    A<char, int, float> obj;
    auto call_a = [](auto &self) {
        self.template a<decltype(self)>();
    };
    auto call_b = [](auto &self) {
        self.template b<decltype(self)>();
    };
    obj.for_each_type(call_a);
    obj.for_each_type(call_b);
    return 0;
}

അഡ്വാൻസ്ഡ് സി ++ ടെക്നിക്കുകൾ ഉപയോഗിച്ച് ടെംപ്ലേറ്റ് ഫംഗ്ഷൻ ഡിസ്പാച്ച് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു

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

മറ്റൊരു പരിഗണന കംപൈൽ-സമയ പിശകുകൾ മനോഹരമായി കൈകാര്യം ചെയ്യുന്നു. സങ്കീർണ്ണമായ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുമ്പോൾ, ഡീബഗ്ഗിംഗ് ബുദ്ധിമുട്ടാക്കുന്ന ക്രിപ്റ്റിക് പിശക് സന്ദേശങ്ങളാണ് ഒരു പൊതുവായ പ്രശ്നം. ഇത്, ആശയങ്ങൾ അല്ലെങ്കിൽ sfinae (പകരക്കാരന്റെ പരാജയം ഒരു പിശക് അല്ല) ഉപയോഗിക്കാൻ കഴിയും. ആശയങ്ങൾ, സി ++ 20 ൽ അവതരിപ്പിച്ച, ടെംപ്ലേറ്റുകൾക്ക് കൈമാറിയ തരങ്ങൾ പരിമിതപ്പെടുത്താൻ ഡവലപ്പർമാരെ അനുവദിക്കുക, സാധുവായ തരങ്ങൾ മാത്രമേ ഡിസ്പാച്ചറിൽ ഉപയോഗിക്കൂ എന്ന് ഉറപ്പാക്കുന്നു. ഈ ഫലങ്ങൾ ക്ലീനർ പിശക് സന്ദേശങ്ങൾക്കും മികച്ച കോഡ് വ്യക്തതയ്ക്കും കാരണമാകുന്നു. കൂടാതെ, SFinae- ന് പിന്തുണയ്ക്കാത്ത തരങ്ങൾക്ക് ഫാൾബാക്ക് നടപ്പാക്കലുകൾ നൽകാൻ കഴിയും, നിങ്ങളുടെ ഡിസ്പാച്ചർ പ്രവർത്തന കേസുകൾ നേരിടേണ്ടിവരുമ്പോഴും പ്രവർത്തിക്കുന്നു.

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