șabloane în C++Edit

Articol principal: șablon (c++)

C++ utilizează șabloane pentru a activa tehnici de programare generice. Biblioteca standard C++ include biblioteca standard de șabloane sau STL care oferă un cadru de șabloane pentru structuri și algoritmi de date comune. Șabloanele în C++ pot fi, de asemenea, utilizate pentru metaprogramarea șabloanelor, care este o modalitate de pre-evaluare a unei părți a codului în timpul compilării, mai degrabă decât în timpul rulării. Folosind Specializarea șabloanelor, șabloanele C++ sunt considerate Turing complete.,prezentare generală Tehnicăwedit

există două tipuri de șabloane: șabloane de funcții și șabloane de clasă. Un șablon de funcție este un model pentru crearea de funcții obișnuite bazate pe tipurile de parametrizare furnizate atunci când instantiated. De exemplu, Biblioteca de șabloane standard C++ conține șablonul de funcții max(x, y) care creează funcții care returnează fie x, fie y, oricare dintre acestea este mai mare., max() ar putea fi definită astfel:

template <typename T>T max(T x, T y) { return x < y ? y : x;}

Specializari de această funcție șablon, eng cu tipuri specifice, poate fi numit la fel ca un obișnuit funcția:

std::cout << max(3, 7); // Outputs 7.

compilator examinează argumentele folosite pentru a apela max și stabilește că acesta este un apel la max(int, int)., Atunci instanțiază o versiune a funcției de unde parametrizarea tip T este int, ceea ce face echivalentă cu următoarea funcție:

int max(int x, int y) { return x < y ? y : x;}

Aceasta funcționează dacă argumentele x și y sunt numere întregi, șiruri de caractere, sau orice alt tip pentru care expresia x < y este sensibil, sau mai precis, pentru orice tip pentru care operatorul< este definit. Moștenirea comună nu este necesară pentru setul de tipuri care pot fi utilizate și, prin urmare, este foarte asemănătoare cu tastarea rață., Un program care definește un tip de date personalizat poate folosi supraîncărcarea operatorului pentru a defini semnificația < pentru acel tip, permițând astfel utilizarea acestuia cu șablonul funcției max (). În timp ce acest lucru poate părea un beneficiu minor în acest exemplu izolat, în contextul unei biblioteci cuprinzătoare precum STL, permite programatorului să obțină funcționalități extinse pentru un nou tip de date, doar definind câțiva operatori pentru acesta., Doar definirea < permite un tip pentru a fi utilizate cu standardul sort(), stable_sort(), și binary_search() algoritmi sau să fi pus în structuri de date, cum ar fi seturi, grămezi, și tablouri asociative.șabloanele C++ sunt complet sigure la momentul compilării. Ca o demonstrație, complexul de tip standard nu definește operatorul<, deoarece nu există o ordine strictă asupra numerelor complexe. Prin urmare, max(x, y) va eșua cu o eroare de compilare, dacă x și y sunt valori complexe., De asemenea, alte șabloane care se bazează pe < nu pot fi aplicate datelor complexe decât dacă este furnizată o comparație (sub forma unui functor sau a unei funcții). De exemplu: un complex nu poate fi folosit ca cheie pentru o hartă decât dacă este furnizată o comparație. Din păcate, compilatoarele generează istoric mesaje de eroare oarecum ezoterice, lungi și nefolositoare pentru acest tip de eroare. Asigurarea faptului că un anumit obiect aderă la un protocol de metodă poate atenua această problemă. Limbile care folosesc comparați în loc de < pot utiliza, de asemenea, valori complexe ca chei.,

al doilea tip de șablon, un șablon de clasă, extinde același concept la clase. O specializare șablon de clasă este o clasă. Șabloanele de clasă sunt adesea folosite pentru a face containere generice. De exemplu, STL are un container de listă legat. Pentru a face o listă înlănțuită de întregi, se scrie lista<int>. O listă de șiruri este notată lista<string>. O listă are un set de funcții standard asociate cu acesta, care funcționează pentru orice tipuri de parametrizare compatibile.,o caracteristică puternică a șabloanelor C++este specializarea șabloanelor. Acest lucru permite ca implementările alternative să fie furnizate pe baza anumitor caracteristici ale tipului parametrizat care este instanțiat. Specializarea șabloanelor are două scopuri: pentru a permite anumite forme de optimizare și pentru a reduce umflarea codului.

de exemplu, luați în considerare o funcție de șablon sort (). Una dintre activitățile principale pe care o astfel de funcție o face este de a schimba sau de a schimba valorile în două dintre pozițiile containerului., Dacă valorile sunt mari (în ceea ce privește numărul de octeți necesari pentru a stoca fiecare dintre ele), atunci este adesea mai rapid să construiți mai întâi o listă separată de indicii pentru obiecte, să sortați acei indicatori și apoi să construiți secvența sortată finală. În cazul în care valorile sunt destul de mici, cu toate acestea, este de obicei cel mai rapid pentru a schimba doar valorile în loc după cum este necesar. În plus, dacă tipul parametrizat este deja de un tip de pointer, atunci nu este nevoie să construiți o matrice de pointer separată., Specializarea șabloanelor permite creatorului de șabloane să scrie diferite implementări și să specifice caracteristicile pe care trebuie să le aibă tipul(tipurile) parametrizat (e) pentru fiecare implementare.spre deosebire de șabloanele de funcții, șabloanele de clasă pot fi parțial specializate. Aceasta înseamnă că o versiune alternativă a codului șablonului de clasă poate fi furnizată atunci când unii dintre parametrii șablonului sunt cunoscuți, lăsând în același timp alți parametri ai șablonului generici., Aceasta poate fi utilizată, de exemplu, pentru a crea o implementare implicită (Specializarea primară) care presupune că copierea unui tip de parametrizare este costisitoare și apoi crearea unor specializări parțiale pentru tipurile care sunt ieftine de copiat, crescând astfel eficiența generală. Clienții unui astfel de șablon de clasă folosesc doar specializări ale acestuia fără a fi nevoie să știe dacă compilatorul a folosit Specializarea primară sau o specializare parțială în fiecare caz., Șabloanele de clasă pot fi, de asemenea, complet specializate, ceea ce înseamnă că o implementare alternativă poate fi furnizată atunci când toate tipurile de parametrizare sunt cunoscute.

Avantajele și disadvantagesEdit

Unele utilizări de template-uri, cum ar fi funcția max (), au fost anterior umplut de funcție-ca preprocesor macro-uri (o moștenire a C limbaj de programare). De exemplu, aici este o posibilă max() macro:

#define max(a,b) ((a) < (b) ? (b) : (a))

macrocomenzile sunt extinse de preprocesor, înainte de compilare propriu-zisă; șabloanele sunt extinse la momentul compilării., Macrocomenzile sunt întotdeauna extinse inline; șabloanele pot fi extinse și ca funcții inline atunci când compilatorul consideră că este adecvat. Astfel, atât macro-urile, cât și șabloanele de funcții nu au cheltuieli generale.cu toate acestea, șabloanele sunt în general considerate o îmbunătățire față de macro-uri în aceste scopuri. Șabloanele sunt sigure pentru tip. Șabloanele evită unele dintre erorile comune găsite în cod care utilizează intens macro-urile asemănătoare funcțiilor, cum ar fi evaluarea parametrilor cu efecte secundare de două ori. Poate cel mai important, șabloanele au fost concepute pentru a fi aplicabile problemelor mult mai mari decât macrocomenzile.,există patru dezavantaje principale în utilizarea șabloanelor: caracteristici acceptate, suport compilator, mesaje de eroare slabe și bloat Cod:

  1. șabloanele din C++ nu au multe caracteristici, ceea ce face ca implementarea și utilizarea lor într-un mod simplu să fie adesea imposibilă. În schimb programatorii trebuie să se bazeze pe trucuri complicate care duc la cod umflat, greu de înțeles și greu de întreținut. Evoluțiile actuale ale standardelor C++ exacerbează această problemă prin utilizarea intensă a acestor trucuri și construirea unei mulțimi de noi caracteristici pentru șabloane pe ele sau cu ele în minte.,
  2. multe compilatoare au istoric un suport slab pentru șabloane, astfel utilizarea șabloanelor poate face codul ceva mai puțin portabil. Suportul poate fi, de asemenea, slab atunci când un compilator C++ este utilizat cu un linker care nu este conștient de C++sau când încercați să utilizați șabloane peste limitele bibliotecii partajate. Majoritatea compilatoarelor moderne au însă acum suport pentru șabloane destul de robust și standard, iar noul standard C++, C++11, abordează în continuare aceste probleme.
  3. aproape toate compilatoarele produc mesaje de eroare confuze, lungi sau uneori nefolositoare atunci când sunt detectate erori în codul care utilizează șabloane., Acest lucru poate face șabloanele dificil de dezvoltat.
  4. în cele din urmă, utilizarea șabloanelor necesită compilatorului să genereze o instanță separată a clasei sau funcției Template pentru fiecare permutare a parametrilor de tip utilizați cu acesta. (Acest lucru este necesar deoarece tipurile din C++ nu sunt toate de aceeași dimensiune, iar dimensiunile câmpurilor de date sunt importante pentru modul în care funcționează clasele.) Deci, utilizarea nediscriminatorie a șabloanelor poate duce la umflarea codului, rezultând executabile excesiv de mari., Cu toate acestea, utilizarea judicioasă a șablon de specializare și de derivare poate reduce dramatic de un astfel de cod umfla în unele cazuri:

Deci, poate derivare fi folosit pentru a reduce problema de cod de reprodus din cauza template-uri sunt folosite? Acest lucru ar implica derivarea unui șablon dintr-o clasă obișnuită. Această tehnică s-a dovedit de succes în reducerea codului bloat în uz real. Oamenii care nu folosesc o tehnică ca aceasta au descoperit că codul replicat poate costa megabytes de spațiu de cod chiar și în programe de dimensiuni moderate.,

— Bjarne Stroustrup, Proiectarea și Evoluția C++, 1994

in plus eng generate de template-uri poate provoca, de asemenea, debugger-ele să aibă dificultăți de lucru cu grație, cu template-uri. De exemplu, setarea unui punct de întrerupere de depanare într-un șablon dintr-un fișier sursă poate fie să rateze setarea punctului de întrerupere în instantierea reală dorită, fie poate seta un punct de întrerupere în fiecare loc în care șablonul este instanțiat.,

De asemenea, deoarece compilatorul trebuie să efectueze extinderi macro-like ale șabloanelor și să genereze diferite instanțe ale acestora la momentul compilării, codul sursă de implementare pentru clasa sau funcția template trebuie să fie disponibil (de exemplu, inclus într-un antet) codului care îl folosește. Clasele sau funcțiile template, inclusiv o mare parte din biblioteca de șabloane standard (STL), dacă nu sunt incluse în fișierele antet, nu pot fi compilate. (Acest lucru este în contrast cu codul non-templated, care poate fi compilat la binar, oferind doar un fișier antet declarații pentru codul folosind-o.,) Acest lucru poate fi un dezavantaj prin expunerea codului de implementare, care elimină unele abstracții și ar putea restricționa utilizarea acestuia în proiecte cu sursă închisă.

șabloane în DEdit

limbajul de programare D acceptă șabloane bazate în design pe C++.,Cele mai multe idiomuri de șabloane C++ vor fi transferate la D fără alterare, dar D adaugă unele funcționalități suplimentare:

  • parametrii șablonului în D nu sunt limitați doar la tipuri și valori primitive, ci permit și valori arbitrare de timp de compilare (cum ar fi șiruri și literale struct) și aliasuri la identificatori arbitrari, inclusiv alte șabloane sau
  • constrângerile șablonului și declarația statică if oferă o alternativă la eșecul de substituție al C++nu este un mecanism de eroare (SFINAE), similar cu conceptele C++.
  • este (…,) expression permite instanțierii speculative să verifice trăsăturile unui obiect la momentul compilării.
  • cuvântul cheie auto și expresia typeof permit inferența de tip pentru declarațiile variabile și valorile de returnare a funcțiilor, care la rândul lor permit „tipuri Voldemort” (tipuri care nu au un nume global).

Șabloane în D folosi o sintaxă diferită decât în C++: întrucât în C++ șablonul de parametri sunt învelite în paranteze unghiulare (Template<param1, param2>),D folosește un semn de exclamare și paranteze: Șablon!(param1, param2).,Acest lucru evită dificultățile de analiză C++ datorate ambiguității cu operatorii de comparație.Dacă există un singur parametru, parantezele pot fi omise.în mod convențional, D combină caracteristicile de mai sus pentru a oferi polimorfismul în timp de compilare folosind programarea generică bazată pe trăsături.,De exemplu, o gama de intrare este definit ca orice tip care satisface verificările efectuate de isInputRange, care este definit după cum urmează:

O funcție care acceptă numai de intrare variază pot apoi folosi modelul de mai sus într-un șablon de constrângere:

auto fun(Range)(Range range) if (isInputRange!Range){ // ...}
Cod generationEdit

În plus față de șablon metaprogram, D, de asemenea, oferă mai multe caracteristici pentru a permite compilare-timp de generare de cod:

  • import exprimare permite citirea unui fișier de pe disc și folosind conținutul său ca un șir de exprimare.,
  • compilarea-timp de reflecție permite enumerarea și inspectarea declarațiilor și a membrilor lor în timpul compilării.
  • atributele definite de utilizator permit utilizatorilor să atașeze identificatori arbitrari la declarații, care pot fi apoi enumerați folosind reflecția în timp de compilare.
  • Compile-Time Function Execution (CTFE) permite ca un subset de D (limitat la operații sigure) să fie interpretat în timpul compilării.
  • mixinele String permit evaluarea și compilarea conținutului unei expresii string ca cod D care devine parte a programului.,combinarea celor de mai sus permite generarea de cod pe baza declarațiilor existente.De exemplu, cadrele de serializare D pot enumera membrii unui tip și pot genera funcții specializate pentru fiecare tip serializat pentru a efectua serializarea și deserializarea.Atributele definite de utilizator ar putea indica în continuare reguli de serializare.expresia de import și execuția funcției de compilare permit, de asemenea, implementarea eficientă a limbajelor specifice domeniului.,De exemplu, o funcție care ia un șir care conține un șablon HTML și se întoarce echivalent D cod sursă, este posibil să-l folosească în felul următor:

    Genericitatea în EiffelEdit

    Generic clase au fost o parte a Eiffel din metoda originală și limbaj de design. Publicațiile Fundației Eiffel, folosesc termenul genericitate pentru a descrie crearea și utilizarea claselor generice.

    Genericityedit de bază/neconstrâns

    clasele generice sunt declarate cu numele clasei lor și o listă cu unul sau mai mulți parametri generici formali., În codul de mai jos, clasa LIST are una formală parametrul generic G

    formală parametrii generici sunt substituenți pentru arbitrară de clasă nume care vor fi furnizate atunci când o declarație de clasă generică este făcut, așa cum se arată în cele două generic derivatii de mai jos, unde ACCOUNT și DEPOSIT sunt alte nume de clasa. ACCOUNT și DEPOSIT sunt considerate real parametrii generici ca vor oferi un nume de clasa a substitui G în utilizarea reală.,

     list_of_accounts: LIST -- Account list list_of_deposits: LIST -- Deposit list

    în Cadrul Eiffel tip de sistem, deși clasa LIST este considerat o clasă, nu este considerat un tip. Cu toate acestea, o derivare generică a LIST cum ar fi LIST este considerată un tip.

    Constrâns genericityEdit

    Pentru lista de clasa a arătat mai sus, un real parametrul generic substituie G poate fi orice alt disponibile în clasă., Pentru a constrânge setul de clase din care pot fi aleși parametrii generici valizi, poate fi specificată o constrângere generică. În declarația de clasa SORTED_LIST mai jos, generic constrângere impune ca orice valabile real parametrul generic va fi o clasă care moștenește de la clasa COMPARABLE. Constrângerea generică asigură că elementele unui SORTED_LIST pot fi de fapt sortate.,

    class SORTED_LIST

    Generice în JavaEdit

    articol Principal: Generics în Java

    Suport pentru medicamentele generice, sau „containere-de-tip-T” a fost adăugat la limbajul de programare Java în 2004, ca parte a J2SE 5.0. În Java, genericele sunt verificate numai la momentul compilării pentru corectitudinea tipului. Informațiile de tip generic sunt apoi eliminate printr-un proces numit type erasure, pentru a menține compatibilitatea cu implementările JVM vechi, făcându-l indisponibil în timpul rulării., De exemplu, o listă<String> este convertită în lista de tip raw. Compilatorul introduce tipul de aruncări pentru a converti elementele la tipul de șir atunci când sunt preluate din listă, reducând performanța în comparație cu alte implementări, cum ar fi șabloanele C++.generice au fost adăugate ca parte a. Net Framework 2.0 În noiembrie 2005, pe baza unui prototip de cercetare de la Microsoft Research a început în 1999. Deși similar cu generice în Java,.,Genericele nete nu aplică ștergerea de tip, ci implementează generice ca mecanism de primă clasă în timpul rulării folosind reificarea. Această alegere de design oferă funcționalități suplimentare, cum ar fi permiterea reflecției cu conservarea tipurilor generice, precum și atenuarea unora dintre limitările ștergerii (cum ar fi imposibilitatea de a crea matrice generice). Acest lucru înseamnă, de asemenea, că nu există nici un hit de performanță de la distribuții de rulare și conversii de box în mod normal scumpe., Când tipurile primitive și de valoare sunt folosite ca argumente generice, ele obțin implementări specializate, permițând colecții și metode generice eficiente. La fel ca în C++ și Java, imbricate tipuri generice, cum ar fi Dicționarul<string, Lista<int>> sunt valabile tipuri, cu toate acestea sunt contraindicate pentru statele semnături în codul analiza reguli de proiectare.

    .,NET permite șase varietăți de constrângeri de tip generic folosind cuvântul cheie where, inclusiv restricționarea tipurilor generice pentru a fi tipuri de valori, pentru a fi clase, pentru a avea constructori și pentru a implementa interfețe. Mai jos este un exemplu cu o interfață constrângere:

    MakeAtLeast() metoda permite operarea la tablouri cu elemente de tip generic T. metoda de tip constrângere indică faptul că metoda este aplicabilă la orice tip T care implementează generic în aplicare icomparable<T> interfață., Aceasta asigură o eroare de timp de compilare, dacă metoda este apelată dacă tipul nu acceptă comparația. Interfața oferă metoda generică CompareTo (T).metoda de mai sus ar putea fi, de asemenea, scrisă fără tipuri generice, folosind pur și simplu Tipul de matrice non-generic. Cu toate acestea, deoarece matricele sunt contravariante, turnarea nu ar fi sigură de tip, iar compilatorul nu ar putea găsi anumite erori posibile care altfel ar fi prinse atunci când se utilizează tipuri generice. În plus, metoda ar trebui să acceseze elementele de matrice ca obiecte în schimb, și ar necesita turnare pentru a compara două elemente., (Pentru valoarea tipuri de astfel de tipuri, cum ar fi int acest lucru necesită un box de conversie, deși acest lucru poate fi lucrat în jurul valorii de folosind Comparer<T> clasa, cum se face în standard colecție de clase.)

    un comportament notabil al membrilor statici într-o clasă.net generică este instanțierea statică a membrilor pe tip de rulare (vezi exemplul de mai jos).

    Genericitate în DelphiEdit

    dialectul Pascal al obiectului Delphi a dobândit generice în versiunea Delphi 2007, inițial doar cu (acum întrerupt).,NET compilator înainte de a fi adăugat la codul nativ în Delphi 2009 de presă. Semantica și capacitățile Delphi generics sunt în mare parte modelate pe cele pe care le-au avut generics în. Net 2.0, deși implementarea este prin necesitate destul de diferită. Iată o traducere mai mult sau mai puțin directă a primului exemplu C# prezentat mai sus:

    ca și în cazul C#, metodele precum și tipurile întregi pot avea unul sau mai mulți parametri de tip. În exemplu, TArray este un tip generic (definit de limbă) și facecel puțin o metodă generică., Constrângerile disponibile sunt foarte asemănătoare cu constrângerile disponibile în C#: orice tip de valoare, orice clasă, o anumită clasă sau interfață și o clasă cu un constructor fără parametri. Constrângerile Multiple acționează ca o uniune aditivă.

    Genericitate în PascalEdit liber

    Free Pascal a implementat generice înainte de Delphi și cu sintaxă și semantică diferite. Cu toate acestea, de la versiunea FPC 2.6.0, sintaxa în stil Delphi este disponibilă atunci când se utilizează modul de limbă {$mode Delphi}. Astfel, programatorii Free Pascal sunt capabili să folosească generice în orice stil preferă.,

    Delphi și Free Pascal exemplu:

    Funcțional languagesEdit

    Genericitatea în HaskellEdit

    tip clasa mecanism de Haskell sprijină generic de programare.Șase dintre clasele de tip predefinite din Haskell (inclusiv Eq, tipurile care pot fi comparate pentru egalitate și arată, tipurile ale căror valori pot fi redate ca șiruri) au proprietatea specială de a susține instanțe derivate., Aceasta înseamnă că un programator care definește un nou tip poate afirma că acest tip trebuie să fie o instanță a uneia dintre aceste clase de tip special, fără a furniza implementări ale metodelor de clasă, așa cum este de obicei necesar atunci când se declară instanțe de clasă. Toate metodele necesare vor fi „derivate” – adică construite automat-pe baza structurii tipului.,De exemplu, următoarea declarație a unui tip de arbori binari afirmă că este de a fi un exemplu de clase Eq și Arată:

    data BinTree a = Leaf a | Node (BinTree a) a (BinTree a) deriving (Eq, Show)

    Acest lucru duce la o egalitate de funcție (==) și un șir de reprezentare funcția (show) fiind definite în mod automat pentru orice tip de formă BinTree T cu condiția ca T se sprijină operațiunile respective.,

    suport pentru derivate cazuri de Eq și Spectacolul face lor metode == și arată generic într-un mod calitativ diferit de para-metrically polimorfă funcții: aceste „funcții” (mai precis, de tip indexate familii de funcții) pot fi aplicate la valori de diverse tipuri, și, deși se comportă în mod diferit pentru fiecare tip argument, pic de lucru este nevoie pentru a adăuga suport pentru un tip nou. Ralf Hinze (2004) a arătat că un efect similar poate fi obținut pentru clasele de tip definite de utilizator prin anumite tehnici de programare., Alți cercetători au propus abordări pentru acest tip și alte tipuri de genericitate în contextul Haskell și extensiile la Haskell (discutate mai jos).

    PolyPEdit

    polip a fost prima extensie generică a limbajului de programare Haskell. În polip, funcțiile generice se numesc politipice. Limbajul introduce o construcție specială în care astfel de funcții politipice pot fi definite prin inducție structurală peste structura funcționorului de model al unui tip de date obișnuit. Tipuri de date regulate în polip sunt un subset de Haskell datatypes., Un tip de date T obișnuit trebuie să fie de tip * → *, iar dacă a este argumentul de tip formal din definiție, atunci toate apelurile recursive către t trebuie să aibă forma t A. aceste restricții exclud tipurile de date de tip superior, precum și tipurile de date imbricate, unde apelurile recursive sunt de o formă diferită.Funcția aplatiza în polip este aici furnizat ca un exemplu:

    generic HaskellEdit

    Generic Haskell este o altă extensie a Haskell, dezvoltat la Universitatea Utrecht din Olanda., Extensiile pe care le oferă sunt:

    • valorile indexate de tip sunt definite ca o valoare indexată pe diferiți constructori de tip Haskell (unitate, tipuri primitive, sume, produse și constructori de tip definiți de utilizator). În plus, putem specifica, de asemenea, comportamentul valorilor indexate de tip pentru un constructor specific folosind cazuri de constructor și reutilizăm o definiție generică în alta folosind cazuri implicite.

    valoarea indexată de tip rezultată poate fi specializată pentru orice tip.

    • tipurile indexate Kind sunt tipuri indexate peste tipuri, definite dând un caz atât pentru*, cât și pentru k → k’., Instanțele sunt obținute prin aplicarea tipului indexat la un fel.
    • definițiile generice pot fi utilizate prin aplicarea lor la un tip sau tip. Aceasta se numește aplicație generică. Rezultatul este un tip sau o valoare, în funcție de tipul de definiție generică aplicată.
    • abstractizarea generică permite definirea definițiilor generice prin abstractizarea unui parametru de tip (de un anumit tip).
    • tipurile indexate de tip sunt tipuri care sunt indexate pe constructorii de tip. Acestea pot fi folosite pentru a da tipuri de valori generice mai implicate., Tipurile indexate de tip rezultate pot fi specializate pentru orice tip.

    Ca un exemplu, egalitatea funcționeze în Generic Haskell:

    CleanEdit

    Curata oferă generic de programare bazat Polip și generic Haskell sprijinite de GHC>=6.0. Acesta parametrizes de fel ca cele, dar oferă supraîncărcarea.

    alte limbiedit

    familia ML de limbaje de programare suportă programarea generică prin polimorfism parametric și module generice numite funcori.,Atât ML standard, cât și OCaml oferă funcții, care sunt similare cu șabloanele de clasă și cu pachetele generice ale Ada. Schema abstracțiile sintactice au, de asemenea, o legătură cu genericitatea – acestea sunt de fapt un superset de templating à la c++.

    un modul Verilog poate lua unul sau mai mulți parametri, cărora valorile lor reale sunt atribuite la instanțierea modulului. Un exemplu este o matrice registru generic în cazul în care lățimea matrice este dată printr-un parametru., O astfel de matrice, combinat cu un vector de sârmă generic, poate face un tampon generic sau modul de memorie cu o lățime de biți arbitrară dintr-o singură implementare modul.

    VHDL, fiind derivat din Ada, are, de asemenea, capabilități generice.