Pros

• Assignment is simple. You write minimum of code, the compiler does all the work.
  It’s hard for you as a programmer to make a mistake – both in correctness and performance. Machines don’t make errors and compilers are much better at optimization than humans.
• No function call is needed.
  Function calls are slow, generally speaking. Sometimes the optimizer can get rid of them, but getting rid of one while preserving maintainability of the code cannot be bad.
• When used as a local variable, the array is stored on the stack.
  Allocation is fast, deallocation is fast.

Cons

• Assignment is simple. You write minimum of code, the compiler does all the work.
  It might not be obvious that such an assignment is quite an expensive operation. Certainly more expensive than a simple int assignment. Confusing your future self or any other contributors to your project is bad.
• Typing arr1.data[i] is more annoying than typing arr1[i].
• When used as a local variable, the array is stored on the stack.
  Therefore it must be really tiny. Otherwise you get stack overflow.
• Unlike C99 variable-length arrays, these arrays have their length defined at compile time.
• You rarely need this.
  Tiny arrays of fixed width with the ability of assignment en masse are not very useful in practice. If you come across their real-world application, please @ping me in a comment with its description, I will be interested.

I’d like to write more about the last point.

Basically you have d-dimensional vectors for a fixed d, known at compile time. This could be useful if d could change in a future version of the program, but I guess that this is an extremely unlikely scenario and that plain structs would be better in such an application. By plain structs I mean structs used not only as a minimal wrapper of a single array; sure they can still contain an array as a member.

What you need more is the ability to copy parts of an array and to assign them separately. The memcpy() function serves that purpose. You can use it even with the arrays inside structs, like the ones in this question.

Another way to look at array assignment is through pointers. Sometimes you don’t need to have two distinct chunks of memory, you need just several names for one. In such a scenario, you should use pointers to the memory and thus avoid copying the array. Pointer assignment is fast and simple.

Miscellaneous remarks to the code

• The initializers should have double braces:

  INT_ARR arr2 = {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}};
  

  The outer ones are for the struct, the inner ones for the array.

• In your code, there is an unused int i. I guess it is a relict from testing your code.
• In C, you should use int main(void) instead of int main(). The latter is deprecated syntax and may be removed in future versions of C. In function declarations (not definitions), empty parentheses mean “I don’t say anything about parameters”. Using this instead of explicit void can lead to very unpleasant surprises.
• You should choose more descriptive and preferably English identifiers. Even if you’re not a native English speaker. Thus you enable others to collaborate with you. I edited your question to improve the naming convention.

There is no "one true answer". It depends what you want to do. In fact, you probably won't use this in real programming except for some basic school projects.

As Sam said, you should use memcpy(). The only con I can think of is code performance. Find out more here.