cppreference.com - Recent changes [en]

cpp/language/operator arithmetic

2012-05-17T02:00:04Z

table doesn't agree with text: they usually return values (and they really do), but table prototypes all return references.

Show changes

cpp/language/operator precedence

2012-05-17T01:37:18Z

-comment (addressed in operator page now)

cpp/language/operator arithmetic

2012-05-17T01:35:22Z

fix two typos, address todo for remainders

cpp/algorithm/mismatch

2012-05-17T00:23:43Z

Possible implementation should not use operator!=

cpp/language/operator arithmetic

2012-05-17T00:06:55Z

+forgot another use of unary plus

User:Gabriel

2012-05-16T23:49:07Z

New user account

cpp/language/operator arithmetic

2012-05-16T22:10:44Z

-todo for conversons: the individual operator examples that I added already demonstrate the caveats. +remaining library overloads

Template:cpp/container/at assoc

2012-05-16T21:35:33Z

both overloads of map::at are since c++11

Template:cpp/container/at assoc

2012-05-16T21:23:53Z

Corrected signature of second at method.

Talk:cpp/numeric/math/atan2

2012-05-16T21:09:23Z

sign

Talk:cpp/numeric/math/atan2

2012-05-16T20:30:47Z

confusion?

Talk:cpp/numeric/math/atan2

2012-05-16T19:21:45Z

no, it's correct

cpp/algorithm/find end

2012-05-16T17:04:44Z

cpp/algorithm/find first of

2012-05-16T16:37:31Z

cpp/language/operator arithmetic

2012-05-16T16:22:22Z

+descs

Template:cpp/iterator/move iterator/title

2012-05-16T15:34:58Z

New page

<onlyinclude>{{cpp/title | n=move_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}</onlyinclude>

cpp/language/operator arithmetic

2012-05-16T15:34:08Z

+std library overloads of + and -

cpp/chrono/duration

2012-05-16T15:23:53Z

missing nonmember arithmetics

cpp/chrono/time point

2012-05-16T15:21:08Z

arith and cast aren't members

cpp/language/operator arithmetic

2012-05-16T15:15:45Z

+example for additives, +note on iterator concept

cpp/algorithm/find end

2012-05-16T14:27:03Z

cpp/language/operator arithmetic

2012-05-16T14:25:55Z

+conversions

cpp/algorithm/find end

2012-05-16T14:09:23Z

cpp/language/implicit cast

2012-05-16T13:22:49Z

no conversion->no integral promotions

cpp/language/operator arithmetic

2012-05-16T13:01:06Z

only object types for pointer arith

Template:param list/doc

2012-05-16T12:51:55Z

Talk:c/language/operator precedence

2012-05-16T12:42:02Z

done

c/language/operator precedence

2012-05-16T12:41:08Z

fix lost formatting

Talk:c/language/operator precedence

2012-05-16T07:37:21Z

Talk:cpp/numeric/math/atan2

2012-05-16T07:27:16Z

Graphic wrong?

New page

Could it be that this graphic: http://upload.cppreference.com/mwiki/images/thumb/9/91/math-atan2.png/285px-math-atan2.png is wrong?

Im working with the g++ and after 2 hours i figured out, that std::atan2 has the same behavior like the matlab atan2-function:

http://www.mathworks.de/help/techdoc/ref/atan2.html

Look at the quadrants: Matlab's atan2 is positive for all y > 0, so it's different from the graphic in this article.

[[Special:Contributions/62.206.211.29|62.206.211.29]] 00:27, 16 May 2012 (PDT)

Template:cpp/chrono/duration/title

2012-05-16T05:03:34Z

New page

<onlyinclude>{{cpp/title | n=chrono::duration::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}</onlyinclude>

cpp/language/operator arithmetic

2012-05-16T05:00:31Z

unary operators (including the poor unloved unary plus)

cpp/memory

2012-05-16T03:33:09Z

Need the at the bottom so C library doesn't have the equals around it.

User:ComputerGhost

2012-05-16T03:04:40Z

Created page with "When writing a lot of code at one time, it isn't very fun to get distracted while prettying up the rest of the code before compiling to check the code for accuracy. It is at ..."

New page

When writing a lot of code at one time, it isn't very fun to get distracted while prettying up the rest of the code before compiling to check the code for accuracy. It is at times like these, and at times where alternate methods need to be investigated, that cppreference.com really comes in handy! I made my first edit quite a while back, and it was awesome contributing to a site that I daily use, so I created an account.

I'll likely just make small edits until I get the hang of things, but I see myself making larger contributions in the future, and I can hardly wait to be a part of creating something that I and many other people use every day.

My site? Everybody else has links on their user pages. My site is mostly just a personal website, but has a cool easter egg if you can find it, and there are a few source code downloads. [http://www.nathanbelue.com http://www.nathanbelue.com]

Help:Manual of style

2012-05-16T02:39:29Z

Fixed error, comma after last template parameter.

Template:cpp/thread/mutex/unlock

2012-05-15T21:45:10Z

add my triple example

Template:cpp/thread/mutex/lock

2012-05-15T21:40:16Z

add example

Template:cpp/thread/mutex/try lock

2012-05-15T21:34:55Z

refine example

cpp/algorithm/unique

2012-05-15T21:31:57Z

Fixed (again) to work with empty ranges

@@ Line 68: / Line 68: @@
 ! 5
 | <code>*</code> <code>/</code> <code>%</code>
-| Multiplication, division, and remainder<!--
+| Multiplication, division, and remainder
-The note is outdated (C++11 redefined binary %), and belongs in the page about this operator, not here.
-<ref>ISO/IEC 14882:2003 : Programming languages -- C++. "the binary % operator yields the remainder from the division of the first expression by the second. .... If both operands are nonnegative then the remainder is nonnegative; if not, the sign of the remainder is implementation-defined".</ref>
-  : The note is a copy from http://en.wikipedia.org/wiki/Modulo_operation, but worth pointing out IMO
--->
 |-
 ! 6

@@ Line 134: / Line 134: @@
 {{ddcl list end}}
-The builtin unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts {{c|char}} to {{c|int}) or if the operand is subject to lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion.
+The builtin unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts {{c|char}} to {{c|int}} or if the operand is subject to lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion.
 The builtin unary minus operator calculates the negative of its operand. For unsigned {{tt|a}}, the value of {{tt|-a}} is {{math|2{{su|p=b}}-a}}, where {{tt|b}} is the number of bits after promotion.
@@ Line 152: / Line 152: @@
                << "-1, where 1 is unsigned char: " << -n2 << '\n'
                << "-1, where 1 is unsigned int: " << -n3 << '\n';
+}
   | output=
@@ Line 158: / Line 160: @@
 -1, where 1 is unsigned char: -1
 -1, where 1 is unsigned int: 4294967295
 }}
@@ Line 221: / Line 225: @@
 The binary operator * performs multiplication of its operands (after usual arithmetic conversions).
-The binary operator / divides the first operand by the second (after usual arithmetic conversions). For integral operands, it yields the algebraic quotient with any fractinoal part discarded (truncated towards zero). If the second operand is zero, the behavior is undefined.
+The binary operator / divides the first operand by the second (after usual arithmetic conversions).If the second operand is zero, the behavior is undefined. For integral operands, it yields the algebraic quotient
 The binary operator % yields the remainder of the division of the first operand by the second (after usual arithmetic conversions). If the quotient {{tt|a/b}} is representible in the result type, {{c|1=(a/b)*b + a%b == a}}. If the second operand is zero, the behavior is undefined.
+*if one or both operands are negative, the sign of the remainder is implementation-defined, as it depends on the rounding direction of integer division {{mark until c++11}}
-{{todo|mention pre-c++11 rules for remainders}}
 ====Bitwise logic operators====

@@ Line 44: / Line 44: @@
      mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+{
-     for (; first1 != last1; ++first1, ++first2) {
+     while (first1 != last1 && *first1 == *first2) {
-        if (*first1 != *first2) {
+        ++first1, ++first2;
-            return std::make_pair(first1, first2);
-−
+     }
      return std::make_pair(first1, first2);
@@ Line 56: / Line 54: @@
      mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate p)
+{
-     for (; first1 != last1; ++first1, ++first2) {
+     while (first1 != last1 && p(*first1, *first2)) {
-        if (!p(*first1, *first2)) {
+        ++first1, ++first2;
-            return std::make_pair(first1, first2);
-−
+     }
      return std::make_pair(first1, first2);

@@ Line 102: / Line 102: @@
 ====Conversions====
-If the operand passed to an arithmetic operator is integral or unscoped enumeration type, then before any other action, the operand undergoes [[cpp/language/implicit_cast#integral promotion|integral promotion]].
+If the operand passed to an arithmetic operator is integral or unscoped enumeration type, then before any other action (but after lvalue-to-rvalue conversion, if applicable), the operand undergoes [[cpp/language/implicit_cast#integral promotion|integral promotion]]. If an operand has array or function type, array-to-pointer and function-to-pointer conversions are applied.
 For the binary operators (except shifts), if the promoted operands have different types, additional set of implicit conversions is applied, known as ''usual arithmetic conversions'' with the goal to produce the ''common type'' (also accessible via the {{c|std::common_type}} type trait)
@@ Line 134: / Line 134: @@
 {{ddcl list end}}
-The builtin unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts {{c|char}} to {{c|int}}.
+The builtin unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts {{c|char}} to {{c|int}) or if the operand is subject to lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion.
 The builtin unary minus operator calculates the negative of its operand. For unsigned {{tt|a}}, the value of {{tt|-a}} is {{math|2{{su|p=b}}-a}}, where {{tt|b}} is the number of bits after promotion.

@@ Line 125: / Line 125: @@
 The ''conversion rank'' above increases in order {{c|bool}}, {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}}, {{c|long long}}. The rank of any unsigned type is equal to the rank of the corresponding signed type. The rank of {{c|char}} is equal to the rank of {{c|signed char}} and {{c|unsigned char}}. The ranks of {{c|char16_t}}, {{c|char32_t}}, and {{c|wchar_t}} are equal to the ranks of their underlying types.
 ====Unary arithmetic operators====
@@ Line 302: / Line 300: @@
 ====Multiplicative operators====
-{{todo}}
+{{dcl list begin}}
 ====Bitwise logic operators====
-{{todo}}
+{{dcl list begin}}
 ====Bitwise shift operators====

@@ Line 2: / Line 2: @@
 {{cpp/container/{{{1|}}}/sidebar}}
 {{ddcl list begin}}
-{{ddcl list item | num=1 | notes={{cpp/container/mark since c++11 | {{{1|}}} }} |
+{{ddcl list item | num=1 | notes={{mark since c++11}} |
 T& at( const Key& key );
 }}

@@ Line 6: / Line 6: @@
 }}
 {{ddcl list item | num=2 | notes={{mark since c++11}} |
-T& at( Key&& key );
+const T & at( const Key& key ) const;
 }}
 {{ddcl list end}}

← Older revision		Revision as of 21:09, 16 May 2012
(One intermediate revision by one user not shown)
Line 13:		Line 13:

	:: I think there's some confusion here. Remember that atan2 takes y as the first argument, not x. atan2(-1,1) corresponds to x=1, y=-1, and is -0.78540. At x=-1, y=1, we'd use atan2(1,-1) which is 2.3. In fact, for every positive value of y, atan2 is positive. And unless I'm mistaken, that's exactly what the diagram in question shows -- the upper half of the square corresponds to positive y, and only contains positive atan2 values. --[[User:Nate\|Nate]] 13:30, 16 May 2012 (PDT)		:: I think there's some confusion here. Remember that atan2 takes y as the first argument, not x. atan2(-1,1) corresponds to x=1, y=-1, and is -0.78540. At x=-1, y=1, we'd use atan2(1,-1) which is 2.3. In fact, for every positive value of y, atan2 is positive. And unless I'm mistaken, that's exactly what the diagram in question shows -- the upper half of the square corresponds to positive y, and only contains positive atan2 values. --[[User:Nate\|Nate]] 13:30, 16 May 2012 (PDT)
		+
		+	::: I've already fixed the plot, hence the confusion. It indeed was incorrect previously. -- [[User:P12\|P12]] 14:09, 16 May 2012 (PDT)

← Older revision		Revision as of 20:30, 16 May 2012
Line 11:		Line 11:
	: atan2 is not always positive when y is positive. Take for example x=-1, y=1. atan2(x,y) = atan(y/x) = atan(-1) = -0.78540.		: atan2 is not always positive when y is positive. Take for example x=-1, y=1. atan2(x,y) = atan(y/x) = atan(-1) = -0.78540.
	: try {{c\|lang=matlab\|ezsurf ( @(x,y) atan2(x,y) )}} in matlab to see a 3D plot --[[User:Bazzy\|Bazzy]] 12:21, 16 May 2012 (PDT)		: try {{c\|lang=matlab\|ezsurf ( @(x,y) atan2(x,y) )}} in matlab to see a 3D plot --[[User:Bazzy\|Bazzy]] 12:21, 16 May 2012 (PDT)
		+
		+	:: I think there's some confusion here. Remember that atan2 takes y as the first argument, not x. atan2(-1,1) corresponds to x=1, y=-1, and is -0.78540. At x=-1, y=1, we'd use atan2(1,-1) which is 2.3. In fact, for every positive value of y, atan2 is positive. And unless I'm mistaken, that's exactly what the diagram in question shows -- the upper half of the square corresponds to positive y, and only contains positive atan2 values. --[[User:Nate\|Nate]] 13:30, 16 May 2012 (PDT)

← Older revision		Revision as of 19:21, 16 May 2012
Line 8:		Line 8:

	[[Special:Contributions/62.206.211.29\|62.206.211.29]] 00:27, 16 May 2012 (PDT)		[[Special:Contributions/62.206.211.29\|62.206.211.29]] 00:27, 16 May 2012 (PDT)
		+
		+	: atan2 is not always positive when y is positive. Take for example x=-1, y=1. atan2(x,y) = atan(y/x) = atan(-1) = -0.78540.
		+	: try {{c\|lang=matlab\|ezsurf ( @(x,y) atan2(x,y) )}} in matlab to see a 3D plot --[[User:Bazzy\|Bazzy]] 12:21, 16 May 2012 (PDT)

@@ Line 26: / Line 26: @@
 ===Return value===
-iterator to the beginning of last subsequence {{tt|[s_first, s_last)}} in range {{tt|[first, last)}}. If {{tt|[s_first, s_last)}} is empty or if no such subsequence is found, {{tt|last}} is returned.
+iterator to the beginning of last subsequence {{tt|[s_first, s_last)}} in range {{tt|[first, last)}}.<br>
 ===Complexity===

@@ Line 3: / Line 3: @@
 {{ddcl list begin}}
 {{ddcl list header | algorithm}}
-{{ddcl list item | num=1 |
+{{ddcl list item | num=1 | notes={{mark until c++11}}<br><br><br>{{mark since c++11}} |
 template< class ForwardIterator1, class ForwardIterator2 >
 ForwardIterator1 find_first_of( ForwardIterator1 first, ForwardIterator1 last,
                                  ForwardIterator2 s_first, ForwardIterator2 s_last );
 }}
-{{ddcl list item | num=2 |
+{{ddcl list item | num=2 | notes={{mark until c++11}}<br><br><br>{{mark since c++11}} |
 template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
 ForwardIterator1 find_first_of( ForwardIterator1 first, ForwardIterator1 last,
                                  ForwardIterator2 s_first, ForwardIterator2 s_last, BinaryPredicate p );
 }}
 {{ddcl list end}}
@@ Line 35: / Line 41: @@
 {{eq fun cpp
   | 1=
-template<class ForwardIterator1, class ForwardIterator2>
+template<class InputIterator, class ForwardIterator>
-ForwardIterator1 find_first_of(ForwardIterator1 first, ForwardIterator1 last,
+InputIterator find_first_of(InputIterator first, InputIterator last,
-                               ForwardIterator2 s_first, ForwardIterator2 s_last)
+                            ForwardIterator s_first, ForwardIterator s_last)
+{
      for (; first != last; ++first) {
-         for (ForwardIterator2 it = sfirst; it != s_last; ++it) {
+         for (ForwardIterator it = s_first; it != s_last; ++it) {
              if (*first == *it) {
                  return first;
@@ Line 49: / Line 55: @@
+}
   | 2=
-template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
+template<class InputIterator, class ForwardIterator, class BinaryPredicate>
-ForwardIterator1 find_first_of(ForwardIterator1 first, ForwardIterator1 last,
+InputIterator find_first_of(InputIterator first, InputIterator last,
-                               ForwardIterator2 s_first, ForwardIterator2 s_last,
+                            ForwardIterator s_first, ForwardIterator s_last,
-                               BinaryPredicate p)
+                            BinaryPredicate p)
+{
      for (; first != last; ++first) {
-         for (ForwardIterator2 it = sfirst; it != s_last; ++it) {
+         for (ForwardIterator it = s_first; it != s_last; ++it) {
              if (p(*first, *it)) {
                  return first;

@@ Line 275: / Line 275: @@
 Arithmetic operators are overloaded for many standard library types.
 ====Unary arithmetic operators====
 {{dcl list begin}}
@@ Line 282: / Line 281: @@
 {{dcl list mem fun | cpp/numeric/valarray/operator_arith | title=operator+<br>operator- | applies a unary arithmetic operator to each element of the valarray}}
 {{dcl list end}}
 ====Bitwise shift operators====

@@ Line 49: / Line 49: @@
 {{dcl list begin}}
 {{dcl list template | cpp/chrono/duration/dcl list common_type}}
-{{dcl list mem fun | cpp/chrono/duration/operator_cmp | title=operator==<br>operator!=<br>operator<<br>operator<=<br>operator><br>operator>= | compares two durations}}
+{{dcl list tfun | cpp/chrono/duration_point/operato_arith4 | title=operator+<br>operator-<br>operator*<br>operator/<br>operator% | implements arithmetic operations with durations as arguments}}
-{{dcl list mem fun | cpp/chrono/duration/duration_cast | converts a duration to another, with a different tick interval}}
+{{dcl list tfun | cpp/chrono/duration/operator_cmp | title=operator==<br>operator!=<br>operator<<br>operator<=<br>operator><br>operator>= | compares two durations}}
 {{dcl list end}}

@@ Line 34: / Line 34: @@
 {{dcl list begin}}
 {{dcl list template | cpp/chrono/time_point/dcl list common_type}}
-{{dcl list mem fun | cpp/chrono/time_point/operato_arith2 | title=operator+<br>operator- | modifies the time point by the given duration}}
+{{dcl list tfun | cpp/chrono/time_point/operato_arith2 | title=operator+<br>operator- | modifies the time point by the given duration}}
-{{dcl list mem fun | cpp/chrono/time_point/operator_cmp | title=operator==<br>operator!=<br>operator<<br>operator<=<br>operator><br>operator>= | compares two time points}}
+{{dcl list tfun | cpp/chrono/time_point/operator_cmp | title=operator==<br>operator!=<br>operator<<br>operator<=<br>operator><br>operator>= | compares two time points}}
-{{dcl list mem fun | cpp/chrono/time_point/time_point_cast | converts a time point to another time point on the same clock, with a different duration}}
+{{dcl list tfun | cpp/chrono/time_point/time_point_cast | converts a time point to another time point on the same clock, with a different duration}}
 {{dcl list end}}

← Older revision		Revision as of 12:42, 16 May 2012
Line 6:		Line 6:

	The `Pointer to member` operator is also an C++ feature. It only matters for classes.		The `Pointer to member` operator is also an C++ feature. It only matters for classes.
		+
		+	:Fixed. --[[User:Cubbi\|Cubbi]] 05:42, 16 May 2012 (PDT)

	== sizeof ==		== sizeof ==

@@ Line 114: / Line 114: @@
 * Otherwise, if either operand is {{c|float}}, the other operand is converted to {{c|float}}
-* Otherwise, the argument is integer type (because bool, char, char16_t, char32_t, wchar_t, and unscoped enumeration were promoted at this point) and [[cpp/language/implicit_cast#integral conversions|integral conversions]] are applied to produce the common type, as follows:
+* Otherwise, the operand has integer type (because bool, char, char16_t, char32_t, wchar_t, and unscoped enumeration were promoted at this point) and [[cpp/language/implicit_cast#integral conversions|integral conversions]] are applied to produce the common type, as follows:
 :* If both operands are signed or both are unsigned, the operand with lesser ''conversion rank'' is converted to the operand with the greater integer conversion rank
@@ Line 126: / Line 126: @@
 The ''conversion rank'' above increases in order {{c|bool}}, {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}}, {{c|long long}}. The rank of any unsigned type is equal to the rank of the corresponding signed type. The rank of {{c|char}} is equal to the rank of {{c|signed char}} and {{c|unsigned char}}. The ranks of {{c|char16_t}}, {{c|char32_t}}, and {{c|wchar_t}} are equal to the ranks of their underlying types.
-{{todo|example, some of these conversions catch people by surprise}}
+{{todo|maybe add example, some of these conversions catch people by surprise}}
 ====Unary arithmetic operators====
@@ Line 135: / Line 135: @@
 {{ddcl list item | A operator-(A)}}
 {{ddcl list end}}
-The builtin unary plus operator returns the value of its argument. The only time it makes a difference is if its argument is integral type or unscoped enumeration type, which is when it applies promotion, e.g, it converts {{c|char}} to {{c|int}}. The builtin unary minus operator calculates the negative of its argument. For unsigned {{tt|a}}, the value of {{tt|-a}} is {{math|2{{su|p=b}}-a}}, where {{tt|b}} is the number of bits after promotion.
 {{example
@@ Line 171: / Line 174: @@
 where {{tt|LR}} is the result of usual arithmetic conversions on {{tt|L}} and {{tt|R}}
-{{todo}}
+With operands of arithmetic or enumeration type, the result of binary plus is the sum of the operands (after usual arithmetic converesions), and the result of the binary minus operator is the result of subtracting the second operand from the first (after usual arithmetic conversions).
 ====Multiplicative operators====
@@ Line 193: / Line 231: @@
 {{ddcl list item |LR operator{{!}}(L, R)}}
 {{ddcl list end}}
 {{todo}}
@@ Line 206: / Line 245: @@
 For unsigned {{tt|a}}, the value of {{tt|a << b}} is the value of {{math|a * 2{{su|p=b}}}}, reduced modulo maximum value of the return type plus 1 (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded). For signed {{tt|a}}, the value of {{tt|a << b}} is {{math|a * 2{{su|p=b}}}} if it is representable by the return type, otherwise the behavior is undefined.
-For unsigned {{tt|a}} and for signed {{tt|a}} with nonnegative value, the value of {{tt|a >> b}} is the integer part of {{math|a/2{{su|p=b}}}}. For negative {{tt|a}}, the value of {{tt|a >> b}} is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative)
+For unsigned {{tt|a}} and for signed {{tt|a}} with nonnegative values, the value of {{tt|a >> b}} is the integer part of {{math|a/2{{su|p=b}}}}. For negative {{tt|a}}, the value of {{tt|a >> b}} is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative)
-In any case, if the value of the right argument is negative or is greater or equal to the number of bits in the promoted left operand, the behavior is undefined.
+In any case, if the value of the right operand is negative or is greater or equal to the number of bits in the promoted left operand, the behavior is undefined.
 {{example

@@ Line 101: / Line 101: @@
 All arithmetic operators compute the result of specific arithmetic operation and returns its result. The arguments are not modified.
-{{todo|usual arithmetic conversions/promotions/common type}}
+====Conversions====
 ====Unary arithmetic operators====

@@ Line 45: / Line 45: @@
          ForwardIterator1 new_result = std::search(first, last, s_first, s_last);
          if (new_result == last) {
-             return result;
+            return result;
          } else {
              result = new_result;
@@ Line 55: / Line 55: @@
+}
   | 2=
-template<class ForwardIterator1, class ForwardIterator2>
+template<class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
 ForwardIterator1 find_end(ForwardIterator1 first, ForwardIterator1 last,
                            ForwardIterator2 s_first, ForwardIterator2 s_last,
@@ Line 65: / Line 65: @@
      while (1) {
          ForwardIterator1 new_result = std::search(first, last, s_first, s_last, p);
-         if( new_result == last ) {
+         if (new_result == last) {
              return result;
          } else {

@@ Line 30: / Line 30: @@
 ===Numeric conversions===
-====Integer promotion====
+====Integral promotion====
-Integer types may be converted to larger types in order to do calculations. This does not change the actual contents of the variable.
+Prvalues of small integral types (such as {{c|char}}) may be converted to prvalues of larger integral types (such as {{c|int}}). In particular, [[cpp/language/operator_arithmetic|arithmetic operators]] do not accept types smaller than {{c|int}} as arguments, and integral promotions are automatically applied. This conversion always preserves the value.
-The following conversions may apply:
+The following implicit conversions are classified as integral promotions:
-:*{{ttb|signed char}} or {{ttb|signed short}} may be casted to {{c|int}}.
+:*{{ttb|signed char}} or {{ttb|signed short}} can be converted to {{c|int}}.
-:*{{ttb|unsigned char}} or {{ttb|unsigned short}} may be casted to {{c|unsigned int}}.
+:*{{ttb|unsigned char}} or {{ttb|unsigned short}} can be converted to {{c|unsigned int}}.
-:*{{ttb|char}} may be casted to {{c|int}} or {{c|unsigned int}} depending on the underlying type - {{c|signed char}} or {{c|unsigned char}} (see above)
+:*{{ttb|char}} can be converted to {{c|int}} or {{c|unsigned int}} depending on the underlying type: {{c|signed char}} or {{c|unsigned char}} (see above)
-:*{{ttb|wchar_t}} or {{ttb|char16_t}} or {{ttb|char32_t}} may be casted to the first type from the following list able to hold their entire value range: {{c|int}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}.
+:*{{ttb|wchar_t}}, {{ttb|char16_t}}, and {{ttb|char32_t}} can be converted to the first type from the following list able to hold their entire value range: {{c|int}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, {{c|unsigned long long}}.
-:* An ''enumeration'' type whose underlying type is not fixed may be casted to the first type from the following list able to hold their entire value range: {{c|int}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, or {{c|unsigned long long}}. If the value range is greater, no conversions apply.
+:* An ''unscoped enumeration'' type whose underlying type is not fixed can be converted to the first type from the following list able to hold their entire value range: {{c|int}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, or {{c|unsigned long long}}. If the value range is greater, no integral promotions apply.
-:* An ''enumeration'' type whose underlying type is fixed can be converted to its underlying type. Additionally, the resulting value can be promoted to {{c|int}} or {{c|unsigned int}}. {{mark since c++11}}
+:* An ''unscoped enumeration'' type whose underlying type is fixed can be converted to its promoted underlying type. {{mark since c++11}}
-:* A ''bitfield type'' can be converted to {{c|int}} if it can represent entire value range of the bitfield, otherwise to {{c|unsigned int}} if it can represent entire value range of the bitfield, otherwise no conversions apply.
+:* A ''bitfield type'' can be converted to {{c|int}} if it can represent entire value range of the bitfield, otherwise to {{c|unsigned int}} if it can represent entire value range of the bitfield, otherwise no integral promotions apply.
 ====Integral conversions====

← Older revision		Revision as of 13:01, 16 May 2012
(One intermediate revision by one user not shown)
Line 134:		Line 134:
	}}		}}

		+	====Additive operators====
		+	For every pair of promoted arithmetic types {{tt\|L}} and {{tt\|R}} and for every object type {{tt\|T}}, the following function signatures participate in overload resolution:
		+	{{ddcl list begin}}
		+	{{ddcl list item \| LR operator+(L, R)}}
		+	{{ddcl list item \| LR operator-(L, R)}}
		+	{{ddcl list item \| T* operator+(T*, std::ptrdiff_t)}}
		+	{{ddcl list item \| T* operator+(std::ptrdiff_t, T*)}}
		+	{{ddcl list item \| T* operator-(T*, std::ptrdiff_t)}}
		+	{{ddcl list item \| std::ptrdiff_t operator-(T, T)}}
		+	{{ddcl list end}}
		+	where {{tt\|LR}} is the result of usual arithmetic conversions on {{tt\|L}} and {{tt\|R}}
		+
		+	{{todo}}
		+
		+	====Multiplicative operators====
		+
		+	For every pair of promoted arithmetic types {{tt\|LA}} and {{tt\|RA}} and for every pair of promoted integral types {{tt\|LI}} and {{tt\|RI}} the following function signatures participate in overload resolution:
		+	{{ddcl list begin}}
		+	{{ddcl list item \| LRA operator*(LA, RA)}}
		+	{{ddcl list item \| LRA operator/(LA, RA)}}
		+	{{ddcl list item \| LRI operator%(LI, RI)}}
		+	{{ddcl list end}}
		+	where {{tt\|LRx}} is the result of usual arithmetic conversions on {{tt\|Lx}} and {{tt\|Rx}}
		+
		+	{{todo}}
		+
		+	====Bitwise logic operators====
		+	For every pair of promoted integral types {{tt\|L}} and {{tt\|R}} the following function signatures participate in overload resolution:
		+	{{ddcl list begin}}
		+	{{ddcl list item \|R operator~(R)}}
		+	{{ddcl list item \|LR operator&(L, R)}}
		+	{{ddcl list item \|LR operator^(L, R)}}
		+	{{ddcl list item \|LR operator{{!}}(L, R)}}
		+	{{ddcl list end}}

	{{todo}}		{{todo}}

@@ Line 17: / Line 17: @@
 {{tl | param list pred2 | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }} - binary predicate
-{{tl | param list pred2 eq | ''parameter_name'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{small|(optional)}} }} - binary equality predicate
+{{tl | param list pred2 eq | ''parameter_name'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }} - binary equality predicate
-{{tl | param list cmp | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{small|(optional)}} }} - comparison function
+{{tl | param list cmp | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }} - comparison function
-{{tl | param list ccmp | ''parameter_name'' | ''additional_explanation}}{{mark optional}} }} - C-style comparison function
+{{tl | param list ccmp | ''parameter_name'' | ''additional_explanation'' {{mark optional}} }} - C-style comparison function
 {{tl | param list opf | ''parameter_name'' | ''action'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type''}} - function
@@ Line 27: / Line 27: @@
 {{tl | param list op1 | ''parameter_name'' | ''action'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type''}} - unary operation
-{{tl | param list op2 | ''parameter_name'' | ''action'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{small|(optional)}} }} - binary operation
+{{tl | param list op2 | ''parameter_name'' | ''action'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }} - binary operation
 {{tl | param list gen | ''parameter_name'' | ''action'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type'' }} - generator

@@ Line 23: / Line 23: @@
 |-
 | style="border-bottom-style: none; border-top-style: none" | <code>.</code>
-| style="border-bottom-style: none; border-top-style: none" | Element selection by reference
+| style="border-bottom-style: none; border-top-style: none" | Structure and union member access
 |-
 | style="border-bottom-style: none; border-top-style: none" | <code>−&gt;</code>
-| style="border-bottom-style: none; border-top-style: none" | Element selection through pointer
+| style="border-bottom-style: none; border-top-style: none" | Structure and union member access through pointer
 |-
 | style="border-bottom-style: none; border-top-style: none" | <code>(''type''){''list''}</code>
-| style="border-bottom-style: none; border-top-style: none" | Compound literal
+| style="border-bottom-style: none; border-top-style: none" | Compound literal{{mark c99}}
 |-
 ! rowspan=8| 2
@@ Line 55: / Line 55: @@
 |-
 | style="border-bottom-style: none; border-top-style: none" | <code>_Alignof</code>
-| style="border-bottom-style: none; border-top-style: none" | Alignment requirement
+| style="border-bottom-style: none; border-top-style: none" | Alignment requirement{{mark c11}}
 |-
 ! 3
-| <code>.*</code> <code>->*</code>
+| <code>*</code> <code>/</code> <code>%</code>
-| Pointer to member
+| Multiplication, division, and remainder
-| style="vertical-align: top" rowspan="12" | Left-to-right
+| style="vertical-align: top" rowspan="11" | Left-to-right
 |-
 ! 4
 | <code>+</code> <code>−</code>
 | Addition and subtraction
 |-
-! 6
+! 5
 | <code>&lt;&lt;</code> <code>&gt;&gt;</code>
 | Bitwise left shift and right shift
 |-
-! rowspan=2| 7
+! rowspan=2| 6
 | style="border-bottom-style: none" | <code>&lt;</code> <code>&lt;=</code>
 | style="border-bottom-style: none" | For relational operators < and ≤ respectively
@@ Line 85: / Line 77: @@
 | style="border-top-style: none" | For relational operators > and ≥ respectively
 |-
-! 8
+! 7
 | <code>==</code> <code>!=</code>
 | For relational = and ≠ respectively
 |-
-! 9
+! 8
 | <code>&amp;</code>
 | Bitwise AND
 |-
-! 10
+! 9
 | <code>^</code>
 | Bitwise XOR (exclusive or)
 |-
-! 11
+! 10
 | <code><nowiki>|</nowiki></code>
 | Bitwise OR (inclusive or)
 |-
-! 12
+! 11
 | <code>&amp;&amp;</code>
 | Logical AND
 |-
-! 13
+! 12
 | <code><nowiki>||</nowiki></code>
 | Logical OR
 |-
-! 14
+! 13
 | <code>?:</code>
 | Ternary conditional
-| style="vertical-align: top" rowspan="7" | Right-to-Left
+| style="vertical-align: top" rowspan="6" | Right-to-Left
 |-
-! rowspan=5| 15
+! rowspan=5| 14
 | style="border-bottom-style: none" | <code>=</code>
 | style="border-bottom-style: none" | Simple assignment
@@ Line 130: / Line 122: @@
 | style="border-top-style: none" | Assignment by bitwise AND, XOR, and OR
 |-
-! 16
+! 15
 | <code>,</code>
 | Comma

← Older revision		Revision as of 07:37, 16 May 2012
Line 4:		Line 4:

	:Fixed. -- [[User:P12\|P12]] 06:10, 8 May 2012 (PDT)		:Fixed. -- [[User:P12\|P12]] 06:10, 8 May 2012 (PDT)
		+
		+	The `Pointer to member` operator is also an C++ feature. It only matters for classes.

	== sizeof ==		== sizeof ==

← Older revision		Revision as of 03:33, 16 May 2012
Line 73:		Line 73:

	===[[cpp/memory/c\|C library]]===		===[[cpp/memory/c\|C library]]===
		+

@@ Line 62: / Line 62: @@
 template <
      class TemplateParam,
-     class TemplateParam2,
+     class TemplateParam2
 > class TemplateClass;
 }}

@@ Line 18: / Line 18: @@
 ===Example===
-{{example |
+{{example
   | code=
   | output=
 }}

@@ Line 28: / Line 28: @@
      std::mutex test;
      if (test.try_lock()==true)
-         std::cout << "lock aquired" << std::endl;
+         std::cout << "lock acquired" << std::endl;
      else
-         std::cout << "lock not aquired" << std::endl;
+         std::cout << "lock not acquired" << std::endl;
-     test.unlock();
+     test.unlock();	//now unlock the mutex
-     test.lock();
+     test.lock();	//to lock it again
      if (test.try_lock())  //true can be left out
-         std::cout << "lock aquired" << std::endl;
+         std::cout << "lock acquired" << std::endl;
      else
-         std::cout << "lock not aquired" << std::endl;
+         std::cout << "lock not acquired" << std::endl;
      test.lock(); //and now the finale (a block)
+}
 }}

@@ Line 31: / Line 31: @@
 ForwardIterator unique(ForwardIterator first, ForwardIterator last)
+{
-     if (first != last) {
+     if (first == last)
-         ForwardIterator result = first;
+         return last;
-        while (++first != last) {
-            if (!(*result == *first)) {
+    ForwardIterator result = first;
-                *(++result) = *first;
+    while (++first != last) {
+        if (!(*result == *first)) {
+         }
+     }
@@ Line 46: / Line 47: @@
                         BinaryPredicate p)
+{
-     if (first != last) {
+     if (first == last)
-         ForwardIterator result = first;
+         return last;
-        while (++first != last) {
-            if (!p(*result, *first)) {
+    ForwardIterator result = first;
-                *(++result) = *first;
+    while (++first != last) {
+        if (!p(*result, *first)) {
+         }
+     }