Schreiben Sie eine Funktion, fdie eine positive Ganzzahl aufnimmt und eine Funktion zurückgibt.

Die zurückgegebene neue Funktion sollte mit identisch sein f. Wenn jedoch der "Beendigungsaufruf" auftritt, fsollte stattdessen die Summe aller übergebenen Ganzzahlen zurückgegeben werden.

Zum Beispiel sollte g=f(4)(wenn fist die erste Funktion) auf geine andere Funktion eingestellt werden. h=g(3)werde das gleiche tun. Wenn Sie jedoch hkeine Argumente aufrufen (siehe unten für Details), sollte 7 ausgegeben werden, da dies die Summe der vorherigen Funktionsargumente ist. Anders ausgedrückt f(3)(4)() == 7.

Beachten Sie, dass dies nicht dasselbe ist wie f(3,4)().

"Terminierungsanruf" ist eine der folgenden Optionen (Ihre Wahl):

• Aufruf ohne Argumente
• Null als Argument
• ein nicht positiver Wert

Beliebig viele Funktionsaufrufe sollen unterstützt werden, es gibt kein vordefiniertes Limit.

Es ist garantiert, dass die Gesamtsumme nicht größer als 1'000 sein wird.

Wir können davon ausgehen, dass vor dem "Terminierungsanruf" mindestens ein Anruf getätigt wird.

In Ihrem Code sollten keine statischen programmspezifischen Variablen verwendet werden. Daher sollte es möglich sein, das Experiment mehrere Male in derselben Laufzeit auszuführen und genau dasselbe Verhalten zu beobachten.

Beispiele:

f(1)() == 1
f(4)(2)(7)() == 13
f(4)(2)(7)(5)(2)() == 20

JavaScript (ES6), 18 Byte

f=n=>m=>m?f(m+n):n

Übergeben Sie einen falschen Wert, um die Summe abzurufen. Nullen können für 2 Byte zugelassen werden.

Probieren Sie es online aus

Ungolfed:

f = function(n) {
    return function(m) {
        if (m) {
            return f(m+n);
        } else {
            return n;
        }
    }
}

Haskell (GHC), 118 Bytes

Dies sind 98 Byte für den Code und 20 Byte für das GHC-Compiler-Flag -XFlexibleInstances, das eine Typsystemerweiterung ermöglicht.

class F a where f::Int->a
instance F(()->Int)where f n()=n
instance F a=>F(Int->a)where f=(f.).(+)

Dies definiert eine "Funktion" f, die mit einer beliebigen Anzahl von Ganzzahlen aufgerufen werden kann, gefolgt von der Einheit (), nach der eine Ganzzahl zurückgegeben wird. Typanmerkungen sind erforderlich. Probieren Sie es online!

Erläuterung

Damit das strenge Typensystem von Haskell dies zulässt, ist ein gewisses Maß an Magie erforderlich, nämlich die Aktivierung der GHC-Erweiterung für flexible Typklasseninstanzen. Wie dies funktioniert, fist eine parametrisch polymorphe Funktion, die durch eine Typklassenbeschränkung eingeschränkt ist: ihr Typ ist F a => Int -> a. Dies bedeutet, dass für jeden Typ , der zur Typenklasse gehört, feine Ganzzahl verwendet und ein Wert vom Typ zurückgegeben awird . ist nur der Name der Typklasse, die die Funktion bereitstellt ; Es ist in der ersten Zeile deklariert.aFFf

Die nächsten beiden Zeilen sind zwei Instanzen von Ffür verschiedene Typen a. Die zweite Zeile gibt an, dass der Typ der Funktionen von ()bis zu ganzen Zahlen gehört F(wobei ()der Einheitentyp ist, dessen einziges Element der Wert ist ()), und die Implementierung ist f n () = n; Die Funktion gibt ihr erstes Argument zurück. Die letzte Zeile besagt, dass, wenn zu agehört F, auch die Art der Funktionen von Ganzzahlen zu a: von einer Funktion können f :: Int -> awir eine andere Funktion generieren f :: Int -> Int -> a. Die Implementierung ist f m n = f (m+n)(der Code verwendet Kombinatoren, um sie zu verkürzen), wobei flinks die neue und frechts die alte ist. Dies gibt im Wesentlichenfein neues ganzzahliges Argument, das dem nächsten hinzugefügt wird. Mehrere Argumente werden folgendermaßen zusammengefasst:

  f  a1   a2   a3   a4   a5  ()
= f (a1 + a2)  a3   a4   a5  ()
= f (a1 + a2 + a3)  a4   a5  ()
= f (a1 + a2 + a3 + a4)  a5  ()
= f (a1 + a2 + a3 + a4 + a5) ()
=    a1 + a2 + a3 + a4 + a5

Die fin jeder Zeile hat einen anderen Typ.

Haskell-Funktionen werden automatisch aufgerufen. Wenn Sie also fnur Ganzzahlen angeben, erhalten Sie eine Funktion.

Python 2, 42 41 36 Bytes

Diese Lösung wird niemals überlaufen, da Python Ganzzahlen mit willkürlicher Genauigkeit unterstützt. Null ist der "spezielle Wert".

f=lambda n:lambda m:m and f(m+n)or n

Probieren Sie es online aus

Ungolfed:

def f(n):
    def g(m=''):
        return f(m+n)if m<''else n
    return g

C, 62 58 Bytes, Borderline-Konkurrenz

4 Bytes gespart dank Kevin! (Typedef wird immer noch nicht entfernt, da es zum Aufrufen benötigt wird.)

typedef(*(*B)(_))(_);q;f(x,o,_){x=x?(q+=x,f):(x=q,q=0,x);}

Die aufzurufende Funktion ist f; Sie hören auf, es anzurufen, und erhalten das Ergebnis, indem Sie es mit einer nicht positiven Zahl wie aufrufen 0. Probieren Sie ein Testgeschirr online aus!

Soweit ich das beurteilen kann, besteht die einzige Möglichkeit, Funktionen mit mehreren Rückgabetypen zu "curryen", darin, eine der folgenden Aktionen auszuführen:

1. Wandeln Sie das Ergebnis in eine Funktion um, um dem Compiler mitzuteilen, dass Sie das Ergebnis erneut aufrufen möchten.
2. Oder erstellen Sie einen union/ struct-Typ mit einem intund -Funktions- / Selbstreferenz-Untertyp.

Ich habe versucht (2) zu tun, aber es schien ein bisschen gegen den Geist der Frage und, ganz offen gesagt, fast unlösbar. Aus diesem Grund habe ich mich im Sinne der Herausforderung für Option (1) entschieden. Dazu muss jede zurückgegebene Funktion in eine Funktion umgewandelt werden, die verwendet werden kann.

Diese "currying" Syntax sieht ein bisschen seltsam aus, ist aber ziemlich ähnlich. Um zu emulieren f(21)(1), müsste man schreiben ((B)((B)f(21))(1))(0). Ich habe den BTyp als eine Funktion definiert, die eine Ganzzahl annimmt und einen Zeiger auf eine Funktion zurückgibt, die eine Ganzzahl annimmt. Erweitert sieht das so aus:

   ( (B)( (B) f(21) )(1) )(0)
//            f(21)            - call f with 21
//        (B)                  - cast to B, a function pointer
//      (           )(1)       - call with 1
//   (B)                       - cast to a function pointer
// (                     )(0)  - call with 0

Mathematica, 25 Bytes

f[x_]@y_=f[x+y]
f[x_][]=x

Probieren Sie es online! (Verwenden von Mathematik.)

Durch Portierung der JavaScript-Antwort können drei Bytes gespart werden, aber ich wollte eine idiomatischere Mathematica-Lösung vorstellen. Das @ist nur ein bisschen syntaktischer Zucker, was die Lösung äquivalent macht zu:

f[x_][y_]=f[x+y]
f[x_][]=x

Die Idee ist also, dass Sie in Mathematica nicht nur eine Funktion definieren, f[x_]sondern einem komplizierteren Ausdruck f, der z. B. f[x_]ein anderes Argument enthält , direkt einen Wert zuweisen können. Indem wir zwei Definitionen dafür einrichten, können wir das gewünschte Verhalten erhalten:

• Die erste Definition reduziert einen f[x][y]Aufruf auf f[x+y]einen "Aufruf" und addiert die darin enthaltenen Argumente. Diese Regel gilt, bis wir mit verlassen werden f[sum][].
• Die zweite Definition packt diesen letzten Fall aus, indem sie das gesamte zu bewertende Objekt definiert sum.

C ++, 72 Bytes

#define O(P)operator()(P){return{P+a};}int
struct F{F O(int(m))O()a;}f;

Dies definiert einen Typ, Fder als angeforderte Funktion fungiert, und eine Variable fdieses Typs, die aufgerufen werden soll. Es ist ab C ++ 11 gültig und funktioniert mit Online-Versionen von GCC, Clang, ICC und VC ++.

Verwendungszweck:

int main() {
  return f(1)(2)(3)(); // returns 6
}

Erläuterung:

Nach der Vorverarbeitung und Neuformatierung sieht es so aus:

struct F {
  F operator()(int(m)) { return{int(m)+a}; }
  int operator()() { return {+a}; }
  int a;
} f;

Dies würde normalerweise geschrieben werden:

struct F {
  F operator()(int m) { return {m+a}; }
  int operator()() { return a; }
  int a;
} f;

return a;und return {+a};das gleiche tun, als einstellige +den Wert nicht ändert, und redundante Klammern um den Rückgabewert erlaubt. int mund int(m)das gleiche tun, wie redundante Klammern um einen Variablennamen erlaubt sind, einschließlich Funktionsparameter. return {m+a};und return {int(m)+a};mache dasselbe, da eine Besetzung von mvon intbis intihren Wert nicht ändert. Diese Änderungen rücken die beiden operator()Überladungen in der Syntax näher zusammen, sodass eine einzelne Makrodefinition zweimal aufgerufen werden kann. Wenn Sie die richtige Reihenfolge für die drei Elemente auswählen, wird auch das erste Wort der nächsten Zeile ( int) in die Makrodefinition aufgenommen.

Ruby, 23 Bytes

f=->n{->m{m ?f[n+m]:n}}

Verwendungszweck:

f[1][2][3][nil]
=> 6

C 104 96 Bytes

#define a(i)s(i)|b
#define b(i)u(i)|c
#define c(i)u(i)|b
b,c,d;s(i){b=c=i;i=d;}u(i){c=b+=i;i=d;}

Verwendet die Methode aus dem Link, den @JulianWolf freigegeben hat. Das letzte Argument muss 0 sein.

Probieren Sie es online!

Math.JS, 38 Bytes

f(x)=i(x,0)
i(x,y)=x<0?y:j(z)=i(z,y+x)

Nennen Sie es mit f(number_a)(number_b)(...)(negative_number)

Wenn wir den ersten Aufruf angeben dürfen, können 12 Bytes ( f(x)=i(x,0)\n) verworfen und mit aufgerufen werdeni(number_one,0)(number_two)(...)(negative_number)

Versuch es!

Explination

Wie in obigem LaTex gezeigt, f(x)ruft es einfach auf i(x,0)und gibt dann i(x,y)den Wert von yif xkleiner als 0 oder die Funktion zurück j(z)=i(z,x+y), die ein Argument annimmt und die eine Schleife durchläuft. Addieren zum Wert von y.

C 232 206 Bytes

#include<string.h>
#include<stdlib.h>
#define f(X)s(""#X)?0:g
#define g(X)u(""#X)?0:h
#define h(X)u(""#X)?0:g
g=0,h=0;s(char*s){g=h=atoi(s);return 0;}u(char*s){char*a=strlen(s)?s:"0";g=h+=atoi(a);return 0;}

Dies kann wahrscheinlich erheblich verbessert werden, sollte jedoch als Beweis dafür dienen, dass C ohne Spracherweiterungen * verwendet werden kann, um dieses Problem durch Aufrufen ohne Argumente und nicht mit einem magischen Wert zu lösen.

* @hvd hat festgestellt, dass dies zwar mit gcc funktioniert, einige Verhaltensweisen jedoch nicht im C-Standard definiert sind, was bedeutet, dass dies möglicherweise nicht portabel ist. Benutzung auf eigene Gefahr!

Ungolfed:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define f(X) start("" #X) ? 0 : f0
#define f0(X) update("" #X) ? 0 : f1
#define f1(X) update("" #X) ? 0 : f0

long f0 = 0;
long f1 = 0;

int start(const char *s) {
    f0 = f1 = strtol(s, NULL, 10);

    return 0;
}

int update(const char *s) {
    const char *a = strlen(s) ? s : "0";
    f0 = f1 += strtol(a, NULL, 10);

    return 0;
}

int main() {
    printf("f(1)()          -> %ld\n", f(1)());
    printf("f(1)(2)(0)(3)() -> %ld\n", f(1)(2)(0)(3)());
    printf("f(1)(-2)(3)()   -> %ld\n", f(1)(-2)(3)());
    printf("f()             -> %ld\n", f());

    return 0;
}

Kompilieren und Ausführen mit gcc arbitrary-length-currying.c -o arbitrary-length-currying && ./arbitrary-length-curryingAusgaben (nach einigen Warnungen)

f(1)()          -> 1
f(1)(2)(3)(0)() -> 6
f(1)(-2)(3)()   -> 2
f()             -> 0

8086 Maschinencode, 27 Bytes

00000000  bb 00 00 85 c0 74 13 01  d8 be 00 01 89 e7 47 47  |.....t........GG|
00000010  57 b9 1b 00 f3 a4 5b 89  47 01 c3                 |W.....[.G..|
0000001b

Dieser Maschinencode muss an der Adresse 0x100 sein und setzt das winzige Codemodell (cs = ds = es = ss) voraus. Der Funktionsort kann jedoch geändert werden, ohne dass zusätzliche Bytes anfallen. Wenn Sie den Wert auf Offset setzen 0, wird ein Byte ( xor si,sianstelle von mov si, 0x100) gespeichert.

Erforderliche Anrufkonvention

Dies setzt voraus, dass der Aufrufer mindestens 27 Bytes auf dem Stapel vorab zugewiesen hat. Es nimmt eine Zahl in axund gibt einen Funktionszeiger in zurück bx. Der Aufruf dieses Zeigers mit ax=0beendet die Kette und gibt die Summe in zurück bx.
Also für den ersten Anruf:

mov bp, sp
sub sp, 28
mov ax, number_to_add
call function
; new function pointer in bx

Dann für jeden nachfolgenden Anruf:

sub sp, 28
mov ax, number_to_add
call bx
; new function pointer in bx

Zu beenden:

mov ax, 0
call bx
; result in bx
mov sp, bp

Ungolfed (kommentierte Demontage des Maschinencodes):

00000000  BB0000            mov bx,0x0      ; 0 is replaced after copying
00000003  85C0              test ax,ax
00000005  7413              jz 0x1a         ; if(ax==0) ret (with value in bx)
00000007  01D8              add ax,bx       ; arg += total
00000009  BE0001            mov si,0x100    ; address of the original: ds:0x100
0000000C  89E7              mov di,sp
0000000E  47                inc di
0000000F  47                inc di          ; dst = sp+2 = above return address
00000010  57                push di
00000011  B91B00            mov cx,0x1b
00000014  F3A4              rep movsb         ; copy the function code.
00000016  5B                pop bx            ; bx = start of copy destination
00000017  894701            mov [bx+0x1],ax   ; update total in the copied code
0000001A  C3                ret               ; with bx = function pointer

Nach dem Aufruf mit AX ungleich Null wird bx = spder Puffer mit einer geänderten Kopie des Maschinencodes von gefüllt function. Das 16-Bit-Direkt in der ersten Anweisung enthält die Summe. (Es ist von der letzten Anweisung vor dem geschrieben ret.)

push diIch pop bxkönnte durch mov bx, di(vorher rep movsb) ersetzt werden, was es einfacher macht, aber keine Einsparungen bringt.

Wenn der Aufrufer einen Zeiger an den dst-Puffer übergeben muss di, werden 4 Bytes gespart, verglichen mit der Berechnung in Bezug auf sp.

Wenn Sie die Startadresse der Funktion auf die gleiche Größe wie die Funktionsgröße einstellen, wird ein Byte ( mov cx, si) gespeichert .

C #, 62 Bytes

dynamic f(int n)=>(System.Func<int,dynamic>)(m=>m<0?n:f(n+m));

Um den Anruf zu beenden, geben Sie eine negative Nummer ein, z

f(1)(2)(3)(-1) == 6

Scala, 58 Zeichen

case class f(n:Int){def apply(m:Int)=f(n+m)
def apply()=n}

Probieren Sie es online aus

Ungolfed:

case class f(n:Int){
  def apply(m:Int)=f(n+m)
  def apply()=n
}

Erläuterung:

Dieser Code definiert ein case classaufgerufenes f, wobei ein Konstruktor ein int übernimmt. Definieren Sie eine Case-Klasse, die die Methoden equals, hashcode, toString und copy generiert, und ein Begleitobjekt mit demselben Namen, um die Objekterstellung ohne das newSchlüsselwort zu ermöglichen .

Diese Klasse verfügt über eine überladene Apply-Methode: Eine verwendet eine andere Ganzzahl zum Hinzufügen und erstellt ein neues Objekt mit der aktualisierten Summe und eine ohne Argumente zum Abrufen der Summe.

In Scala kann jedes Objekt mit einer apply-Methode wie eine Methode aufgerufen werden, dh wie folgt o.apply(x)geschrieben werden o(x). Dies wird in der Standardbibliothek für Arrays, Listen, Maps und die Function1von anonymen Funktionen implementierten Merkmale verwendet

Pyth, 19 Bytes

DhdDebR?bh+dbdR$end

Probieren Sie es online!

Ich bin beeindruckt, dass Javascript Pyth schlägt, aber andererseits ist Pyth nicht so konzipiert, dass es Funktionen übergibt.

Perl 5, 36 Bytes

sub f{my$n=pop;sub{@_?f($n+pop):$n}}

say f(1)->(); # 1
say f(1)->(2)->(3)->(); # 6

Brain-Flak , 6 Bytes

Eigentlich ist mir gerade aufgefallen, dass, da der ToS ein gültiges Rückgabeformat ist, das Poppen der 0 nicht wirklich benötigt wird, was 2 Bytes spart:

({{}})

Probieren Sie es online!

Ursprüngliche Einreichung (en), 8 Bytes

Verwendet 0als Sonderwert:

({{}}{})

Probieren Sie es online!

Erläuterung

Mit den Argumenten a ₁ , a ₂ ,…, a _n , 0 sieht der Stack zunächst so aus:

                                                       a _n

                                                       ⋮

                                                       a ₂

                                                       a ₁

                                                       0

Der Code geht dann auf, jede erscheint ein _i , sammelt sie, springt der 0 fügt sie und legt das Ergebnis:

(      )  -- push the following value:
 {  }     --   while ToS ≠ 0 (sums the runs):
  {}      --     pop 1 element
     {}   --   pop the remaining 0 & add it

Alternative Lösungen, 8 Bytes

Anstatt die 0 zu platzieren und zur Summe hinzuzufügen, können wir auch die Stapel tauschen, da der rechte anfänglich leer ist:

({{}}<>)

Probieren Sie es online!

Mit dem -rFlag befindet sich die 0 oben auf dem Stapel, so dass wir sie zuerst platzieren können:

({}{{}})

Probieren Sie es online!

{}({{}})

Probieren Sie es online!

C (GCC) 83 Bytes

Mein erstes C Golf! Es gibt ein paar andere C-Lösungen, aber diese sind etwas anders. Die Verwendung von Präprozessoren ist rein kosmetisch. Dieser Ansatz wurde zuerst in der Antwort von Conor O'Brien hier erörtert .

#define r union r
t=0;r{int v;r(*f)();};r e;r f(a){t+=a;e.v=a?f:t;t*=a>0;return e;}

Der Endwert ist Null. Der Rückgabewert ist eine Vereinigung. Um das Ergebnis aufzurufen, verwenden Sie das Feld f, und um auf den Endwert zuzugreifen, verwenden Sie das Feld v, z

f(1).f(2).f(3).f(0).v

Probieren Sie es online

Einschränkungen

Eine globale Variable enthält die laufende Summe. Dies ist zwar ausdrücklich untersagt, die Übermittlung unterstützt jedoch wiederholte Aufrufe (die Gesamtsumme wird im Terminalaufruf zurückgesetzt), was der Grund für das Verbot des globalen Staates zu sein scheint.

Ein Zeiger auf fwird über das intMitglied in der zurückgegebenen Union gespeichert , sodass dies eindeutig nicht portierbar ist. Ich bin mir nicht sicher, ob dies auf GCC auf allen Plattformen oder nur auf Linux oder nur auf x86 oder nur mit ELF oder ... funktioniert.

APL (Dyalog Classic) , 48 47 46 ₄₄ 32 Bytes

∇r←(a f)x
r←⍎'(a+x)f'↓⍨-0=x
∇
0f

Probieren Sie es online!

Beendet durch Übergabe von Null. Aufrufsyntax:((0 f 1) 2) 0

-15 Bytes dank @ngn

Benötigt ⎕IO←0

Alle Golftipps sind willkommen!

Perl 6 , 31 Bytes

sub f(\n){->$m?{$m??f n+$m!!n}}

Dyvil , 34 Bytes

infix int apply(i:int,j:int=0)=i+j

Verwendung :

0() // = 0
0(1)() // = 1
0(1)(2)() // = 3

Das Nachziehen ()kann weggelassen werden.

Erklärung :

Definiert einen Nebeneinanderstellungsoperator, der zwei Ints benötigt und diese hinzufügt. Der Parameter jhat den Standardwert 0, um den Aufruf ohne Argumente zu unterstützen. Das 0in den obigen Beispielen ist nicht der Name, sondern ein Literal.

Julia v0.5 +, 52 Bytes

type F n end
F()=0
(f::F)()=f.n
(f::F)(x)=(f.n+=x;f)

Anrufen als F. Dies könnte wahrscheinlich durch die Anwendung einer weniger OO-Methode erheblich verkürzt werden, aber ich mag es immer, die Chance zu bekommen, diese Redewendung zu verwenden.

Wenn davon ausgegangen werden kann, dass "mindestens ein Anruf vor dem Beendigungsanruf getätigt wird", kann die zweite Zeile entfernt werden, um 6 Bytes zu sparen.

Julia 0,5 , 18 Bytes

!n=k->k>0?!(n+k):n

Probieren Sie es online!

R, 40 Bytes

f=function(x)function(y)`if`(y,f(x+y),x)

0 fungiert hier als Stoppwert. Für zwei weitere Bytes können wir es weglassen.

Das Problem ist, dass R ein knappes eingebautes Lambda fehlt. Aber wenn wir eins hinzufügen , können wir den Code auf 26 Bytes bringen :

f=x->(y->`if`(y,f(x+y),x))

(Ja, das ist gültig R. Es muss nur importiert werden.)

PHP, 44 Bytes

Eine Idee von @ user63956

Kündigungsruf 0

function f($i){return[$_GET[0]+=$i][$i]?:f;}

Online Version

Termination Anruf mit NULLbenötigen einen CAST [$i]zu[+$i]

PHP, 47 Bytes

function f($i){global$s;return$i?f.!$s+=$i:$s;}

Online Version

PHP, 52 Bytes

Abbruchaufruf NULLoder ein anderer Wert, der in PHP falsch ist

function f($i){global$s;$i?$s+=$i:print$s;return f;}

Wenn das Programm nach der Ausgabe beendet werden muss, ersetzen Sie es print$sdurch die("$s")+ 2 Bytes

Online Version

PowerShell, 86 Byte

$f={$n=$args[0];$f=(gv f).value;{if($args){&$f($args[0]+$n)}else{$n}}.getnewclosure()}

Probieren Sie es online!

Testcode:

&(&(&(&(&(&$f 4)2)7)5)2)

Ausgabe: 20

Python 3 , 63 Bytes

f=lambda n,l=[]:n and(l.append(n)or f)or sum(l)*(l.clear()or 1)

Probieren Sie es online!

Beendet mit 0

Python, 69 Bytes

def f(a=0,s=[]):
    if a:
        return lambda b=0:f(b,s+[a])
    return sum(s)

Oktave, 39 Bytes

function r=f(n)r=@(m)merge(m,f(m+n),n);

* Argument des Beendigungsaufrufs ist 0.

Probieren Sie es online!

* endfunctionerforderlich, um weitere Codes hinzuzufügen.

R, 54 52 Bytes

f=function(x){g=function(y='')'if'(y>'',f(x+y),x);g}

2 Bytes gespart dank MickyT!

Ähnlich wie bei einer der Python-Antworten. Ungolfed:

f=function(x){
  g=function(y=''){
    if(y>''){
      f(y+x)
      }
      else{x}
  }
  g
}

Läuft als

> f(1)(2)(4)()
[1] 7

C ++ (GCC) , 95 91 Bytes

struct f{int s;f(int t):s(t){}int operator()(){return s;}f operator()(int t){return s+t;}};

Probieren Sie es online!