[diff.cpp14] - C++14 → C++17

Files changed (1) hide show

tmp/tmpobn6iebw/{from.md → to.md} +252 -0

tmp/tmpobn6iebw/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,252 @@

+## C++and ISO C++14 <a id="diff.cpp14">[[diff.cpp14]]</a>
+This subclause lists the differences between C++and ISO C++14(ISO/IEC
+14882:2014, *Programming Languages — C++*), by the chapters of this
+document.
+### Clause  [[lex]]: lexical conventions <a id="diff.cpp14.lex">[[diff.cpp14.lex]]</a>
+[[lex.phases]] **Change:** Removal of trigraph support as a required
+feature. **Rationale:** Prevents accidental uses of trigraphs in non-raw
+string literals and comments. **Effect on original feature:** Valid
+C++14code that uses trigraphs may not be valid or may have different
+semantics in this International Standard. Implementations may choose to
+translate trigraphs as specified in C++14if they appear outside of a raw
+string literal, as part of the *implementation-defined* mapping from
+physical source file characters to the basic source character set.
+[[lex.ppnumber]] **Change:** *pp-number* can contain `p` *sign* and `P`
+*sign*. **Rationale:** Necessary to enable hexadecimal floating
+literals. **Effect on original feature:** Valid C++14code may fail to
+compile or produce different results in this International Standard.
+Specifically, character sequences like `0p+0` and `0e1_p+0` are three
+separate tokens each in C++14, but one single token in this
+International Standard.
+``` cpp
+#define F(a) b ## a
+int b0p = F(0p+0);  // ill-formed; equivalent to ``int b0p = b0p + 0;'' in C++14
+```
+### Clause  [[expr]]: expressions <a id="diff.cpp14.expr">[[diff.cpp14.expr]]</a>
+[[expr.post.incr]], [[expr.pre.incr]] **Change:** Remove increment
+operator with `bool` operand. **Rationale:** Obsolete feature with
+occasionally surprising semantics. **Effect on original feature:** A
+valid C++14expression utilizing the increment operator on a `bool`
+lvalue is ill-formed in this International Standard. Note that this
+might occur when the lvalue has a type given by a template parameter.
+[[expr.new]], [[expr.delete]] **Change:** Dynamic allocation mechanism
+for over-aligned types. **Rationale:** Simplify use of over-aligned
+types. **Effect on original feature:** In C++14code that uses a
+*new-expression* to allocate an object with an over-aligned class type,
+where that class has no allocation functions of its own,
+`::operator new(std::size_t)` is used to allocate the memory. In this
+International Standard, `::operator new(std::size_t, std::align_val_t)`
+is used instead.
+### Clause  [[dcl.dcl]]: declarations <a id="diff.cpp14.dcl.dcl">[[diff.cpp14.dcl.dcl]]</a>
+[[dcl.stc]] **Change:** Removal of `register` *storage-class-specifier*.
+**Rationale:** Enable repurposing of deprecated keyword in future
+revisions of this International Standard. **Effect on original
+feature:** A valid C++14declaration utilizing the `register`
+*storage-class-specifier* is ill-formed in this International Standard.
+The specifier can simply be removed to retain the original meaning.
+[[dcl.spec.auto]] **Change:** `auto` deduction from *braced-init-list*.
+**Rationale:** More intuitive deduction behavior. **Effect on original
+feature:** Valid C++14code may fail to compile or may change meaning in
+this International Standard. For example:
+``` cpp
+auto x1{1};    // was std::initializer_list<int>, now int
+auto x2{1, 2}; // was std::initializer_list<int>, now ill-formed
+```
+### Clause  [[dcl.decl]]: declarators <a id="diff.cpp14.decl">[[diff.cpp14.decl]]</a>
+[[dcl.fct]] **Change:** Make exception specifications be part of the
+type system. **Rationale:** Improve type-safety. **Effect on original
+feature:** Valid C++14code may fail to compile or change meaning in this
+International Standard:
+``` cpp
+void g1() noexcept;
+void g2();
+template<class T> int f(T *, T *);
+int x = f(g1, g2);    // ill-formed; previously well-formed
+```
+[[dcl.init.aggr]] **Change:** Definition of an aggregate is extended to
+apply to user-defined types with base classes. **Rationale:** To
+increase convenience of aggregate initialization. **Effect on original
+feature:** Valid C++14code may fail to compile or produce different
+results in this International Standard; initialization from an empty
+initializer list will perform aggregate initialization instead of
+invoking a default constructor for the affected types:
+``` cpp
+struct derived;
+struct base {
+  friend struct derived;
+private:
+  base();
+};
+struct derived : base {};
+derived d1{};       // Error. The code was well-formed before.
+derived d2;         // still OK
+```
+### Clause  [[special]]: special member functions <a id="diff.cpp14.special">[[diff.cpp14.special]]</a>
+[[class.inhctor.init]] **Change:** Inheriting a constructor no longer
+injects a constructor into the derived class. **Rationale:** Better
+interaction with other language features. **Effect on original
+feature:** Valid C++14code that uses inheriting constructors may not be
+valid or may have different semantics. A *using-declaration* that names
+a constructor now makes the corresponding base class constructors
+visible to initializations of the derived class rather than declaring
+additional derived class constructors.
+``` cpp
+struct A {
+  template<typename T> A(T, typename T::type = 0);
+  A(int);
+};
+struct B : A {
+  using A::A;
+  B(int);
+};
+B b(42L); // now calls B(int), used to call B<long>(long),
+          // which called A(int) due to substitution failure
+          // in A<long>(long).
+```
+### Clause  [[temp]]: templates <a id="diff.cpp14.temp">[[diff.cpp14.temp]]</a>
+[[temp.deduct.type]] **Change:** Allowance to deduce from the type of a
+non-type template argument. **Rationale:** In combination with the
+ability to declare non-type template arguments with placeholder types,
+allows partial specializations to decompose from the type deduced for
+the non-type template argument. **Effect on original feature:** Valid
+C++14code may fail to compile or produce different results in this
+International Standard:
+``` cpp
+template <int N> struct A;
+template <typename T, T N> int foo(A<N> *) = delete;
+void foo(void *);
+void bar(A<0> *p) {
+  foo(p); // ill-formed; previously well-formed
+}
+```
+### Clause  [[except]]: exception handling <a id="diff.cpp14.except">[[diff.cpp14.except]]</a>
+[[except.spec]] **Change:** Remove dynamic exception specifications.
+**Rationale:** Dynamic exception specifications were a deprecated
+feature that was complex and brittle in use. They interacted badly with
+the type system, which became a more significant issue in this
+International Standard where (non-dynamic) exception specifications are
+part of the function type. **Effect on original feature:** A valid
+C++14function declaration, member function declaration, function pointer
+declaration, or function reference declaration, if it has a potentially
+throwing dynamic exception specification, will be rejected as ill-formed
+in this International Standard. Violating a non-throwing dynamic
+exception specification will call `terminate` rather than `unexpected`
+and might not perform stack unwinding prior to such a call.
+### Clause  [[library]]: library introduction <a id="diff.cpp14.library">[[diff.cpp14.library]]</a>
+[[namespace.future]] **Change:** New reserved namespaces. **Rationale:**
+Reserve namespaces for future revisions of the standard library that
+might otherwise be incompatible with existing programs. **Effect on
+original feature:** The global namespaces `std` followed by an arbitrary
+sequence of digits is reserved for future standardization. Valid
+C++14code that uses such a top-level namespace, e.g., `std2`, may be
+invalid in this International Standard.
+### Clause  [[utilities]]: general utilities library <a id="diff.cpp14.utilities">[[diff.cpp14.utilities]]</a>
+[[func.wrap]] **Change:** Constructors taking allocators removed.
+**Rationale:** No implementation consensus. **Effect on original
+feature:** Valid C++14code may fail to compile or may change meaning in
+this International Standard. Specifically, constructing a
+`std::function` with an allocator is ill-formed and uses-allocator
+construction will not pass an allocator to `std::function` constructors
+in this International Standard.
+[[util.smartptr.shared]] **Change:** Different constraint on conversions
+from `unique_ptr`. **Rationale:** Adding array support to `shared_ptr`,
+via the syntax `shared_ptr<T[]>` and `shared_ptr<T[N]>`. **Effect on
+original feature:** Valid C++14code may fail to compile or may change
+meaning in this International Standard. For example:
+``` cpp
+#include <memory>
+std::unique_ptr<int[]> arr(new int[1]);
+std::shared_ptr<int> ptr(std::move(arr)); // error: int(*)[] is not compatible with int*
+```
+### Clause  [[strings]]: strings library <a id="diff.cpp14.string">[[diff.cpp14.string]]</a>
+[[basic.string]] **Change:** Non-const `.data()` member added.
+**Rationale:** The lack of a non-const `.data()` differed from the
+similar member of `std::vector`. This change regularizes behavior for
+this International Standard. **Effect on original feature:** Overloaded
+functions which have differing code paths for `char*` and `const char*`
+arguments will execute differently when called with a non-const string’s
+`.data()` member in this International Standard.
+``` cpp
+int f(char *) = delete;
+int f(const char *);
+string s;
+int x = f(s.data()); // ill-formed; previously well-formed
+```
+### Clause  [[containers]]: containers library <a id="diff.cpp14.containers">[[diff.cpp14.containers]]</a>
+[[associative.reqmts]] **Change:** Requirements change: **Rationale:**
+Increase portability, clarification of associative container
+requirements. **Effect on original feature:** Valid C++14code that
+attempts to use associative containers having a comparison object with
+non-const function call operator may fail to compile in this
+International Standard:
+``` cpp
+#include <set>
+struct compare
+{
+  bool operator()(int a, int b)
+  {
+    return a < b;
+  }
+};
+int main() {
+  const std::set<int, compare> s;
+  s.find(0);
+}
+```
+### Annex  [[depr]]: compatibility features <a id="diff.cpp14.depr">[[diff.cpp14.depr]]</a>
+**Change:** The class templates `auto_ptr`, `unary_function`, and
+`binary_function`, the function templates `random_shuffle`, and the
+function templates (and their return types) `ptr_fun`, `mem_fun`,
+`mem_fun_ref`, `bind1st`, and `bind2nd` are not defined. **Rationale:**
+Superseded by new features. **Effect on original feature:** Valid
+C++14code that uses these class templates and function templates may
+fail to compile in this International Standard.
+**Change:** Remove old iostreams members \[depr.ios.members\].
+**Rationale:** Redundant feature for compatibility with pre-standard
+code has served its time. **Effect on original feature:** A valid
+C++14program using these identifiers may be ill-formed in this
+International Standard.

Diff to HTML by rtfpessoa