[개탱][C][C++][2차원배열][operator overloading][행렬]

 

http://gaetaeng.tistory.com/16

[행렬의 합, 행렬의 곱 등등.. Dynamic allocation 으로 만든 행렬]

 

 

따로 뺄셈, 곱셈 등등의 산술연산 식들은 이전에 만들었던

위의 링크와 양식이 같기 때문에 따로 작성하지 않겠습니다!

 

 

------------------------------------------------------------------------------------------

 

Operator overloading

( 새로 우리가 만든 type(class . . )에 대하여 cin, cout 을 통한 I/O가 불가능 하기때문에

operator overloading 을 통하여 cin, cout 에 대한 I/O가 가능하게 만들어 준다.

또한 + - * / 등등의 산술연산 에 대하여도 만들어 줄수있다 )

 

 

2차원 배열의 

Dynamic Allocation 

 

함수에 대한

(class) member function

total function

#include <iostream>
 
using namespace std;
 
class Matrix
{
    int** mp_ptr; 
    int m_iRow;
    int m_iCol;
public:
    Matrix(int row, int col);
    Matrix(Matrix& m);
    ~Matrix(){
        if(mp_ptr != NULL) {
            for(int i = 0; i < m_iRow; i++) delete []mp_ptr[i];
            delete []mp_ptr;
        }
    }
 
    void set(int i, int j, int x);
    //행렬의 덧셈
    Matrix add(Matrix& m) 
    {
        Matrix tmp(m_iRow, m_iCol);
        for(int i = 0; i < m_iRow; i++) {
            for(int j = 0; j < m_iCol; j++) {
                tmp.mp_ptr[i][j] = mp_ptr[i][j] + m.mp_ptr[i][j];
            }
        }
        return Matrix(tmp);
    }
    //////////////////////////
    Matrix& operator=(Matrix& m){
        m_iRow = m.m_iRow;
        m_iCol = m.m_iCol;
        mp_ptr = new int*[m_iRow];
        for(int i = 0; i < m_iRow; i++)
        {
            mp_ptr[i] = new int[m_iCol];
            for(int j = 0; j < m_iCol; j++)
            {
                mp_ptr[i][j] = m.mp_ptr[i][j];
            }
        }
        return *this;
    }
 
    Matrix operator+(Matrix& m) {
        Matrix tmp(m_iRow, m_iCol);
        for(int i = 0; i < m_iRow; i++) {
            for(int j = 0; j < m_iCol; j++) {
                tmp.mp_ptr[i][j] = mp_ptr[i][j] + m.mp_ptr[i][j];
            }
        }
        return Matrix(tmp);
    }
    friend ostream& operator<<(ostream& o, Matrix& m);
    friend istream& operator>>(istream& ins, Matrix& m);
    friend Matrix add(Matrix& m1, Matrix& m2);
};
Matrix::Matrix(Matrix& m)
{
    m_iRow = m.m_iRow;
    m_iCol = m.m_iCol;
    mp_ptr = new int*[m_iRow];
    for(int i = 0; i < m_iRow; i++)
    {
        mp_ptr[i] = new int[m_iCol];
        for(int j = 0; j < m_iCol; j++)
        {
            mp_ptr[i][j] = m.mp_ptr[i][j];
        }
    }
}
Matrix::Matrix(int row, int col) // 2차원 배열 Dynamic Allocation 방식으로 만들어주는 생성자
{
    m_iRow = row;
    m_iCol = col;
    mp_ptr = new int*[row];
    for(int i = 0; i < row; i++)
    {
        mp_ptr[i] = new int[col];
        for(int j = 0; j < col; j++)
        {
            mp_ptr[i][j] = 0;
        }
    }
}
 
Matrix add(Matrix& m1, Matrix &m2)
{
    Matrix tmp(m1.m_iRow,m1. m_iCol);
        for(int i = 0; i < m1.m_iRow; i++) {
            for(int j = 0; j <m1.m_iCol; j++) {
                tmp.mp_ptr[i][j] =m1.mp_ptr[i][j] + m2.mp_ptr[i][j];
            }
        }
        return Matrix(tmp);
}
 
ostream& operator<<(ostream& o, Matrix& m) // operator overloading 
{ // http://blog.naver.com/nuckly/221134548594
    for(int i = 0; i < m.m_iRow; i++)
    {
        for(int j = 0; j < m.m_iCol; j++)
        {
            o << m.mp_ptr[i][j] << "\t";
        }
        o << endl;
    }
    return o;
}
 
istream& operator>>(istream& ins, Matrix& m)
{
    int row = m.m_iRow;
    int col = m.m_iCol;
    int **p = m.mp_ptr;
 
    for(int i = 0; i < row; i++) {
        for(int j = 0; j < col; j++) {
            int x;
            cout << "data[" << i << "][" << j << "] = ";
            ins >> x;
            p[i][j] = x;
        }
    }
    return ins;
}
 
void Matrix::set(int i, int j, int x)
{
    mp_ptr[i][j] = x;
}
 
void main()
{
    Matrix A(2,3);
    Matrix B(2,3);
    Matrix C(2,3);
    Matrix D(5,3);
 
    D = C;
/*
    A.set(0, 0, 10);
    A.set(0, 1, 12);
    A.set(0, 2, 21);
    A.set(1, 0, 11);
    A.set(1, 1, 43);
    A.set(1, 2, 13);
    B.set(0, 0, 3);
    B.set(0, 1, 35);
    B.set(0, 2, 654);
    B.set(1, 0, 45);
    B.set(1, 1, 76);
    B.set(1, 2, 478);
    */
 
    cin >> A;            
    cin >> B;            
    // operator overloading 방식으로 만들어낸 입력 양식
    // Matrix 는 사용자 정의 class(type)이기 때문에 cout 기본 신택스에는 현재 존재하지 않는 입력 타입이다
    // 그렇기 때문에 operator overloading 방식으로 따로 만들어 주어야한다.                    
 
 
    cout << A << endl;; 
    cout << B << endl;; 
    // operator overloading 방식으로 만들어낸 출력 양식
    // Matrix 는 사용자 정의 class(type)이기 때문에 cout 기본 신택스에는 현재 존재하지 않는 출력 타입이다
    // 그렇기 때문에 operator overloading 방식으로 따로 만들어 주어야한다.
 
 
 
 
    /////////////////////////////////////////////////////////////////
    
    //C = A.add(B); // member function 방식으로 짜는 add 함수
    //C = add(A,B); // total function전역 함수 방식으로 짜는 add 함수
    C = A + B;    // Operator overloading 방식으로 짜는 add 함수
 
    cout << C << endl;
}