Requisito previo: sobrecarga de operadores
Dadas dos arrays mat1[][] y mat2[][] de NxN dimensiones, la tarea es realizar operaciones de array utilizando la sobrecarga de operadores .
Ejemplos:
Entrada: arr1[][] = { {1, 2, 3}, {4, 5, 6}, {1, 2, 3}}, arr2[][] = { {1, 2, 3}, { 4, 5, 16}, {1, 2, 3}}
Salida: La
suma de dos Arrays dadas es:
2 4 6
8 10 22
2 4 6
La resta de dos Arrays dadas es:
0 0 0
0 0 -10
0 0 0
La multiplicación de dos Arrays dadas es:
12 18 44
30 45 110
12 18 44
Entrada: arr1[][] = { {11, 2, 3}, {4, 5, 0}, {1, 12, 3}}, arr2[][] = { {1, 2, 3}, {41, 5, 16}, {1, 22, 3}}
Salida: La
suma de dos Arrays dadas es:
12 4 6
45 10 16
2 34 6
Resta de dos Arrays dadas es :
10 0 0
-37 0 -16
0 -10 0
La multiplicación de dos Arrays dadas es:
96 98 74
209 33 92
496 128 204
Enfoque:
Para sobrecargar los operadores + , – , * , crearemos una clase llamada array y luego haremos una función pública para sobrecargar los operadores.
- Para sobrecargar el operador ‘+’ use el prototipo:
Return_Type classname :: operator +(Argument list)
{
// Function Body
}
- Por ejemplo:
Sean dos arrays M1[][] y M2[][] de las mismas dimensiones. Usando la sobrecarga de operadores M1[][] y M2[][] se pueden agregar como M1 + M2 .
En la sentencia anterior, M1 se trata como hai global y M2[][] se pasa como argumento a la función “void Matrix::operator+(Matrix x) “.
En la función sobrecargada anterior, el enfoque para la suma de dos arrays se implementa tratando M1[][] como la primera y M2[][] como la segunda array, es decir, la array x (como argumentos).
- Para sobrecargar el operador ‘-‘ use prototipo:
Return_Type classname :: operator -(Argument list)
{
// Function Body
}
- Por ejemplo:
Sean dos arrays M1[][] y M2[][] de las mismas dimensiones. Usando la sobrecarga del operador M1[][] y M2[][] se pueden agregar como M1 – M2
En la declaración anterior, M1 se trata como hai global y M2[][] se pasa como argumento a la función “void Matrix::operator-(Matrix x) “.
En la función sobrecargada anterior, el enfoque para la resta de dos arrays se implementa tratando M1[][] como la primera y M2[][] como la segunda array, es decir, la array x (como argumentos).
- Para sobrecargar el operador ‘*’ use el prototipo:
Return_Type classname :: operator *(Argument list)
{
// Function Body
}
Sean dos arrays M1[][] y M2[][] de las mismas dimensiones. Usando la sobrecarga de operadores M1[][] y M2[][] se pueden agregar como M1 * M2 .
En la declaración anterior, M1 se trata como hai global y M2[][] se pasa como argumento a la función “void Matrix::operator*(Matrix x) “.
En la función sobrecargada anterior, el enfoque para la multiplicación de dos arrays se implementa tratando M1[][] como la primera y M2[][] como la segunda array, es decir, la array x (como argumentos).
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ program for the above approach
#include "bits/stdc++.h"
#define rows 50
#define cols 50
using namespace std;
int N;
// Class for Matrix operator overloading
class Matrix {
// For input Matrix
int arr[rows][cols];
public:
// Function to take input to arr[][]
void input(vector<vector<int> >& A);
void display();
// Functions for operator overloading
void operator+(Matrix x);
void operator-(Matrix x);
void operator*(Matrix x);
};
// Functions to get input to Matrix
// array arr[][]
void Matrix::input(vector<vector<int> >& A)
{
// Traverse the vector A[][]
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
arr[i][j] = A[i][j];
}
}
}
// Function to display the element
// of Matrix
void Matrix::display()
{
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Print the element
cout << arr[i][j] << ' ';
}
cout << endl;
}
}
// Function for addition of two Matrix
// using operator overloading
void Matrix::operator+(Matrix x)
{
// To store the sum of Matrices
int mat[N][N];
// Traverse the Matrix x
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Add the corresponding
// blocks of Matrices
mat[i][j] = arr[i][j]
+ x.arr[i][j];
}
}
// Display the sum of Matrices
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Print the element
cout << mat[i][j] << ' ';
}
cout << endl;
}
}
// Function for subtraction of two Matrix
// using operator overloading
void Matrix::operator-(Matrix x)
{
// To store the difference of Matrices
int mat[N][N];
// Traverse the Matrix x
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Subtract the corresponding
// blocks of Matrices
mat[i][j] = arr[i][j]
- x.arr[i][j];
}
}
// Display the difference of Matrices
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Print the element
cout << mat[i][j] << ' ';
}
cout << endl;
}
}
// Function for multiplication of
// two Matrix using operator
// overloading
void Matrix::operator*(Matrix x)
{
// To store the multiplication
// of Matrices
int mat[N][N];
// Traverse the Matrix x
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Initialise current block
// with value zero
mat[i][j] = 0;
for (int k = 0; k < N; k++) {
mat[i][j] += arr[i][k]
* (x.arr[k][j]);
}
}
}
// Display the multiplication
// of Matrices
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
// Print the element
cout << mat[i][j] << ' ';
}
cout << endl;
}
}
// Driver Code
int main()
{
// Dimension of Matrix
N = 3;
vector<vector<int> > arr1
= { { 1, 2, 3 },
{ 4, 5, 6 },
{ 1, 2, 3 } };
vector<vector<int> > arr2
= { { 1, 2, 3 },
{ 4, 5, 16 },
{ 1, 2, 3 } };
// Declare Matrices
Matrix mat1, mat2;
// Take Input to matrix mat1
mat1.input(arr1);
// Take Input to matrix mat2
mat2.input(arr2);
// For addition of matrix
cout << "Addition of two given"
<< " Matrices is : \n";
mat1 + mat2;
// For subtraction of matrix
cout << "Subtraction of two given"
<< " Matrices is : \n";
mat1 - mat2;
// For multiplication of matrix
cout << "Multiplication of two"
<< " given Matrices is : \n";
mat1* mat2;
return 0;
}
Addition of two given Arrays is : 2 4 6 8 10 22 2 4 6 Subtraction of two given Arrays is : 0 0 0 0 0 -10 0 0 0 Multiplication of two given Arrays is : 12 18 44 30 45 110 12 18 44
Publicación traducida automáticamente
Artículo escrito por deepakverma8a y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA