Why would we want to do this:
#include <iostream>
void print(std::ostream& os) {
os << "Hi";
}
int main() {
print(std::cout);
return 0;
}
instead of this:
#include <iostream>
void print() {
std::cout << "Hi";
}
int main() {
print();
return 0;
}
Is there some certain advantage or functionality that is obtained only with the first version?
Yes, the first version is significantly better. Like already mentioned in the comments, it allows you to use any kind of std::ostream, not just std::cout. Some of the most important consequences of this architectural choice are:
You can use your function to print the required data to standard output, a file, a custom class written by your colleagues (e.g. database adapter, logger).
It is possible to test your void print function. E.g.:
TEST(MyFunctionShould, printHello)
{
std::string expectedResult("Hello");
std::ostringstream oss;
print(oss);
ASSERT_EQ(expectedResult, oss.str());
}
Consider this example:
#include <vector>
#include <string>
#include <functional>
#include <iostream>
using closure_type = std::function<void(void)>;
using closure_vec = std::vector<closure_type>;
class callbacks {
static closure_type common(std::string name, uint32_t number) {
return [number, name]() { std::cout << name << number << std::endl; };
}
public:
static closure_type foo(uint32_t number) { return common("foo ", number); }
static closure_type print(std::string msg) {
return [msg]() { std::cout << "print " << msg << std::endl; };
}
};
template <typename... calls_t> closure_vec wrap(uint32_t number, calls_t &&... calls) {
return closure_vec {
callbacks::foo(number),
std::forward<calls_t>(calls)...,
};
}
int main() {
auto vec = wrap(42,
callbacks::print("hello, "),
callbacks::print("world"));
for(auto &e: vec)
e();
return 0;
}
Demo (On the right most tab there is a full message)
When this code is checked with clang-tidy, I get the following warning:
warning: Potential memory leak [clang-analyzer-cplusplus.NewDeleteLeaks]
The line number points at the scope exit of the wrap function.
As I understand the message, the tool is concerned that the results form callbacks::foo might be lost. But I don not understand how is it possible: std::function is a safe class and should destroy everything nicely in its destructor. Also its lifetime is controlled by the vector which is safe too.
What is going on here? How do I fix this or workaround?
Unfortunately I cannot just suppress the warning, as this code is scattered everywhere in the codebase.
Try
closure_vec retval;
retval.reserve(sizeof...(calls)+1);
retval.push_back(callbacks::foo(number));
( retval.push_back(std::forward<calls_t>(calls)), ... );
return retval;
this avoids the const initializer_list contained copies of std function your code created, so should be more efficient as well.
Live example.
I tried using a C style array here, but I got the warning as well despite not using a std::initializer_list.
This also works:
std::array<closure_type, sizeof...(calls)+1> tmp ={
nullptr,
std::forward<calls_t>(calls)...
};
tmp[0] = callbacks::foo(number);
return {std::make_move_iterator(std::begin(tmp)), std::make_move_iterator(std::end(tmp))};
the problem is callbacks::foo(number) within the initalization.
I'm trying to create a class like std::cout, however, with colored output. The idea is to call colorstream, but when I overload the operator << gives error.
Codes below:
main.cpp
#include <colorstream/colorstream.hpp>
int main ( int argc, char **argv )
{
cpk::colorstream test;
test << "Hello World";
return 0;
}
colorstream/colorstream.hpp
#include <string>
#ifndef CPK_COLORSTREAM_HPP
#define CPK_COLORSTREAM_HPP
namespace cpk
{
class colorstream
{
public:
colorstream ( ) { };
colorstream operator<<( std::string n );
};
}
#endif // #ifndef CPK_COLORSTREAM_HPP
colorstream/colorstream.cpp
#include <string>
#include <iostream>
/**
* CPK Color Stream Header
*/
#include <colorstream/colorstream.hpp>
cpk::colorstream::colorstream operator<<( std::string n )
{
std::cout << n << std::endl;
}
This is the first time I'm trying to overload operators in, so please help me and if I can explain my mistake.
Thank you, Bruno Alano
#edit
The error:
CMakeFiles/cpk.dir/source/cpk.cpp.o: In function `main':
cpk.cpp:(.text+0x45): undefined reference to `cpk::colorstream::operator<<(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
collect2: ld returned 1 exit status
make[2]: ** [cpk] Erro 1
make[1]: ** [CMakeFiles/cpk.dir/all] Erro 2
make: ** [all] Erro 2
Well, the error is that you're definition of the operator is garbled. It should be
cpk::colorstream cpk::colorstream::operator<< (std::string n)
That said, I strong recommend not to pursue this approach further! To create custom streams you want to derive from std::streambuf and override the relevant operations there (e.g. overflow() and, possibly, xsputn() for output streams).
Actually, if you want to change color e.g. using ANSI Escape Codes you can just create suitable color manipulators and use them with an std::ostream:
#include <iostream>
namespace color
{
std::ostream& red(std::ostream& out) {
return out << "\x1b[31m";
}
std::ostream& reset(std::ostream& out) {
return out << "\x1b[0m";
}
}
int main()
{
std::cout << "hello " << color::red << "world" << color::reset << "\n";
}
On non-UNIX platforms some other mechanism might be necessary, though...
When defining a member operator, what you need to qualify with the class name is the operator name, not the return type.
namespace cpk {
colorstream colorstream::operator<<( std::string n )
{
std::cout << n << std::endl;
}
}
Now, to allow chaining calls to << like you can do with std::cout you need to actually return a value from your operator!
namespace cpk {
colorstream colorstream::operator<<( std::string n )
{
std::cout << n << std::endl;
return *this;
}
}
However, this will return a copy of the stream because it returns by value. That's probably not desirable, so you might be better with returning by reference:
colorstream& colorstream::operator<<( std::string n )
{
std::cout << n << std::endl;
return *this;
}
I need more information on what you are trying to accomplish and what are the errors that are coming up.
I made an assumption with the code provided below that you wanted to output the color to standard out.
I feel that I am completely wrong with this assumption, however here is the code...
main.cpp
#include <colorstream/colorstream.hpp>
int main ( int argc, char **argv )
{
cpk::colorstream test;
test.SetColor("RED");
std::cout << test << std::endl;
return 0;
}
colorstream/colorstream.hpp should be:
#include <iostream>
#include <string>
#ifndef CPK_COLORSTREAM_HPP
#define CPK_COLORSTREAM_HPP
namespace cpk
{
class colorstream
{
public:
std::ostream& operator<< (std::ostream& stream, const cpk::colorstream& cs);
void SetColor(const std::string &color){m_Color = color;}
private:
std::string m_Color;
};
}
#endif // #ifndef CPK_COLORSTREAM_HPP
colorstream/colorstream.cpp should be:
#include <string>
#include <iostream>
/**
* CPK Color Stream Header
*/
#include <colorstream/colorstream.hpp>
std::ostream& operator<<(std::ostream& stream, const cpk::colorstream& cs)
{
stream << cs.m_Color;
return stream;
}
I've a working logger class, which outputs some text into a richtextbox (Win32, C++).
Problem is, i always end up using it like this:
stringstream ss;
ss << someInt << someString;
debugLogger.log(ss.str());
instead, it would be much more convenient to use it like a stream as in:
debugLogger << someInt << someString;
Is there a better way than forwarding everything to an internal stringstream instance? If'd do this, when would i need to flush?
You need to implement operator << appropriately for your class. The general pattern looks like this:
template <typename T>
logger& operator <<(logger& log, T const& value) {
log.your_stringstream << value;
return log;
}
Notice that this deals with (non-const) references since the operation modifies your logger. Also notice that you need to return the log parameter in order for chaining to work:
log << 1 << 2 << endl;
// is the same as:
((log << 1) << 2) << endl;
If the innermost operation didn't return the current log instance, all other operations would either fail at compile-time (wrong method signature) or would be swallowed at run-time.
Overloading the insertion operator<< is not the way to go. You will have to add overloads for all the endl or any other user defined functions.
The way to go is to define your own streambuf, and to bind it into a stream. Then, you just have to use the stream.
Here are a few simple examples:
Logging In C++ by Petru Marginean, DDJ Sept 05th 2007
Rutger E.W. van Beusekom's logstream class, check also the .hpp alongside with this file
As Luc Hermitte noted, there is "Logging In C++" article which describes very neat approach to solve this problem. In a nutshell, given you have a function like the following:
void LogFunction(const std::string& str) {
// write to socket, file, console, e.t.c
std::cout << str << std::endl;
}
it is possible to write a wrapper to use it in std::cout like way:
#include <sstream>
#include <functional>
#define LOG(loggingFuntion) \
Log(loggingFuntion).GetStream()
class Log {
using LogFunctionType = std::function<void(const std::string&)>;
public:
explicit Log(LogFunctionType logFunction) : m_logFunction(std::move(logFunction)) { }
std::ostringstream& GetStream() { return m_stringStream; }
~Log() { m_logFunction(m_stringStream.str()); }
private:
std::ostringstream m_stringStream;
LogFunctionType m_logFunction;
};
int main() {
LOG(LogFunction) << "some string " << 5 << " smth";
}
(online demo)
Also, there is very nice solution provided by Stewart.
An elegant solution that also solves the flushing issues is the following:
#include <string>
#include <memory>
#include <sstream>
#include <iostream>
class Logger
{
using Stream = std::ostringstream;
using Buffer_p = std::unique_ptr<Stream, std::function<void(Stream*)>>;
public:
void log(const std::string& cmd) {
std::cout << "INFO: " << cmd << std::endl;
}
Buffer_p log() {
return Buffer_p(new Stream, [&](Stream* st) {
log(st->str());
});
}
};
#define LOG(instance) *(instance.log())
int main()
{
Logger logger;
LOG(logger) << "e.g. Log a number: " << 3;
return 0;
}
In the Logger class, override the << operator.
Click Here to know how to implement the << operator.
You can also avoid the logging statements inside the code
using Aspect Oriented programming.
I'm currently working on some logging code that supposed to - among other things - print information about the calling function. This should be relatively easy, standard C++ has a type_info class. This contains the name of the typeid'd class/function/etc. but it's mangled. It's not very useful. I.e. typeid(std::vector<int>).name() returns St6vectorIiSaIiEE.
Is there a way to produce something useful from this? Like std::vector<int> for the above example. If it only works for non-template classes, that's fine too.
The solution should work for gcc, but it would be better if I could port it. It's for logging so it's not so important that it can't be turned off, but it should be helpful for debugging.
Given the attention this question / answer receives, and the valuable feedback from GManNickG, I have cleaned up the code a little bit. Two versions are given: one with C++11 features and another one with only C++98 features.
In file type.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());
}
#endif
In file type.cpp (requires C++11)
#include "type.hpp"
#ifdef __GNUG__
#include <cstdlib>
#include <memory>
#include <cxxabi.h>
std::string demangle(const char* name) {
int status = -4; // some arbitrary value to eliminate the compiler warning
// enable c++11 by passing the flag -std=c++11 to g++
std::unique_ptr<char, void(*)(void*)> res {
abi::__cxa_demangle(name, NULL, NULL, &status),
std::free
};
return (status==0) ? res.get() : name ;
}
#else
// does nothing if not g++
std::string demangle(const char* name) {
return name;
}
#endif
Usage:
#include <iostream>
#include "type.hpp"
struct Base { virtual ~Base() {} };
struct Derived : public Base { };
int main() {
Base* ptr_base = new Derived(); // Please use smart pointers in YOUR code!
std::cout << "Type of ptr_base: " << type(ptr_base) << std::endl;
std::cout << "Type of pointee: " << type(*ptr_base) << std::endl;
delete ptr_base;
}
It prints:
Type of ptr_base: Base*
Type of pointee: Derived
Tested with g++ 4.7.2, g++ 4.9.0 20140302 (experimental), clang++ 3.4 (trunk 184647), clang 3.5 (trunk 202594) on Linux 64 bit and g++ 4.7.2 (Mingw32, Win32 XP SP2).
If you cannot use C++11 features, here is how it can be done in C++98, the file type.cpp is now:
#include "type.hpp"
#ifdef __GNUG__
#include <cstdlib>
#include <memory>
#include <cxxabi.h>
struct handle {
char* p;
handle(char* ptr) : p(ptr) { }
~handle() { std::free(p); }
};
std::string demangle(const char* name) {
int status = -4; // some arbitrary value to eliminate the compiler warning
handle result( abi::__cxa_demangle(name, NULL, NULL, &status) );
return (status==0) ? result.p : name ;
}
#else
// does nothing if not g++
std::string demangle(const char* name) {
return name;
}
#endif
(Update from Sep 8, 2013)
The accepted answer (as of Sep 7, 2013), when the call to abi::__cxa_demangle() is successful, returns a pointer to a local, stack allocated array... ouch!
Also note that if you provide a buffer, abi::__cxa_demangle() assumes it to be allocated on the heap. Allocating the buffer on the stack is a bug (from the gnu doc): "If output_buffer is not long enough, it is expanded using realloc." Calling realloc() on a pointer to the stack... ouch! (See also Igor Skochinsky's kind comment.)
You can easily verify both of these bugs: just reduce the buffer size in the accepted answer (as of Sep 7, 2013) from 1024 to something smaller, for example 16, and give it something with a name not longer than 15 (so realloc() is not called). Still, depending on your system and the compiler optimizations, the output will be: garbage / nothing / program crash.
To verify the second bug: set the buffer size to 1 and call it with something whose name is longer than 1 character. When you run it, the program almost assuredly crashes as it attempts to call realloc() with a pointer to the stack.
(The old answer from Dec 27, 2010)
Important changes made to KeithB's code: the buffer has to be either allocated by malloc or specified as NULL. Do NOT allocate it on the stack.
It's wise to check that status as well.
I failed to find HAVE_CXA_DEMANGLE. I check __GNUG__ although that does not guarantee that the code will even compile. Anyone has a better idea?
#include <cxxabi.h>
const string demangle(const char* name) {
int status = -4;
char* res = abi::__cxa_demangle(name, NULL, NULL, &status);
const char* const demangled_name = (status==0)?res:name;
string ret_val(demangled_name);
free(res);
return ret_val;
}
Boost core contains a 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>
}
It's basically just a wrapper for abi::__cxa_demangle, as has been suggested previously.
If all we want is the unmangled type name for the purpose of logging, we can actually do this without using std::type_info or even RTTI at all.
A slightly portable solution that works for the big 3 main compiler front-ends (gcc, clang, and msvc) would be to use a function template and extract the type name from the function name.
gcc and clang both offer __PRETTY_FUNCTION__ which is the name of a current function or function template with all type-argument in the string. Similarly MSVC has __FUNCSIG__ which is equivalent. Each of these are formatted a little differently, for example, for a call of void foo<int>, the compilers will output something different:
gcc is formatted void foo() [with T = int; ]
clang is formatted void foo() [T = int]
msvc is formatted void foo<int>()
Knowing this, it's just a matter of parsing out a prefix and suffix and wrapping this into a function in order to extract out the type name.
We can even use c++17's std::string_view and extended constexpr to get string names at compile-time, just by parsing the name of a template function. This could also be done in any earlier C++ version, but this will still require some form of string parsing.
For example:
#include <string_view>
template <typename T>
constexpr auto get_type_name() -> std::string_view
{
#if defined(__clang__)
constexpr auto prefix = std::string_view{"[T = "};
constexpr auto suffix = "]";
constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(__GNUC__)
constexpr auto prefix = std::string_view{"with T = "};
constexpr auto suffix = "; ";
constexpr auto function = std::string_view{__PRETTY_FUNCTION__};
#elif defined(_MSC_VER)
constexpr auto prefix = std::string_view{"get_type_name<"};
constexpr auto suffix = ">(void)";
constexpr auto function = std::string_view{__FUNCSIG__};
#else
# error Unsupported compiler
#endif
const auto start = function.find(prefix) + prefix.size();
const auto end = function.find(suffix);
const auto size = end - start;
return function.substr(start, size);
}
With this, you can call get_type_name<T>() to get a std::string_view at compile-time indicating the unmangled type name.
For example:
std::cout << get_type_name<std::string>() << std::endl;
on GCC will output:
std::__cxx11::basic_string<char>
and on clang will output:
std::basic_string<char>
Live Example
A similar augmentation to this approach which avoids a prefix and suffix is to assume that the function name is the same for all types, and search for a sentinel type to parse out the offset to the sentinel from each end. This ensures that the string searching only happens once, and the offset is assumed to find the string name each time. For example, using double as a simple sentinel:
template <typename T>
constexpr auto full_function_name() -> std::string_view
{
#if defined(__clang__) || defined(__GNUC__)
return std::string_view{__PRETTY_FUNCTION__};
#elif defined(_MSC_VER)
return std::string_view{__FUNCSIG__};
#else
# error Unsupported compiler
#endif
}
// Outside of the template so its computed once
struct type_name_info {
static constexpr auto sentinel_function = full_function_name<double>();
static constexpr auto prefix_offset = sentinel_function.find("double");
static constexpr auto suffix_offset = sentinel_function.size() - prefix_offset - /* strlen("double") */ 6;
};
template <typename T>
constexpr auto get_type_name() -> std::string_view
{
constexpr auto function = full_function_name<T>();
const auto start = type_name_info::prefix_offset;
const auto end = function.size() - type_name_info::suffix_offset;
const auto size = end - start;
return function.substr(start, size);
}
Live Example
This isn't portable to all compilers, but can be modified for any compiler that offers a __FUNCSIG__/__PRETTY_FUNCTION__ equivalent; it just requires a bit of parsing.
note: This hasn't been fully tested, so there may be some bugs; but the primary idea is to parse any output that contains the name in totality -- which is often a side-effect of __func__-like outputs on compilers.
This is what we use. HAVE_CXA_DEMANGLE is only set if available (recent versions of GCC only).
#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
Here, take a look at type_strings.hpp it contains a function that does what you want.
If you just look for a demangling tool, which you e.g. could use to mangle stuff shown in a log file, take a look at c++filt, which comes with binutils. It can demangle C++ and Java symbol names.
It's implementation defined, so it's not something that's going to be portable. In MSVC++, name() is the undecorated name, and you have to look at raw_name() to get the decorated one.
Just a stab in the dark here, but under gcc, you might want to look at demangle.h
I also found a macro called __PRETTY_FUNCTION__, which does the trick. It gives a pretty function name (figures :)). This is what I needed.
I.e. it gives me the following:
virtual bool mutex::do_unlock()
But I don't think it works on other compilers.
The accepted solution [1] works mostly well.
I found at least one case (and I wouldn't call it a corner case) where it does not report what I expected... with references.
For those cases, I found another solution, posted at the bottom.
Problematic case (using type as defined in [1]):
int i = 1;
cout << "Type of " << "i" << " is " << type(i) << endl;
int & ri = i;
cout << "Type of " << "ri" << " is " << type(ri) << endl;
produces
Type of i is int
Type of ri is int
Solution (using type_name<decltype(obj)>(), see code below):
cout << "Type of " << "i" << " is " << type_name<decltype(i)>() << endl;
cout << "Type of " << "ri" << " is " << type_name<decltype(ri)>() << endl;
produces
Type of i is int
Type of ri is int&
as desired (at least by me)
Code
.
It has to be in an included header, not in a separately compiled source, due to specialization issues. See undefined reference to template function for instance.
#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;
}
Not a complete solution, but you may want to look at what some of the standard (or widely supported) macro's define. It's common in logging code to see the use of the macros:
__FUNCTION__
__FILE__
__LINE__
e.g.:
log(__FILE__, __LINE__, __FUNCTION__, mymessage);
A slight variation on Ali's solution. If you want the code to still be very similar to
typeid(bla).name(),
writing this instead
Typeid(bla).name() (differing only in capital first letter)
then you may be interested in this:
In file type.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
type.cpp stays same as in Ali's solution
Following Ali's solution, here is the C++11 templated alternative which worked best for my usage.
// 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();
}
Usage:
// 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;
}
Will print:
double
int
test::SomeStruct
Take a look at __cxa_demangle which you can find at 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;
}
I've always wanted to use type_info, but I'm sure that the result of the name() member function is non-standard and won't necessarily return anything that can be converted to a meaningful result.
If you are sticking to one compiler, there maybe a compiler specific function that will do what you want. Check the documentation.
boost::typeindex provides something helpful.
#include <boost/type_index.hpp>
#include <iostream>
#include <vector>
class Widget {};
int main() {
using boost::typeindex::type_id_with_cvr;
const std::vector<Widget> vw;
std::cout << type_id_with_cvr<decltype(vw)>().pretty_name() << std::endl;
std::cout << type_id_with_cvr<decltype(vw[0])>().pretty_name() << std::endl;
return 0;
}
The output is
std::vector<Widget, std::allocator<Widget> > const
Widget const&
What is worthy of notice is that type_id_with_cvr preserves reference and c/v qualifiers, while typeid doesn't. See the following example:
#include <iostream>
#include <boost/type_index.hpp>
#include <typeindex>
#include <vector>
#include <typeinfo>
class Widget {};
template <typename T>
void f(const T ¶m) {
std::cout << typeid(param).name() << std::endl;
std::cout
<< boost::typeindex::type_id_with_cvr<decltype(param)>().pretty_name()
<< std::endl;
}
int main() {
const std::vector<Widget> vw(1);
f(&vw[0]);
return 0;
}
The output is
PK6Widget
Widget const* const&
Here, typeid produces PK6Widget, which means Pointer to Konst Widget. The number '6' is the length of the name 'Widget'. This is not the correct type of param, in which the reference and const qualifier are dropped.
The type_id_with_cvr actually uses the demangling functions in boost::core, as has been mentioned in this answer. To preserve the cv qualifiers or reference, it just defines an empty template named cvr_saver and then passes cvr_saver<type> to typeid.
Effective Modern C++ Item 4 talks about this.