In a C++ array of structs, is it legal to iterate/slice over corresponding data members using pointer arithmetic?

In an array of structs of type S, the offset in bytes between neighboring corresponding data members is always sizeof(S). Is it legal, according to the C++ standard, to directly jump from one data member to the next corresponding one by adding sizeof(S) to the address, like in this example?

#include <vector>
#include <string>
#include <iostream>

using namespace std;

struct S
{
    vector<int> v;
    string s;
    int i;
    char c;
};

void print_all(const string* s, size_t n, ptrdiff_t stride_in_bytes)
{
    while (n > 0)
    {
        cout << *s << "\n";
        --n;
        // jump over any other data from string to string
        s = reinterpret_cast<const string*>(reinterpret_cast<uintptr_t>(s)+stride_in_bytes);
    }
}

int main(int, char**)
{
    S my_array[3];
    my_array[0].s = "a";
    my_array[1].s = "b";
    my_array[2].s = "c";
    print_all(&my_array[0].s, 3, sizeof(S));
    return 0;
}

This would enable using the same non-templated print_all() function for all kinds of structs.

It appears to work with GCC and MSVC, but is it legal according to the standard?

Conversions between pointer types and integer types (of sufficient size) are completely implementation-defined, except that converting the integer value obtained by such a conversion from a pointer value back to the original pointer type will reproduce the original pointer value.

So, you'll need to read the documentation of your compiler which should document the behavior.

However, if you had used (unsigned) char* instead of uintptr_t, then it would have undefined behavior. Specifically the pointer resulting from the cast will still point to the original string object or to its object representation. Then pointer arithmetic is either not allowed at all because T in the pointer type T* is not similar to the actual pointed-to object's type (std::string), or because it would increment the pointer (far) beyond the object representation of the std::string object. You can only do pointer arithmetic inside an array, including one-past the last element, and only if the pointer type is similar to that of the actual array. (Objects which are not elements of an array are considered to be elements of a one-element array for this purpose.) Any other pointer arithmetic has in itself undefined behavior.

Since C++17 at least there is no way to get from a pointer to one of the s members to any other other members of the same S object or to any other S object in the same array without relying on implementation-specific behavior. The compiler would be allowed to optimize under this assumption (even if I don't think any do).

So it shouldn't be expected that the uintptr_t variant will work either. There is a concept of pointer provenance that implies pointer values to carry information beyond simply their address. It isn't specified how this should interact with integer representations of pointers, but see e.g. P2318 for some approaches. Compilers will use this to some degree for optimization purposes.

Whether or not it is legal (I don't know for sure, but I suspect not), I would not suggest using that approach at all. A much safer and definitely legal option would be to use a pointer-to-member instead, applying it to each struct instance in the array, eg:

#include <vector>
#include <string>
#include <iostream>

using namespace std;

struct S
{
    vector<int> v;
    string s;
    string s2;
    int i;
    char c;
};

void print_all(const S* arr, size_t n, const string S::*member)
{
    while (n > 0)
    {
        cout << arr->*member << "\n";
        ++arr;
        --n;
    }
}

int main(int, char**)
{
    S my_array[3];

    my_array[0].s = "a";
    my_array[1].s = "b";
    my_array[2].s = "c";

    my_array[0].s2 = "d";
    my_array[1].s2 = "e";
    my_array[2].s2 = "f";

    print_all(my_array, 3, &S::s);
    print_all(my_array, 3, &S::s2);

    return 0;
}

Online Demo

Which you can generalize with templates:

#include <vector>
#include <string>
#include <iostream>

using namespace std;

struct S
{
    vector<int> v;
    string s;
    string s2;
    int i;
    char c;
};

template<typename T, typename U>
void print_all(const T* arr, size_t n, const U T::*member)
{
    while (n > 0)
    {
        cout << arr->*member << "\n";
        ++arr;
        --n;
    }
}

template<typename T, typename U, size_t N>
void print_all(const T (&arr)[N], const U T::*member)
{
    print_all(arr, N, member);
}

int main(int, char**)
{
    S my_array[3];

    my_array[0].s = "a";
    my_array[1].s = "b";
    my_array[2].s = "c";

    my_array[0].s2 = "d";
    my_array[1].s2 = "e";
    my_array[2].s2 = "f";

    my_array[0].i = 1;
    my_array[1].i = 2;
    my_array[2].i = 3;
 
    my_array[0].c = 'g';
    my_array[1].c = 'h';
    my_array[2].c = 'i';

    print_all(my_array, &S::s);
    print_all(my_array, &S::s2);
    print_all(my_array, &S::c);
    print_all(my_array, &S::i);

    return 0;
}

Online Demo

It a nice idea and concept. However you abandon type safety for tricky calculation. Errors are only seen by the programmer: 3 and sizeof(S). It is definitely not worth here. You can loop applying an access to a field. Every case a new access, but that introduces type safety.

It would have some reason, if y0u parsed field offsets of a struct to have a alignment independent streaming of data.

And yes it is more or less legal.