std::remove_reference erklären?

Sah ich mögliche Implementierungen für std::remove_reference wie unten

template< class T > struct remove_reference      {typedef T type;};
template< class T > struct remove_reference<T&>  {typedef T type;};
template< class T > struct remove_reference<T&&> {typedef T type;};

Warum ist es, dass es Spezialisierungen für lvalue und rvalue reference? Nicht die Allgemeine Schablone selbst ausreichend sein, und den Verweis entfernen? Ich bin verwirrt, weil hier in der T& oder T&& Spezialisierung, wenn ich versuche, mit ::type sollte ich noch bekommen T& oder T&& bzw. rechts?

Könnten Sie erklären, wie, warum werfen wir zu remove_reference<t>::type&& im Zug? (ist es denn, dass der parameter benannt ist, so wird er behandelt, wie ein lvalue innerhalb der verschieben-Funktion?).

Außerdem konnten Sie zeigen einen Weg, wobei ich herausfinden kann und drucken, was das geben wird? für e.g, wenn seine rvalue Typ int dann sollte ich in der Lage zu drucken, die int&& übergeben wurde? (Ich habe mit std::is_same zu überprüfen, sondern manuell.)

Vielen Dank für Ihre Zeit.

Dies ist eine SEHR gute Frage!

InformationsquelleAutor Koushik Shetty | 2013-06-08

c++c++11 template-specialization templates

37

warum ist es, dass es Spezialisierungen für lvalue und rvalue-Referenz?

Wenn nur die primäre Vorlage existiert, dann tut:
```
remove_reference<int&>::type
```
Geben würde Sie:
```
int&
```
Haben und tun:
```
remove_reference<int&&>::type
```
Geben würde Sie:
```
int&&
```
Ist nicht, was Sie wollen. Die Spezialisierungen für lvalue rvalue Referenzen und Verweise ermöglichen das abstreifen des & und die && bzw. aus dem type-argument übergeben Sie.

Zum Beispiel, wenn Sie tun:
```
remove_reference<int&&>
```
Art int&& wird mit dem Muster gemäß der T&& Spezialisierung, mit T wird int. Seit der Spezialisierung definiert den Typ alias type zu T (in diesem Fall int), in:
```
remove_reference<int&&>::type
```
Geben Sie int.

könnten Sie erklären, wie, warum werfen wir zu remove_reference<t>::type&& im move?

Das ist, weil, wenn move() wurden wie folgt definiert:
```
    template<typename T>
    T&& move(T&& t) { ... }
// ^^^
// Resolves to X& if T is X& (which is the case if the input has type X
// and is an lvalue)
```
Dann die return-Typ wird X& wenn das argument von move() ist ein lvalue des Typs X (das ist, wie die so genannten "universal-Verweise"). Wir wollen sicherstellen, dass der Rückgabetyp ist immer eine rvalue-Referenz.

Zweck der move() ist, um Ihnen wieder ein rvalue, egal, was Sie übergeben, input. Da ein Funktionsaufruf für eine Funktion, deren Rückgabetyp ist eine rvalue-Referenz ist ein rvalue, wollen wir wirklich move() um immer wieder eine rvalue-Referenz.

Das ist, warum wir tun remove_reference<T>::type&&, weil anfügen && zu einem nicht-Referenz-Typ ist immer gewährleistet, ergeben eine rvalue-Referenz-Typ.

Außerdem konnten Sie zeigen einen Weg, wobei ich herausfinden kann und drucken, was das geben wird?

Ich bin mir nicht sicher, was du meinst mit "print" hier. Es gibt keinen portablen Weg, den ich kenne, der Umwandlung der Namen von einem Typ zu einem string (egal wie man zu erhalten, die Art).

Wenn Ihr Ziel ist, um sicherzustellen, dass ein rvalue übergeben wurde, auf der anderen Seite, könnte man eine statische Behauptung etwa so:
```
#include <type_traits>

template<typename T>
void foo(T&&)
{
    static_assert(!std::is_reference<T>::value, "Error: lvalue was passed!");
    //...
}
```
Die stützt sich auf die Tatsache, dass, wenn ein lvalue des Typs X übergeben wird, T abgeleitet werden X&.

Könnten Sie auch einen gleichwertigen SFINAE-Einschränkung, wenn Sie nur wollen, um zu produzieren eine substitution failure:
```
#include <type_traits>

template<typename T, typename std::enable_if<
    !std::is_reference<T>::value>::type* = nullptr>
void foo(T&&)
{
    //...
}
```
- warum ist dann die Spezialisierung für T&&? Allgemeine Vorlage behandeln können dieses Recht?
- Du meinst die primäre Vorlage? Gut, wenn nur die primäre Vorlage existiert, dann remove_reference<int&&>::type geben würde, Sie zurück int&&
- ja Korrektur vorgenommen. in den Spezialisierungen auch wir bekommen das gleiche Recht? für T&& bekommen wir T&& für ::type Recht?
- Nein, wir bekommen T, weil die Spezialisierung der dem Muster entspricht T&&, so dass, wenn Sie passieren (sagen) int&& und passen Sie es mit T&& Ihre T muss nur int
- oh ok ok ok...:-) ich bin so dumm. jetzt ist alles glasklar. ich war unter der impressin, dass für T&& Spezialisierung der T in die typedef ist immer noch T&&. aber ich bin falsch.es ist T . Vielen Dank:-)
- Du bist nicht dumm, es ist nur eine Frage der übung 😉 Immer die hängen von diesen Dingen ist nicht so einfach
- ah ja, ich muss zu viel üben. Diese Art der Spezialisierungen sind für template-Funktionen auch?
- Ja und Nein. Explizite Spezialisierungen sind zulässig, partielle Spezialisierungen sind nicht. Und selbst, wenn es erlaubt ist, spezialisiert Funktion Vorlagen ist in der Regel als eine schlechte Idee, weil es nicht immer tun, was Sie denken. Können die Funktionen überladen auf der anderen Seite, und die Funktion überladen ist, als eine überlegene Technik. Es können die meisten der Probleme lösen (manchmal mit Hilfe einer Technik namens "tag Versand"), also die Situation, dass wirklich call-Funktion für template-Spezialisierung sind selten. Ich würde raten, mit überlastung, so viel wie Sie können für die Funktion Vorlagen
- ah die SFINAE Einschränkung sieht eher saftig. ich denke, es wird besser und ja, ich werde bei überlastungen fortan. Vielen Dank für Ihre Hilfe.:-)
- Du bist willkommen, schön, dass es geholfen 🙂
- Es ist eigentlich nicht standard-konform, um eine void-Zeiger als nicht-Typ template-parameter. Sollten Sie eine anonyme typename = std::enable_if_t<...> statt
- Nicht std::is_reference<T>::value gilt für rvalues zu?
- Die Suche nach "Spedition Referenzen" auf Google. Es ist ein besonderer Fall, um den Unterschied zwischen lvalue und rvalue.
- Und es ist ein guter Beitrag zu diesem Thema: Perfect Forwarding
InformationsquelleAutor Andy Prowl
0

Wenn Sie behandeln einige Typ als template-parameter compiler sucht für die meisten "spezialisierten" Spezialisierung. Wenn du an eine int&& zu dieser Vorlage, compiler verwenden remove_reference<T&&> version. Allgemeine Spezialisierung nicht geben Ihnen, was Sie wollen - wenn Sie pass int&& Allgemeinen specialiation, Typ int&&

Wenn Sie drucken möchten geben, verwenden Sie typeid(some_type).name()
- ich typeid verwendet, aber in der gcc war es etwas umständlich. ich glaube, ich habe zu verwenden, einige filter richtig? andere als die typeid ist es eine compile-Zeit-Zeug? so, dass ich mit static_assert?
- Bitte könnten Sie klarstellen, dass ein Teil der Frage? Wollen Sie eine Zeichenfolge, die enthält den Namen des Typs, oder tun Sie nur wollen, um sicherzustellen, dass eine rvalue-Referenz übergeben wurde?
- es wird gut sein, um die Zeichenfolge während der debug-phase und ja ich möchte sicherstellen, dass nur rvalue übergeben wurde andy. wenn ich das während der compile-Zeit dann seiner sehr hilfreich.
- OK, ich bearbeitet meine Antwort. Es gibt keinen portablen Weg, um den Namen eines Typs, obwohl (zum Teil ist dies jedoch möglich: Sie können mit google nach "C++ pretty print")
- Sie können laufen c++filt -t zu unmangle gcc typeid()::name() Ausgabe. Zum Beispiel c++filt -t FRSt8ios_baseS0_E zurück std::ios_base& (std::ios_base&) - das ist der Typ der Funktion std::boolalpha.
InformationsquelleAutor Evgeny Eltishev

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.