C++ remove_pointer und const correctness

[Sprachloser Dude (Gast)]

Warum entfernt der folgende Code nicht nur den Pointer sondern auch das 
const?

# include <iostream>
using std :: cout;
using std :: endl;
# include <typeinfo>
# if 201103L <= __cplusplus
#  include <type_traits>
using std :: remove_pointer;
# else
template <typename T>
struct remove_pointer {
        typedef T type;
};
template <typename T>
struct remove_pointer <T*>{
        typedef T type;
};
# endif
int main () {
        cout << typeid (int) . name () << endl;
        cout << typeid (int*) . name () << endl;
        cout << typeid (int const*) . name () << endl;
        cout << typeid (remove_pointer <int> :: type) . name () << endl;
        cout << typeid (remove_pointer <int*> :: type) . name () << endl;
        cout << typeid (remove_pointer <int const*> :: type) . name () << endl;
}

% g++ -std=c++98 -pedantic -otest test.cpp
% c++filt -t `./test`
int
int*
int const*
int
int
int

% g++ -std=c++20 -pedantic -otest test.cpp
% c++filt -t `./test`                     
int
int*
int const*
int
int
int

[Rolf M. (rmagnus)]

Er entfernt es nicht, sondern das const ist einfach nicht Teil der 
typeid.
Füge einfach mal

        cout << typeid (int const) . name () << endl;

hinzu.

[Sprachloser Dude (Gast)]

Rolf M. schrieb:
> Er entfernt es nicht, sondern das const ist einfach nicht Teil der
> typeid.

Danke, das wusste ich noch gar nicht, dass sich Typeid und Traits da 
unterscheiden.

[code]
$ cat test.cxx
# include <iostream>
using std :: cout;
using std :: endl;
# include <typeinfo>
# include <type_traits>
using std :: is_same;
int main () {
        cout << is_same <int, int const> :: value << endl;
        cout << (typeid (int) == typeid (int const)) << endl;
}
$ c++ test.cxx && ./a.out
0
1
[code]

[mh (Gast)]

Falls du es noch nicht kennst, solltest du dir _PRETTY_FUNCTION_ 
angucken.
Dieses "Makro" ist sehr hilfreich, im beim Loggen von Debuginfos und 
generell beim Umgang mit Templates. Vor allem das folgende Beispiel ist 
sehr hiflreich, wenn man mal keine Lust hat über type deduction 
nachzudenken:

#include <iostream>
#include <type_traits>

template<typename T>
void foo() {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
}

int main () {
        foo<int>();
        foo<int*>();
        foo<int const*>();
        foo<std::remove_pointer<int>::type>();
        foo<std::remove_pointer<int*>::type>();
        foo<std::remove_pointer<int const*>::type>();
}

liefert

void foo() [T = int]
void foo() [T = int *]
void foo() [T = const int *]
void foo() [T = int]
void foo() [T = int]
void foo() [T = const int]

Mindestens gcc und clang kennen _PRETTY_FUNCTION_.