什么是C ++中比较晦涩的部分？

Question

我已经阅读了很多有关C ++的初学者书籍，而且还读了很多，但是C ++较晦涩的方面是什么？或者在哪里可以找到关于C ++的信息/教程？

Answer 1

ADL (aka Koenig Lookup) is pretty obscure, even though people use it without realizing it in every Hello World program.

The " ScopeGuard trick", where const references as return values from functions are bound to the scope of something they're assigned to, is also fairly obscure. That article raised awareness about it quite a bit, though.

There are also a few properties and usages of sizeof() that count as obscure, especially when used in macros or template metaprograms.

Answer 2

The aphorism for the candidate features is "you don't need it very often, but when you need it, you need it bad."

• Placement new
• extern "C++"
• local classes
• std::allocator
• mutable, explicit, volatile
• pointer-to-any-member-of-any-class

So, for the people who have had reason to use these features (library authors), they won't be obscure, and for the majority of C++ programmers, they will be unknown.

Answer 3

Actually caring about bad_alloc.

no?

Edit: what I mean is that in many of the sometimes huge C++ projects in which I have had the pleasure to fix bugs, the concept of catching bad_alloc and acting upon it have been missing. That would put it in the "obscure" part of C++, even though it should not be.

Answer 4

Some obscure C++ features:

• analog literals http://web.archive.org/web/20120110153227/http://weegen.home.xs4all.nl/eelis/analogliterals.xhtml
• anonymous/unnamed namespaces http://publib.boulder.ibm.com/infocenter/comphelp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8a.doc%2Flanguage%2Fref%2Funnamed_namespaces.htm
• casting functions return values to void https://stackoverflow.com/a/689716/2028887
• changing function default arguments http://cpptruths.blogspot.fi/2005/07/changing-c-function-default-arguments.html
• const qualifiers http://publib.boulder.ibm.com/infocenter/iadthelp/v7r1/index.jsp?topic=/com.ibm.etools.iseries.langref.doc/as400clr57.htm
• direct initialization (of primitive types) https://stackoverflow.com/a/1029069/2028887
• explicit -keyword http://www.glenmccl.com/tip_023.htm
• function try blocks http://www.drdobbs.com/introduction-to-function-try-blocks/184401297
• local classes https://stackoverflow.com/a/3100801/2028887
• main-function does not require return statement https://stackoverflow.com/a/1771776/2028887
• mutable -keyword Does the 'mutable' keyword have any purpose other than allowing the variable to be modified by a const function?
• overloading operators ++ and -- https://stackoverflow.com/a/3846374/2028887
• placement new http://www.parashift.com/c++-faq/placement-new.html
• pure virtual function implementations https://stackoverflow.com/a/2089176/2028887
• ref qualifiers http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2819.html
• references to temporary values http://bytes.com/topic/c/answers/169672-const-reference-temporary-object-why
• register -keyword http://en.cppreference.com/w/cpp/keyword/register
• returning void values https://stackoverflow.com/a/2176229/2028887
• template argument as a friend Template parameter as a friend
• template template arguments http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=%2Fcom.ibm.xlcpp8l.doc%2Flanguage%2Fref%2Ftemplate_template_arguments.htm
• variadic functions http://en.cppreference.com/w/cpp/utility/variadic
• variadic macros http://en.wikipedia.org/wiki/Variadic_macro
• virtual inheritance https://stackoverflow.com/a/21607/2028887
• volatile -keyword http://en.cppreference.com/w/cpp/keyword/volatile

Answer 5

Very obscure:

• void operator,();
• precedence of operator||() and operator&&() when short circuiting
  logical expressions
• what happens when you overload operator&()
• order of initialization of stateful virtual inhertiance.
• deferencing pointers to template members
• function try blocks
• the allocator::rebind syntax
• non default behaviour of std::unexpected
• std::cout.imbue()
• Anything with locales,especially custom facets
• overriding via dominance
• trigraphs

Just to name a few

Answer 6

赫伯·萨特（Herb Sutter）的书籍是该主题的绝佳来源-从http://www.gotw.ca/publications/xc++.htm开始。

Answer 7

No one mentioned what I think it one of the weirdest parts of C++, obviously an after thought, the syntax for the pre-decrement and pre-increment operators.

class A {
public:
  A &operator++() {...} // Post increment
  A &operator--() {...} // Post decrement
};

vs.

class A {
public:
  A &operator++(int) {...} // Pre increment
  A &operator--(int) {...} // Pre decrement
};

Of course post increment means add one but return the previous value and pre increment means add one and return the new value. Eg:

A a;
f(a++); // Post increment a
f(++a); // Pre increment a

I'm not sure what happens if you try to use or pass the 'int' argument. You could try to pass it like this:

obj.operator++(0);

I suppose that is how you differentiate between the two operators when calling them explicitly.

Answer 8

Template metaprogramming (an entire litte turing-complete programming language in C++ executed by the compiler) and hacks with the preprocessor can be very hard! (You can even create completely new syntax with this - just take a look at boost::lambda )

But I think the most important thing to learn and understand is the STL (C++ standard library) which is inevitably useful but may look somewhat strange.

Answer 9

All books explain what exceptions are.
But very few talk about exception safety and the exception grantees.

How to use RAII (easy example smart pointers) to make your code exception safe.

What are the exception guarantees that you should provide.

• Destructor should grantee that no exceptions escape.
• Several of the STL algorithms use things like swap which also should grantee no exceptions escape to work correctly in all situations.
• etc...

Answer 10

Not so obvious is the implementation of certain methods in terms of other methods.

Assignment operator:
-> implement as a copy construction and swap.

operator +
-> implemented as copy construction and operator +=

operator !=
-> implement in terms of operator ==

etc...

The concept is that the work should be localized in one method and the other methods use this method to do the real work then add their unique twist to it.

Answer 11

If you want to learn something obscure about C++, try templates in depth and read Modern C++ Design by Andrei Alexandrescu . This book is classics about template metaprogramming.