Az általános függvény meghatározása

A” generikus “kifejezésnek több jelentése van.

Informális meghatározás

“általános” a mindennapi nyelvben olyasvalami, amely közös tulajdonságokkal rendelkezik, de bizonyos szempontból kevésbé specifikus.

Ebben a perspektívában megfontolhatja az qsort() általános nevet: ennek a függvénynek a kódját képes rendezni bármilyen rögzített méretű adatszerkezetet, amelyhez összehasonlítási függvényt határozhat meg a QSORT algoritmus használatával.

Ugyanez vonatkozik a summation() függvényedre is, amely a függvények használatával kapott kifejezéseket egyetlen paraméterrel foglalja össze.

Formális meghatározás

A programozási nyelvek, például a C ++ vagy a Java, lehetővé teszik az általános programozást sablonok vagy generikusok használatával:

Definíció a C ++ 14 szabványból : A sablon osztály- vagy függvénycsaládot vagy álnevet definiál egy típuscsaládhoz.

Az elv az, hogy egy osztály vagy egy függvény megvalósítását típusok szerint lehet paraméterezni.

E formálisabb nézőpont szerint qsort() nem általános függvény. Megvalósításának nem kell meghatároznia a fordítás során semmilyen típust, viselkedése pedig típusfüggetlen. Az egyetlen dolog, amire szüksége van, az a rendezendő elemek mérete, és ez a méret egy hétköznapi argumentum, amelyet futás közben dolgoznak fel.

olyan nyelv esetében, amely nincs statikusan beírva, például Python , nem vagyok biztos benne, mit válaszoljak a . Úgy gondolom, hogy nem általános, mert a megvalósítása és viselkedése nem típusfüggő: ez a függvény csak egy magasabb rendű függvény, a term argumentummal Nem használ olyan funkciót, amely típusok alapján megváltoztatná ennek a függvénynek a viselkedését.

Egy általános függvény szemléltetéséhez nézze meg a C ++ szabványos függvényt std::sort() : végrehajtása az argumentumok típusától függ (és adott esetben egy összehasonlító függvény egy meghatározott típusú argumentumokkal). A C ++ sablonok szolgáltatásainak felhasználásával bármilyen típusú tárolót rendezhet, azzal a feltétellel, hogy rendelkezik az operátorokkal / tagfunkciókkal / vonásokkal / iterátorokkal, amelyekre az általános függvény megvalósítása szükséges.

Lehet-e egy dinamikus gépelt nyelvnek általános funkciója?

A dinamikusan beírt nyelv megköveteli kevesebb általános kód, mint a statikusan tipizált nyelvek.

Ha például van dinamikus típusú objektumokból álló tárolója, akkor a qsort függvény generikusan rendezheti a tárolót, amennyiben a tároló két elemének bármilyen kombinációja összehasonlítható.

De ilyen rugalmas környezetben is hasznos lehet az általános – típusfüggő – programozás. A tipikus használati eset a multimódok, ahol a viselkedés vagy a kód függ az argumentumok típusától vagy akár a típusok kombinációjától (például két különböző alakzat metszéspontjának meghatározásához). További információ:

• Általános programozási csomag a python számára: multidispatching
• Az általános függvények használhatóvá tétele a smalltalk alkalmazásban
• Példa a General Lisp általános funkcióira

Megjegyzések

• Nem biztos, miért hasonlítjuk össze a generikusakat (főleg arra használják, hogy elkerüljék a Java-típusok átküldését (lásd: specifikáció vagy oktatóanyag ). Mindazonáltal ‘ enyhén szerkesztettem a definíciós részt, hogy foglalkozzon a megjegyzésével.
• A Python Generic csomagjának semmi köze az általános függvényekhez. Kivéve, ha ugyanaz a melléknév van.
• @Killian, ha általános programozás , arról szól, hogy elvonatkoztatnak a konkrét, hatékony algoritmusoktól. különböző algoritmusok megszerzéséhez, amelyek különböző adatábrázolásokkal kombinálhatók , úgy gondolom, hogy az adott csomagban szereplő multimódoknak be kell lenniük, ne gondolja

Az általános függvények legalább egy függvény argumentumának típusát veszik át fordításkor. Vagyis a fordító kideríti, hogy egy adott helyen melyik típust használják, és pontosan ezt a típust alkalmazza ott, ahol a függvényben használják. Például. ha a függvényében van egy általános argumentum, amelyet egy + operátorral használnak, akkor a típusnak megfelelő módszerekkel kell rendelkeznie. A karakterláncok / tömbök esetében ez sok esetben összefűzés, az egész szám / lebegés pedig összeadás lehet. A fordító észlelheti, hogy egy alkalmazás helyes műveletet alkalmaz. A C rutin ebben az értelemben nem általános, mivel a programozó alkalmaz bizonyos méretinformációkat, és nem a fordító észleli a típust és a megfelelő méretet használja.

Pl. Valamilyen fiktív nyelven

func add(p1,p2) { return p1+p2 } print add("a", "b") // yields "ab" print add(1, 2) // yields 3 

Itt a fordító első esetben észleli, hogy két karakterláncot alkalmaznak, és belsőleg kibővítenek például

func add(p1:string, p2:string) 

és a + -t összefűzésként kezelje, míg a második esetben ez kibővül

func add(p1:int, p2:int) 

egész paraméterek. Általános azt jelenti, hogy a fordító a fordítási idő alatt egyedi kódot generál. A Python például be van írva, és futás közben ilyen típusú helyettesítést hajt végre. Azt jelenti: A Pythonnak nincsenek általános funkciói, mivel minden valamiféle általános.

Megjegyzések

• Nem jött létre az ötleted. Úgy érted, hogy a + egy általános függvény, szintaxis a C ++ nyelven?
• A függvényfüggvény-argumentumok magasabb rendűek funkció s a Python / JavaScript világban. A C-ben függvénymutatókra van szükségünk.
• Lásd a fenti szerkesztésemet.
• Tehát milyen funkció a summation, Magasabb rendű funkció? és ezen kívül semmi más?
• Nagyon sok definíció létezik a generikus kifejezésre vonatkozóan. A Stroustrup például ” programozásként definiálja a típusokat paraméterként “. A wikipédia használatához inkább

Ezt a C ++ perspektívájából fogom kezdeni, majd továbbmegyek C-be.

Az olyan statikusan beírt nyelvekben, mint a C, C ++, Java, stb., egy “általános” függvény lehetővé teszi a függvényműveletek egyszer megadását, helyettesítők használatával minden típushoz, amely változhat a különböző hívások között (ami azt jelenti, hogy olyan funkciók vannak, mint qsort és bsearch, egészen biztosan not általános függvények). Ideális esetben azt is szeretné, ha a fordító automatikusan észlelné az általános függvény minden hívását, és szükség esetén létrehozná a tényleges kódot.

A C ++ megkönnyíti ezt a ¹ -et azáltal, hogy sablonokat kínál:

template <typename T> T summation( T *values, size_t numValues ) { T result = 0; for ( size_t i = 0; i < numValues; i++ ) result += values[i]; return result; } 

T bármely ² típus helyőrzője, ezért hívhatja:

int ivals[] = {1,2,3,4,5,6,7,8,9}; double dvals[] = {1,2,3,4,5,6,7,8,9}; int sumi = summation( ivals, 10 ); double sumd = summation( dvals, 10 ); 

A kód fordításakor a fordító meglátja a két hívást a summation címre, és levezeti az argumentumok típusait. Minden más típushoz generál egy új példányt a függvényből, egyedi nevet adva neki:

int summation_i( int *values, size_t numValues ) // actual compilers will generate { // more complex "mangled" names int result = 0; // than this ... } double summation_d( double *values, size_t numValues ) { double result = 0; ... } 

Ezután kódot generál oly módon, hogy a summation_i eredményt a sumi és a summation_d fájlhoz hozzárendeljük id = “1d3d5f0441”>