Question

Frage: Was ist die Bedeutung vom fehlendem -> bei Lambda-Funktionen?

Hallo an alle :)

Ich kenne folgende Varianten der Lambdafunktion:

Gibt ein int Wert an sum:

auto sum = [](int x, int y) -> int { return x + y; };


Gibt eine Funktion an sum zurück (man könnte jetzt sum(5)(2) oder auch (sum(5))(2) wenn ich richtig geklammert habe)
auto sum = [](int x) -> std::function<int(int)> { return [x](int y) { return x + y; }; };


Was aber bedeutet es, bzw. was bekommt man zurück wenn man sowas hat?

auto sum2 = [](int x, int y) { return x + y; };


  Im Kontext konnte ich nur folgenden Kommentar finden: // Beachte. Inferenz von Rueckgabe Typ ist moeglich

  und das man anscheinend folgendes aufrufen kann:

  cout << sum2(5, 2) << endl;
    cout << sum2(10, 5) << endl;


Geht das denn überhaupt?

Denn sum2 wäre nicht dem Muster entsprechend welches (wie ich dachte) einzuhalten ist:

[capture](paramters) -> return_type { function_body }


Answer 1

Inferenz von Rueckgabe Typ ist moeglich

Der Compiler entscheidet anhand der Datentypen von x und y, welche Variante von + verwendet wird. Der Datentyp des Rückgabewertes dieser Variante ist dann auch der Datentyp des Rückgabewertes von sum2.

Comments

Was bedeutet "Variante von +"?

Ist dies in Bezug auf die oberen sum Funktionen gemeint?

---

Es gibt mehrere Operatoren, die + heißen. Sie unterscheiden sich darin, welchen Datentyp die Summanden haben. Zum Beispiel gibt es einen, der ganze Zahlen addieren kann und einen deer Fließkommazahlen addieren kann. Man kann auch eine Addition für eigene Datentypen definieren:

#include <iostream>

class Punkt {
  public:
    Punkt (double x, double y, double z)
      : x(x), y(y), z(z) {}
    double x, y, z;
};

Punkt operator*(double k, Punkt p) {
    return Punkt(k*p.x, k*p.y, k*p.z);
}
Punkt operator+(Punkt p1, Punkt p2) {
    return Punkt(p1.x + p2.x, p1.y + p2.y, p1.z + p2.z);
}
Punkt operator-(Punkt p1, Punkt p2) {
    return p1 + (-1)*p2;
}
std::ostream& operator<<(std::ostream& o, Punkt p) {
    return o << "(" << p.x << " | " << p.y  << " | " << p.z << ")";
}

int main() {
    std::cout << 3*Punkt(1,1,0) - 2*Punkt(1, 0, 1) << "\n";
}