Tucancitto

Pb04. Matrice

Apr 15th, 2021
402
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. ///Matrice.h
  2. #pragma once
  3. #include <iostream>
  4. using namespace std;
  5.  
  6. class Matrice
  7. {
  8. private:
  9.     int nrLinii = 0, nrColoane = 0;
  10.     float** elemente = nullptr;
  11. public:
  12.     float** alocare(int, int);
  13.  
  14.     Matrice(int);
  15.     Matrice(int, int);
  16.  
  17.     Matrice(const Matrice&);
  18.     ~Matrice();
  19.  
  20.     void setLinii(int);
  21.     void setColoane(int);
  22.  
  23.     int getLinii();
  24.     int getColoane();
  25.     float** getElemente();
  26.  
  27.     friend istream& operator >>(istream&, Matrice&);
  28.     friend ostream& operator <<(ostream&, Matrice);
  29.  
  30.     Matrice& operator =(const Matrice&);
  31.     float* operator[](int indexLinie) throw (out_of_range)
  32.     {
  33.         if (indexLinie < 0 or indexLinie >= nrLinii)
  34.             throw out_of_range("Index in afara limitelor");
  35.  
  36.         return elemente[indexLinie];
  37.     }
  38.  
  39.     Matrice operator +(Matrice);
  40.     Matrice operator -(Matrice);
  41.     Matrice operator *(Matrice);
  42.     Matrice operator *(float scalar);
  43.  
  44.     int getValueAt(int indexLinie, int indexColoana) throw (out_of_range, string)
  45.     {
  46.         if (indexLinie < 0 or indexLinie >= nrLinii or indexColoana < 0 or indexColoana >= nrColoane)
  47.             throw out_of_range("Indicii in afara limitelor");
  48.         //string s = "Indicii in afara limitelor";
  49.         //throw s;
  50.  
  51.         return elemente[indexLinie][indexColoana];
  52.     }
  53. };
  54.  
  55. //Matrice.cpp
  56. #include "Matrice.h"
  57. using namespace std;
  58.  
  59. float** Matrice::alocare(int nrLinii, int nrColoane)
  60. {
  61.     float** matrice = new float* [nrLinii];
  62.     for (int i = 0; i < nrLinii; ++i)
  63.         matrice[i] = new float[nrColoane] {};
  64.     return matrice;
  65. }
  66.  
  67. Matrice::Matrice(int nrLinii, int nrColoane)
  68. {
  69.     this->nrLinii = nrLinii;
  70.     this->nrColoane = nrColoane;
  71.     elemente = alocare(nrLinii, nrColoane);
  72. }
  73.  
  74. Matrice::Matrice(int dim) : Matrice(dim, dim)
  75. {}
  76.  
  77. /*
  78. Matrice::Matrice(int dim)
  79. {
  80.     nrLinii = dim, nrColoane = dim;
  81.     elemente = alocare(dim, dim);
  82. }
  83. */
  84.  
  85. Matrice::Matrice(const Matrice& M)
  86. {
  87.     nrLinii = M.nrLinii;
  88.     nrColoane = M.nrColoane;
  89.     elemente = alocare(nrLinii, nrColoane);
  90.  
  91.     for (int i = 0; i < nrLinii; ++i)
  92.         for (int j = 0; j < nrColoane; ++j)
  93.             elemente[i][j] = M.elemente[i][j];
  94.  
  95.     cout << "Apel al constructorului de copiere. \n";
  96. }
  97.  
  98. Matrice::~Matrice()
  99. {
  100.     for (int i = 0; i < nrLinii; ++i)
  101.         delete[] elemente[i];
  102.     delete[]elemente;
  103. }
  104.  
  105. void Matrice::setLinii(int nrLiniiNou)
  106. {
  107.     nrLinii = nrLiniiNou;
  108. }
  109.  
  110. void Matrice::setColoane(int nrColoaneNou)
  111. {
  112.     nrColoane = nrColoaneNou;
  113. }
  114.  
  115. int Matrice::getLinii()
  116. {
  117.     return nrLinii;
  118. }
  119.  
  120. int Matrice::getColoane()
  121. {
  122.     return nrColoane;
  123. }
  124.  
  125. float** Matrice::getElemente()
  126. {
  127.     return elemente;
  128. }
  129.  
  130. Matrice& Matrice::operator =(const Matrice& M)
  131. {
  132.     if (this != &M) // daca obiectele sunt diferite
  133.     {
  134.         if (nrLinii != M.nrLinii or nrColoane != M.nrColoane)
  135.         {
  136.             this->~Matrice(); // facem dealocare
  137.             nrLinii = M.nrLinii;
  138.             nrColoane = M.nrColoane;
  139.             elemente = alocare(nrLinii, nrColoane);
  140.         }
  141.  
  142.         for (int i = 0; i < nrLinii; ++i)
  143.             for (int j = 0; j < nrColoane; ++j)
  144.                 elemente[i][j] = M.elemente[i][j];
  145.     }
  146.  
  147.     return *this;
  148. }
  149.  
  150. Matrice Matrice::operator+(Matrice M)
  151. {
  152.     Matrice Suma(M.nrLinii, M.nrColoane);
  153.  
  154.     for (int i = 0; i < M.nrLinii; ++i)
  155.         for (int j = 0; j < M.nrColoane; ++j)
  156.             Suma.elemente[i][j] = elemente[i][j] + M.elemente[i][j];
  157.  
  158.     return Suma;
  159. }
  160.  
  161. Matrice Matrice::operator-(Matrice M)
  162. {
  163.     Matrice Diferenta(M.nrLinii, M.nrColoane);
  164.  
  165.     for (int i = 0; i < M.nrLinii; ++i)
  166.         for (int j = 0; j < M.nrColoane; ++j)
  167.             Diferenta.elemente[i][j] = elemente[i][j] - M.elemente[i][j];
  168.  
  169.     return Diferenta;
  170. }
  171.  
  172. Matrice Matrice::operator*(Matrice M)
  173. {
  174.     Matrice Produs(nrLinii, M.nrColoane);
  175.  
  176.     for (int i = 0; i < nrLinii; ++i)
  177.         for (int j = 0; j < M.nrColoane; ++j)
  178.             for (int k = 0; k < nrColoane; ++k)
  179.                 Produs.elemente[i][j] += elemente[i][k] * M.elemente[k][j];
  180.  
  181.     return Produs;
  182. }
  183.  
  184. Matrice Matrice::operator*(float scalar)
  185. {
  186.     Matrice Produs(nrLinii, nrColoane);
  187.     for (int i = 0; i < nrLinii; ++i)
  188.         for (int j = 0; j < nrColoane; ++j)
  189.             Produs.elemente[i][j] = elemente[i][j] * scalar;
  190.  
  191.     return Produs;
  192. }
  193.  
  194. istream& operator>>(istream& in, Matrice& M)
  195. {
  196.     for (int i = 0; i < M.nrLinii; ++i)
  197.         for (int j = 0; j < M.nrColoane; ++j)
  198.             in >> M.elemente[i][j];
  199.     return in;
  200. }
  201.  
  202. ostream& operator<<(ostream& out, Matrice M)
  203. {
  204.     for (int i = 0; i < M.nrLinii; ++i, out << endl)
  205.         for (int j = 0; j < M.nrColoane; ++j)
  206.             out << M.elemente[i][j] << ' ';
  207.     return out;
  208. }
  209.  
  210. int main()
  211. {
  212.     try
  213.     {
  214.         Matrice A(3);
  215.         cin >> A;
  216.         cout << A.getValueAt(0, 0) << endl;
  217.         cout << A[2][2];
  218.     }
  219.     catch (out_of_range& e)
  220.     {
  221.         cout << "Eroare de tipul: " << e.what();
  222.     }
  223.  
  224.     /*
  225.     catch (string s)
  226.     {
  227.         cout << "Eroare de tipul: " << s;
  228.     }
  229.     */
  230.  
  231.     return 0;
  232. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×