Definition der generischen Funktion

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

Generische Funktionen nehmen zum Zeitpunkt der Kompilierung generisch den Typ mindestens eines Funktionsarguments an. Das heißt, der Compiler findet heraus, welcher Typ an einer bestimmten Stelle verwendet wird, und wendet genau diesen Typ an, wo er in der Funktion verwendet wird. Z.B. Wenn Ihre Funktion ein generisches Argument enthält, das mit einem Operator + verwendet wird, muss der Typ über geeignete Methoden verfügen. Für Strings / Arrays wäre dies in vielen Fällen eine Verkettung und für und Integer / Float eine Addition. Der Compiler kann erkennen, dass eine die richtige Operation anwendet. Ihre C-Routine ist in diesem Sinne nicht generisch, da der Programmierer einige Größeninformationen anwendet und nicht der Compiler den Typ erkennt und die richtige Größe verwendet.

ZB in einer fiktiven Sprache

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

Hier erkennt der Compiler im ersten Fall, dass zwei Zeichenfolgen angewendet werden, und erweitert intern so etwas wie

func add(p1:string, p2:string) 

und behandeln Sie die + als Verkettung, während sie im zweiten Fall

func add(p1:int, p2:int) 

wie angegeben erweitert wird Ganzzahlige Parameter. Generisch bedeutet, dass der Compiler während der Kompilierungszeit individuellen Code generiert. Python ist beispielsweise untypisiert und würde diese Art der Ersetzung zur Laufzeit durchführen. Mittel: Python verfügt nicht über generische Funktionen, da alles generisch ist.

Kommentare

• Sie haben Ihre Idee nicht verstanden. Sie meinen, + ist eine generische Funktion, Syntax in C ++?
• Funktionsargumente mit höherer Funktion sind von höherer Ordnung Funktion s in der Python / JavaScript-Welt. In C benötigen wir dafür Funktionszeiger.
• Siehe meine Bearbeitung oben.
• Also, welche Art von Funktion ist summation, Funktion höherer Ordnung? und nichts weiter als das?
• Es gibt viele Definitionen für das, was generisch ist. Stroustrup definiert es beispielsweise als “ -Programmierung unter Verwendung von Typen als Parameter „. Für die Wikipedia-Referenz gehe ich ‚ lieber zu: en.wikipedia.org/wiki/Generic_programming

Ich werde dies aus der Perspektive von C ++ beginnen und mich dann in C hineinarbeiten.

In statisch typisierten Sprachen wie C, C ++, Java usw. können Sie mit einer „generischen“ Funktion die Funktionsoperationen einmal angeben und Platzhalter für alle Typen verwenden, die variieren können zwischen verschiedenen Aufrufen (dh Funktionen wie qsort und bsearch sind definitiv nicht generische Funktionen). Idealerweise soll der Compiler auch alle Aufrufe dieser generischen Funktion automatisch erkennen und den tatsächlichen Code nach Bedarf generieren.

C ++ macht dies einfach ¹ , indem es Vorlagen anbietet:

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 ist ein Platzhalter für einen beliebigen Typ ² , sodass Sie ihn als

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

Wenn der Code kompiliert wird, sieht der Compiler die beiden Aufrufe von summation und leitet die Arten der Argumente ab. Für jeden unterschiedlichen Typ wird eine neue Instanz der Funktion generiert , die einen eindeutigen Namen erhält:

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

Anschließend wird Code generiert so dass das Ergebnis von summation_i sumi und summation_d sumd.

C bietet nichts Ähnliches wie die Vorlagenfunktion. Traditionell haben wir die generische Programmierung auf zwei Arten angegriffen – entweder mithilfe von Makros oder mithilfe von void * überall verteilen und typabhängige Operationen an andere Funktionen delegieren.

Hier ist ein schlechtes Beispiel für eine makrobasierte Lösung:

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

Die SUMMATION_DEF ist ungefähr einer Vorlage insofern ähnlich, als es die Funktionsoperationen angibt, wobei der Makroparameter t als Typplatzhalter verwendet wird. Wir verwenden auch t als Teil des Funktionsnamens – ## ist der Token-Einfügeoperator, und der Präprozessor erweitert t und hängen Sie diesen Wert an den Namen der Funktion ³ an.

Wo er sich von C ++ unterscheidet, ist die Tatsache, dass ein Makro nur eine dumme Textersetzung ist. Es wird nicht ausgelöst spezielle Operationen des Compilers. Die tatsächlichen Funktionsinstanzen werden nicht automatisch basierend auf Aufrufen des Makros SUMMATION generiert – wir müssen die gewünschten Funktionen explizit generieren (daher die SUMMATION_DEF(int) und SUMMATION_DEF(double) vor main). Dies bedeutet auch, wenn wir summation_xxx aufrufen Über das Makro SUMMATION müssen wir den Typ als Teil der Makroargumentliste übergeben, damit die richtige Funktion aufgerufen wird. Was für ein Schmerz.

Die Der C 2011-Standard hat das Schlüsselwort _Generic hinzugefügt, was das Leben in dieser Hinsicht etwas erleichtern kann:

#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 Mit dem Schlüsselwort _Generic können Sie Ausdrücke basierend auf types auswerten. Wenn also der type des ersten Arguments SUMMATION ist int *, wir nennen summation_int; es ist „s double * nennen wir summation_double. Auf diese Weise müssen wir den Typnamen nicht in den Makroargumenten angeben.

Wie Sie gesehen haben, besteht der andere Ansatz darin, void * zu verwenden und typabhängige Operationen an andere Funktionen zu delegieren. Es ist keine wirklich „generische“ Programmierung, da Sie jede Vergleichsfunktion für jeden Typ manuell implementieren müssen. Sie können es nicht nur einmal codieren und damit fertig sein. Mit void * werfen Sie die Typensicherheit grundsätzlich aus dem Fenster in den Gegenverkehr.

Und bevor sich jemand beschwert – nein, keine dieser Summierungsfunktionen prüft oder behandelt arithmetischen Überlauf. Das ist ein Thema für einen anderen Tag.

---

1. Für ausreichend lose Definitionen von „einfach“. Die Metaprogrammiersprache, die zur Unterstützung von Vorlagen verwendet wird, ist Turing-complete, sodass Sie * wirklich erstaunliche * und damit unmöglich zu verstehende Dinge tun können.
2. Für ausreichend lose Definitionen von „jedem Typ“. Beachten Sie, dass jeder Typ, den Sie verwenden, den Operator += unterstützen muss, sonst schreit der Compiler Sie an.
3. Dieser Code wird für Typen wie unsigned int oder long double unterbrochen, da der Name Leerzeichen enthält. Ich kenne die Lösung für dieses Problem nicht sofort und habe so viel Zeit für diese Antwort aufgewendet.