projekt

#include <iostream>
using namespace std;

class macierz
{
      public:
      //zmienne
      unsigned int wiersze;
      unsigned int kolumny;
      double **tablica;        //wskaznik na dynamiczna tablice (macierz)

      //konstruktory i destruktory
      macierz(unsigned int wiersze, unsigned int kolumny); //konstruktor dwuparametrowy
      macierz(); //konstruktor domyslny
      ~macierz() //destruktor
      {
      for( int i = 0; i < wiersze; i++ )
      {delete[]tablica[i];}
      delete[] tablica;
      }

      macierz(macierz const &m); //konstruktor kopiujacy

      //zaprzyjaznione operatory przeciazane
      friend macierz operator+(const macierz &m1, const macierz &m2);
      friend macierz operator-(const macierz &m1, const macierz &m2);
      friend macierz operator*(const macierz &m1, const macierz &m2);
      friend macierz operator*(const macierz &m1, const double skalar);
      //metody
      void Wyswietl()const;
      void WprowadzDane(unsigned int wiersze, unsigned int kolumny);
};

class macierzkwadratowa: public macierz
{ macierzkwadratowa(unsigned int wymiar){wiersze=kolumny=wymiar;};
  ~macierzkwadratowa();
  friend macierzkwadratowa operator+(const macierzkwadratowa &m1, const macierzkwadratowa &m2);
  friend macierzkwadratowa operator-(const macierzkwadratowa &m1, const macierzkwadratowa &m2);
  friend macierzkwadratowa operator*(const macierzkwadratowa &m1, const macierzkwadratowa &m2);
  friend macierzkwadratowa operator*(const macierzkwadratowa &m1, const double skalar);

};

//////////////////////////////////////////////////////////////////////////////////////////////////
void macierz::WprowadzDane (unsigned int wiersze, unsigned int kolumny)
{for ( int i = 0; i < wiersze; i ++ )
      {  for (int j=0; j<kolumny; j++)
          { cout << "Wprowadz [" << i << "]" << "[" << j << "] element macierzy: ";
              double wartosc;
              while(!(cin>>wartosc))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
              {
              cout << "Wprowadz poprawna wartosc: ";
              cin.clear(); //kasowanie flagi błędu strumienia
              cin.sync(); //kasowanie zawartosci bufora obiektu cin
              }
          tablica[i][j] = wartosc;
          }
      }
}
///////////////////////////////////////////////////////////////////////////////
macierz::macierz ()  //domyslnie tworzy macierz 2x2 wypelniona zerami
{
      wiersze=kolumny=2;

      tablica = new double *[wiersze];
      for (int i=0; i<wiersze;i++)
          tablica[i]=new double[kolumny];

      for ( int i = 0; i < wiersze; i ++ )
      {
          cout<<"wiersz "<<i<<": ";
          for (int j=0; j<kolumny; j++)
              tablica[i][j] = 0;

      }
}
////////////////////////////////////////////////////////////////////////////////

macierz::macierz(macierz const &m)  //konstruktor kopiujacy
{
    kolumny = m.kolumny;
    wiersze = m.wiersze;
    tablica = new double *[wiersze];
    for (int i = 0; i < wiersze; i ++ )
        tablica[i] = new double[kolumny];

    for (int i = 0; i < wiersze; i ++ )
        for (int j = 0; j < kolumny; j ++ )
            tablica[i][j] = m.tablica[i][j];
}

///////////////////////////////////////////////////////////////////////////////
macierz::macierz (unsigned int wier, unsigned int kol)  //konstruktor dwuparametrowy
{
      kolumny = kol;
      wiersze = wier;
      double wartosc;
      tablica = new double *[wiersze];
      for (int i=0; i<wiersze;i++)
          tablica[i]=new double[kolumny];
}
///////////////////////////////////////////////////////////////////////////////
void macierz::Wyswietl()const
{
      for ( int i = 0; i < wiersze; i ++ )
      {
          cout<<endl<<"wiersz "<<i<<": \t";
          for (int j=0; j<kolumny; j++)
          {
              cout<<tablica[i][j]<<" ";
          }
      }
      cout<<endl;
}
//////////////////////////////////////////////////////////////////////////////
macierz operator+(const macierz &m1, const macierz &m2)
{

  if (!(m1.wiersze == m2.wiersze && m1.kolumny == m2.kolumny))
     cerr << "Wymiary macierzy nie sa zgodne, nie mozna wykonac dodawania";
  else
  { macierz m3(m1);
      for (int i=0; i<m3.wiersze; i++)
          for (int j=0; j<m3.kolumny; j++)
          {
              m3.tablica[i][j] += m2.tablica[i][j];
          }
          return m3;
  }


}
////////////////////////////////////////////////////////////////////////////////
macierz operator-(const macierz &m1, const macierz &m2)
{

  if (m1.wiersze != m2.wiersze || m1.kolumny != m2.kolumny)
     cerr << "Wymiary macierzy nie sa zgodne, nie mozna wykonac odejmowania";
  else
  { macierz m3(m1);
      for (int i=0; i<m3.wiersze; i++)
          for (int j=0; j<m3.kolumny; j++)
          {
              m3.tablica[i][j] -= m2.tablica[i][j];
          }
          return m3;
  }


}
///////////////////////////////////////////////////////////////////////////////////
macierz operator*(const macierz &m1, const macierz &m2)
{
  if (m1.kolumny != m2.wiersze)
     cerr << "Wymiary macierzy nie sa zgodne, nie mozna wykonac mnozenia";
  else
  {    macierz m3(m1);
       for (int i = 0; i <m1.wiersze; i++)
           {for (int j = 0; j <m2.kolumny; j++)
               {m3.tablica[i][j] = 0;}}

       for(int i = 0; i < m1.wiersze; i++)
               {for(int j = 0; j < m2.kolumny; j++){
                       for(int k = 0; k < m2.wiersze; k++){
       m3.tablica[i][j] = m3.tablica[i][j] + m1.tablica[i][k] * m2.tablica[k][j];}}}
  return m3;
  }
}
//////////////////////////////////////////////////////////////////////////
macierz operator*(const macierz &m1, const double skalar)
{
macierz m2(m1);

       for (int i = 0; i <m1.wiersze; i++)
       for (int j = 0; j <m1.kolumny; j++)
       m2.tablica[i][j] = m1.tablica[i][j]*skalar;
       return m2;
}
//////////////////////////////////////////////////////////////////////
void wyswietlmenu(){
    cout << "Program wykonujacy dzialania na macierzach\n";
    cout << "1.Dodaj macierze\n";
    cout << "2.Odejmij macierze\n";
    cout << "3.Pomnoz macierze (A*B)\n";
    cout << "4.Pomnoz przez skalar\n";
    cout << "5.Transponuj (tylko dla macierzy kwadratowej)\n";
    cout << "6.Wyjscie\n";
    cout << "Wybierz wlasciwa opcje\n";
     };
////////////////////////////////////////////////////////////////////
void obslugabledow (){
     cout << "Wprowadz poprawna wartosc: ";
     cin.clear(); //kasowanie flagi błędu strumienia
     cin.sync(); //kasowanie zawartosci bufora obiektu cin
     }
///////////////////////////////////////////////////////////////////
int main()
{   wyswietlmenu();
    int wybor;
    while(!(cin>>wybor))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
    {obslugabledow();}

    int liczbawierszy;
    int liczbakolumn;

    switch (wybor){

           case 1: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
                   while(!(cin>>liczbawierszy))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
                   while(!(cin>>liczbakolumn))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   macierz A (liczbawierszy,liczbakolumn);
                   A.WprowadzDane (liczbawierszy,liczbakolumn);

                   cout << "Wprowadz liczbe wierszy drugiej macierzy: ";
                   while(!(cin>>liczbawierszy))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}
                   cout << "Wprowadz liczbe kolumn drugiej macierzy: ";
                   while(!(cin>>liczbakolumn))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   macierz B (liczbawierszy,liczbakolumn);
                   B.WprowadzDane (liczbawierszy, liczbakolumn);

                   if (A.wiersze==B.wiersze&&A.kolumny==B.kolumny)
                   {macierz C=A+(B);
                   C.Wyswietl();}
                   else
                   {cerr << "Nie mozna wykonac dzialania\n";}
                   break;}
                   //DODAWANIE

           case 2: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
                   while(!(cin>>liczbawierszy))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
                   while(!(cin>>liczbakolumn))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   macierz A (liczbawierszy,liczbakolumn);
                   A.WprowadzDane(liczbawierszy, liczbakolumn);


                   cout << "Wprowadz liczbe wierszy drugiej macierzy: ";
                   while(!(cin>>liczbawierszy))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}


                   cout << "Wprowadz liczbe kolumn drugiej macierzy: ";
                   while(!(cin>>liczbakolumn))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   macierz B (liczbawierszy,liczbakolumn);
                   B.WprowadzDane(liczbawierszy, liczbakolumn);
                   if (A.wiersze==B.wiersze&&A.kolumny==B.kolumny)
                   {macierz C=A-(B);
                   C.Wyswietl();}
                   else
                   {cerr << "Nie mozna wykonac dzialania\n";}
                   break;}//ODEJMOWANIE

           case 3: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
                   while(!(cin>>liczbawierszy))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
                   while(!(cin>>liczbakolumn))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   macierz A (liczbawierszy,liczbakolumn);
                   A.WprowadzDane(liczbawierszy, liczbakolumn);

                   cout << "Wprowadz liczbe wierszy drugiej macierzy: ";
                   while(!(cin>>liczbawierszy))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   cout << "Wprowadz liczbe kolumn drugiej macierzy: ";
                   while(!(cin>>liczbakolumn))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   macierz B (liczbawierszy,liczbakolumn);
                   B.WprowadzDane(liczbawierszy, liczbakolumn);

                   if (A.kolumny == B.wiersze)
                   {macierz C=A*(B);
                   C.Wyswietl();}
                   else
                   cerr << "Nie mozna wykonac dzialania\n";
                   break;} //MNOZENIE

           case 4: {cout << "Wprowadz liczbe wierszy pierwszej macierzy: ";
                   while(!(cin>>liczbawierszy))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   cout << "Wprowadz liczbe kolumn pierwszej macierzy: ";
                   while(!(cin>>liczbakolumn))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}

                   macierz A (liczbawierszy,liczbakolumn);
                   A.WprowadzDane(liczbawierszy, liczbakolumn);
                   cout << "Wprowadz skalar: ";
                   double skalar;

                   while(!(cin>>skalar))//wykonuje sie dopoki uzytkownik bedzie wprowadzal bledne dane
                   {obslugabledow();}
                   macierz C=A*(skalar);
                   C.Wyswietl();
                   break;}
                ; //MNOZENIE PRZEZ SKALAR
           case 5:break; //TRANSPONOWANIE
           case 6: cout << "Koniec programu!\n";

                break; //WYJSCIE
           default:break  ;

           };

    system ("PAUSE");
    return 0;
}