क्या मानक C ++ में एक चर के प्रकार को प्रिंट करना संभव है?


393

उदाहरण के लिए:

int a = 12;
cout << typeof(a) << endl;

अपेक्षित उत्पादन:

int

2
यहाँ हावर्ड के लंबे फार्म के समाधान का सारांश दिया गया है लेकिन एक समकालिक वन-लाइन मैक्रो के साथ कार्यान्वित किया गया है #define DEMANGLE_TYPEID_NAME(x) abi::__cxa_demangle(typeid((x)).name(), NULL, NULL, NULL):। आप पार मंच समर्थन की जरूरत है: का प्रयोग करें #ifdef, #else, #endifMSVC जैसे अन्य प्लेटफार्मों के लिए एक मैक्रो प्रदान करने के लिए।
ट्रेवर बॉयड स्मिथ

अधिक स्पष्ट मानव पठनीय आवश्यकता के साथ: stackoverflow.com/questions/12877521/…
Ciro Santilli 病 able able able

3
यदि आप केवल डीबगिंग के लिए इसका उपयोग करते हैं, तो आप विचार करना चाह सकते हैं template<typename T> void print_T() { std::cout << __PRETTY_FUNCTION__ << '\n'; }। फिर उदा का उपयोग रनटाइम पर print_T<const int * const **>();प्रिंट करेगा void print_T() [T = const int *const **]और सभी क्वालीफायर (जीसीसी और क्लैंग में काम करता है) को संरक्षित करेगा ।
हेनरी मेनके

@ हेनरी, __PRETTY_FUNCTION__स्टैंडर्ड सी ++ नहीं है (आवश्यकता प्रश्न शीर्षक में है)।
टोबे स्पीट

जवाबों:


505

C ++ 11 एक बहुत पुराने प्रश्न के लिए अद्यतन: C ++ में चर प्रकार प्रिंट करें।

स्वीकृत (और अच्छा) उत्तर का उपयोग करना है typeid(a).name(), जहां aएक चर नाम है।

अब C ++ 11 में हमारे पास decltype(x)एक अभिव्यक्ति है , जो एक प्रकार में बदल सकती है। और decltype()बहुत ही दिलचस्प नियमों के अपने सेट के साथ आता है। उदाहरण के लिए decltype(a)और decltype((a))आम तौर पर विभिन्न प्रकार के (और अच्छे और समझ में आने वाले कारणों के लिए एक बार उन कारणों को उजागर किया जाएगा)।

क्या हमारा ट्रस्टी typeid(a).name()हमें इस बहादुर नई दुनिया का पता लगाने में मदद करेगा ?

नहीं।

लेकिन उपकरण जो कि जटिल नहीं है। और यह वह उपकरण है जिसका उपयोग मैं इस प्रश्न के उत्तर के रूप में कर रहा हूं। मैं इस नए टूल की तुलना और इसके विपरीत करूंगा typeid(a).name()। और यह नया उपकरण वास्तव में शीर्ष पर बनाया गया है typeid(a).name()

मूलभूत मुद्दा:

typeid(a).name()

Cv- क्वालीफायर, रेफरेंस और लैवल्यू / रैवल्यू-नेस को फेंक देता है। उदाहरण के लिए:

const int ci = 0;
std::cout << typeid(ci).name() << '\n';

मेरे लिए आउटपुट:

i

और मैं MSVC आउटपुट पर अनुमान लगा रहा हूँ:

int

यानी constचला गया। यह एक QOI (कार्यान्वयन की गुणवत्ता) समस्या नहीं है। मानक इस व्यवहार को अनिवार्य करता है।

जो मैं नीचे सुझा रहा हूं वह है:

template <typename T> std::string type_name();

जिसका उपयोग इस तरह किया जाएगा:

const int ci = 0;
std::cout << type_name<decltype(ci)>() << '\n';

और मेरे लिए आउटपुट:

int const

<disclaimer>मैंने MSVC पर इसका परीक्षण नहीं किया है। </disclaimer> लेकिन मैं उन लोगों से प्रतिक्रिया का स्वागत करता हूं जो करते हैं।

सी ++ 11 समाधान

मैं __cxa_demangleगैर- एमएसवीसी प्लेटफार्मों के लिए उपयोग कर रहा हूं, जैसा कि आईपैडोप द्वारा सुझाए गए हैं, जो कि उनके प्रकारों के उत्तर में हैं। लेकिन typeidएमएसवीसी पर मैं नामों के नाम (अनट्रेडेड) पर भरोसा कर रहा हूं । और यह कोर कुछ सरल परीक्षण के चारों ओर लिपटा हुआ है जो इनपुट प्रकार के संदर्भों, पुनर्स्थापित और रिपोर्ट cv-qualifiers और संदर्भों के बारे में बताता है।

#include <type_traits>
#include <typeinfo>
#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;
}

परिणाम

इस समाधान के साथ मैं यह कर सकता हूं:

int& foo_lref();
int&& foo_rref();
int foo_value();

int
main()
{
    int i = 0;
    const int ci = 0;
    std::cout << "decltype(i) is " << type_name<decltype(i)>() << '\n';
    std::cout << "decltype((i)) is " << type_name<decltype((i))>() << '\n';
    std::cout << "decltype(ci) is " << type_name<decltype(ci)>() << '\n';
    std::cout << "decltype((ci)) is " << type_name<decltype((ci))>() << '\n';
    std::cout << "decltype(static_cast<int&>(i)) is " << type_name<decltype(static_cast<int&>(i))>() << '\n';
    std::cout << "decltype(static_cast<int&&>(i)) is " << type_name<decltype(static_cast<int&&>(i))>() << '\n';
    std::cout << "decltype(static_cast<int>(i)) is " << type_name<decltype(static_cast<int>(i))>() << '\n';
    std::cout << "decltype(foo_lref()) is " << type_name<decltype(foo_lref())>() << '\n';
    std::cout << "decltype(foo_rref()) is " << type_name<decltype(foo_rref())>() << '\n';
    std::cout << "decltype(foo_value()) is " << type_name<decltype(foo_value())>() << '\n';
}

और आउटपुट है:

decltype(i) is int
decltype((i)) is int&
decltype(ci) is int const
decltype((ci)) is int const&
decltype(static_cast<int&>(i)) is int&
decltype(static_cast<int&&>(i)) is int&&
decltype(static_cast<int>(i)) is int
decltype(foo_lref()) is int&
decltype(foo_rref()) is int&&
decltype(foo_value()) is int

ध्यान दें (उदाहरण के लिए) के बीच decltype(i)और अंतर decltype((i))। पूर्व के प्रकार है घोषणा की i। उत्तरार्द्ध अभिव्यक्ति का "प्रकार" है i। (अभिव्यक्तियों में संदर्भ प्रकार कभी नहीं होता है, लेकिन एक सम्मेलन के रूप में decltypeअंतराल के संदर्भों के साथ भाव अभिव्यक्ति का प्रतिनिधित्व करता है)।

इस प्रकार यह उपकरण केवल decltypeअपने कोड की खोज और डीबगिंग के अलावा, सीखने के लिए एक उत्कृष्ट वाहन है ।

इसके विपरीत, अगर मैं सिर्फ typeid(a).name()खो cv- क्वालीफायर या संदर्भों को जोड़ने के बिना, इस पर निर्माण करने वाले थे , तो आउटपुट होगा:

decltype(i) is int
decltype((i)) is int
decltype(ci) is int
decltype((ci)) is int
decltype(static_cast<int&>(i)) is int
decltype(static_cast<int&&>(i)) is int
decltype(static_cast<int>(i)) is int
decltype(foo_lref()) is int
decltype(foo_rref()) is int
decltype(foo_value()) is int

यानी हर संदर्भ और सीवी-क्वालिफायर को छीन लिया जाता है।

C ++ 14 अद्यतन

जब आप सोचते हैं कि आपको किसी समस्या का हल मिल गया है, तो कोई व्यक्ति हमेशा कहीं से बाहर निकलता है और आपको बेहतर तरीके से दिखाता है। :-)

जाम्बोरे के इस उत्तर से पता चलता है कि संकलन समय में C ++ 14 में टाइप नाम कैसे प्राप्त करें। यह कुछ कारणों से एक शानदार समाधान है:

  1. यह संकलन समय पर है!
  2. आपको लाइब्रेरी के बजाय काम करने के लिए कंपाइलर ही मिल जाता है (यहां तक ​​कि एक std :: lib)। इसका मतलब है नवीनतम भाषा सुविधाओं (जैसे लंबोदा) के लिए अधिक सटीक परिणाम।

जाम्बोरे के जवाब में वीएस के लिए सब कुछ नहीं रखा गया है, और मैं उनके कोड को थोड़ा छोटा कर रहा हूं। लेकिन चूंकि इस उत्तर को बहुत सारे विचार मिलते हैं, इसलिए वहां जाने के लिए कुछ समय लें और अपने उत्तर को बढ़ाएं, जिसके बिना, यह अद्यतन कभी नहीं होगा।

#include <cstddef>
#include <stdexcept>
#include <cstring>
#include <ostream>

#ifndef _MSC_VER
#  if __cplusplus < 201103
#    define CONSTEXPR11_TN
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN
#  elif __cplusplus < 201402
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN noexcept
#  else
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN constexpr
#    define NOEXCEPT_TN noexcept
#  endif
#else  // _MSC_VER
#  if _MSC_VER < 1900
#    define CONSTEXPR11_TN
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN
#  elif _MSC_VER < 2000
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN
#    define NOEXCEPT_TN noexcept
#  else
#    define CONSTEXPR11_TN constexpr
#    define CONSTEXPR14_TN constexpr
#    define NOEXCEPT_TN noexcept
#  endif
#endif  // _MSC_VER

class static_string
{
    const char* const p_;
    const std::size_t sz_;

public:
    typedef const char* const_iterator;

    template <std::size_t N>
    CONSTEXPR11_TN static_string(const char(&a)[N]) NOEXCEPT_TN
        : p_(a)
        , sz_(N-1)
        {}

    CONSTEXPR11_TN static_string(const char* p, std::size_t N) NOEXCEPT_TN
        : p_(p)
        , sz_(N)
        {}

    CONSTEXPR11_TN const char* data() const NOEXCEPT_TN {return p_;}
    CONSTEXPR11_TN std::size_t size() const NOEXCEPT_TN {return sz_;}

    CONSTEXPR11_TN const_iterator begin() const NOEXCEPT_TN {return p_;}
    CONSTEXPR11_TN const_iterator end()   const NOEXCEPT_TN {return p_ + sz_;}

    CONSTEXPR11_TN char operator[](std::size_t n) const
    {
        return n < sz_ ? p_[n] : throw std::out_of_range("static_string");
    }
};

inline
std::ostream&
operator<<(std::ostream& os, static_string const& s)
{
    return os.write(s.data(), s.size());
}

template <class T>
CONSTEXPR14_TN
static_string
type_name()
{
#ifdef __clang__
    static_string p = __PRETTY_FUNCTION__;
    return static_string(p.data() + 31, p.size() - 31 - 1);
#elif defined(__GNUC__)
    static_string p = __PRETTY_FUNCTION__;
#  if __cplusplus < 201402
    return static_string(p.data() + 36, p.size() - 36 - 1);
#  else
    return static_string(p.data() + 46, p.size() - 46 - 1);
#  endif
#elif defined(_MSC_VER)
    static_string p = __FUNCSIG__;
    return static_string(p.data() + 38, p.size() - 38 - 7);
#endif
}

constexprयदि आप अभी भी प्राचीन C ++ 11 में अटके हुए हैं तो यह कोड ऑटो-बैकऑफ़ होगा । और अगर आप C ++ 98/03 के साथ गुफा की दीवार पर पेंटिंग कर रहे हैं, तो noexceptभी बलिदान किया जाता है।

C ++ 17 अद्यतन

नीचे दिए गए टिप्पणियों में लिबर्टा बताती है कि नई std::string_viewजगह ले सकती है static_string:

template <class T>
constexpr
std::string_view
type_name()
{
    using namespace std;
#ifdef __clang__
    string_view p = __PRETTY_FUNCTION__;
    return string_view(p.data() + 34, p.size() - 34 - 1);
#elif defined(__GNUC__)
    string_view p = __PRETTY_FUNCTION__;
#  if __cplusplus < 201402
    return string_view(p.data() + 36, p.size() - 36 - 1);
#  else
    return string_view(p.data() + 49, p.find(';', 49) - 49);
#  endif
#elif defined(_MSC_VER)
    string_view p = __FUNCSIG__;
    return string_view(p.data() + 84, p.size() - 84 - 7);
#endif
}

मैंने वी.एस. के लिए स्थिरांक को अपडेट किया है नीचे दिए गए टिप्पणियों में जिव डडसन द्वारा बहुत अच्छे जासूसी कार्य के लिए धन्यवाद।

अपडेट करें:

नीचे दिए गए इस पुनर्लेखन को अवश्य देखें, जो मेरे नवीनतम फॉर्मूलेशन में अपठनीय मैजिक नंबरों को समाप्त करता है।


4
वीएस 14 सीटीपी ने सही प्रकारों को प्रिंट किया, मुझे केवल एक #include <iostream>लाइन जोड़ना था।
मैक्स गलकिन

3
क्यों टेम्प्लेट <टाइपनेम टी> एसटीडी :: स्ट्रिंग टाइप_नाम ()? आप एक प्रकार को तर्क के रूप में क्यों नहीं पारित कर रहे हैं?
चांदनी

2
मेरा मानना ​​है कि मेरा तर्क यह था कि कभी-कभी मेरे पास केवल एक प्रकार (जैसे कि एक घटा हुआ टेम्पलेट पैरामीटर) होता है, और मैं नहीं चाहता था कि टाइप करने के लिए कृत्रिम रूप से उनमें से एक का निर्माण किया जाए (हालांकि ये दिन declvalकाम करेंगे)।
हावर्ड हिनांट

5
@AngelusMortis: चूँकि C ++ कोड की तुलना में अंग्रेज़ी अस्पष्ट / अस्पष्ट है, इसलिए मैं आपको अपने टेस्ट केस में उस विशिष्ट प्रकार के साथ कॉपी / पेस्ट करने के लिए प्रोत्साहित करता हूँ, जिसमें आप रुचि रखते हैं और जिस विशिष्ट कंपाइलर के साथ आप रुचि रखते हैं, और अधिक के साथ वापस लिखें। यदि परिणाम आश्चर्यजनक और / या असंतोषजनक है तो विवरण।
हावर्ड हिनान्ट

3
@ HowardHinnant आप std::string_viewइसके बजाय उपयोग कर सकते हैं static_string?
Lyberta

231

प्रयत्न:

#include <typeinfo>

// …
std::cout << typeid(a).name() << '\n';

इसके लिए आपको अपने संकलक विकल्पों में RTTI को सक्रिय करना होगा। इसके अतिरिक्त, इस का उत्पादन संकलक पर निर्भर करता है। यह एक कच्चे प्रकार का नाम या नाम का प्रतीक या बीच में कुछ भी हो सकता है।


4
नाम () फ़ंक्शन द्वारा लौटाए गए स्ट्रिंग को कार्यान्वयन क्यों परिभाषित किया गया है?
विध्वंसक

4
@PravasiMeet कोई अच्छा कारण नहीं है, जहां तक ​​मुझे पता है। समिति केवल कंपाइलर कार्यान्वयनकर्ताओं को विशेष तकनीकी दिशाओं में बाध्य नहीं करना चाहती थी - शायद एक गलती, एक दृष्टि में।
कोनराड रुडोल्फ

2
क्या आरटीटीआई को सक्षम करने के लिए एक ध्वज का उपयोग किया जा सकता है? हो सकता है कि आप अपने उत्तर को समावेशी बना सकें।
जिम

4
@ डेस्ट्रक्टर एक मानकीकृत नाम प्रदान करने वाला प्रारूप प्रदान कर रहा है, यह धारणा दे सकता है कि दो अलग-अलग संकलक द्वारा निर्मित बायनेरिज़ के बीच अंतर संभव है और / या सुरक्षित है, जब यह नहीं है। चूँकि C ++ में एक मानक ABI नहीं है, एक मानक नाम प्रबंध योजना व्यर्थ होगी, और संभवतः भ्रामक और खतरनाक होगी।
एल्कविस

1
@Jim संकलक झंडे पर अनुभाग उत्तर की तुलना में लंबे समय तक परिमाण का एक आदेश होगा। जीसीसी डिफ़ॉल्ट रूप से इसके साथ संकलित करता है, इसलिए "-fno-rtti", अन्य संकलक नहीं चुन सकते हैं, लेकिन संकलक झंडे के लिए कोई मानक नहीं है।
केफ्सोन

82

बहुत बदसूरत है, लेकिन अगर आप केवल संकलन जानकारी चाहते हैं (उदाहरण के लिए डिबगिंग):

auto testVar = std::make_tuple(1, 1.0, "abc");
decltype(testVar)::foo= 1;

यह दिखाता है:

Compilation finished with errors:
source.cpp: In function 'int main()':
source.cpp:5:19: error: 'foo' is not a member of 'std::tuple<int, double, const char*>'

2
केवल c ++ इसे इतना कठिन बना सकता है (संकलन समय पर एक ऑटो वैरिएबल टाइप करना)। केवल C ++।
कार्ल पिकेट

3
@ कार्ल अच्छी तरह से निष्पक्ष होने के लिए थोड़ा auto testVar = std::make_tuple(1, 1.0, "abc"); decltype(testVar)::foo = 1;
दृढ़ है

VC ++ 17 पर, यह एक सादे संदर्भ के लिए एक प्रतिद्वंद्विता-संदर्भ को कम करता है, यहां तक ​​कि अग्रेषण-संदर्भ पैरामीटर के साथ एक टेम्पलेट फ़ंक्शन में भी, और ऑब्जेक्ट नाम std में लिपटा हुआ :: आगे।
जिव डडसन

आप किसी भी नए पहियों को बनाए बिना टाइप करने में सक्षम थे!
स्टीवन एकॉफ

1
इस तकनीक का वर्णन "आइटम 4: प्रभावी
कटौती

54

शामिल करने के लिए मत भूलना <typeinfo>

मेरा मानना ​​है कि आप जो बात कर रहे हैं वह रनटाइम प्रकार की पहचान है। आप कर के ऊपर प्राप्त कर सकते हैं।

#include <iostream>
#include <typeinfo>

using namespace std;

int main() {
  int i;
  cout << typeid(i).name();
  return 0;
}

36

हॉवर्ड के समाधान के अनुसार , यदि आप जादू नंबर नहीं चाहते हैं, तो मुझे लगता है कि यह प्रतिनिधित्व करने का एक अच्छा तरीका है और सहज ज्ञान युक्त है:

#include <string_view>

template <typename T>
constexpr std::string_view 
type_name()
{
    std::string_view name, prefix, suffix;
#ifdef __clang__
    name = __PRETTY_FUNCTION__;
    prefix = "std::string_view type_name() [T = ";
    suffix = "]";
#elif defined(__GNUC__)
    name = __PRETTY_FUNCTION__;
    prefix = "constexpr std::string_view type_name() [with T = ";
    suffix = "; std::string_view = std::basic_string_view<char>]";
#elif defined(_MSC_VER)
    name = __FUNCSIG__;
    prefix = "class std::basic_string_view<char,struct std::char_traits<char> > __cdecl type_name<";
    suffix = ">(void)";
#endif
    name.remove_prefix(prefix.size());
    name.remove_suffix(suffix.size());
    return name;
}

4
यह पिछले कई सी ++ संस्करणों पर प्रयासों का एक बड़ा आसवन है जो कुछ छोटा और मीठा है। +1।
einpoklum

1
यह मेरा पसंदीदा भी है!
हावर्ड हिनांत

1
यहाँ एक समान कार्य जो मैं उपयोग करता हूँ, जो प्रत्यय / उपसर्ग का स्वतः पता लगाता है: stackoverflow.com/questions/1055452/…
HolyBlackCat

22

ध्यान दें कि C ++ की RTTI सुविधा द्वारा उत्पन्न नाम पोर्टेबल नहीं हैं । उदाहरण के लिए, वर्ग

MyNamespace::CMyContainer<int, test_MyNamespace::CMyObject>

निम्नलिखित नाम होंगे:

// MSVC 2003:
class MyNamespace::CMyContainer[int,class test_MyNamespace::CMyObject]
// G++ 4.2:
N8MyNamespace8CMyContainerIiN13test_MyNamespace9CMyObjectEEE

इसलिए आप इस जानकारी को क्रमांकन के लिए उपयोग नहीं कर सकते। लेकिन फिर भी, टाइपिड (ए) .नाम () संपत्ति अभी भी लॉग / डिबग उद्देश्यों के लिए उपयोग की जा सकती है


19

आप टेम्प्लेट का उपयोग कर सकते हैं।

template <typename T> const char* typeof(T&) { return "unknown"; }    // default
template<> const char* typeof(int&) { return "int"; }
template<> const char* typeof(float&) { return "float"; }

ऊपर के उदाहरण में, जब प्रकार का मिलान नहीं किया जाता है तो यह "अज्ञात" प्रिंट करेगा।


3
क्या यह शॉर्ट्स और चार्ट्स के लिए "int" प्रिंट नहीं करेगा? और युगल के लिए "फ्लोट"?
गार्टनरीज़

1
@gartenriese विशेषज्ञता में वह खामी नहीं है। क्योंकि doubleयह विशेषज्ञता का उपयोग करने के लिए एक अंतर्निहित प्रकार रूपांतरण करने के बजाय टेम्पलेट फ़ंक्शन के गैर-विशिष्ट संस्करण को संकलित करेगा: cpp.sh/2wzc
chappjc

1
@ अप्प्पजक: मैं ईमानदारी से नहीं जानता कि मैंने उस समय क्यों पूछा, यह मेरे लिए बहुत स्पष्ट है। लेकिन वैसे भी एक साल पुराने सवाल का जवाब देने के लिए धन्यवाद!
गार्टनरीज़

2
@gartenriese मुझे बहुत लगा, लेकिन "इंटरनेट" कुछ बिंदु पर एक ही सवाल हो सकता है।
चापजेक

18

जैसा कि उल्लेख किया गया है, typeid().name()एक मंगली नाम वापस कर सकता है। GCC (और कुछ अन्य संकलक) में आप निम्नलिखित कोड के साथ इसके आसपास काम कर सकते हैं:

#include <cxxabi.h>
#include <iostream>
#include <typeinfo>
#include <cstdlib>

namespace some_namespace { namespace another_namespace {

  class my_class { };

} }

int main() {
  typedef some_namespace::another_namespace::my_class my_type;
  // mangled
  std::cout << typeid(my_type).name() << std::endl;

  // unmangled
  int status = 0;
  char* demangled = abi::__cxa_demangle(typeid(my_type).name(), 0, 0, &status);

  switch (status) {
    case -1: {
      // could not allocate memory
      std::cout << "Could not allocate memory" << std::endl;
      return -1;
    } break;
    case -2: {
      // invalid name under the C++ ABI mangling rules
      std::cout << "Invalid name" << std::endl;
      return -1;
    } break;
    case -3: {
      // invalid argument
      std::cout << "Invalid argument to demangle()" << std::endl;
      return -1;
    } break;
 }
 std::cout << demangled << std::endl;

 free(demangled);

 return 0;

}


10

आप इसके लिए एक विशेषता वर्ग का उपयोग कर सकते हैं। कुछ इस तरह:

#include <iostream>
using namespace std;

template <typename T> class type_name {
public:
    static const char *name;
};

#define DECLARE_TYPE_NAME(x) template<> const char *type_name<x>::name = #x;
#define GET_TYPE_NAME(x) (type_name<typeof(x)>::name)

DECLARE_TYPE_NAME(int);

int main()
{
    int a = 12;
    cout << GET_TYPE_NAME(a) << endl;
}

DECLARE_TYPE_NAMEसभी प्रकार आप की जरूरत करने के लिए उम्मीद के लिए यह लक्षण वर्ग घोषित करने में अपने जीवन को आसान बनाने के लिए मौजूद है परिभाषित।

यह शामिल समाधानों की तुलना में अधिक उपयोगी हो सकता है typeidक्योंकि आप आउटपुट को नियंत्रित करते हैं। उदाहरण के लिए, मेरे संकलक के typeidलिए उपयोग करने long longसे "x" मिलता है।


10

C ++ 11 में, हमारे पास डिक्लेपट है। मानक प्रकार ++ में कोई तरीका नहीं है जो डिक्लेपट का उपयोग करके घोषित किए गए सटीक प्रकार के चर को प्रदर्शित करता है। हम type_id_with_cvrनीचे टाइप टाइप करने के लिए बूस्ट टाइपिंडेक्स अर्थात ( cvr का मतलब कॉन्स्टेबल , अस्थिर, संदर्भ) का उपयोग कर सकते हैं ।

#include <iostream>
#include <boost/type_index.hpp>

using namespace std;
using boost::typeindex::type_id_with_cvr;

int main() {
  int i = 0;
  const int ci = 0;
  cout << "decltype(i) is " << type_id_with_cvr<decltype(i)>().pretty_name() << '\n';
  cout << "decltype((i)) is " << type_id_with_cvr<decltype((i))>().pretty_name() << '\n';
  cout << "decltype(ci) is " << type_id_with_cvr<decltype(ci)>().pretty_name() << '\n';
  cout << "decltype((ci)) is " << type_id_with_cvr<decltype((ci))>().pretty_name() << '\n';
  cout << "decltype(std::move(i)) is " << type_id_with_cvr<decltype(std::move(i))>().pretty_name() << '\n';
  cout << "decltype(std::static_cast<int&&>(i)) is " << type_id_with_cvr<decltype(static_cast<int&&>(i))>().pretty_name() << '\n';
  return 0;
}

1
यह आसान होगा एक सहायक समारोह का उपयोग करें:template<typename T> void print_type(T){cout << "type T is: "<< type_id_with_cvr<T>().pretty_name()<< '\n';}
r0ng

6

आप टाइप नाम के साथ c + filt का उपयोग भी कर सकते हैं प्रकार टाइप करने के लिए:

#include <iostream>
#include <typeinfo>
#include <string>

using namespace std;

int main() {
  auto x = 1;
  string my_type = typeid(x).name();
  system(("echo " + my_type + " | c++filt -t").c_str());
  return 0;
}

केवल लिनक्स पर परीक्षण किया गया।


1
नरक बदसूरत है, लेकिन मैं क्या जरूरत के लिए करेंगे। और अन्य समाधानों की तुलना में बहुत छोटा है। मैक btw पर काम करता है।
मार्को लुग्लियो

6

हावर्ड हिनान्ट ने टाइप नाम निकालने के लिए मैजिक नंबरों का उपयोग किया। used fix सुझाए गए स्ट्रिंग उपसर्ग और प्रत्यय। लेकिन उपसर्ग / प्रत्यय बदलते रहते हैं। "जांच_ प्रकार" के साथ टाइप_नाम स्वचालित रूप से "जांच_टाइप" प्रकार नाम निकालने के लिए उपसर्ग और प्रत्यय आकार की गणना करता है:

#include <iostream>
#include <string_view>

using namespace std;

class probe_type;

template <typename T>
constexpr string_view type_name() {
  string_view probe_type_name("class probe_type");
  const string_view class_specifier("class");

  string_view name;
#ifdef __clang__
  name = __PRETTY_FUNCTION__;
  probe_type_name.remove_prefix(class_specifier.length());
#elif defined(__GNUC__)
  name = __PRETTY_FUNCTION__;
  probe_type_name.remove_prefix(class_specifier.length());
#elif defined(_MSC_VER)
  name = __FUNCSIG__;
#endif

  if (name.find(probe_type_name) != string_view::npos)
    return name;

  const string_view probe_type_raw_name = type_name<probe_type>();

  const size_t prefix_size = probe_type_raw_name.find(probe_type_name);

  name.remove_prefix(prefix_size);
  name.remove_suffix(probe_type_raw_name.length() - prefix_size - probe_type_name.length());

  return name;
}

class test;

int main() {
  cout << type_name<test>() << endl;

  cout << type_name<const int*&>() << endl;
  cout << type_name<unsigned int>() << endl;

  const int ic = 42;
  const int* pic = &ic;
  const int*& rpic = pic;
  cout << type_name<decltype(ic)>() << endl;
  cout << type_name<decltype(pic)>() << endl;
  cout << type_name<decltype(rpic)>() << endl;

  cout << type_name<probe_type>() << endl;
}

उत्पादन

gcc 10.0.0 20190919 वैंडबॉक्स:

 test
 const int *&
 unsigned int
 const int
 const int *
 const int *&
 constexpr std::string_view type_name() [with T = probe_type; std::string_view = std::basic_string_view<char>]

क्लैंग 10.0.0 वैंडबॉक्स:

 test
 const int *&
 unsigned int
 const int
 const int *
 const int *&
 std::__1::string_view type_name() [T = probe_type]

वीएस 2019 संस्करण 16.3.3:

class test
const int*&
unsigned int
const int
const int*
const int*&
class std::basic_string_view<char,struct std::char_traits<char> > __cdecl type_name<class probe_type>(void)

5

RTTI (टाइपिड) से जुड़े अन्य उत्तर संभवतः वही हैं जो आप चाहते हैं, जब तक:

  • आप मेमोरी ओवरहेड को वहन कर सकते हैं (जो कुछ संकलक के साथ काफी हो सकता है)
  • आपके संकलक रिटर्न उपयोगी हैं

विकल्प, (ग्रेग हेवगिल के उत्तर के समान), लक्षणों के संकलन-समय सारणी का निर्माण करना है।

template <typename T> struct type_as_string;

// declare your Wibble type (probably with definition of Wibble)
template <>
struct type_as_string<Wibble>
{
    static const char* const value = "Wibble";
};

ध्यान रखें कि यदि आप किसी मैक्रो में घोषणाओं को लपेटते हैं, तो आपको अल्पविराम के कारण एक से अधिक पैरामीटर (जैसे std :: map) लेने वाले टेम्पलेट प्रकारों के नाम घोषित करने में परेशानी होगी।

एक चर के प्रकार तक पहुंचने के लिए, आपको बस जरूरत है

template <typename T>
const char* get_type_as_string(const T&)
{
    return type_as_string<T>::value;
}

1
अल्पविराम के बारे में अच्छी बात, मुझे पता था कि एक कारण था कि मैक्रोज़ एक बुरा विचार थे, लेकिन उस समय ऐसा नहीं सोचा था!
ग्रेग हेवगिल सेप

2
स्थिर कास्ट चार * मूल्य = "वाइबल"; आपको लगता है कि दोस्त :) ऐसा नहीं कर सकते
litb - Johannes Schaub

5

मेरे पिछले एक से अधिक कार्य के बिना एक अधिक सामान्य समाधान:

template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";

    return Type;}

यहाँ MyClass उपयोगकर्ता परिभाषित वर्ग है। यहां और भी हालात जोड़े जा सकते हैं।

उदाहरण:

#include <iostream>



class MyClass{};


template<typename T>
std::string TypeOf(T){
    std::string Type="unknown";
    if(std::is_same<T,int>::value) Type="int";
    if(std::is_same<T,std::string>::value) Type="String";
    if(std::is_same<T,MyClass>::value) Type="MyClass";
    return Type;}


int main(){;
    int a=0;
    std::string s="";
    MyClass my;
    std::cout<<TypeOf(a)<<std::endl;
    std::cout<<TypeOf(s)<<std::endl;
    std::cout<<TypeOf(my)<<std::endl;

    return 0;}

आउटपुट:

int
String
MyClass

5

मुझे निक की विधि पसंद है, एक पूर्ण रूप यह हो सकता है (सभी बुनियादी डेटा प्रकारों के लिए):

template <typename T> const char* typeof(T&) { return "unknown"; }    // default
template<> const char* typeof(int&) { return "int"; }
template<> const char* typeof(short&) { return "short"; }
template<> const char* typeof(long&) { return "long"; }
template<> const char* typeof(unsigned&) { return "unsigned"; }
template<> const char* typeof(unsigned short&) { return "unsigned short"; }
template<> const char* typeof(unsigned long&) { return "unsigned long"; }
template<> const char* typeof(float&) { return "float"; }
template<> const char* typeof(double&) { return "double"; }
template<> const char* typeof(long double&) { return "long double"; }
template<> const char* typeof(std::string&) { return "String"; }
template<> const char* typeof(char&) { return "char"; }
template<> const char* typeof(signed char&) { return "signed char"; }
template<> const char* typeof(unsigned char&) { return "unsigned char"; }
template<> const char* typeof(char*&) { return "char*"; }
template<> const char* typeof(signed char*&) { return "signed char*"; }
template<> const char* typeof(unsigned char*&) { return "unsigned char*"; }

2
(i) यह अन्य प्रकारों के लिए काम नहीं करेगा (अर्थात बिल्कुल सामान्य नहीं); (ii) बेकार कोड ब्लोट; (iii) उसी के साथ typeidया (सही तरीके से) किया जा सकता है decltype

2
आप सही हैं, लेकिन इसमें सभी बुनियादी प्रकार शामिल हैं ... और यही मुझे अभी चाहिए ..
जाहिद

2
क्या आप मुझे बता सकते हैं, आप इसे घोषणा के साथ कैसे करेंगे,
जाहिद

1
यदि यह एक संकलन-समय की परीक्षा है, तो आप std :: is_same <T, S> का उपयोग कर सकते हैं और T और S. को प्राप्त करने की घोषणा कर सकते हैं
edmz

4

जैसा कि मैंने चुनौती दी है कि मैंने यह परीक्षण करने का निर्णय लिया है कि कोई व्यक्ति प्लेटफ़ॉर्म-इंडिपेंडेंट (उम्मीद) टेम्पलेट ट्रिक के साथ कितनी दूर जा सकता है।

संकलन के समय नाम पूरी तरह से इकट्ठे होते हैं। (जिसका अर्थ है typeid(T).name()कि उपयोग नहीं किया जा सकता है, इस प्रकार आपको गैर-यौगिक प्रकारों के लिए स्पष्ट रूप से नाम प्रदान करना होगा। अन्यथा इसके स्थान पर प्लेसहोल्डर प्रदर्शित किए जाएंगे।)

उदाहरण उपयोग:

TYPE_NAME(int)
TYPE_NAME(void)
// You probably should list all primitive types here.

TYPE_NAME(std::string)

int main()
{
    // A simple case
    std::cout << type_name<void(*)(int)> << '\n';
    // -> `void (*)(int)`

    // Ugly mess case
    // Note that compiler removes cv-qualifiers from parameters and replaces arrays with pointers.
    std::cout << type_name<void (std::string::*(int[3],const int, void (*)(std::string)))(volatile int*const*)> << '\n';
    // -> `void (std::string::*(int *,int,void (*)(std::string)))(volatile int *const*)`

    // A case with undefined types
    //  If a type wasn't TYPE_NAME'd, it's replaced by a placeholder, one of `class?`, `union?`, `enum?` or `??`.
    std::cout << type_name<std::ostream (*)(int, short)> << '\n';
    // -> `class? (*)(int,??)`
    // With appropriate TYPE_NAME's, the output would be `std::string (*)(int,short)`.
}

कोड:

#include <type_traits>
#include <utility>

static constexpr std::size_t max_str_lit_len = 256;

template <std::size_t I, std::size_t N> constexpr char sl_at(const char (&str)[N])
{
    if constexpr(I < N)
        return str[I];
    else
        return '\0';
}

constexpr std::size_t sl_len(const char *str)
{
    for (std::size_t i = 0; i < max_str_lit_len; i++)
        if (str[i] == '\0')
            return i;
    return 0;
}

template <char ...C> struct str_lit
{
    static constexpr char value[] {C..., '\0'};
    static constexpr int size = sl_len(value);

    template <typename F, typename ...P> struct concat_impl {using type = typename concat_impl<F>::type::template concat_impl<P...>::type;};
    template <char ...CC> struct concat_impl<str_lit<CC...>> {using type = str_lit<C..., CC...>;};
    template <typename ...P> using concat = typename concat_impl<P...>::type;
};

template <typename, const char *> struct trim_str_lit_impl;
template <std::size_t ...I, const char *S> struct trim_str_lit_impl<std::index_sequence<I...>, S>
{
    using type = str_lit<S[I]...>;
};
template <std::size_t N, const char *S> using trim_str_lit = typename trim_str_lit_impl<std::make_index_sequence<N>, S>::type;

#define STR_LIT(str) ::trim_str_lit<::sl_len(str), ::str_lit<STR_TO_VA(str)>::value>
#define STR_TO_VA(str) STR_TO_VA_16(str,0),STR_TO_VA_16(str,16),STR_TO_VA_16(str,32),STR_TO_VA_16(str,48)
#define STR_TO_VA_16(str,off) STR_TO_VA_4(str,0+off),STR_TO_VA_4(str,4+off),STR_TO_VA_4(str,8+off),STR_TO_VA_4(str,12+off)
#define STR_TO_VA_4(str,off) ::sl_at<off+0>(str),::sl_at<off+1>(str),::sl_at<off+2>(str),::sl_at<off+3>(str)

template <char ...C> constexpr str_lit<C...> make_str_lit(str_lit<C...>) {return {};}
template <std::size_t N> constexpr auto make_str_lit(const char (&str)[N])
{
    return trim_str_lit<sl_len((const char (&)[N])str), str>{};
}

template <std::size_t A, std::size_t B> struct cexpr_pow {static constexpr std::size_t value = A * cexpr_pow<A,B-1>::value;};
template <std::size_t A> struct cexpr_pow<A,0> {static constexpr std::size_t value = 1;};
template <std::size_t N, std::size_t X, typename = std::make_index_sequence<X>> struct num_to_str_lit_impl;
template <std::size_t N, std::size_t X, std::size_t ...Seq> struct num_to_str_lit_impl<N, X, std::index_sequence<Seq...>>
{
    static constexpr auto func()
    {
        if constexpr (N >= cexpr_pow<10,X>::value)
            return num_to_str_lit_impl<N, X+1>::func();
        else
            return str_lit<(N / cexpr_pow<10,X-1-Seq>::value % 10 + '0')...>{};
    }
};
template <std::size_t N> using num_to_str_lit = decltype(num_to_str_lit_impl<N,1>::func());


using spa = str_lit<' '>;
using lpa = str_lit<'('>;
using rpa = str_lit<')'>;
using lbr = str_lit<'['>;
using rbr = str_lit<']'>;
using ast = str_lit<'*'>;
using amp = str_lit<'&'>;
using con = str_lit<'c','o','n','s','t'>;
using vol = str_lit<'v','o','l','a','t','i','l','e'>;
using con_vol = con::concat<spa, vol>;
using nsp = str_lit<':',':'>;
using com = str_lit<','>;
using unk = str_lit<'?','?'>;

using c_cla = str_lit<'c','l','a','s','s','?'>;
using c_uni = str_lit<'u','n','i','o','n','?'>;
using c_enu = str_lit<'e','n','u','m','?'>;

template <typename T> inline constexpr bool ptr_or_ref = std::is_pointer_v<T> || std::is_reference_v<T> || std::is_member_pointer_v<T>;
template <typename T> inline constexpr bool func_or_arr = std::is_function_v<T> || std::is_array_v<T>;

template <typename T> struct primitive_type_name {using value = unk;};

template <typename T, typename = std::enable_if_t<std::is_class_v<T>>> using enable_if_class = T;
template <typename T, typename = std::enable_if_t<std::is_union_v<T>>> using enable_if_union = T;
template <typename T, typename = std::enable_if_t<std::is_enum_v <T>>> using enable_if_enum  = T;
template <typename T> struct primitive_type_name<enable_if_class<T>> {using value = c_cla;};
template <typename T> struct primitive_type_name<enable_if_union<T>> {using value = c_uni;};
template <typename T> struct primitive_type_name<enable_if_enum <T>> {using value = c_enu;};

template <typename T> struct type_name_impl;

template <typename T> using type_name_lit = std::conditional_t<std::is_same_v<typename primitive_type_name<T>::value::template concat<spa>,
                                                                               typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>,
                                            typename primitive_type_name<T>::value,
                                            typename type_name_impl<T>::l::template concat<typename type_name_impl<T>::r>>;
template <typename T> inline constexpr const char *type_name = type_name_lit<T>::value;

template <typename T, typename = std::enable_if_t<!std::is_const_v<T> && !std::is_volatile_v<T>>> using enable_if_no_cv = T;

template <typename T> struct type_name_impl
{
    using l = typename primitive_type_name<T>::value::template concat<spa>;
    using r = str_lit<>;
};
template <typename T> struct type_name_impl<const T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con>,
                                 con::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<vol>,
                                 vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<const volatile T>
{
    using new_T_l = std::conditional_t<type_name_impl<T>::l::size && !ptr_or_ref<T>,
                                       spa::concat<typename type_name_impl<T>::l>,
                                       typename type_name_impl<T>::l>;
    using l = std::conditional_t<ptr_or_ref<T>,
                                 typename new_T_l::template concat<con_vol>,
                                 con_vol::concat<new_T_l>>;
    using r = typename type_name_impl<T>::r;
};
template <typename T> struct type_name_impl<T *>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, ast>,
                                 typename type_name_impl<T>::l::template concat<     ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T &&>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, amp, amp>,
                                 typename type_name_impl<T>::l::template concat<     amp, amp>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T, typename C> struct type_name_impl<T C::*>
{
    using l = std::conditional_t<func_or_arr<T>,
                                 typename type_name_impl<T>::l::template concat<lpa, type_name_lit<C>, nsp, ast>,
                                 typename type_name_impl<T>::l::template concat<     type_name_lit<C>, nsp, ast>>;
    using r = std::conditional_t<func_or_arr<T>,
                                 rpa::concat<typename type_name_impl<T>::r>,
                                             typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<enable_if_no_cv<T[]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<rbr, typename type_name_impl<T>::r>;
};
template <typename T, std::size_t N> struct type_name_impl<enable_if_no_cv<T[N]>>
{
    using l = typename type_name_impl<T>::l;
    using r = lbr::concat<num_to_str_lit<N>, rbr, typename type_name_impl<T>::r>;
};
template <typename T> struct type_name_impl<T()>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<rpa, typename type_name_impl<T>::r>;
};
template <typename T, typename P1, typename ...P> struct type_name_impl<T(P1, P...)>
{
    using l = typename type_name_impl<T>::l;
    using r = lpa::concat<type_name_lit<P1>,
                          com::concat<type_name_lit<P>>..., rpa, typename type_name_impl<T>::r>;
};

#define TYPE_NAME(t) template <> struct primitive_type_name<t> {using value = STR_LIT(#t);};

2
#include <iostream>
#include <typeinfo>
using namespace std;
#define show_type_name(_t) \
    system(("echo " + string(typeid(_t).name()) + " | c++filt -t").c_str())

int main() {
    auto a = {"one", "two", "three"};
    cout << "Type of a: " << typeid(a).name() << endl;
    cout << "Real type of a:\n";
    show_type_name(a);
    for (auto s : a) {
        if (string(s) == "one") {
            cout << "Type of s: " << typeid(s).name() << endl;
            cout << "Real type of s:\n";
            show_type_name(s);
        }
        cout << s << endl;
    }

    int i = 5;
    cout << "Type of i: " << typeid(i).name() << endl;
    cout << "Real type of i:\n";
    show_type_name(i);
    return 0;
}

आउटपुट:

Type of a: St16initializer_listIPKcE
Real type of a:
std::initializer_list<char const*>
Type of s: PKc
Real type of s:
char const*
one
two
three
Type of i: i
Real type of i:
int

2

जैसा कि प्रभावी आधुनिक C ++ में स्कॉट मेयर्स द्वारा समझाया गया है,

कॉल करने के लिए std::type_info::nameanythong समझदार वापस जाने के लिए गारंटी नहीं है।

सबसे अच्छा समाधान यह है कि संकलक को टाइप कटौती के दौरान त्रुटि संदेश उत्पन्न करने दें, उदाहरण के लिए,

template<typename T>
class TD;

int main(){
    const int theAnswer = 32;
    auto x = theAnswer;
    auto y = &theAnswer;
    TD<decltype(x)> xType;
    TD<decltype(y)> yType;
    return 0;
}

परिणाम कुछ इस तरह होगा, जो संकलक पर निर्भर करता है,

test4.cpp:10:21: error: aggregate TD<int> xType has incomplete type and cannot be defined TD<decltype(x)> xType;

test4.cpp:11:21: error: aggregate TD<const int *> yType has incomplete type and cannot be defined TD<decltype(y)> yType;

इसलिए, हम जानते हैं कि xप्रकार है int, yप्रकार हैconst int*


0

अभी भी आने वाले किसी भी व्यक्ति के लिए, मेरे पास हाल ही में एक ही मुद्दा था और इस पोस्ट के उत्तरों के आधार पर एक छोटी सी लाइब्रेरी लिखने का फैसला किया। यह कॉन्स्टैक्सप्र टाइप नाम प्रदान करता है और मैक, विंडोज और उबंटू पर इनडाइस इंड का परीक्षण किया जाता है।

लाइब्रेरी कोड यहाँ है: https://github.com/TheLartians/StaticTypeInfo

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.