Assigning an array to an array

[MACE]

Could someone explain to me why we can not assign an array of type char to an array of char?

An example to be clear:

#include <iostream>
using namespace std;
int main ()
{
    char word[25];
    char copyword[25];
    cin >> word;
    word = copyword;
    cout << copyword;
}

the above code gives me this error:

In function `int main()':|error: ISO C++ forbids assignment of arrays|
||=== Build finished: 1 errors, 0 warnings ===|

Another example:

#include <iostream>
using namespace std;
int main ()
{
    char matrix [20][20];
    char word[25];
    cin >> word;
    for (int i = 0; word[i] != '\0'; i++)
    {
        matrix [i] = word;
    }
}

I do not understand why we can not do that. Can someone explain it to me?

[!const]

For compatibility with C++ for which that can be compatible with earlier language that had a model of different picture.

That's why things like boost::array is not bad because it gives a true semantics of first order in C++ array. It is safer to use boost::array then a plain array, because it is not a pointer in disguise. It is much faster than normal array.

[MACE]

Can you to explain me what is "boost:: array"? How is it used? What can do what? An example would be more than enough to understand the concept of boost:: array.

Header <boost/array.hpp> consists of the below code:

namespace boost {
  template<typename T, std::size_t N> class array;
  template<typename T, std::size_t N> void swap(array<T, N>&, array<T, N>&);
  template<typename T, std::size_t N> 
    bool operator==(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N> 
    bool operator!=(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N> 
    bool operator<(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N> 
    bool operator>(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N> 
    bool operator<=(const array<T, N>&, const array<T, N>&);
  template<typename T, std::size_t N> 
    bool operator>=(const array<T, N>&, const array<T, N>&);
}

[!const]

boost:: array template is a class that behaves exactly like an array in terms of behavior and performance but also gives him a real semantic value (copy, placement, etc.).

Usage example:

#include <boost/array.hpp>

int main()
{
  const int size = 5;
  boost::array<double,size> arr;
  for (int p=0; p!=size+1; ++p) arr.at(p)=p; //Checks range
  for (int i=0; i!=size+1; ++i) arr[i]=i; //Does not check range
  return 0;
}