Programmiererforum

is_pointer_like_dereferencable

is_pointer_like_arrow_dereferencable

is_pointer_like

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*

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
}

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]is_pointer_like_dereferencable[/code] welche überprüft den Bediener*()
[*][code]is_pointer_like_arrow_dereferencable[/code] welche überprüft-> ()
[*][code]is_pointer_like[/code], 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]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*[/code] werden nicht korrekt erkannt). Warum ist das? < /P>

[code]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
}
[/code]

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?