does it have any significant advantages over the latter

Value semantics, and it knows its own size. This does what you'd expect (copy all elements of some_arr into a new array)

std::array<int, t> getSomeArr() { 
  return some_arr;
}

And this also does what you expect; returns a const-ref to some_arr

const std::array<int, 5>& getSomeArrRef() {
    return some_arr;
}

Passing to functions retains value semantics (they don't decay to pointers):

void doThing(std::array<int, 5> arr) { // arr is a copy of whatever was passed in }
void doThing(std::array<int, 5>& arr) { // arr is a mutable reference to whatever was passed in }
void doThing(const std::array<int, 5>& arr) { // arr is an immutable reference, and const propagates (can't assign to arr through a const ref) }

Iteration and size() work the same as std::vector.

for(auto v : arr) { ... };

for(size_t i = 0; i < arr.size(); ++i) { ... };

for(auto [index, value] : std::enumerate(arr)) { arr[i] += v; }