Agfdhyk

I have a slight problem. I have a Matrix class defined as follows (in row-major form):

template<typename T>

class Matrix {

    // must be inline

    friend std::ostream &operator<<(std::ostream &lhs, const Matrix &rhs) {

        std::size_t maxlen;

        std::max_element(rhs._data.begin(), rhs._data.end(),

            [&maxlen](auto &a1, auto &a2) {

                std::ostringstream temp;

                temp << a1; 

                std::size_t len1 = temp.str().size();

                temp.str("");

                temp << a2; 

                maxlen = (len1 < (temp.str().size()) ? temp.str().size() : len1);

                return (len1 < (temp.str().size()));

             });

        for (std::size_t i = 0; i < rhs._m; i++) {

            for (std::size_t j = 0; j < rhs._n; j++)

                lhs << std::setw(maxlen) << rhs[i][j] << ' ';

            lhs << std::endl;

        }

        return lhs;

    }   



    private:

        class RowVector {

            private:

                T *_vec;

                std::size_t _l; 



            public:

                RowVector(T *vec, std::size_t l); 



                const T &operator(std::size_t index) const;

                T &operator(std::size_t index);



                operator std::vector<T>() const;

        };



        std::vector<T> _data;

        std::size_t _m; 

        std::size_t _n; 



    public:

        Matrix(std::size_t m, size_t n, const T &elem = T());



        const RowVector operator(std::size_t index) const;

        RowVector operator(std::size_t index);



        std::size_t getm() const;

        std::size_t getn() const;

        void fill(const T &elem);

        void fillRow(std::size_t index, const T &elem);

        void fillCol(std::size_t index, const T &elem);



        Matrix &transpose(unsigned int i = 1);



        const std::vector<T> &data() const;

};

and wish to overload two RowVector operators=

typename Matrix<T>::RowVector &operator=(const std::vector<T> &vec);

typename Matrix<T>::RowVector &operator=(const Matrix<T> &mat);

so I can return a RowVector & using A[0] and reassign its value using either a vector or a matrix. Keep in mind that I (presumably) can ignore the rule of three because I provide no explicit way for the client to construct a RowVector object.

However, in attempting to write the function bodies for the overloads, I have come across a problem: that

(1) I cannot copy-construct a vector/Matrix object that will persist outside of the operator='s scope so that I can assign its data() to _vec and its size() to _l.

(2) I cannot directly modify _data since it is not a static variable; even if I could, I have no way to discover the index so I can overwrite the relevant region of memory in the enclosing Matrix object.

Do you know of any way in which this can be done? These would be two very useful assets for my class.

Edit: To make it more clear, I would like to be able to write something like this:

Matrix<int> A(3, 4);

std::vector<int> v {1, 2, 3, 4};

Matrix<int> row(1, 4, 3);

// *****************

A[0] = v;

A[1] = row;

// *****************

(Hopefully my variable names are self-explanatory)
I think my prototypes are correct, but I just can't find a way to do this.

Thanks!