C++ should I loop and set an array or set all by hand for performance

A raw array is not assignable (as a whole), but a struct with a raw array in it is assignable. And std::array is such a struct. Then you can just assign a default very zero instance, like this:

#include <array>

class Mat4
{
private:
    std::array<double, 16>  data_;
public:
    void clear() { data_ = {}; }        // ← how to clear.

    auto item( int const row, int const col ) const
        -> double
    { return data_[4*row + col]; }

    auto item( int const row, int const col )
        -> double&
    { return data_[4*row + col]; }

    Mat4() : data_() {}
};

#include <iostream>
using namespace std;

void display( Mat4 const& m )
{
    for( int row = 0; row < 4; ++row )
    {
        for( int col = 0; col < 4; ++ col )
        {
            cout << m.item( row, col ) << ' ';
        }
        cout << endl;
    }
}

auto main() -> int
{
    Mat4 m;
    for( int i = 0; i < 4; ++i )
        m.item( i, i ) = 1;
    display( m );
    m.clear();
    cout << endl;
    display( m );
}

There is no need to do loops, or std::fill, or (gulp) memset, or extraordinary verbose assignments to each array item.

Just assign a zeroed array, like above, and let the compiler deal with how to do that efficiently.

Using a static array like that, in all likeliness both methods are the same. Take a look at optimizations like loop unrolling.

https://gcc.gnu.org/onlinedocs/gcc-3.3.5/gcc/Optimize-Options.html

Compilers will usually unroll the loop anyway (but this depends of course), so you should loop it. This will also make your code more readable and thus maintainable.

You can't really make an assumption like "unrolling the loop is always better". It will be very slightly faster to actually go through the loop, but then your actual list of chip instructions will be longer. Loading the program will be slower then, among other things. Think of it this way: if all of your function take 16 times as much space in the binary then you will get more cache misses just because of that during normal execution of the program. If you start compiling to a device with very little ram, or say that you start compiling the code into javascript via emscripten and your client is trying to JIT compile it in their web browser, in both cases you are surely better off if that loop is not unrolled, and if functions are compressed rather than inlined basically whenever possible.

If you really want effectively to "force" the compiler to inline the loop, wihtout making assumptions about what compiler options are passed, you could change it so that the loop body is a template function and the loop variable is a template parameter. But there's no reason that you should want that, you should let the compiler decide whether to inline the code or not -- if you do this in production code I expect that your colleagues would hit you :p

template<int i> void loop_body(int * array);
template<int i> void loop_body<i>(int * array) { array[i-1] = 0; loop_body<i-1>(array); }
template<> void loop_body<0>(int * array) {}

// use it like
loop_body<16>(elements);