Lambda mit return void function?

[cppbert (Gast)]

wiso darf ich Lambdas return mit void machen?

clang, gcc und VS2017/19 sage das ist ok und explodieren dann beim 
Aufruf

was ist das tiefere Sinn dahinter?

void blub(){}

int main()
{
    auto x = []()
    { 
      // das erlaubt der Kompiler???
      return blub(); 
    };

    // das erlaubt der Kompiler nicht, völlig klar
    //return blub(); 

    return 0;
}

Cpp Insights (https://cppinsights.io/) macht das draus:
warum stört sich der Kompiler hier nicht an den return blub()s?

void blub(){}

int main()
{
  class __lambda_5_14
  {
    public: 
    inline /*constexpr */ void operator()() const
    {
      return blub();
    }
    
    using retType_5_14 = void (*)();
    inline /*constexpr */ operator retType_5_14 () const noexcept
    {
      return __invoke;
    };
    
    private: 
    static inline void __invoke()
    {
      return blub();
    }
  };
  __lambda_5_14 x = __lambda_5_14{};
  return 0;
}

[Rolf M. (rmagnus)]

cppbert schrieb:
> wiso darf ich Lambdas return mit void machen?

Das hat eigentlich nichts mit Lambdas zu tun.

> clang, gcc und VS2017/19 sage das ist ok und explodieren dann beim
> Aufruf
>
> was ist das tiefere Sinn dahinter?

Der Sinn sind Templates. Es kann den Fall geben, dass man ein Template 
schreiben will, das eine Funktion aufruft, und was immer die zurückgibt, 
soll weitergegeben werden. Ohne dieses Feature würde das für alle 
Rückgabetypen außer eben void funktionieren.

[cppbert (Gast)]

ah, ok der Fehler ist nicht das ich von void returne sondern das meine 
main ein int als return-wert hat

aber trotzdem - warum wird so was nicht verhindern?
ist das wegen Templates und auto damit man da keinen Sonderweg gehen 
muss?

[cppbert (Gast)]

also eher

warum ist das valide?

void blub(){}
void test(){ return blub(); }

int main()
{
  test();  
  return 0;
}

[Rolf M. (rmagnus)]

cppbert schrieb:
> aber trotzdem - warum wird so was nicht verhindern?

Diese Möglichkeit wurde ganz bewusst hinzugefügt, um eben in Templates 
nicht unterscheiden zu müssen zwischen Funktionen, die void 
zurückliefern und Funktionen, die etwas andres zurückliefern.
Um mal dein Beispiel aufzugreifen:

void blub(){}
int  blah(){return 0;}

template<typename Ret>
struct X
{
    Ret test() { return func(); }
    Ret (*func)();
};

int main()
{
    X<void> a { blub };
    X<int> b { blah };
    
    a.test();
    return b.test();
}

Das würde ohne diese Möglichkeit nicht funktionieren. Man müsste extra 
eine Template-Spezialisierung der Klasse schreiben, nur um im Falle von 
Ret=void das return in test() wegzulassen.

[cppbert (Gast)]

sowas dachte ich mir schon - Danke