Unmangling wynik std:: type info:: name

Boost core zawiera demangler. Checkout core / demangle.hpp :

#include <boost/core/demangle.hpp>
#include <typeinfo>
#include <iostream>

template<class T> struct X
{
};

int main()
{
    char const * name = typeid( X<int> ).name();

    std::cout << name << std::endl; // prints 1XIiE
    std::cout << boost::core::demangle( name ) << std::endl; // prints X<int>
}

To w zasadzie tylko opakowanie dla abi::__cxa_demangle, jak sugerowano wcześniej.

Tego właśnie używamy. HAVE_CXA_DEMANGLE jest ustawiane tylko, jeśli jest dostępne (tylko najnowsze wersje GCC).

#ifdef HAVE_CXA_DEMANGLE
const char* demangle(const char* name)
{
   char buf[1024];
    unsigned int size=1024;
    int status;
    char* res = abi::__cxa_demangle (name,
                                 buf,
                                 &size,
                                 &status);
    return res;
  }
#else
const char* demangle(const char* name)
{
  return name;
}
#endif  

Tutaj, spójrz na type_strings.HPP zawiera funkcję, która robi to, co chcesz.

Jeśli szukasz narzędzia do demanglingu, którego np. możesz użyć do zmanipulowania rzeczy pokazanych w pliku dziennika, spójrz na c++filt, który jest dostarczany z binutils. Może demangle C++ i Java nazwy symboli.

To implementacja zdefiniowana, więc nie jest to coś, co będzie przenośne. W MSVC++ nazwa() jest niedekorowaną nazwą i musisz spojrzeć na raw_name (), aby uzyskać dekorowaną nazwę.
To tylko dźgnięcie w ciemności, ale pod gcc, możesz chcieć spojrzeć na demangle.h

Znalazłem również makro o nazwie __PRETTY_FUNCTION__, które robi sztuczkę. Daje ładną nazwę funkcji (figury:)). Tego potrzebowałem.

Czyli daje mi to:

virtual bool mutex::do_unlock()

Ale chyba nie działa na innych kompilatorach.

Nie jest to kompletne rozwiązanie, ale warto przyjrzeć się definicjom niektórych standardowych (lub powszechnie obsługiwanych) makr. Często w kodzie logowania widać użycie makr:

__FUNCTION__
__FILE__
__LINE__

e.g.:

log(__FILE__, __LINE__, __FUNCTION__, mymessage);

Mała wariacja na temat rozwiązania Ali. Jeśli chcesz, aby Kod był nadal bardzo podobny do

typeid(bla).name(),

Pisanie tego zamiast

Typeid(bla).name() (różni się tylko wielką literą)

W takim razie może cię to zainteresować:

W pliku Wpisz.hpp

#ifndef TYPE_HPP
#define TYPE_HPP

#include <string>
#include <typeinfo>

std::string demangle(const char* name);

/*
template <class T>
std::string type(const T& t) {

  return demangle(typeid(t).name());
}
*/

class Typeid {
 public:

  template <class T>
    Typeid(const T& t) : typ(typeid(t)) {}

  std::string name() { return demangle(typ.name()); }

 private:
  const std::type_info& typ;
};


#endif

Typ.cpp pozostaje taki sam jak w rozwiązaniu Ali

Spójrz na __cxa_demangle, które znajdziesz na cxxabi.h.

// KeithB's solution is good, but has one serious flaw in that unless buf is static
// it'll get trashed from the stack before it is returned in res - and will point who-knows-where
// Here's that problem fixed, but the code is still non-re-entrant and not thread-safe.
// Anyone care to improve it?

#include <cxxabi.h>

// todo: javadoc this properly
const char* demangle(const char* name)
{
    static char buf[1024];
    size_t size = sizeof(buf);
    int status;
    // todo:
    char* res = abi::__cxa_demangle (name,
                                 buf,
                                 &size,
                                 &status);
    buf[sizeof(buf) - 1] = 0; // I'd hope __cxa_demangle does this when the name is huge, but just in case.
    return res;
  }

Przyjęte rozwiązanie [1] działa głównie dobrze. Znalazłem przynajmniej jeden przypadek (i nie nazwałbym go przypadkiem narożnym), w którym nie zgłasza tego, czego się spodziewałem... z referencjami.

W tych przypadkach znalazłem inne rozwiązanie, umieszczone na dole.

Problematyczny przypadek (używając {[5] } zgodnie z definicją w [1]):

int i = 1;
cout << "Type of " << "i" << " is " << type(i) << endl;
int & ri = i;
cout << "Type of " << "ri" << " is " << type(ri) << endl;

Produkuje

Type of i is int
Type of ri is int

Rozwiązanie (używając type_name<decltype(obj)>(), patrz kod poniżej):

cout << "Type of " << "i" << " is " << type_name<decltype(i)>() << endl;
cout << "Type of " << "ri" << " is " << type_name<decltype(ri)>() << endl;

Produkuje

Type of i is int
Type of ri is int&

Zgodnie z życzeniem (przynajmniej przeze mnie)

Kod . Musi być w dołączonym nagłówku, a nie w osobno skompilowanym źródle, ze względu na problemy ze specjalizacją. Zobacz na przykład undefined reference to template function .

#ifndef _MSC_VER
#   include <cxxabi.h>
#endif
#include <memory>
#include <string>
#include <cstdlib>

template <class T>
std::string
type_name()
{
    typedef typename std::remove_reference<T>::type TR;
    std::unique_ptr<char, void(*)(void*)> own
           (
#ifndef _MSC_VER
                abi::__cxa_demangle(typeid(TR).name(), nullptr,
                                           nullptr, nullptr),
#else
                nullptr,
#endif
                std::free
           );
    std::string r = own != nullptr ? own.get() : typeid(TR).name();
    if (std::is_const<TR>::value)
        r += " const";
    if (std::is_volatile<TR>::value)
        r += " volatile";
    if (std::is_lvalue_reference<T>::value)
        r += "&";
    else if (std::is_rvalue_reference<T>::value)
        r += "&&";
    return r;
}

Zawsze chciałem użyć type_info, ale jestem pewien, że wynik funkcji member name() jest niestandardowy i niekoniecznie zwróci coś, co można przekonwertować na znaczący wynik.
Jeśli trzymasz się jednego kompilatora, może istnieje specjalna funkcja kompilatora, która zrobi to, co chcesz. Sprawdź dokumentację.

Idąc za rozwiązaniem Ali, oto C++11 template alternatywa, która działała najlepiej w moim użyciu.

// type.h
#include <cstdlib>
#include <memory>
#include <cxxabi.h>

template <typename T>
std::string demangle() {
  int status = -4;

  std::unique_ptr<char, void (*)(void*)> res{
      abi::__cxa_demangle(typeid(T).name(), NULL, NULL, &status), std::free};
  return (status == 0) ? res.get() : typeid(T).name();
}

Użycie:

// main.cpp
#include <iostream>

namespace test {
    struct SomeStruct {};
}

int main()
{
    std::cout << demangle<double>() << std::endl;
    std::cout << demangle<const int&>() << std::endl;
    std::cout << demangle<test::SomeStruct>() << std::endl;

    return 0;
}

Wydrukuje:

double                                                                        
int                                                                           
test::SomeStruct