Definisjon av generisk funksjon

def identity(k): return k def cube(k): return pow(k, 3) def square(k): return pow(k,2) def summation(n, term): if n == 0: return 0 else: return term(n) + summation(n-1, term) def sum_cubes(n): return summation(n, cube) if __name__ == "__main__": sum = sum_cubes(4) print(sum) """ In C, We can implement the same using function pointers. Goal is, to perform similar operations(Sum of ..) using single function summation()""" 

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); 

Generiske funksjoner tar typen av minst ett funksjonsargument generisk ved kompileringstidspunktet. Det vil si at kompilatoren finner ut hvilken type som brukes på et bestemt sted og bruker nøyaktig denne typen der den brukes i funksjonen. F.eks. hvis du har et generelt argument i funksjonen din som brukes med en + -operatør, må typen ha passende metoder. For strenger / arrays vil dette i mange tilfeller være en sammenkobling og for og heltall / flyte et tillegg. Kompilatoren kan oppdage at en bruker riktig operasjon. C-rutinen din er ikke generisk i den forstand, siden det er programmereren som bruker litt størrelsesinformasjon og ikke kompilatoren som oppdager typen og bruker riktig størrelse.

F.eks. På noe fiktivt språk

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

Her oppdager kompilatoren i det første tilfellet at to strenger brukes og vil utvide noe sånt som

func add(p1:string, p2:string) 

og behandle + som sammenkobling, mens det i det andre tilfellet vil utvides

func add(p1:int, p2:int) 

som levert heltallsparametere. Generisk betyr at kompilatoren genererer individuell kode i løpet av kompileringstiden. Python er for eksempel ikke skrevet og vil gjøre den typen erstatning under kjøretiden. Betyr: Python har ikke generiske funksjoner siden alt er slags generisk.

Kommentarer

• Fikk ikke ideen din. du mener + er en generisk funksjon, syntaksen i C ++?
• Argumenter for funksjonsfunksjonen er høyere orden funksjon s i Python / JavaScript-verden. I C trenger vi funksjonspekere for det samme.
• Se min redigering ovenfor.
• Så hva slags funksjon er summation, Høyere ordrefunksjon? og ikke noe mer enn det?
• Det er mange definisjoner for hva generisk er. Stroustrup definerer for eksempel det som » programmering ved hjelp av typer som parametere «. For wikipedia-referansen går jeg ‘ heller til: en.wikipedia.org/wiki/Generic_programming

Jeg skal starte dette fra perspektivet til C ++, og deretter jobbe meg inn i C.

På statisktypede språk som C, C ++, Java, etc., lar en «generisk» funksjon deg spesifisere funksjonsoperasjonene en gang ved å bruke plassholdere for alle typer som kan variere mellom forskjellige samtaler (som betyr at funksjoner som qsort og bsearch er absolutt ikke generiske funksjoner). Ideelt sett vil du også at kompilatoren automatisk skal oppdage samtaler til denne generiske funksjonen og generere den faktiske koden etter behov.

C ++ gjør dette enkelt ¹ ved å tilby maler :

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 er en plassholder for alle typer ² , så du kan kalle det som

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 ); 

Når koden er kompilert, ser kompilatoren de to anropene til summation og educerer typene av argumentene. For hver annen type genererer den en ny forekomst av funksjonen, og gir den et unikt navn:

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; ... } 

Den genererer deretter kode slik at resultatet av summation_i er tildelt sumi og summation_d tildeles sumd.

C tilbyr ikke noe som ligner på malfunksjonen. Tradisjonelt har vi angrepet generisk programmering på en av to måter – enten ved å bruke makroer eller ved å bruke void * overalt og delegere typebevisste operasjoner til andre funksjoner.

Her er et dårlig eksempel på en makrobasert løsning:

#include <stdio.h> #define SUMMATION_DEF(t) \ t summation_##t( t *values, size_t numValues ) \ { \ t result = 0; \ for ( size_t i = 0; i < numValues; i++ ) \ result += values[i]; \ return result; \ } #define SUMMATION(t,x,s) summation_##t(x, s) SUMMATION_DEF(int) SUMMATION_DEF(double) int main( void ) { int ivals[] = {1, 2, 3, 4, 5}; double dvals[] = {1, 2, 3, 4, 5}; int sumi = SUMMATION(int, ivals, 5); double sumd = SUMMATION(double, dvals, 5); printf( "sumi = %d\n", sumi ); printf( "sumd = %f\n", sumd ); return 0; } 

SUMMATION_DEF er omtrent lik en mal ved at den spesifiserer funksjonsoperasjonene, ved hjelp av makroparameteren t som en plassholder. Vi bruker også t som en del av funksjonsnavnet – ## er symbolet for liming av token, og forprosessoren vil utvide t og legg den verdien til navnet på funksjonen ³ .

Hvor den skiller seg fra C ++, er det faktum at en makro bare er en dum tekstutskiftning. eventuelle spesielle operasjoner fra kompilatorens side. De faktiske funksjonsforekomstene genereres ikke automatisk basert på alle påkallelser av SUMMATION makroen – vi må eksplisitt generere de funksjonene vi ønsker (derav SUMMATION_DEF(int) og SUMMATION_DEF(double) før main). Det betyr også at når vi kaller summation_xxx gjennom SUMMATION makroen, må vi passere typen som en del av listen over makroargumenter, slik at den rette funksjonen blir kalt. For en smerte.

C 2011-standarden la til _Generic søkeordet, noe som kan gjøre livet litt lettere i så måte:

#include <stdio.h> #define SUMMATION_DEF(t) \ t summation_##t( t *values, size_t numValues ) \ { \ t result = 0; \ for ( size_t i = 0; i < numValues; i++ ) \ result += values[i]; \ return result; \ } #define SUMMATION(x,s) _Generic((x), \ int * : summation_int, \ double * : summation_double \ )(x, s) SUMMATION_DEF(int) SUMMATION_DEF(double) int main( void ) { int ivals[] = {1, 2, 3, 4, 5}; double dvals[] = {1, 2, 3, 4, 5}; int sumi = SUMMATION(ivals, 5); double sumd = SUMMATION(dvals, 5); printf( "sumi = %d\n", sumi ); printf( "sumd = %f\n", sumd ); return 0; } 

The _Generic nøkkelord lar deg evaluere uttrykk basert på typer ; dermed hvis typen av det første argumentet til SUMMATION er int *, vi kaller summation_int; det «s it» s double *, vi kaller summation_double. På denne måten trenger vi ikke å spesifisere typenavnet i makroargumentene.

Den andre tilnærmingen, som du har sett, er å bruke void * og å delegere typebevisste operasjoner til andre funksjoner. Som jeg sa ovenfor, at » s egentlig ikke «generisk» programmering, siden du må implementere hver sammenligningsfunksjon manuelt for hver type. Du kan ikke bare kode det en gang og være ferdig med det. Og ved å bruke void * kaster du i utgangspunktet typesikkerhet ut av vinduet og inn i møtende trafikk.

Og før noen klager – nei, ingen av disse summeringsfunksjonene ser etter eller tar for seg aritmetisk overløp. Det er et emne for en annen dag.

---

1. For tilstrekkelig løse definisjoner av «lett». Metaprogrammeringsspråket som brukes til å støtte maler er Turing-komplett, så du kan gjøre * virkelig fantastisk * og umulig å forstå ting med det.
2. For tilstrekkelig løse definisjoner av «hvilken som helst type». Merk at uansett hvilken type du bruker må støtte += operatøren, ellers vil kompilatoren rope på deg.
3. Denne koden brytes for typer som unsigned int eller long double siden de har et mellomrom i navnet. Jeg vet ikke umiddelbart løsningen på det problemet, og jeg har brukt nok tid på dette svaret slik det er.