P3785R1
Library Wording Changes for Defaulted Postfix Increment and Decrement Operations

1. Revision History

Changes from R1:

• Rebase on latest draft.

• Add investigation of noexcept consistency to § 3 Proposal.

• Receive direction from LWG, see § 3.4 LWG Feedback and Direction.

• Update § 4 Proposed Wording.

2. Motivation and Scope

C operator++(C& c, int){
    C copy = C(c);
    ++c;
    return copy;
}

This allows users to write shorter code using this sensible default with a universally-accepted meaning. The standard library also defines many objects with postfix increment and decrement operations, and each one is defined in full with code which is equivalent to the above definition. For example, std::regex_iterator defines its postfix increment operation as follows:

regex_iterator operator++(int);
⁹ Effects: As if by:

regex_iterator tmp = *this;
++(*this);
return tmp;

This pattern of explicitly defining the default meaning of the postfix operation is repeated on every iterator which exhibits the default behaviour in the standard. While this has been necessary up to this point, with P3668 core-approved for C++29, we can allow for a more concise library specification. We are able to mark these operations as defaulted, which allows us to keep their meanings clear while eliminating many unnecessary boilerplate definitions from the standard document.

We consider this a strictly non-semantic, wording only change to the specification; and do not anticipate that implementations will have to update around this paper. The semantics of every affected overload after this proposal are identical to before it; however the specification for them is permitted to be shorter and simpler.

3. Proposal

The authors have identified 51 candidate operations in the standard which may be defaulted. Most of these are simple: they are a single postfix increment or decrement operator which has behaviour equivalent to the defaulted definition which can be immediately replaced. There are also some which we highlight for specific consideration as they have additional properties which LWG may prefer not to word as defaulted. The authors are not library wording experts, so defer such decisions to LWG.

3.1. Simple Defaultable Operations

The following table lists all standard library postfix operations which are specified as exactly equivalent to the canonical definition. This expressly does not include any iterators which have any additional complexities which might raise wording questions if they were instead specified as = default. Those are covered in the next section. The below tables feature the a column "noexcept status", where ✓ means that the implicitly-added noexcept status from defaulting a function is consistent with the dependent operations (ie, either all suboperations are marked noexcept and the defaulted function is marked noexcept, or at least one suboperation is not marked noexcept and the defaulted function is also not marked noexcept), and ✗ means that defaulting the postfix operator will result in a breaking or inconsistent noexcept specification (see § 3.4 LWG Feedback and Direction).

move_iterator tmp = *this;
--current;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

counted_iterator tmp = *this;
--*this;
return tmp;

regex_iterator tmp = *this;
++(*this);
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

iterator tmp = *this;
++*this;
return tmp;

iterator tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto temp = *this;
++current_;
return temp;

++current_;
return *this;

auto temp = *this;
--current_;
return temp;

--current_;
return *this;

auto temp = *this;
++*this;
return temp;

auto temp = *this;
--*this;
return temp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

3.2. Postfix Operations Requiring LWG Input

This table lists postfix operations which have equivalent semantics to the default behaviour, but which have complexities in the specification, and so may require some input from library wording experts. We have intentionally made this table as conservative as possible and intentionally list things which we believe will be uncontentious to change; but explicitly want to ensure that any wording questions, no matter how trivial, are noted. LWG feedback was that all of these categories are permissible to default under the correct circumstances; however we retain this table for easy categorisation of design intent. For the sake of easier formatting, the "Reason" column will also list noexcept consistency as described above.

To define the terms we use to describe why we believe an operator belongs in this table:

• Compile-time branching - the specification either uses if constexpr or wording to state that the behaviour of a function is equivalent to the default in some cases (typically when operating on a forward range), but not others. This could be remedied by introducing a constrained defaulted overload.

• Precondition/Constraint - the postfix operator overload lists a (potentially hardened) formal precondition or constraint. It is not clear whether LWG would prefer to avoid defaulting functions with listed preconditions or constraints.

• Transitive precondition - the postfix operator overload itself has no preconditions or postconditions; however one of the dependent operations (typically the prefix) does list preconditions or postconditions.

istream_iterator tmp = *this;
++*this;
return tmp;

move_iterator tmp = *this;
++current;
return tmp;

 if constexpr (forward_range<Base>) {
    auto tmp = *this;
    ++*this;
    return tmp;
} else
    ++*this;
}

 if constexpr (forward_range<Base>) {
    auto tmp = *this;
    ++*this;
    return tmp;
} else
    ++*this;
}

common_iterator tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

counted_iterator tmp = *this;
++*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

auto tmp = *this;
--*this;
return tmp;

auto tmp = *this;
++*this;
return tmp;

To save some counting, we did not find any postfix operations which would receive a breaking noexcept specification.

3.3. Container Iterators and Named Requirements

The iterators for standard library containers are not specified in terms of specific functions in the same way the above operations are, but instead as being some type which meets one or more named requirements or iterator concepts. For example, std::vector::iterator must meet Cpp17RandomAccessIterator and model std::contiguous_iterator; and the standard defers to these rather than providing a dedicated section for std::vector::iterator::operator++(int).

We do not propose changing the contents of the named requirements tables or the wording for the standard iterator concepts. The purpose of this proposal is a net simplification of standard library wording and we feel that this would work against that goal. The most we would suggest is adding a note to the table to state that a defaulted operation is valid for that case, but we defer to LWG’s judgement on whether it is necessary.

3.4. LWG Feedback and Direction

LWG reviewed this paper at the Brno meeting, on 2026-06-10. Guidance on how best to shape the wording was given. In particular the three categories of possible contention listed in the previous section were resolved as follows:

• Compile-time branching: It is not a problem to introduce a new, constrained defaulted overload.

• Precondition/constraints: It is not a problem to default a function with a listed precondition or constraint, however it is not desirable to list = default; as a definition for the function and then also list a subclause definition for that same function. Typically these can and should be written such that the constraint or precondition is subsumed into the call for the prefix operator.

• Transitive preconditions: This is no problem. The library wording is happy to assume that it knows how = default; works and that as a consequence the dependent operation with a precondition will be called.

Several other points were raised. In particular, as a defaulted function will implicitly inherit the noexcept specification of its suboperations, we need to ensure that this does not result in a breaking change in the wording by adding a defaulted overload. Implementations are welcome to strengthen the noexcept specification as they see fit. However, we do not believe that the implicit addition of noexcept will cause a problem, as most specified prefix operations and copy operations are not marked noexcept. For the sake of completeness we do note the noexcept status in every example in the tables in § 3 Proposal.

It was also raised that we should drop unnecessary constexpr on newly-defaulted postfix increment and decrement operators, as all defaulted functions are implicitly constexpr. Similarly, advice was given that in the case where a postfix increment or decrement operator function has the same constraints as its prefix equivalent, we can remove the constraints and preconditions from the postfix operation as these will be de facto inherited from the checks on the precondition function.

LWG also advised that we drop any changes to std::simd types, as this was better deferred to be handled alongside specific std::simd library papers.

4. Proposed Wording

Modify [const.iterators.iterator] as follows:

constexpr basic_const_iterator& operator++();
constexpr void operator++(int);
constexpr basic_const_iterator operator++(int) requires forward_iterator<Iterator> = default;

constexpr basic_const_iterator& operator--() requires bidirectional_iterator<Iterator>;
constexpr basic_const_iterator operator--(int) requires bidirectional_iterator<Iterator> = default;

Modify [const.iterators.ops] as follows:

constexpr basic_const_iterator operator++(int) requires forward_iterator<Iterator>;
¹⁰Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr basic_const_iterator operator--(int) requires bidirectional_iterator<Iterator>;
¹²Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [move.iterator] as follows:

constexpr move_iterator& operator++();
constexpr autovoid operator++(int);
move_iterator operator++(int) requires forward_iterator<Iterator> = default;
constexpr move_iterator& operator--();
constexpr move_iterator operator--(int) = default;

Modify [move.iter.nav] as follows:

constexpr autovoid operator++(int);
³ Effects: If Iterator models forward_iterator, equivalent to:

move_iterator tmp = *this;
++current;
return tmp;

Otherwise, equivalent to ++current.

³ Effects: Equivalent to ++current.

[...]

constexpr move_iterator operator--(int);
⁶Effects: As if by:

move_iterator tmp = *this;
--current;
return tmp;

Modify [common.iterator] as follows:

constexpr common_iterator& operator++();
constexpr decltype(auto) operator++(int);
common_iterator operator++(int) requires forward_iterator<I> = default;

Modify [common.iter.nav] as follows:

constexpr common_iterator& operator++()
¹Hardened Preconditions: holds_alternative<I>(v_) is true.
²Effects: Equivalent to ++get<I>(v_).
³Returns: *this.

constexpr decltype(auto) operator++(int);
⁴Hardened Preconditions: holds_alternative<I>(v_) is true.
⁵Effects: If I models forward_iterator, equivalent to:

common_iterator tmp = *this;
++*this;
return tmp;

Otherwise, if If requires(I& i) { { *i++ } -> can-reference; } is true or

indirectly_readable<I> && constructible_from<iter_value_t<I>, iter_reference_t<I>> &&
move_constructible<iter_value_t<I>>

is false, equivalent to:

return get<I>(v_)++;

Otherwise, equivalent to:

postfix-proxy p(**this);
++*this;
return p;

where postfix-proxy is the exposition-only class:

class postfix-proxy {
    iter_value_t<I> keep_;
    constexpr postfix-proxy(iter_reference_t<I>&& x)
        : keep_(std::forward<iter_reference_t<I>>(x)) {}
    public:
    constexpr const iter_value_t<I>& operator*() const noexcept {
        return keep_;
    }
};

Modify [counted.iterator] as follows:

constexpr counted_iterator& operator++();
constexpr decltype(auto) operator++(int);
constexpr counted_iterator operator++(int)
    requires forward_iterator<I>  = default;
constexpr counted_iterator& operator--() 
    requires bidirectional_iterator<I>;
constexpr counted_iterator operator--(int) 
    requires bidirectional_iterator<I> = default;

Modify [counted.iterator.nav] as follows:

constexpr counted_iterator operator++(int) requires forward_iterator<I>
⁵Effects: Equivalent to:

counted_iterator tmp = *this;
++*this;
return tmp;

[...]

constexpr counted_iterator operator--(int)
requires bidirectional_iterator<I>
⁷Effects: Equivalent to:

counted_iterator tmp = *this;
--*this;
return tmp;

Modify [istream.iterator.general] as follows:

istream_iterator& operator++();
istream_iterator  operator++(int) = default;

Modify [istream.iterator.ops] as follows:

istream_iterator& operator++();
⁵Preconditions: in_stream != nullptr is true.
⁶Effects: Equivalent to:

if(!(*in_stream >> value))
    in_stream = nullptr;

⁷Returns: *this

istream_iterator operator++(int);
⁸Preconditions: in_stream != nullptr is true.
⁹ Effects: Equivalent to:

istream_iterator tmp = *this;
++*this;
return tmp;

Modify [range.iota.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires incrementable<W> = default;

constexpr iterator& operator--() requires decrementable<W>;
constexpr iterator operator--(int) requires decrementable<W> = default;

[...]

constexpr iterator operator++(int) requires incrementable<W>;
⁸ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires decrementable<W>;
¹⁰ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.repeat.iterator] as follows:

constexpr iterator& operator++();
constexpr iterator operator++(int) = default;

constexpr iterator& operator--();
constexpr iterator operator--(int) = default;

[...]

constexpr iterator operator++(int);
⁶ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int);
⁹Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.filter.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires forward_range<Base> = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int) requires forward_range<Base>;
¹² Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹⁴ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.transform.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires forward_range<Base> = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int) requires forward_range<Base>;
⁹ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹¹ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.chunk.fwd.iter] as follows:

constexpr value_type operator*() const;
constexpr iterator& operator++();
constexpr iterator operator++(int) = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int);
⁹Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹¹Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.join.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int)
    requires ref-is-glvalue && forward_range<Base> &&
            forward_range<range_reference_t<Base>> = default;

constexpr iterator& operator--()
    requires ref-is-glvalue && bidirectional_range<Base> &&
            bidirectional_range<range_reference_t<Base>> &&
            common_range<range_reference_t<Base>>;

constexpr iterator operator--(int)
    requires ref-is-glvalue && bidirectional_range<Base> &&
            bidirectional_range<range_reference_t<Base>> &&
            common_range<range_reference_t<Base>> = default;

[...]

constexpr iterator operator++(int) requires ref-is-glvalue && forward_range<Base> && forward_range<range_reference_t<Base>>;
¹⁵ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires ref-is-glvalue && bidirectional_range<Base> && bidirectional_range<range_reference_t<Base>> && common_range<range_reference_t<Base>>;
¹⁷ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.join.with.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int)
    requires ref-is-glvalue && forward_iterator<OuterIter> &&
            forward_iterator<InnerIter> = default;

constexpr iterator& operator--()
    requires ref-is-glvalue && bidirectional_range<Base> &&
            bidirectional-common<InnerBase> && bidirectional-common<PatternBase>;
constexpr iterator operator--(int)
    requires ref-is-glvalue && bidirectional_range<Base> &&
            bidirectional-common<InnerBase> && bidirectional-common<PatternBase> = default;

[...]

constexpr iterator operator++(int) requires ref-is-glvalue && forward_iterator<OuterIter> && forward_iterator<InnerIter>;
¹⁵ Effects: Equivalent to:

iterator tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires ref-is-glvalue && bidirectional_range<Base> && bidirectional-common<InnerBase> && bidirectional-common<PatternBase>;
¹⁷ Effects: Equivalent to:

iterator tmp = *this;
--*this;
return tmp;

Modify [range.lazy.split.outer] as follows:

constexpr outer-iterator& operator++();

constexpr decltype(auto) operator++(int) {
    if constexpr (forward_range<Base>) {
        auto tmp = *this;
        ++*this;
        return tmp;
    } else
        ++*this;
}


constexpr void operator++(int) {
    ++*this;
}
outer-iterator operator++(int) requires forward_range<Base> = default;


friend constexpr bool operator==(const outer-iterator& x, const outer-iterator& y)
    requires forward_range<Base>;

Modify [range.lazy.split.inner] as follows:

constexpr inner-iterator& operator++();

constexpr decltype(auto) operator++(int) {
    if constexpr (forward_range<Base>) {
        auto tmp = *this;
        ++*this;
        return tmp;
    } else
        ++*this;
}


constexpr void operator++(int) {
    ++*this;
}
inner-iterator operator++(int) requires forward_range<Base> = default;


friend constexpr bool operator==(const inner-iterator& x, const inner-iterator& y)
    requires forward_range<Base>;

Modify [range.split.iterator] as follows:

constexpr iterator& operator++();
constexpr iterator operator++(int) = default;

[...]

constexpr iterator operator++(int);
⁵ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

Modify [range.concat.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int)
    requires all-forward<Const, Views...> = default;
constexpr iterator& operator--()
    requires concat-is-bidirectional<Const, Views...>;
constexpr iterator operator--(int)
    requires concat-is-bidirectional<Const, Views...> = default;

[...]

constexpr iterator operator++(int) requires all-forward<Const, Views...>;
¹⁵Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires concat-is-bidirectional<Const, Views...>;
¹⁸Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.elements.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires forward_range<Base> = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int) requires forward_range<Base>;
¹⁰ Effects: Equivalent to:

auto temp = *this;
++current_;
return temp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹² Effects: Equivalent to:

auto temp = *this;
--current_;
return temp;

Modify [range.enumerate.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires forward_range<Base> = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int) requires forward_range<Base>;
⁹ Effects: Equivalent to:

auto temp = *this;
++*this;
return temp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹¹ Effects: Equivalent to:

auto temp = *this;
--*this;
return temp;

Modify [range.zip.iterator] as follows:

constexpr auto operator*() const;
constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires all-forward<Const, Views...> = default;

constexpr iterator& operator--() requires all-bidirectional<Const, Views...>;
constexpr iterator operator--(int) requires all-bidirectional<Const, Views...> = default;

[...]

constexpr iterator operator++(int) requires all-forward<Const, Views...>;
⁹ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires all-bidirectional<Const, Views...>;
¹¹ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.zip.transform.iterator] as follows:

constexpr decltype(auto) operator*() const noexcept(see below);
constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires forward_range<Base> = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int) requires forward_range<Base>;
⁸ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹⁰ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.adjacent.iterator] as follows:

constexpr iterator& operator++();
constexpr iterator operator++(int) = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int);
¹⁰Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹⁴Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.adjacent.transform.iterator] as follows:

constexpr decltype(auto) operator*() const noexcept(see below);
constexpr iterator& operator++();
constexpr iterator operator++(int) = default;
constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;
constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;
constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>;

[...]

constexpr iterator operator++(int);
⁷ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
⁹ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.slide.iterator] as follows:

constexpr auto operator*() const;
constexpr iterator& operator++();
constexpr iterator operator++(int) = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int);
¹⁰Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹⁴Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.chunk.by.iter] as follows:

constexpr value_type operator*() const;
constexpr iterator& operator++();
constexpr iterator operator++(int) = default;

constexpr iterator& operator--() requires bidirectional_range<V>;
constexpr iterator operator--(int) requires bidirectional_range<V> = default;

[...]

constexpr iterator operator++(int);
⁷Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<V>;
⁹ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.stride.iterator] as follows:

constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires forward_range<Base> = default;

constexpr iterator& operator--() requires bidirectional_range<Base>;
constexpr iterator operator--(int) requires bidirectional_range<Base> = default;

[...]

constexpr iterator operator++(int) requires forward_range<Base>;
¹⁰ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires bidirectional_range<Base>;
¹² Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [range.cartesian.iterator] as follows:

constexpr auto operator*() const;
constexpr iterator& operator++();
constexpr void operator++(int);
constexpr iterator operator++(int) requires forward_range<maybe-const<Const, First>> = default;

constexpr iterator& operator--()
    requires cartesian-product-is-bidirectional<Const, First, Vs...>;
constexpr iterator operator--(int)
    requires cartesian-product-is-bidirectional<Const, First, Vs...> = default;

[...]

constexpr iterator operator++(int) requires forward_range<maybe-const<Const, First>>;
¹⁴ Effects: Equivalent to:

auto tmp = *this;
++*this;
return tmp;

[...]

constexpr iterator operator--(int) requires cartesian-product-is-bidirectional<Const, First, Vs...>;
¹⁶ Effects: Equivalent to:

auto tmp = *this;
--*this;
return tmp;

Modify [re.regiter.general] as follows:

regex_iterator& operator++();
regex_iterator operator++(int) = default;

Modify [re.regiter.incr] as follows:

regex_iterator operator++(int);
⁹ Effects: As if by:

regex_iterator tmp = *this;
++(*this);
return tmp;

Modify [re.tokiter.general] as follows:

regex_token_iterator& operator++();
regex_token_iterator operator++(int) = default;

Modify [re.tokiter.incr] as follows:

regex_token_iterator& operator++(int);
⁹Effects: Constructs a copy tmp of *this, then calls ++(*this)
¹⁰Returns: tmp