How to implement a copy constructor for a two-dimensional array in C ++?

Here's a tried and tested solution that can take advantage of all the power of C ++ operator overhead:

Matriz.h

#ifndef MATRIZ_H
#define MATRIZ_H

#include <iostream>

class Matriz
{
    public:
        Matriz(unsigned int nL, unsigned int nC);
        virtual ~Matriz(void);
        Matriz( const Matriz &ptr );
        Matriz& operator=( const Matriz &ptr );

        Matriz& operator+=(const Matriz &ptr );
        const Matriz operator+(const Matriz &ptr) const;
        Matriz& operator-=(const Matriz &ptr);
        const Matriz operator-(const Matriz &ptr) const;
        const Matriz operator*(const Matriz &ptr) const;

        friend std::ostream &operator<<( std::ostream &out, const Matriz& obj );
        friend std::istream &operator>>( std::istream &in, Matriz &obj );

    protected:
        unsigned int nLinhas;
        unsigned int nColunas;
        int** matrix;

    private:
        void inicializar( unsigned int nL, unsigned int nC, int ** m = 0 );
        void finalizar(void);
};

#endif

Matriz.cpp

#include <iostream>
#include <cstring>

#include "Matriz.h"

Matriz::Matriz(unsigned int nL, unsigned int nC){
    this->inicializar( nL, nC );
}

Matriz::~Matriz(void){
    this->finalizar();
}

void Matriz::inicializar( unsigned int nL, unsigned int nC, int ** m ){
    this->matrix = new int*[nL];
    for( unsigned int i = 0; i < nL; ++i ){
        this->matrix[i] = new int[nC];
        if(!m)
            std::memset( this->matrix[i], 0, sizeof(int) * nC );
        else
            std::memcpy( this->matrix[i], m[i], sizeof(int) * nC );
    }
    this->nLinhas = nL;
    this->nColunas = nC;
}

void Matriz::finalizar(void){
    for(unsigned int i = 0; i < this->nLinhas; ++i)
        delete [] this->matrix[i];
    delete [] this->matrix;
}


Matriz::Matriz( const Matriz &ref ){
    this->inicializar( ref.nLinhas, ref.nColunas, ref.matrix );
}

Matriz& Matriz::operator=( const Matriz &ref ){
    for (unsigned int i = 0; i < ref.nLinhas; ++i)
        std::memcpy( this->matrix[i], ref.matrix[i], sizeof(int) * ref.nColunas );
    return *this;
}

Matriz& Matriz::operator+=(const Matriz &ptr){

    for(unsigned int i = 0; i < this->nLinhas; i++)
        for(unsigned int j = 0; j < this->nColunas; j++)
            this->matrix[i][j] += ptr.matrix[i][j];
    return *this;
}

const Matriz Matriz::operator+(const Matriz &ptr) const {
    Matriz m(*this);
    m += ptr;
    return m;
}

Matriz& Matriz::operator-=(const Matriz &ptr) {
    for(unsigned int i = 0; i < this->nLinhas; i++)
        for(unsigned int j = 0; j < this->nColunas; j++)
            this->matrix[i][j] = this->matrix[i][j] - ptr.matrix[i][j];
    return *this;
}

const Matriz Matriz::operator-(const Matriz &ptr) const {
    Matriz m(*this);
    m -= ptr;
    return m;
}

const Matriz Matriz::operator*(const Matriz &ptr) const {
    Matriz m(*this);
    for(unsigned i = 0; i < this->nLinhas; i++)
        for(unsigned j = 0; j < ptr.nColunas; j++)
                m.matrix[i][j] = this->matrix[i][j] * ptr.matrix[i][j];
    return m;
}


std::ostream &operator<<( std::ostream &out, const Matriz &ref ){
    for(unsigned int i = 0; i < ref.nLinhas; i++) {
        for(unsigned int j = 0; j < ref.nColunas; j++)
            out << ref.matrix[i][j] << "\t";
        out << std::endl;
    }
    return out;
}

std::istream &operator>>( std::istream &in, Matriz &ref ){
    for(unsigned int i = 0; i < ref.nLinhas; i++)
        for(unsigned int j = 0; j < ref.nColunas; j++)
        {
            std::cout << "(" << i << "," << j << "): ";
            in >> ref.matrix[i][j];
        }
    return in;
}

main.cpp

#include <iostream>
#include "Matriz.h"

using namespace std;

int main( void )
{
    Matriz m1(2, 2);
    Matriz m2(2, 2);

    cin >> m1;
    cin >> m2;

    cout << "Matriz 1:" << endl;
    cout << m1;

    cout << "Matriz 2:" << endl;
    cout << m2;

    cout << "A soma é: " << endl;
    cout << m1 + m2;

    cout << "A subtração é: " << endl;
    cout << m1 - m2;

    cout << "A multiplicação é: " << endl;
    cout << m1 * m2;

    cout << "m2 = m1:" << endl;
    m2 = m1;
    cout << m2;

    cout << "m1 += m2:" << endl;
    m1 += m2;
    cout << m1;

    cout << "m1 -= m2:" << endl;
    m1 -= m2;
    cout << m1;

    return 0;
}

Test:

./matriz 
(0,0): 2
(0,1): 4
(1,0): 6
(1,1): 8
(0,0): 1
(0,1): 3
(1,0): 5
(1,1): 7
Matriz 1:
2   4   
6   8   
Matriz 2:
1   3   
5   7   
A soma é: 
3   7   
11  15  
A subtração é: 
1   1   
1   1   
A multiplicação é: 
2   12  
30  56  
m2 = m1:
2   4   
6   8   
m1 += m2:
4   8   
12  16  
m1 -= m2:
2   4   
6   8