Template -Funktion zum Erkennen von Zeiger wie (Dereferencable) -Typen schlägt für tatsächliche Zeigertypen fehl ⇐ C++

[Anonymous]

Ich versuche einen Mechanismus zu schreiben, um festzustellen, ob ein Typ ein zeiger -ähnlicher -Typs ist. Damit meine ich, es ist durch den Operator*() < /code> und operator-> () < /code>. < /P>

Ich habe drei verschiedene Strukturen, die entsprechend spezialisiert sind:

Code: Select all

is_pointer_like_dereferencable

welche überprüft den Bediener*()
[*]

Code: Select all

is_pointer_like_arrow_dereferencable

welche überprüft-> ()
[*]

Code: Select all

is_pointer_like

, der einfach 1 & 2


Ich habe Spezialisierungen für nicht templatte Typen wie int, int*, ... und für templatierte Typen wie std :: vector , std :: shared_ptr , ... . Implementierung von IS_POINGER_IKE_Arrow_Dereferencable . Der relevante Code ist < /p>

Code: Select all

template 
struct is_pointer_like_arrow_dereferencable : std::false_type
{
};

template 
struct is_pointer_like_arrow_dereferencable>
> : std::true_type
{
};

template 
struct is_pointer_like_arrow_dereferencable
, std::enable_if_t<
std::is_same_v()), std::add_pointer_t>>
> : std::true_type
{
};

template 
constexpr bool is_pointer_like_arrow_dereferencable_v = is_pointer_like_arrow_dereferencable::value;
< /code>

Die 2. Struktur sollte prüfen, ob ein nicht templatter Typ entweder ein tatsächlicher Zeigertyp ist oder ob der Typ einen Pfeilbetreiber hat, der einen Zeiger an sich selbst zurückgibt. Wenn ich den Mechanismus jedoch mit dem folgenden Code teste, werden Zeigertypen (wie int*

werden nicht korrekt erkannt). Warum ist das? < /P>

Code: Select all

template 
struct Test
{
T& operator*()
{
return *this;
}

T* operator->()
{
return this;
}
};

void main()
{
bool
a = is_pointer_like_arrow_dereferencable_v, // false
b = is_pointer_like_arrow_dereferencable_v, // false, should be true
c = is_pointer_like_arrow_dereferencable_v, // false
d = is_pointer_like_arrow_dereferencable_v, // false, should be true
e = is_pointer_like_arrow_dereferencable_v, // true
f = is_pointer_like_arrow_dereferencable_v, // false, should be true
g = is_pointer_like_arrow_dereferencable_v, // true
h = is_pointer_like_arrow_dereferencable_v, // false, should be true
i = is_pointer_like_arrow_dereferencable_v; // false
}

Die Struktur is_pointer_like_dereferencable unterscheidet sich nur vom Teil std :: is_Same_v und erfasst tatsächliche Zeigertypen korrekt. < /p>

Die Tatsache, dass es keine Zeigertypen erfasst (die von std :: is_pointer_v < /code> abgedeckt werden sollten) ist für mich keinen Sinn. Kann jemand das erklären?