C/C++语言Notes

Item 1 in the C++ standard that says that non-const references cannot bind to temporary objects.

A temporary object is an instance of an object that does not have a
variable name. For example:

std::string( "Hello world" );

is a temporary, because we have not given it a variable name. This
is not a temporary:

std::string s( "Hello world" );

What is the practical implication of all this? Consider the following:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

// Improperly declared function: parameter should be const reference: void print_me_bad( std::string& s ) { std::cout << s << std::endl; } // Properly declared function: function has no intent to modify s: void print_me_good( const std::string& s ) { std::cout << s << std::endl; } std::string hello( "Hello" ); print_me_bad( hello ); // Compiles ok; hello is not a temporary print_me_bad( std::string( "World" ) ); // Compile error; temporary object print_me_bad( "!" ); // Compile error; compiler wants to construct temporary // std::string from const char* print_me_good( hello ); // Compiles ok print_me_good( std::string( "World" ) ); // Compiles ok print_me_good( "!" ); // Compiles ok

Item 2 On Linux, a thread-specific errno is achieved in a similar manner to
most other UNIX implementations: errno is defined as a macro that expands into a
function call returning a modifiable lvalue that is distinct for each thread.

Because each reference to errno in a threaded program carries the overhead of
a function call.