C++: Unerwarteter Return-Typ von Template-Funktion

[Return-Typ (Gast)]

Guten Abend.
Kann mir jemand sagen, welchen return-Typ man erhält, wenn man eine 
Funktion/Methode

const T& fkt()  hat, mit  T = int&  ?

const T& fkt()  hat, mit  T = int   ?

Erwartet hätte ich in beiden Fällen ein "const int&". Das scheint aber 
falsch zu sein.
Kennt jemand ein Stichwort zu dem Thema zum Nachlesen, oder kann mir 
jemand so erklären, was da los ist?

Danke schon mal,
MfG.

[Trans Betti (Gast)]

Naja bei T=int& kommt wohl int&& raus oder nicht?
Das wäre dann eine rvalue reference.

int& wäre eine lvalue reference o.O

https://www.internalpointers.com/post/understanding-meaning-lvalues-and-rvalues-c#:~:text=In%20C%2B%2B%20an%20lvalue%20is,since%20they%20exist%20as%20variables.

[Löppt (Gast)]

https://en.cppreference.com/w/cpp/language/reference

Stichwort reference collapsing.

Ich würde int& erwarten.

[Return-Typ (Gast)]

Aber warum kein 'const'?? Warum wird T nicht mit 'const' dekoriert?

[Löppt (Gast)]

Return-Typ schrieb:
> Aber warum kein 'const'?? Warum wird T nicht mit 'const'
> dekoriert?

Ups, ja, const int&. Wie kommst darauf, dass dem nicht so ist?

[Michael D. (nospam2000)]

Return-Typ schrieb:
> Aber warum kein 'const'?? Warum wird T nicht mit 'const' dekoriert?

Aus https://en.cppreference.com/w/cpp/language/reference (Link von 
Löppt):

"Reference types cannot be cv-qualified at the top level; there is no 
syntax for that in declaration, and if a qualification is added to a 
typedef-name or decltype specifier, (since C++11) or type template 
parameter, it is ignored."

  Michael

[Return-Typ (Gast)]

@Löppt: Der Compiler meckert.

Uhhh. Danke. Das hatte ich überlesen, mangels Verständnis.
Was bedeutet "top level"?
Und wieso ist das so?
Das wirkt irgendwie unintuitiv.

[Rolf M. (rmagnus)]

Return-Typ schrieb:
> Uhhh. Danke. Das hatte ich überlesen, mangels Verständnis.
> Was bedeutet "top level"?

Eine Referenz kann nicht const sein, sondern nur auf etwas als const 
verweisen, anders als bei Zeigern.

int a;
int* const b = &a; // geht, const-Zeiger auf einen non-const-int
int& const c = a;  // ergibt keinen Sinn und ist syntaktisch nicht erlaubt

> Und wieso ist das so?

Weil Referenzen sowieso nicht geändert werden können. Jeglicher Zugriff 
geht nicht auf die Referenz selber, da sie gar kein Objekt ist, sondern 
auf das, worauf sie verweist. Was sollte es also bringen, sie const zu 
machen?

[Return-Typ (Gast)]

Eine const Referenz ergibt wenig Sinn. Aber bei mir geht es doch um eine 
Referenz auf ein const, oder nicht?

[Rolf M. (rmagnus)]

Ich hab einfach diese beiden Fragen beantwortet:

Return-Typ schrieb:
> Was bedeutet "top level"?
> Und wieso ist das so?

[Wilhelm M. (wimalopaan)]

Wenn Du fkt<int&>() instantiierst, ist demzufolge T dann int&. Im Typ 
der Funktion steht dann im Prinzip: const (int&)&. Wie schon gesagt sind 
Referenz-Typen nicht zusätzlich top-level mit const qualifizierbar, weil 
das sinnlos ist. Daher wird das const ignoriert. Das liefert dann: 
(int&)&, was wieder wegen reference-collapsing zu int& wird.

[Return-Typ (Gast)]

Ich tue mich etwas schwer mit dem Begriff "Top Level".
Top Level von was?
Und warum ist das const in "const T &" kein top-level?

[Wilhelm M. (wimalopaan)]

Return-Typ schrieb:
> Ich tue mich etwas schwer mit dem Begriff "Top Level".
> Top Level von was?

In

int a;
int& r = a;

ist r unveränderlich. Referenzen können nicht zur Laufzeit auf andere 
Objekte verweisen wie Zeiger. Deswegen ist es unsinnig und auch 
syntaktisch gar nicht möglich, eine Referenz an sich read-only zu 
machen, weil sie es bereits sind.

> Und warum ist das const in "const T &" kein top-level?

Weil es gar keine Syntax für ein top-level const von Referenzen gibt.

Hier

int a;
int* const p = &a;

ist p mit einem top-level const ausgestattet: p selbst ist read-only und 
nicht das Ziel.

[Return-Typ (Gast)]

Wie gesagt, dass Referenzen nicht umgebunden werden können, ist klar. 
Was aber geht, ist auf ein non-const Objekt mittels "Referenz auf const" 
zuzugreifen.

Bei "const T &", warum ist dieses const ein top-level const,

und bei "const int &", warum ist dieses kein top-level const?

Bei "const T &" hätte ich auch die Anweisung "Zugriff mittels Referenz 
auf const" vermutet. Wenn es das nicht ist, wie würde man das dann in 
Worte fassen können?

[Oliver S. (oliverso)]

Return-Typ schrieb:
> und bei "const int &", warum ist dieses kein top-level const?

Return-Typ schrieb:
> Bei "const T &", warum ist dieses const ein top-level const,
>
> und bei "const int &", warum ist dieses kein top-level const?

Was bedeutet "const int &"? Schreib es hin...

Oliver

[Rolf M. (rmagnus)]

Return-Typ schrieb:
> Ich tue mich etwas schwer mit dem Begriff "Top Level".
> Top Level von was?

Von der Referenzierung.

> Und warum ist das const in "const T &" kein top-level?

Weil es sich nicht auf die Referenz, sondern auf das referenzierte 
Objekt bezieht.

Return-Typ schrieb:
> Wie gesagt, dass Referenzen nicht umgebunden werden können, ist klar.
> Was aber geht, ist auf ein non-const Objekt mittels "Referenz auf const"
> zuzugreifen.
>
> Bei "const T &", warum ist dieses const ein top-level const,

Ist es nicht. Bei T & const wäre es top-level, wenn es denn sowas gäbe.

> und bei "const int &", warum ist dieses kein top-level const?

Genau wie oben: Weil es sich nicht auf die Referenz selbst bezieht, 
sondern auf das referenzierte Objekt. Vielleicht wird es bei Zeigern 
etwas klarer, wo es mehr Ebenen der "Verzeigerung" geben kann:

int const * const * const * const myptr;

Hier gibt es quasi vier Ebenen, die alle const sind, daher viermal 
const. Die oberste Ebene, also top-level const, ist das letzte in dieser 
Reihe. Bei Referenzen geht das alles nicht. Weder gibt es mehr als zwei 
Ebenen, noch gibt es auf oberster Ebene die Möglichkeit, sie const zu 
machen.

> Bei "const T &" hätte ich auch die Anweisung "Zugriff mittels Referenz
> auf const" vermutet.

Da hast du richtig vermutet.

[Return-Typ (Gast)]

Soo, bevor ich es wieder vergesse:
Auf Grundlage der letzen Beiträge hat es dann auch Klick gemacht bei 
mir. Danke nochmal!