Wie kann ich Compiler eine Art von Nullptr ableiten lassen?

Question

Ich lerne C++. Ich möchte den Compiler veranlassen, nullptr als shared_ptr abzuleiten. Bitte lesen Sie den folgenden Code,

struct A {}; 

struct B { 
    std::shared_ptr<A> a; 
}; 

struct Tag { 
    std::shared_ptr<B> b; 
}; 

auto GetSharedPtrClassB(Tag* tag) { 
    if (tag) { 
     auto& sharedB = *(tag->b); 
     return sharedB.a; 
    } else { 
     return nullptr; // Error : compiler cannot deduce type of nullptr. 
    } 
} 

In GetSharedPtrClassB, nullptr nicht als std::shared_ptr<A> abgeleitet werden. Die Fehlermeldungen sind folgende,

error: inconsistent deduction for ‘auto’: ‘std::shared_ptr<A>’ and then ‘std::nullptr_t’ 

Wie kann ich lassen Compiler deduce nullptr als std::shared_ptr<A>? Ich kann einen Typ decltype(*(tag->b)) bereitstellen, aber ich kann nicht an den nächsten Schritt denken, um einen Typ std::shared_ptr<A> bereitzustellen.

Vielen Dank.

Answer 1

einen bedingten Operator Verwenden Sie die Umwandlung von nullptr zu zwingen, "was auch immer":

auto GetSharedPtrClassB(Tag* tag) { 
    return tag ? tag->b->a : nullptr; 
} 

---

Umwandlung von einem Operanden zum anderen in einem Bedingungsoperator ist gut definiert (siehe [expr.con d]), hier wird die nullptr in ein Objekt vom Typ decltype(tag->b->a) konvertiert.

Auf der anderen Seite sind die Regeln für den Abzug Rückgabetyp, wenn auto ohne Hinterrückgabetyp verwenden, sind sehr streng - die abgeleitete Typ die gleiche für jede return Anweisung sein muss ([dcl.spec.auto/9]):

Wenn eine Funktion mit einem Rückgabetyp deklariert, die einen Platzhalter Typ enthält mehrere return-Anweisungen hat, der Rückgabetyp für jede return-Anweisung abgeleitet wird. Wenn der abgeleitete Typ nicht in jedem Abzug gleich ist, ist das Programm schlecht gebildet.

---

Wenn Ihre Funktion nicht auf einen bedingten Operator reduziert werden kann, können Sie einen nachgestellten Rückgabetyp verwenden:

auto GetSharedPtrClassB(Tag* tag) -> decltype(tag->b->a) { 
    if (tag) { 
     auto& sharedB = *(tag->b); 
     return sharedB.a; 
    } else { 
     return {}; 
    } 
} 

Answer 2

Sie können stattdessen einen standardmäßig erstellten shared_ptr zurückgeben.

auto GetSharedPtrClassB(Tag* tag) { 
    if (tag) { 
     auto& sharedB = *(tag->b); 
     return sharedB.a; 
    } else { 
     return std::shared_ptr<A>{}; 
    } 
} 

Answer 3

Sie static_cast wie diese verwenden:

auto GetSharedPtrClassB(Tag* tag) { 
    if (tag) { 
     auto& sharedB = *(tag->b); 
     return sharedB.a; 
    } else { 
     return static_cast<std::shared_ptr<A> >(nullptr); 
    } 
} 

Answer 4

Ich gehe davon aus, dass der Code tatsächlich in einem allgemeinen Kontext verwendet wird. Wenn Ihr Code keine Vorlagen verwendet, verwenden Sie nicht decltype, geben Sie Typen direkt an.

Um den Rückgabetyp abzuleiten, müssen alle Rückgabeanweisungen zu einem Ausdruck des gleichen Typs auswerten. In Ihrem Code haben Sie zwei Rückgabeanweisungen mit zwei verschiedenen Typen. Eine mit std::shared_ptr<A> und eine mit std::nullptr_t.

Es gibt zwei Lösung: Verwenden Sie die gleichen Typen in beiden Return-Anweisungen, oder definieren Sie explizit einen Rückgabetyp.

Hier ist, wie die gleiche Art zurück:

auto GetSharedPtrClassB(Tag* tag) { 
    if (tag) { 
     auto& sharedB = *(tag->b); 
     return sharedB.a; 
    } 

    // empty constructor same as initializing with `nullptr` 
    return decltype(tag->b->a){}; 
} 

oder explizit einen Rückgabetyp definieren:

auto GetSharedPtrClassB(Tag* tag) -> decltype(tag->b->a) { 
    if (tag) { 
     auto& sharedB = *(tag->b); 
     return sharedB.a; 
    } 

    // empty constructor same as initializing with `nullptr` 
    return {}; 
} 

By the way, in Sie Code auto& sharedB = *(tag->b); return sharedB.a; zu return tag->b->a; reduziert werden konnte