我无法为二维数组赋值

Question

So this is my first attempt to write a program using classes in c++. As an exercise, I'm trying to create a 2d-array class that can do certain things. This is a part of the code in the main.cpp that my class has to be able to run.

int main()
{
    array2d<double> ar(2,2);

    ar(1,1) = 1; 
    ar(0,0) = 2;
    ar(0,1) = 3;
    ar(1,0) = 4;

    auto X{ar};

    array2d<double> c(2,2);
    c = ar;
    c.diagonal(1) = 5; //c(1,1) = 5 
}

And this is my code. I'm getting an error in the diagonal function "error: lvalue required as left operand of assignment". I can't figure out what I should do. The purpose of this function is to assign values in the diagonal elements of the array.

template<typename T>
class array2d
{
private:
    int n,m;
    vector<T> vec;

public:
    array2d(int M, int N)
    : n{N}, m{M}
    {
        vector<T> vec1(n*m);
        vec = vec1;
    }

    array2d(array2d<T> &arr)
    : n{arr.N()} , m{arr.M()}
    {
        vec = arr.V();
    }

    array2d &operator=(array2d<T>  & arr){
        vec = arr.V();
        return *this;
    }

    T &operator()(int i,int j)
    {
        auto it = vec.begin();
        it += i*n+j;
        return *it;
    }  

    T diagonal(int a)
    {
        auto x= *this;
        return x(a,a);
    }

    int M (){return m;}
    int N (){return n;}
    vector<T> V(){return vec;}
};

Edit: I have another problem. Next thing my class should be able to run is this ar = X.transpose(); But I'm getting 2 errors:

error: invalid initialization of non-const reference of type 'array2d&' from an rvalue of type 'array2d' AND

note: initializing argument 1 of 'array2d array2d::operator=(array2d&) [with T = double]'|

My function is this.

array2d<T> transpose  ()
    {
        auto &y = *this ;

        array2d<T> x(y.N(),y.M()) ;

        for (int i{0};i<x.d1();i++){
            for (int j{0}; j<x.d2();j++){
                x(i,j) = y(j,i);
            }
        };

        return x;
    }

Answer 1

I made miscellaneous changes and have commented in the code:

// bad practice:
// using namespace std;

template<typename T>
class array2d {
private:
    // use an unsigned int for dimensions
    unsigned m, n;
    std::vector<T> vec;

public:
    // initialize the vector in the member initializer list too:
    array2d(unsigned M, unsigned N) : m{M}, n{N}, vec(m * n)
    {}

    // arr should be a const&:
    array2d(const array2d<T>& arr) : m{arr.m}, n{arr.n}, vec(arr.vec)
    {}

    // arr should be a const&:
    array2d& operator=(const array2d<T>& arr) {
        vec = arr.vec;
        // n and m should also be copied:
        m = arr.m;
        n = arr.n;
        return *this;
    }

    T& operator()(unsigned i, unsigned j) {
        // unnecessary iterator arithmetic replaced
        return vec[i * n + j];
    }

    // a const version to be used in const contexts:
    const T& operator()(unsigned i, unsigned j) const {
        return vec[i * n + j];
    }

    // You should return a T& and it should be a reference to
    // a T inside vec, not to a copy that will become invalid as soon as the function
    // returns.
    T& diagonal(unsigned a) {
        return (*this)(a, a);
    }

    // this function should be const since you are not supposed to change "this"
    array2d<T> transpose() const {
        // y is just confusing
        // auto& y = *this;

        // Use your member variables (or call the functions M() and N()) directly.
        array2d<T> x(n, m);

        // d1() and d2() doesn't exist in the code you've shown, but they are not
        // needed:
        for(unsigned i = 0; i < x.m; i++) {
            for(unsigned j = 0; j < x.n; j++) {
                x(i, j) = (*this)(j, i);
            }
        }

        return x;
    }

    unsigned M() { return m; }
    unsigned N() { return n; }
    std::vector<T> V() { return vec; }
};