Question

From what I understand, the purpose of size_type and difference_type is not merely the sign — it was also meant to address e.g. segmented architectures and such, where they might be of different sizes.

With that context, if I have a container with random-access iterators, is it safe for me to perform a static_cast between its difference_type and size_type values at will, on the grounds that end() - begin() must always be equal to size(), when either is casted?

(The use case, for example, is to create a container whose size is equal to the number of elements between two iterators, or the reverse: to copy a container of a certain size onto a range delimited by iterators.)

Anything I should watch out for before casting (e.g. loss of data)?

Answer 1

Here’s what the C++11 standard has to say on various things here:

§ 23.2.1

Expression: difference_type
Return Type: signed integer type
Operational Semantics: -
Assertion/note, pre-/post-condition: is identical to the difference type of iterator and const_iterator
Complexity: compile-time

Expression: size_type
Return Type: unsigned integer type
Operational Semantics: -
Assertion/note, pre-/post-condition: size_type can represent any non-negative value of difference_type
Complexity: compile-time

Expression: size()
Return Type: size_type
Operational Semantics: distance(begin(),end()) 
Assertion/note, pre-/post-condition: -
Complexity: constant

Let’s make sure size() is equivalent to end() - begin():

§ 24.4.4/4

distance():
Effects: If InputIterator meets the requirements of random access iterator, 
returns (last - first); otherwise, returns the number of increments needed 
to get from first to last

Since your container has random-access iterators, this holds true. That’s that. As you can see in the first box,

size_type can represent any non-negative value of difference_type

From that, we have that the cast from difference_type to size_type should be valid for all non-negative values.