From: David Blaikie Date: Tue, 18 Oct 2011 05:49:30 +0000 (+0000) Subject: Update documentation to use "C++11" instead of "C++0x" X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=5090e9f96e518bce482fd10b93f8bf3e2b11b5cc;p=clang Update documentation to use "C++11" instead of "C++0x" git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@142339 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/docs/AutomaticReferenceCounting.html b/docs/AutomaticReferenceCounting.html index bc784578e4..ab7debf20c 100644 --- a/docs/AutomaticReferenceCounting.html +++ b/docs/AutomaticReferenceCounting.html @@ -1006,7 +1006,7 @@ with a void* or an __unsafe_unretained object.

This restriction does not apply in Objective-C++. However, -nontrivally ownership-qualified types are considered non-POD: in C++0x +nontrivally ownership-qualified types are considered non-POD: in C++11 terms, they are not trivially default constructible, copy constructible, move constructible, copy assignable, move assignable, or destructible. It is a violation of C++ One Definition Rule to use diff --git a/docs/InternalsManual.html b/docs/InternalsManual.html index 2dffb10740..c22b1e8d91 100644 --- a/docs/InternalsManual.html +++ b/docs/InternalsManual.html @@ -427,10 +427,10 @@ the problem. For example, it might add the missing semicolon at the end of the statement or rewrite the use of a deprecated construct into something more palatable. Here is one such example from the C++ front end, where we warn about the right-shift operator changing -meaning from C++98 to C++0x:

+meaning from C++98 to C++11:

-test.cpp:3:7: warning: use of right-shift operator ('>>') in template argument will require parentheses in C++0x
+test.cpp:3:7: warning: use of right-shift operator ('>>') in template argument will require parentheses in C++11
 A<100 >> 2> *a;
       ^
   (       )
@@ -1323,7 +1323,7 @@ extern "C" {
 
 
The transparent DeclContexts are:

 
 
  • Checks for Upcoming Standard Language Features
   
      
-  
    • C++0x
+  
    • C++11
     
      • 
   
    • C1X
     
        
@@ -192,12 +193,12 @@ language feature) or 0 if not.  They can be used like this:
        
 
 ...
 #if __has_feature(cxx_rvalue_references)
-// This code will only be compiled with the -std=c++0x and -std=gnu++0x
-// options, because rvalue references are only standardized in C++0x.
+// This code will only be compiled with the -std=c++11 and -std=gnu++11
+// options, because rvalue references are only standardized in C++11.
 #endif
 
 #if __has_extension(cxx_rvalue_references)
-// This code will be compiled with the -std=c++0x, -std=gnu++0x, -std=c++98
+// This code will be compiled with the -std=c++11, -std=gnu++11, -std=c++98
 // and -std=gnu++98 options, because rvalue references are supported as a
 // language extension in C++98.
 #endif
@@ -462,176 +463,176 @@ to query if certain upcoming standard language features are enabled.  Those
 features are listed here.  Features that are not yet implemented will be
 noted.
        
 
-
        C++0x
        
+
        C++11
        
 
 
        The features listed below are slated for inclusion in the upcoming
-C++0x standard. As a result, all these features are enabled
-with the -std=c++0x option when compiling C++ code.
        
+C++11 standard. As a result, all these features are enabled
+with the -std=c++11 option when compiling C++ code.
        
 
-
        C++0x SFINAE includes access control
        
+
        C++11 SFINAE includes access control
        
 
 
        Use __has_feature(cxx_access_control_sfinae) or __has_extension(cxx_access_control_sfinae) to determine whether access-control errors (e.g., calling a private constructor) are considered to be template argument deduction errors (aka SFINAE errors), per C++ DR1170.
        
 
-
        C++0x alias templates
        
+
        C++11 alias templates
        
 
 
        Use __has_feature(cxx_alias_templates) or
 __has_extension(cxx_alias_templates) to determine if support for
-C++0x's alias declarations and alias templates is enabled.
        
+C++11's alias declarations and alias templates is enabled.
        
 
-
        C++0x alignment specifiers
        
+
        C++11 alignment specifiers
        
 
 
        Use __has_feature(cxx_alignas) or
 __has_extension(cxx_alignas) to determine if support for alignment
 specifiers using alignas is enabled.
        
 
-
        C++0x attributes
        
+
        C++11 attributes
        
 
 
        Use __has_feature(cxx_attributes) or
 __has_extension(cxx_attributes) to determine if support for attribute
-parsing with C++0x's square bracket notation is enabled.
        
+parsing with C++11's square bracket notation is enabled.
        
 
-
        C++0x generalized constant expressions
        
+
        C++11 generalized constant expressions
        
 
 
        Use __has_feature(cxx_constexpr) to determine if support
 for generalized constant expressions (e.g., constexpr) is
 enabled. Clang does not currently implement this feature.
         
 
-
        C++0x decltype()
        
+
        C++11 decltype()
        
 
 
        Use __has_feature(cxx_decltype) or
 __has_extension(cxx_decltype) to determine if support for the
 decltype() specifier is enabled.
        
 
-
        C++0x default template arguments in function templates
        
+
        C++11 default template arguments in function templates
        
 
 
        Use __has_feature(cxx_default_function_template_args) or
 __has_extension(cxx_default_function_template_args) to determine
 if support for default template arguments in function templates is enabled.
        
 
-
        C++0x delegating constructors
        
+
        C++11 delegating constructors
        
 
 
        Use __has_feature(cxx_delegating_constructors) to determine if
 support for delegating constructors is enabled.
        
 
-
        C++0x deleted functions
        
+
        C++11 deleted functions
        
 
 
        Use __has_feature(cxx_deleted_functions) or
 __has_extension(cxx_deleted_functions) to determine if support for
 deleted function definitions (with = delete) is enabled.
        
 
-
        C++0x explicit conversion functions
        
+
        C++11 explicit conversion functions
        
 
        Use __has_feature(cxx_explicit_conversions) to determine if support for explicit conversion functions is enabled.
        
 
-
        C++0x generalized initializers
        
+
        C++11 generalized initializers
        
 
 
        Use __has_feature(cxx_generalized_initializers) to determine if
 support for generalized initializers (using braced lists and
 std::initializer_list) is enabled. Clang does not currently implement
 this feature.
        
 
-
        C++0x implicit move constructors/assignment operators
        
+
        C++11 implicit move constructors/assignment operators
        
 
 
        Use __has_feature(cxx_implicit_moves) to determine if Clang will
 implicitly generate move constructors and move assignment operators where needed.
        
 
-
        C++0x inheriting constructors
        
+
        C++11 inheriting constructors
        
 
 
        Use __has_feature(cxx_inheriting_constructors) to determine if support for inheriting constructors is enabled. Clang does not currently implement this feature.
        
 
-
        C++0x inline namespaces
        
+
        C++11 inline namespaces
        
 
 
        Use __has_feature(cxx_inline_namespaces) or
 __has_extension(cxx_inline_namespaces) to determine if support for
 inline namespaces is enabled.
        
 
-
        C++0x lambdas
        
+
        C++11 lambdas
        
 
 
        Use __has_feature(cxx_lambdas) or
 __has_extension(cxx_lambdas) to determine if support for lambdas
 is enabled. Clang does not currently implement this feature.
        
 
-
        C++0x noexcept
        
+
        C++11 noexcept
        
 
 
        Use __has_feature(cxx_noexcept) or
 __has_extension(cxx_noexcept) to determine if support for noexcept
 exception specifications is enabled.
        
 
-
        C++0x in-class non-static data member initialization
        
+
        C++11 in-class non-static data member initialization
        
 
 
        Use __has_feature(cxx_nonstatic_member_init) to determine whether in-class initialization of non-static data members is enabled.
        
 
-
        C++0x nullptr
        
+
        C++11 nullptr
        
 
 
        Use __has_feature(cxx_nullptr) or
 __has_extension(cxx_nullptr) to determine if support for
 nullptr is enabled.
        
 
-
        C++0x override control
        
+
        C++11 override control
        
 
 
        Use __has_feature(cxx_override_control) or
 __has_extension(cxx_override_control) to determine if support for
 the override control keywords is enabled.
        
 
-
        C++0x reference-qualified functions
        
+
        C++11 reference-qualified functions
        
 
        Use __has_feature(cxx_reference_qualified_functions) or
 __has_extension(cxx_reference_qualified_functions) to determine
 if support for reference-qualified functions (e.g., member functions with
 & or && applied to *this)
 is enabled.
        
 
-
        C++0x range-based for loop
        
+
        C++11 range-based for loop
        
 
 
        Use __has_feature(cxx_range_for) or
 __has_extension(cxx_range_for) to determine if support for the
 range-based for loop is enabled. 
        
 
-
        C++0x raw string literals
        
+
        C++11 raw string literals
        
 
        Use __has_feature(cxx_raw_string_literals) to determine if support for raw string literals (e.g., R"foo\bar") is enabled.
        
 
-
        C++0x rvalue references
        
+
        C++11 rvalue references
        
 
 
        Use __has_feature(cxx_rvalue_references) or
 __has_extension(cxx_rvalue_references) to determine if support for
 rvalue references is enabled. 
        
 
-
        C++0x static_assert()
        
+
        C++11 static_assert()
        
 
 
        Use __has_feature(cxx_static_assert) or
 __has_extension(cxx_static_assert) to determine if support for
 compile-time assertions using static_assert is enabled.
        
 
-
        C++0x type inference
        
+
        C++11 type inference
        
 
 
        Use __has_feature(cxx_auto_type) or
-__has_extension(cxx_auto_type) to determine C++0x type inference is
+__has_extension(cxx_auto_type) to determine C++11 type inference is
 supported using the auto specifier. If this is disabled, auto
 will instead be a storage class specifier, as in C or C++98.
        
 
-
        C++0x strongly typed enumerations
        
+
        C++11 strongly typed enumerations
        
 
 
        Use __has_feature(cxx_strong_enums) or
 __has_extension(cxx_strong_enums) to determine if support for
 strongly typed, scoped enumerations is enabled.
        
 
-
        C++0x trailing return type
        
+
        C++11 trailing return type
        
 
 
        Use __has_feature(cxx_trailing_return) or
 __has_extension(cxx_trailing_return) to determine if support for the
 alternate function declaration syntax with trailing return type is enabled.
        
 
-
        C++0x Unicode string literals
        
+
        C++11 Unicode string literals
        
 
        Use __has_feature(cxx_unicode_literals) to determine if
 support for Unicode string literals is enabled.
        
 
-
        C++0x unrestricted unions
        
+
        C++11 unrestricted unions
        
 
 
        Use __has_feature(cxx_unrestricted_unions) to determine if support for unrestricted unions is enabled. Clang does not currently support this feature.
        
 
-
        C++0x user-defined literals
        
+
        C++11 user-defined literals
        
 
 
        Use __has_feature(cxx_user_literals) to determine if support for user-defined literals is enabled. Clang does not currently support this feature.
        
 
-
        C++0x variadic templates
        
+
        C++11 variadic templates
        
 
 
        Use __has_feature(cxx_variadic_templates) or
 __has_extension(cxx_variadic_templates) to determine if support
@@ -707,7 +708,7 @@ struct is_convertible_to {
   
      • __is_polymorphic (GNU, Microsoft)
        • 
   
      • __is_union (GNU, Microsoft)
        • 
   
      • __is_literal(type): Determines whether the given type is a literal type
        • 
-  
      • __underlying_type(type): Retrieves the underlying type for a given enum type. This trait is required to implement the C++0x standard library.
        • 
+  
      • __underlying_type(type): Retrieves the underlying type for a given enum type. This trait is required to implement the C++11 standard library.
        • 
 
      
 
 
@@ -814,7 +815,7 @@ the instancetype contextual keyword is available.
      
 
      Enumerations with a fixed underlying type
      
 
 
-
      Clang provides support for C++0x enumerations with a fixed
+
      Clang provides support for C++11 enumerations with a fixed
 underlying type within Objective-C. For example, one can write an
 enumeration type as:
      
 
diff --git a/docs/UsersManual.html b/docs/UsersManual.html
index 9d7981919c..ac19e15ab3 100644
--- a/docs/UsersManual.html
+++ b/docs/UsersManual.html
@@ -480,7 +480,7 @@ constructor.  For example:
   };
   void foo(const NonCopyable&);
   void bar() {
-    foo(NonCopyable());  // Disallowed in C++98; allowed in C++0x.
+    foo(NonCopyable());  // Disallowed in C++98; allowed in C++11.
   }
 
    • @@ -490,7 +490,7 @@ constructor.  For example:
   };
   void foo(const NonCopyable2&);
   void bar() {
-    foo(NonCopyable2());  // Disallowed in C++98; allowed in C++0x.
+    foo(NonCopyable2());  // Disallowed in C++98; allowed in C++11.
   }