C/C++语言Notes

最新推荐文章于 2022-12-17 21:51:04 发布

山庄来客

最新推荐文章于 2022-12-17 21:51:04 发布

阅读量766

点赞数

分类专栏： c/c++编程

本文链接：https://blog.csdn.net/fuyajun01/article/details/12910365

版权

c/c++编程专栏收录该内容

28 篇文章 1 订阅

订阅专栏

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:

  // 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.