സ്റ്റാൻഡേർഡ് ടെമ്പ്ലേറ്റ് ലൈബ്രറി (സി++)
സി++ പ്രോഗ്രാമിങ് ഭാഷയിലെ പ്രധാനപ്പെട്ട ഒരു ഭാഗം ആണ് എസ്.ടി.എൽ (S.T.L) എന്ന് വിളിയ്ക്കപ്പെടുന്ന സ്റ്റാൻഡേർഡ് ടെമ്പ്ലേറ്റ് ലൈബ്രറി. സി++'ലെ തന്നെ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയുടെ ഡിസൈനിനെ എസ്.ടി.എൽ വളരെ സ്വാധീനിച്ചിട്ടുണ്ട്. ഇതിനെ അൽഗോരിതങ്ങൾ, കണ്ടെയ്നറുകൾ, ഫങ്ക്ഷൻ ഒബ്ജക്റ്റുകൾ, ഇറ്ററേറ്ററുകൾ എന്നീ നാല് ഭാഗങ്ങളായി വിഭജിച്ചിരിയ്ക്കുന്നു. ഇത് ഒരു സി++ പ്രോഗ്രാമർക്ക് അത്യാവശ്യം വേണ്ട നാല് തരം സേവനങ്ങൾ നൽകുന്നു.
[1]
എസ്.ടി.എൽ നൽകുന്ന കണ്ടെയ്നറുകൾ ഒരു കൂട്ടം ഒബ്ജക്റ്റുകളെ ശേഖരിച്ചു സൂക്ഷിയ്ക്കാനുള്ള ക്ലാസ്സുകളാണ്. ഈ ഒബ്ജക്റ്റുകൾ എന്നത് സി++ തന്നെ തരുന്ന അടിസ്ഥാന ടൈപ്പ് (built-in types) ഒബ്ജക്റ്റുകൾ ആകാം (ഇന്റെജർ, സ്ട്രിംഗ് തുടങ്ങിയവ). അല്ലെങ്കിൽ ഒരു ഉപഭോക്താവ്‌ തന്നെ ഉണ്ടാക്കിയെടുത്ത ക്ലാസ്സിന്റെ (user defined types) ടൈപ്പിലുള്ള ഒബ്ജക്റ്റുകൾ ആകാം.[2] രണ്ടാമത്തെ ടൈപ്പ് ക്ലാസ്സുകളാണ് ഉപയോഗിയ്ക്കുന്നതെങ്കിൽ അവയിൽ കോപ്പി ചെയ്യാനും അസൈൻ ചെയ്യാനുമുള്ള ചില അടിസ്ഥാന ഫങ്ക്ഷനുകൾ ഉണ്ടായിരിയ്ക്കണം (കോപ്പി കോൺസ്ട്രക്ടർ, അസൈൻമെന്റ് ഓപ്പറേറ്റർ തുടങ്ങിയവ).[3] ഈ കണ്ടെയ്നറുകളിൽ പ്രവർത്തിയ്ക്കുന്ന അൽഗോരിതങ്ങൾ വേറെ ക്ലാസുകൾ ആയി ഡിസൈൻ ചെയ്തിരിയ്ക്കുന്നു. ഈ ഡിസൈൻ എസ്.ടി.എൽ'ന്റെ സങ്കീർണ്ണത വളരെ കുറയ്ക്കാൻ സഹായിയ്ക്കുന്നു.[4]
എസ്.ടി.എൽ പ്രധാനമായും സി++ ടെമ്പ്ലേറ്റുകൾ അടിസ്ഥാനപ്പെടുത്തിയാണ് രൂപകൽപന ചെയ്തിരിയ്ക്കുന്നത്.[5] ഈ ഡിസൈൻ കമ്പൈൽ സമയ പോളിമോർഫിസം നൽകുന്നു. ഇത് റൺ ടൈം പോളിമോർഫിസത്തേക്കാൾ കൂടുതൽ വേഗതയുള്ളതാണ്. സി++'ൽ ക്ലാസ്സുകളുടെ ഉപയോഗം കൊണ്ടുവരുന്ന വേഗതക്കുറവിനെ ഒരു പരിധി വരെ ഈ ഡിസൈനും ഒരു വിധം കമ്പൈലറുകളുടെ കമ്പൈൽ സമയ ഒപ്റ്റിമൈസഷനും സഹായിയ്ക്കുന്നു..
ഭാഗങ്ങൾ[തിരുത്തുക]
കണ്ടെയ്നറുകൾ[തിരുത്തുക]
എസ്.ടി.എൽ അനുക്രമ കണ്ടെയ്നറുകളും (sequence containers) സാഹചര്യ കണ്ടെയ്നറുകളും (associative containers) നൽകുന്നു. മറ്റു ഒബ്ജക്റ്റുകളെ ശേഖരിച്ചു സൂക്ഷിയ്ക്കുന്ന ക്ലാസ്സുകളാണ് കണ്ടെയ്നറുകൾ. അനുക്രമ കണ്ടെയ്നർ (sequence container) എന്നാൽ അതിലെ അംഗങ്ങൾക്ക് ഒരു നിശ്ചിത സ്ഥാനം കാണും. ഇത് കണ്ടെയ്നറിലേയ്ക്ക് അംഗം ഇട്ട സമയമോ സ്ഥാനമോ അനുസരിച്ചു ഇരിയ്ക്കും. പക്ഷെ ഒരിയ്ക്കലും അംഗത്തിന്റെ വിലയുമായി ബന്ധപ്പെട്ടല്ല ഈ സ്ഥാനം. സാഹചര്യ കണ്ടെയ്നർ (associative container) എന്നാൽ അതിലെ അംഗങ്ങളുടെ സ്ഥാനം അവയുടെ വിലയെ അടിസ്ഥാനപ്പെടുത്തി ഇരിയ്ക്കും. അതിനാൽ ഇത്തരം കണ്ടെയ്നറുകളിൽ ഇടുന്ന അംഗങ്ങളെ തമ്മിൽ താരതമ്യപ്പെടുത്താനായി അവയിൽ ഒരു താരതമ്യ ഓപ്പറേറ്റർ അത്യാവശ്യമാണ്.[6]
വെക്ടർ(vector), ഡീക്യൂ(deque), ലിസ്റ്റ് (list) എന്നിവയാണ് അനുക്രമ കണ്ടെയ്നറുകൾ. സെറ്റ്( set), മൾട്ടി സെറ്റ്( multiset), മാപ് map), മൾട്ടി മാപ്(multimap), ഹാഷ് സെറ്റ്(hash_set), ഹാഷ് മാപ്( hash_map), ഹാഷ് മൾട്ടി സെറ്റ്(hash_multiset ) ഹാഷ് മൾട്ടി മാപ്( hash_multimap) എന്നിവയാണ് സാഹചര്യ കണ്ടെയ്നറുകൾ.ഇത്തരം കണ്ടെയ്നറുകളെ അടിസ്ഥാനപ്പെടുത്തി നിർമിച്ച എന്ന വ്യത്യസ്ത ഇന്റർഫേസ് നൽകുന്ന ക്യൂ( queue), പ്രിയോറിറ്റി ക്യൂ(priority_queue), സ്റ്റാക്ക്(stack)എന്നീ കണ്ടെയ്നർ അഡാപ്റ്ററുകളും എസ്.ടി.എൽ നൽകുന്നു. .
| കണ്ടയ്നർ | വിവരണം |
|---|---|
| ലഘു കണ്ടെയ്നറുകൾ | |
| പെയർ(pair) | ഇതൊരു സാഹചര്യ കണ്ടെയ്നർ ആണ്. ഫസ്റ്റ്, സെക്കൻഡ് എന്നീ രണ്ടു ഒബ്ജക്റ്റുകളാണ് ഈ കണ്ടെയ്നറിൽ ഉണ്ടാവുക. ഈ ക്ലാസ് അടിസ്ഥാനമാക്കി ഉണ്ടാക്കുന്ന ഒബ്ജക്റ്റുകളെ കോപ്പി ചെയ്യാം, അസൈൻ ചെയ്യാം, താരതമ്യപ്പെടുത്താം. മാപ്പിലേയും ഹാഷ് മാപ്പിലേയും ഒബ്ജക്റ്റുകൾ പൊതുവെ ഈ ക്ലാസ്സുപയോഗിച്ചാണ് ഉണ്ടാക്കുക. ഇവിടെ ഫസ്റ്റ് ഒബ്ജക്റ്റ് എന്നുപറയുന്നത് മാപ്പിന്റെ കീയും സെക്കന്റ് എന്ന ഭാഗം അതിന്റെ വിലയും ആയിരിയ്ക്കും.. |
| അനുക്രമ കണ്ടെയ്നറുകൾ | |
| വെക്ടർ(vector) | റൺടൈമിൽ തന്നെ വലിപ്പം വ്യത്യാസപ്പെടുത്താവുന്ന ഒരു അടുക്ക് ആണ് എസ്.ടി.എൽ'ലെ വെക്ടർ. ഇതിലേയ്ക്ക് ഒരു ഒബ്ജക്റ്റ് ഇടുമ്പോൾ വേണ്ടത്ര വലിപ്പം ഇല്ലെങ്കിൽ അത് സ്വയം മെമ്മറി അലൊക്കേറ്റ് ചെയ്തു വലുതാവുകയും ഒരു ഒബ്ജക്റ്റ് എടുത്തു കളയുമ്പോൾ ആവശ്യത്തിനനുസരിച്ച് വലിപ്പം കുറയ്ക്കുകയും ചെയ്യും. ഇതിന്റെ പിന്നിൽ ഒരു ഒബ്ജക്റ്റ് ഇടാനായി എടുക്കുന്ന സമയം സ്ഥിരമാണ്. എടുത്തു കളയാനും സ്ഥിര സമയം മതി. എന്നാൽ ഇതിന്റെ മുന്നിലോ ഇടയിലോ ഇടാനോ എടുത്തു കളയാനോവേണ്ട സമയം അതിന്റെ വലിപ്പത്തിന് രേഖീയ അനുപാതത്തിൽ കൂടുന്നു. |
| ലിസ്റ്റ്(list) | ഇരട്ട കൊളുത്തുള്ള ലിങ്ക്ഡ് ലിസ്റ്റ് ആണ് ഇത്. ഇതിലെ അംഗങ്ങളെ മെമ്മറിയിൽ അടുത്തടുത്ത് ആയിട്ടല്ല സ്റ്റോർ ചെയ്തിരിയ്ക്കുക. അംഗങ്ങളെ കണ്ടു പിടിയ്ക്കാൻ ഉള്ള സമയ സങ്കീർണ്ണത രേഖീയം ആണ്. അംഗങ്ങളെ ഇടാൻ സ്ഥിരസമയം മതി. |
| എസ് ലിസ്റ്റ്(slist) |
ഒറ്റക്കൊളുത്തുള്ള ലിങ്ക്ഡ് ലിസ്റ്റ് ആണ് ഇത്. ഇതിലെ അംഗങ്ങളെ മെമ്മറിയിൽ അടുത്തടുത്ത് ആയിട്ടല്ല സ്റ്റോർ ചെയ്തിരിയ്ക്കുക. അംഗങ്ങളെ കണ്ടു പിടിയ്ക്കാൻ ഉള്ള സമയ സങ്കീർണ്ണത രേഖീയം ആണ്. അംഗങ്ങളെ ഇടാൻ സ്ഥിരസമയം മതി. ലിസ്റ്റിന് രണ്ടുവശത്തേയ്ക്കും സഞ്ചരിയ്ക്കാവുന്ന ഇറ്ററേറ്റർ ഉണ്ടെങ്കിൽ ഇതിന് ഒരു വശത്തേയ്ക്കുള്ള ഇറ്ററേറ്റർ മാത്രമേ ഉള്ളൂ എന്നതാണ് ഇതിന്റെ ന്യൂനത. എന്നാൽ ഉപയോഗിയ്ക്കുന്ന മെമ്മറി ലിസ്റ്റിനേക്കാൾ അല്പം കുറവായിരിയ്ക്കും. സി++ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ ഇത് ഫോർവേഡ് ലിസ്റ്റ് (forward_list) എന്ന പേരിൽ ഇമ്പ്ലെമെന്റ് ചെയ്തിട്ടുണ്ട്.
|
| ഡീക്യൂ അഥവാ ഡബിൾ എൻഡഡ്‌ ക്യൂ(deque (double-ended queue)) | ആദ്യമോ അവസാനമോ മാത്രം അംഗങ്ങളെ ഇടുകയോ എടുക്കുകയോ ചെയ്യാൻ മാത്രം പറ്റുന്ന ഒരു വെക്ടർ ആണിത്. ഇത് സ്ഥിര സമയത്തിൽ ചെയ്യാം. |
| കണ്ടെയ്നർ അഡാപ്റ്ററുകൾ | |
| ക്യൂ(queue) | "ആദ്യം ഉള്ളിലേയ്ക്ക് ഇടുന്നവ ആദ്യം പുറത്തേയ്ക്കു എടുക്കാം" (first in first out, FIFO) എന്ന തത്ത്വത്തെ അടിസ്ഥാനപ്പെടുത്തിയുള്ള ഒരു ക്യൂ ആണിത്. പുഷ് (push) / പോപ്പ്(pop) /ഫ്രന്റ്(front) / ബാക്ക് (back) തുടങ്ങിയ ക്യൂവിന്റെ സാധാരണ ഫങ്ക്ഷനുകൾ ഇതിലുണ്ട്.
|
| പ്രിയോറിറ്റി ക്യൂ(priority queue) | പ്രിയോറിറ്റി ക്യൂവിന്റെ ഇന്റർഫേസ് നൽകുന്നു. പുഷ് (push), പോപ്പ്(pop), ടോപ് (top) തുടങ്ങിയവയാണ് ഫങ്ക്ഷനുകൾ (ഏറ്റവും പ്രമുഖമായ അംഗം (with priority) ടോപ്പിൽ ആയിരിയ്ക്കും ).
ഇതിലെ അംഗങ്ങൾ പരസ്പരം താരതമ്യപ്പെടുത്താനുള്ള ഫങ്ക്ഷൻ കൊടുത്തിരിയ്ക്കണം. |
| സ്റ്റാക്ക്(stack) | P"അവസാനം ഉള്ളിലേയ്ക്ക് ഇടുന്നവ ആദ്യം പുറത്തേയ്ക്കു എടുക്കാം" (last in first out, LIFO) എന്ന തത്ത്വത്തെ അടിസ്ഥാനപ്പെടുത്തിയുള്ള സ്റ്റാക്ക് ആണിത്. പുഷ് (push), പോപ്പ്(pop), ടോപ് (top) തുടങ്ങിയവയാണ് ഫങ്ക്ഷനുകൾ. അവസാനം ഉള്ളിലേയ്ക്ക് ഇട്ട അംഗം ടോപ്പിൽ ഉണ്ടാകും. |
| സാഹചര്യ കണ്ടെയ്നറുകൾ | |
| സെറ്റ്(set) | ഗണിതത്തിലെ ഗണത്തിന് തുല്യമായ സെറ്റ് ആണിത്. സാധാരണ സെറ്റ് ഫങ്ക്ഷനുകളായ യൂണിയൻ (യോഗം), ഇന്റർസെക്ഷൻ (സംഗമം), ഡിഫറെൻസ് എന്നിവയും തന്നിരിയ്ക്കുന്ന ഒരംഗം സെറ്റിൽ ഉണ്ടോ എന്ന് നോക്കാനുള്ള ഫങ്ക്ഷനും ഇന്റർഫേസിൽ ഉണ്ടാകും. ഇതിലെ അംഗങ്ങൾ < എന്ന ഓപ്പറേറ്റർ ഇമ്പ്ലെമെന്റ് ചെയ്തിരിയ്ക്കണം. ഈ ഓപ്പറേറ്റർ സ്ട്രിക്ട് വീക്ക് ഓർഡറിങ് എന്ന തത്ത്വം പാലിച്ചിരിയ്ക്കണം. സാധാരണ സ്വന്തമായി തുലനം ചെയ്യുന്ന ഒരു ബൈനറി സെർച്ച് ട്രീ ഉപയോഗിച്ചാണ് സെറ്റ് ഇമ്പ്ലെമെന്റ് ചെയ്യാറ്. |
| മൾട്ടി സെറ്റ്(multiset) | സെറ്റ് പോലെ തന്നെ, പക്ഷെ ഇതിൽ ഒരംഗത്തിന്റെ ഡ്യൂപ്ലിക്കേറ്റ് ആയ അംഗവും ഉള്ളിലേയ്ക്ക് ഇടാം. |
| മാപ്(map) | ഇത് ഒരു കീ വിലയെ ഒരു മൂല്യ അംഗത്തിലേയ്ക്ക് മാപ് ചെയ്യാൻ ഉപയോഗിയ്ക്കുന്നു. ഇതിന്റെ കീ ആയി ഉപയോഗിയ്ക്കുന്ന ഒബ്ജക്റ്റുകളുടെ ടൈപ്പ് സ്ട്രിക്ട് വീക്ക് ഓർഡറിങ് എന്ന തത്ത്വം പാലിയ്ക്കുന്ന ഒരു < ഓപ്പറേറ്റർ ഇമ്പ്ലെമെന്റ് ചെയ്തിരിയ്ക്കണം. സാധാരണ സ്വന്തമായി തുലനം ചെയ്യുന്ന ഒരു ബൈനറി സെർച്ച് ട്രീ ഉപയോഗിച്ചാണ് സെറ്റ് ഇമ്പ്ലെമെന്റ് ചെയ്യാറ്. |
| മൾട്ടി മാപ്(multimap) | മാപ് പോലെ തന്നെ, പക്ഷെ ഇതിൽ ഡ്യൂപ്ലിക്കേറ്റ് ആയ കീകളും ഉള്ളിലേയ്ക്ക് ഇടാം. |
| ഹാഷ് സെറ്റ്(hash_set) ഹാഷ് മൾട്ടി സെറ്റ്(hash_multiset) |
യഥാക്രമം സെറ്റ്, മൾട്ടി സെറ്റ്, മാപ്, മൾട്ടി മാപ് എന്നിവ പോലെ തന്നെ. പക്ഷെ ഒരു ഹാഷ് ടേബിൾ ഉപയോഗിച്ചാണ് ഇവ ഇമ്പ്ലെമെന്റ് ചെയ്യുക. ഇവയിലെ കീകൾ ക്രമരഹിതമായിരിയ്ക്കും. പക്ഷെ കീകൾക്ക് ഒരു ഹാഷ് ഫങ്ക്ഷൻ ഉണ്ടായിരിയ്ക്കണം. സി++ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ നിന്നും ഇവ ഒഴിവാക്കപ്പെട്ടിരിയ്ക്കുന്നു. സി++11 ൽ ഇവ അൺ ഓർഡേർഡ്‌ സെറ്റ്(unordered_set), അൺ ഓർഡേർഡ്‌ മാപ്( unordered_map) എന്നീ പേരുകളിൽ ആണ് സി++ സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ കാണപ്പെടുന്നത്.
|
| മറ്റു തരം കണ്ടെയ്നറുകൾ | |
| ബിറ്റ്സെറ്റ്(bitset) | ഒരു കൂട്ടം ബിറ്റുകളുടെ ഒരു ക്രമമാണ് ബിറ്റ്സെറ്റ്. ഇതിന്റെ ഉപകാരം എന്താണെന്നു വെച്ചാൽ ഇതിൽ ബിറ്റ്വൈസ് ഓപ്പറേഷനുകൾ ചെയ്യാം. ഇതിന് ഇറ്ററേറ്റർ ഇല്ല. |
| വാൽ അറേ(valarray) | കൂടുതൽ വേഗതയുള്ള അടുക്കുകൾ നൽകാനുള്ള ഒരു ക്ലാസ് ആണിത്. സാധാരണയായി ഗണിത കണക്കുകൂട്ടലുകൾ ഇമ്പ്ലെമെന്റ് ചെയ്യാനാണ് ഇതുപയോഗിയ്ക്കുന്നത്. ഇതുപയോഗിച്ച് വളരെ നീണ്ട സദിശങ്ങളും (vector) ചതുരമൂശകളും (matrix) ഉണ്ടാക്കാം. |
ഇറ്ററേറ്ററുകൾ[തിരുത്തുക]
ഒരു കണ്ടെയ്നറിലെ വിലകളെ വീണ്ടെടുക്കാനും അവയെ മാറ്റാനും വേണ്ടി അവയെ ഒന്നിനു പിറകെ മറ്റൊന്നായി സന്ദർശിയ്ക്കാനുള്ള ഒരു വിദ്യയാണ് ഇറ്ററേറ്റർ (iterator). ഒരു സാധാരണ സി അടുക്കിന്റെ സ്ഥാനാങ്കം (index) എന്ന ആശയത്തെ വിപുലപ്പെടുത്തിയതാണ് ഇത്. മുന്നോട്ടു നീങ്ങാനായി ഒരു ++ ഓപ്പറേറ്ററും അംഗത്തെ ഡീറഫറൻസ് ചെയ്തു എടുക്കാനായി ഒരു * ഓപ്പറേറ്ററുമാണ് ഒരു ഇറ്ററേറ്ററിന്റെ പ്രധാന ഫങ്ക്ഷനുകൾ.[7] എസ്.ടി.എൽ അഞ്ചുതരത്തിലുള്ള ഇറ്ററേറ്ററുകൾ നൽകുന്നു.
- ഇന്പുട് ഇറ്ററേറ്ററുകൾ : ഒരു കൂട്ടം വിലകളുടെ അനുക്രമത്തിൽ (sequence) നിന്നും വായിയ്ക്കാൻ മാത്രം ഉപയോഗിയ്ക്കുന്നവ
- ഔട്ട്പുട്ട് ഇറ്ററേറ്ററുകൾ : ഒരു കൂട്ടം വിലകളുടെ അനുക്രമത്തിലേക്ക് (sequence) എഴുതാൻ മാത്രം ഉപയോഗിയ്ക്കുന്നവ
- ഫോർവേഡ് ഇറ്ററേറ്ററുകൾ : വായിയ്ക്കാനും, എഴുതാനും, മുന്നോട്ടേക്ക് നീക്കാനും പറ്റുന്നവ.
- ബൈ ഡൈറെക്ഷണൽ ഇറ്ററേറ്ററുകൾ : വായിയ്ക്കാനും, എഴുതാനും, മുന്നോട്ടേയ്ക്കും പിന്നോട്ടേയ്ക്കും നീക്കാനും പറ്റുന്നവ.
- റാൻഡം അക്സസ്സ് ഇറ്ററേറ്ററുകൾ : ഒറ്റതവണ തന്നെ എത്ര സ്റ്റെപ് വേണമെങ്കിലും നീക്കാൻ പറ്റുന്നവ.
അൽഗോരിതങ്ങൾ[തിരുത്തുക]
കണ്ടെയ്നറുകളിൽ പ്രവർത്തിയ്ക്കുന്ന ഒരു സാധാരണ പ്രോഗ്രാമർക്ക് ആവശ്യമുള്ള ഫങ്ക്ഷനുകളുടെ ഒരു കൂട്ടം ആണിത്.തിരയൽ (search), ക്രമീകരണം (sorting) അങ്ങനെ സാധാരണ ഉപയോഗിയ്ക്കാനുള്ള പല അൽഗോരിതങ്ങളും എസ്.ടി.എൽ തരുന്നു. സങ്കീർണ്ണത കുറയ്ക്കാനായി ഇവയെ കണ്ടെയ്നറുകളിൽ നിന്ന് വേർപെടുത്തി സ്വതന്ത്രമായ ക്ലാസുകൾ ആയാണ് എസ്.ടി.എൽ'ൽ രൂപീകരിച്ചിരിയ്ക്കുന്നത്. ഇത് പൊതുവേ ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിങിന്റെ ഡാറ്റയും അതിൽ പ്രവർത്തിയ്ക്കുന്ന ഫങ്ക്ഷനുകളെയും ഒരുമിച്ചു വയ്ക്കുക എന്ന അടിസ്ഥാന തത്ത്വത്തിന് എതിരായാണ് ഡിസൈൻ ചെയ്തിരിയ്ക്കുന്നത്. എങ്കിലും ഈ ഡിസൈൻ എസ്.ടി.എൽ'ന്റെ പൊതുവെയുള്ള സങ്കീർണ്ണത കുറയ്ക്കുകയും പുനരുപയോഗം വർദ്ധിപ്പിയ്ക്കുകയും ചെയ്യുന്നു.[4]
പൊതുവേ ഈ അൽഗോരിതങ്ങൾ ഒരു കണ്ടെയ്നർ ക്ലാസ് ഇന്പുട് ആയി എടുക്കുന്നതിനുപകരം അതിന്റെ ഇറ്ററേറ്റർ ആണ് എടുക്കുക.
ചരിത്രം[തിരുത്തുക]
അലക്സാണ്ടർ സ്റ്റെപ്പാണോവ് ആണ് ഇതിന്റെ ഉപജ്ഞാതാവ്. 1979 ൽ ജനറിക് പ്രോഗ്രാമിങ് എങ്ങനെ ചെയ്യാം എന്ന അദ്ദേഹത്തിന്റെ അന്വേഷണമാണ് എസ്.ടി.എൽ'ന്റെ രൂപവൽക്കരണത്തിൽ കലാശിച്ചത്. 1994 ൽ ആണ് ഇതിന്റെ ആദ്യ പ്രൊപോസൽ പുറത്തു വരുന്നത്.[8] എന്നാൽ ഇത് സി++'ൽ നിന്നും വ്യത്യസ്തമായ ഒരു ലൈബ്രറി ആയിട്ടാണ് നിർദ്ദേശിയ്ക്കപ്പെട്ടത്. ഹ്യുലെറ്റ്-പക്കാർഡ് 1994 ൽ ഇത് ഒരു ഫ്രീ ലൈബ്രറി ആയി ഇൻറർനെറ്റിൽ പബ്ലിഷ് ചെയ്തു. സ്റ്റെപ്പാണോവ് തന്നെയാണ് ഇതുണ്ടാക്കാനും മുഖ്യ പങ്കു വഹിച്ചത്.
ഇവ കൂടി കാണുക[തിരുത്തുക]
അവലംബം[തിരുത്തുക]
- ↑ Holzner, Steven (2001). C++ : Black Book. Scottsdale, Ariz.: Coriolis Group. p. 648. ISBN 1-57610-777-9.
The STL is made up of containers, iterators, function objects, and algorithms
- ↑ "Apache C++ Standard Library User's Guide". Apache. Retrieved 16 ഏപ്രിൽ 2018.
Containers in the C++ Standard Library can maintain a variety of different types of elements. These include the fundamental datatypes (int, char, and so on), pointers, or user-defined types. Containers cannot hold references. In general, memory management is handled automatically by the standard container classes through the allocator template parameter type.
- ↑ "C++ concepts: Container". Retrieved 16 ഏപ്രിൽ 2018.[പ്രവർത്തിക്കാത്ത കണ്ണി]
- ↑ 4.0 4.1 Josuttis, Nicolai M. (2018). The C++ Standard Library. A Tutorial and Reference. Addison Wesley. p. 89. ISBN 9780321623218.
All in all, this concept reduces the amount of code and increases the power and the flexibility of the library.
- ↑ Josuttis, Nicolai M. (2018). The C++ Standard Library. A Tutorial and Reference. Addison Wesley. p. 14. ISBN 9780321623218.
Almost all parts of the library are written as templates.
- ↑ Josuttis, Nicolai M. (2018). The C++ Standard Library. A Tutorial and Reference. Addison Wesley. p. 71. ISBN 9780321623218.
- ↑ Josuttis, Nicolai M. (2018). The C++ Standard Library. A Tutorial and Reference. Addison Wesley. p. 69. ISBN 9780321623218.
The interface for iterators is almost the same as for ordinary pointers. To increment an iterator you call operator ++. To access the value of an iterator you use operator *
- ↑ Josuttis, Nicolai M. (2018). The C++ Standard Library. A Tutorial and Reference. Addison Wesley. p. 14. ISBN 9780321623218.
Almost all parts of the library are written as templates.