Przesyłanie danych między klasami

Odpowiedz Nowy wątek
sypako
2009-04-10 21:52
sypako
0

mam klasę:

klasy.h

class vec_par
      {
      public:
      string name[3];
      int st[3];
      int ip;
      vec_par() {ip=0;};
      void dodaj(string name1, int st1);
      string zwroc_name(int i);
      };          

// #################################\\\

class vec_trio
      {
      public:
      int wspolczynnik[5];
      vec_par para[5];
      int it;
      vec_trio()  { it=-1;};
      void dodaj(int wsp1 , vec_par para1);
      };

class zmienna
      {
      private:
        string nazwa;
        float wartosc;
      public:
        zmienna(string name);               // konstruktor przepisujący nazwę zmiennej
        zmienna(string name, float number); // konstruktor przepisujący nazwę i wartosc zmiennej
        string zwroc_zmienna();             // zwraca nazwe zmiennej
        float zwroc_wartosc_zmiennej();
      };

// ############  klasa jednomian  ######################################################################

class jednomian
      {
      private:
        friend class wielomian;
        int wspolczynnik;                   // wspolczynnik - a
        int st1, st2, st3;                  // st - stopień - n
        string  name1, name2, name3;        // name - nazwa zmiennej z ktorej tworzymy jednomian - c
        string tekst; 
        vec_par pary;
      public: 

        jednomian(int a, zmienna z, int n);           
        jednomian(int a1, zmienna z1, int n1, int a2, zmienna z2, int n2);      
        jednomian(int a1, zmienna z1, int n1, int a2, zmienna z2, int n2, int a3, zmienna z3, int n3); 
        jednomian(jednomian & old);
        string zwroc_jednomian();   
                          // zwraca utworzony jednomian
      };

// ############  klasa wielomian  ######################################################################

class wielomian
      {
      private:
        string text;
        int ilosc;                       // text przechowuje nasz wielomian
      public:
        vec_trio schowek;
        wielomian();
        wielomian(jednomian j1, jednomian j2);                    // jed - jednomian
        wielomian(jednomian j1, jednomian j2, jednomian j3);
        wielomian(jednomian j1, jednomian j2, jednomian j3, jednomian j4);   
        wielomian(jednomian j1, jednomian j2, jednomian j3, jednomian j4, jednomian j5);
        wielomian(string w1, int w_wolny);          //konstruktor zbudowany na potrzeby pewnej funkcji klasy nierownosci    
        wielomian(vec_trio schowek2);
        string zwroc_wielomian();  
        int dawaj();                // zwraca utworzony wielomian
      };

// ############  klasa nierownosci  ####################################################################

class nierownosci
      {
      private:
        string zwracane_rownanie;
        string uzyty_wielomian;
        wielomian w_actual;
        string znak;
        int wyraz_wolny;
      public:       
        nierownosci();
        nierownosci(wielomian a, int b, string c);    // a - wielomian; b - wyraz wolny; c - znak nierownosci
        string zwroc_rownanie();                      // zwraca utworzoną nierownosc
        nierownosci operator++();

      };

//  ###########  klasa uklad_rownan  ###################################################################

class uklad_rownan
      {
      private:
        string uklad;  
      public:
        uklad_rownan(nierownosci n1, nierownosci n2); 
        uklad_rownan(nierownosci n1, nierownosci n2, nierownosci n3);
        uklad_rownan(nierownosci n1, nierownosci n2, nierownosci n3, nierownosci n4);
        ~uklad_rownan();
        void wyswietl();                         // wyswietla uklad rownan
      };

//  ########################################################################

klasy.cpp

#include<iostream>
using namespace std;
#include<string.h>
#include "klasy.h"
#include<ctime>

const char T = '^';
const char O = '(';
const char Z = ')';

// funkcja zatrzymująca program na określony czas:

void czekaj ( int liczba_sekund )
{
  clock_t a;
  a = clock () + liczba_sekund * CLOCKS_PER_SEC ;
  while (clock() < a) {}
}

// ############  klasa vec_par  #############

void vec_par::dodaj(string name1, int st1)
    {

    name[ip]=name1;
    st[ip]=st1;
    ip++;
    }

string vec_par::zwroc_name(int i)
       {
       return name[i];
       }

// ############  klasa vec_trio  ############

void vec_trio::dodaj(int wsp1 , vec_par para1)
     {
     it++;
     wspolczynnik[it]=wsp1;
     for (int l=0 ; l<3; l++)
        {
        para[it].name[l]=para1.name[l];
        para[it].st[l]=para1.st[l];
        cout << para1.name[l] << "bb ";
        }
     para[it].ip=para1.ip;   

     }

// ############  klasa zmienna  #############

zmienna::zmienna(string name) : nazwa(name) {};  // nazwa = name 
zmienna::zmienna(string name, float number)
    {
    nazwa = name;
    wartosc = number;
    }

string zmienna::zwroc_zmienna()                  // zwraca nazwe zmiennej
    { 
    return nazwa; 
    }

// ############  klasa jednomian  ###########

jednomian::jednomian(int a, zmienna z, int n)     // pierwszy konstruktor jednomianu
      {   
          wspolczynnik = a;
          st1 = n;  st2=0;  st3=0;               // okresla stopnie kolejnych zmiennych jednomianu
          name1 = z.zwroc_zmienna();    
          vec_par tmp;                         // nazwa jedynej zmiennej taka jak c 
          tmp.dodaj(name1, st1);
          pary=tmp;
      }

jednomian::jednomian(int a1, zmienna z1, int n1, int a2, zmienna z2, int n2)
      {      
          wspolczynnik=a1*a2;
          st3=0;
          string c1=z1.zwroc_zmienna(), c2=z2.zwroc_zmienna();
          if (c1==c2)                            //sprawdza czy obie zmienne nie są takie same
             {
             st1 = n1 + n2;  st2=0;
             name1 = name2 = c1;
             }
          else
             {
             st1 = n1;    st2=n2;
             name1 = c1;  name2 = c2;
             }
      vec_par tmp;
      tmp.dodaj(name1, st1);
      tmp.dodaj(name2, st2); 
      pary=tmp;  
      }

jednomian::jednomian(int a1, zmienna z1, int n1, int a2, zmienna z2, int n2, int a3, zmienna z3, int n3)
      {
         wspolczynnik=a1*a2*a3;
         string c1=z1.zwroc_zmienna(), c2=z2.zwroc_zmienna(), c3=z3.zwroc_zmienna();
         if (c1!=c2 && c1!=c3 && c2!=c3)         // sprawdza czy wszystkie zmienna są różne
            {
            st1 = n1;    st2 = n2;    st3 = n3;
            name1 = c1;  name2 = c2;  name3 = c3;
            }
         else {                                  // sprawdza czy istnieją dwie takie same zmienne
              if (c1==c2 && c1==c3 && c2==c3)
                 {
                 st1= n1 + n2 + n3;  st2=0;  st3=0;
                 name1 = name2 = name3 = c1;
                 }
              else 
               {
                 if (c1==c2)
                 {
                 st1 = n1 + n2;  st2=0;  st3 = n3;
                 name1 = name2 = c1;     name3=c3;
                 }
              if (c1==c3)
                 {
                 st1 = n1 + n3;  st3=0;  st2 = n2;
                 name1 = name3 = c1;     name2 = c2;
                 }
              if (c2==c3)
                 {
                 st2 = n2 + n3;  st3=0;  st1 = n1;
                 name2 = name3 = c2;     name1 = c1;

                 }
                 }
              } 
      vec_par tmp;
      tmp.dodaj(name1, st1);
      tmp.dodaj(name2, st2);
      tmp.dodaj(name3, st3);
      pary=tmp;
      cout << "AA" << pary.name[2] << "aa";
      }  

jednomian::jednomian(jednomian & stary)
      {
      wspolczynnik = stary.wspolczynnik;
      st1 = stary.st1;
      st2 = stary.st2;
      st3 = stary.st3;
      name1 = stary.name1;
      name2 = stary.name2;
      name3 = stary.name3;
      }

string jednomian::zwroc_jednomian()
             {
             cout << "LA  " << pary.name[1] << "la ";
             char potega1[10], potega2[10], potega3[10], wsp[10];         // stopnie (potęgi) oraz wspolczynnik nie powinny byc wieksze niz 10znakow
             if (wspolczynnik!=0)       // jednomian niezerowy
                {
                sprintf(wsp, "%d", wspolczynnik );           // przepisz wartosc wspolczynnika do stringa
                if (wspolczynnik < 0)   tekst = wsp;         // jesli wsp. ujemny zapisz do tekstu
                else                                         // jesli nie dodaj '+' na poczatek
                          {
                          tekst = "+";
                          tekst +=  wsp;
                          }
                if (st1!=0)                                  // zapisz do zmiennej tekst wszystkie niezerowe zmienne
                   {
                   sprintf(potega1, "%d", st1 );
                   tekst+= O + name1 + T + potega1 + Z;
                   }  
                if (st2!=0)
                   {
                   sprintf(potega2, "%d", st2 );
                   tekst+= O + name2 + T + potega2 + Z;
                   }                  
                if (st3!=0)
                   {
                   sprintf(potega3, "%d", st3 );
                   tekst+= O + name3 + T + potega3 + Z;
                   }               
                }           
             else tekst="";
             return tekst;                                   // zwroc utworzony jednomian
             }                      

// ############  klasa wielomian  ###########

wielomian::wielomian() {}

wielomian::wielomian(jednomian j1, jednomian j2)               // tworz wielomiany ze składowych jednomianów
       {                     
       ilosc=2; 
       cout << j1.pary.st[0] << "adsfadf";
       schowek.dodaj(j1.wspolczynnik , j1.pary);
       schowek.dodaj(j2.wspolczynnik , j2.pary);
       text=j1.zwroc_jednomian()+j2.zwroc_jednomian();                                                                         // O
       }                                                                                       // N
wielomian::wielomian(jednomian j1, jednomian j2, jednomian j3)                                    // S
       {       
       ilosc=3; 
       cout << j1.pary.st[0] << "adsfadf";

       schowek.dodaj(j1.wspolczynnik , j1.pary);
       schowek.dodaj(j2.wspolczynnik , j2.pary);
       schowek.dodaj(j3.wspolczynnik , j3.pary);
       text=j1.zwroc_jednomian()+j2.zwroc_jednomian()+j3.zwroc_jednomian();                                                                    // R
       }                                                                                       // U
wielomian::wielomian(jednomian j1, jednomian j2, jednomian j3, jednomian j4)                       // K
       {                                                                                       // T
       ilosc=4;
       cout << j1.pary.st[0] << "adsfadf";

       schowek.dodaj(j1.wspolczynnik , j1.pary);
       schowek.dodaj(j2.wspolczynnik , j2.pary);
       schowek.dodaj(j3.wspolczynnik , j3.pary);
       schowek.dodaj(j4.wspolczynnik , j4.pary);
       text=j1.zwroc_jednomian()+j2.zwroc_jednomian()+j3.zwroc_jednomian()+j4.zwroc_jednomian();                                                               // O
       }                                                                                       // R
wielomian::wielomian(jednomian j1, jednomian j2, jednomian j3, jednomian j4, jednomian j5)          // Y
       {
       ilosc=5;
       schowek.dodaj(j1.wspolczynnik , j1.pary);
       schowek.dodaj(j2.wspolczynnik , j2.pary);
       schowek.dodaj(j3.wspolczynnik , j3.pary);
       schowek.dodaj(j4.wspolczynnik , j4.pary);
       schowek.dodaj(j5.wspolczynnik , j5.pary);
       text=j1.zwroc_jednomian()+j2.zwroc_jednomian()+j3.zwroc_jednomian()+j4.zwroc_jednomian()+j5.zwroc_jednomian();
       }

wielomian::wielomian(string w1, int wyraz_wolny)
       {
       char a0[10];
       sprintf(a0, "%d", wyraz_wolny);
       text=w1 + a0;
       }

wielomian::wielomian(vec_trio schowek2)    //konstruktor tworzący wielomian z podanych w wektorze danych weks( wspolczynniki ; jednomiany(zmienne ; potegi))
       {
       for ( int k=0; k < schowek2.it ; k++)  //tyle ile istnieje wektorów temp2 czyli ile jednomianow w wielomianie
           {
           char a0[10];
           sprintf(a0, "%d" , schowek2.wspolczynnik[k]);   //zapisz w a0 kolejne wspolczynniki
           text+=a0;             

                   for ( int m=0 ; m < schowek2.para[k].ip ;  m++) //tyle ile zmiennych w jednomianie
                       { 

                       char pot[10];
                       sprintf(pot , "%d" , schowek2.para[k].st[m]);
                       text+= O + schowek2.para[k].name[m] + T + pot + Z;
                       }
           }
       }

int wielomian::dawaj()
    {
    cout << endl << schowek.wspolczynnik[0] << endl << schowek.para[0].st[0]  << endl  << schowek.para[0].name[0] << endl;
    return 0;
    }

string wielomian::zwroc_wielomian()            // zwraca utworzony wielomian
       {
       return text;
       }

// ############  klasa nierownosci  #########

nierownosci::nierownosci() { };

nierownosci::nierownosci(wielomian w, int b, string c)
          {
          w_actual=w;
          uzyty_wielomian=w.zwroc_wielomian();
          wyraz_wolny=b;
          znak=c;
          };

string nierownosci::zwroc_rownanie()
          {
          wielomian nowy(uzyty_wielomian, wyraz_wolny);                         // utworz nowy wielomian z polaczenia starego i wyrazu wolnego
          if        (nowy.zwroc_wielomian() == "") ;                            // jesli wielomian nie istnieje nie zwracaj rownania
          else      zwracane_rownanie = nowy.zwroc_wielomian() + znak + "0";    // tworz rownanie
          return zwracane_rownanie;                                             // zwroc rownanie
          }

nierownosci nierownosci::operator++()
          {
          string znak_przeciwny;                            //znak przeciwny to przeciwny znak(kierunek) nierownosci                    
          if (znak == "<=") znak_przeciwny=">=";            //blok zmieniajacy kierunek na przeciwny
          else if (znak == ">=") znak_przeciwny="<=";
          else if (znak == ">") znak_przeciwny="<";
          else if (znak == "<") znak_przeciwny=">";
          else znak_przeciwny = znak;                       
              wielomian nowy;
              if (znak_przeciwny!=znak)                     //jesli nastapila zmiana to stworz nową nierownosc!!!
                 {
                 vec_trio schowek2;                                    
                 for ( int k=0 ; k < w_actual.schowek.it ; k++)
                     {

                     schowek2.dodaj(  -(w_actual.schowek.wspolczynnik[k]) , w_actual.schowek.para[k] );
                     }
                 wielomian tmp(schowek2);
                 nowy=tmp; 
                 }
              else 
                   {
                   nowy=w_actual;
                   }

                         //utworz nowy wielomian ze zmienionymi wspolczynnikami

                                                    //zmiana znakow przy kolejnych wspolczynnikach wyrazów wielomianu
          nierownosci nowa( nowy , wyraz_wolny, znak_przeciwny);
          return nowa;
          }

// ############  klasa uklad_rownan  ########

uklad_rownan::uklad_rownan(nierownosci n1 , nierownosci n2)
          {
          uklad = "Uklad rownan: \n" + n1.zwroc_rownanie() + "\n" + n2.zwroc_rownanie();                           // konstruuj nowy uklad rownan
          }

uklad_rownan::uklad_rownan(nierownosci n1, nierownosci n2, nierownosci n3)
          {
          uklad = "Uklad rownan: \n" +n1.zwroc_rownanie() + "\n" + n2.zwroc_rownanie() + "\n" + n3.zwroc_rownanie();     // konstruuj nowy uklad rownan
          }  

uklad_rownan::uklad_rownan(nierownosci n1, nierownosci n2, nierownosci n3, nierownosci n4)
          {
          uklad = "Uklad rownan: \n" +n1.zwroc_rownanie() + "\n" + n2.zwroc_rownanie() + "\n" + n3.zwroc_rownanie() + "\n" + n4.zwroc_rownanie();       // konstruuj nowy uklad rownan
          }                     

uklad_rownan::~uklad_rownan()                                                   // destruktor dla klasy uklad_rownan
          {
          cout << "Czyszcze po ukladzie rownan ... ";                           
          czekaj(1);                                                               
          cout << "Wyczyszczone!" << endl;
          czekaj(1);
          }

void uklad_rownan::wyswietl()
          {
          cout << uklad << endl;                    
          }

main.cpp

#include<iostream>
using namespace std;
#include<string.h>
#include "klasy.h"
#include<vector>

int main() 
{
cout << "#################################################" << endl;
cout << "###############  PROJEKT 2  #####################" << endl;
cout << "###########  XXXXXXXXXXXXX  #################" << endl;
cout << "#################################################" << endl;
cout << endl;

//tworzymy sobie trzy zmienne:

    zmienna Pierwsza("x");
    zmienna Druga("y");
    zmienna Trzecia("z");

//tworzymy pewne jednomiany z naszych zmiennych:

    jednomian First(5 , Pierwsza , 2);  // 5x^2
    jednomian Secound(-7, Druga, 6);    // -9y^6
    jednomian Third(1, Trzecia, 0 , 1 , Druga, -8, -7 , Pierwsza, -3);  // (y^-8) * (-7x^-3)
    jednomian Fourth( 8 , Druga, -2 , -3 , Druga, 7 , -5 , Druga, -7);  // 8 * -3y^7 * -5y^-7 = 120
    jednomian Fifth( 4, Trzecia, -50, 5, Trzecia, 57);  // 20z^7
    jednomian Sixth(0 , Druga , -12);    // 0
    jednomian Seventh(16 , Trzecia, 0, 1 , Pierwsza, 13);  // 13x^13

// tworzymy bezpieczne kopie naszych jednomianow:             // konstruktor kopiujący

    jednomian kopia1( First );
    jednomian kopia2( Secound );
    jednomian kopia3( Third );
    jednomian kopia4( Fourth );
    jednomian kopia5( Fifth );
    jednomian kopia6( Sixth);
    jednomian kopia7( Seventh);

// tworzymy pewne wielomiany z naszych jednomianów:

    wielomian w1 (First, Secound);
    wielomian w2 (Third , Fourth, Fifth);
    wielomian w3 (First, Sixth);
    wielomian w4 (Fourth, Secound);
    wielomian w5 (Seventh, Secound, Seventh);
    wielomian w6 (Fourth, Sixth, Fifth);
    wielomian w7 (Third, First, Seventh, Sixth, Secound);

    w7.dawaj();

// tworzymy nierownosci z naszymi wielomianami:

    nierownosci rownosc1 (w1, 45, ">");
    nierownosci rownosc2 (w2, 3 , "=");
    nierownosci rownosc3 (w3, -12, "<");
    nierownosci rownosc4 (w4, 12, ">=");
    nierownosci rownosc5 (w5, 0 , "<=" );
    nierownosci rownosc6 (w6, 34 , "<");
    nierownosci rownosc7 (w7, -54 , "<="); 

    cout << rownosc7.zwroc_rownanie() << endl;
    nierownosci tymczasowa;
    tymczasowa = ++rownosc7;
    cout << tymczasowa.zwroc_rownanie() << endl;

    cout << rownosc5.zwroc_rownanie() << endl;
    nierownosci tymczasowa2;
    tymczasowa2= ++rownosc5;
    cout << tymczasowa2.zwroc_rownanie() << endl;
    system("pause");

// tworzymy uklady rownan zlozone z naszych nierownosci:

    uklad_rownan u1 (rownosc1, rownosc2, rownosc3);
    uklad_rownan u2 (rownosc6 , rownosc4);
    uklad_rownan u3 (rownosc7, rownosc2, rownosc6, rownosc7);

// wyswietlamy uklady rownan:

    u1.wyswietl(); 

    cout << endl;

    u2.wyswietl();

    cout << endl;      

    u3.wyswietl();

    cout << endl;

cout << "################  THE END  ######################" << endl << endl;

return 0;
}

no i wlasnie probuje jakos dostac sie do elementow przechowywanych w elemencie pary poza konstruktorem no ale nie moge tego zrobic!? ktos wie dlaczego i jak to poprawic bo pol dnia sie z tym mecze i nic nie moge wymyslec. Tak jakby po opuszczeniu konstruktora dane przechowywane w "pary" znikały, jakkolwiek to brzmi. Z góry dzieki.


z całym szacunkiem ale nie sądze zeby komus sie chcialo zanalizowac caly ten kod ;] dlatego umiescilem najwazniejsze fragmenty bo według mnie reszta nie ma na to wpływu. Skoro ci chodzi to powiedz jak to mozliwe ze mnie nie działa?!

Pozostało 580 znaków

2009-04-14 20:06

Rejestracja: 13 lat temu

Ostatnio: 1 rok temu

0

1) #include <string.h> => <string>

i abstrahujac od sensownosci, kompiluje sie, uruchamia i konczy bez wywalena sie, produkujac:

#################################################

  1. PROJEKT 2 #####################
    1. XXXXXXXXXXXXX #################
      #################################################

AAxaaAAyaa4273894adsfadfbb bb bb bb bb bb LA la LA la 4273894adsfadfbb bb bb b
b bb bb bb bb bb LA la LA la LA la 4273894adsfadfbb bb bb bb bb bb LA la LA
la 4273894adsfadfbb bb bb bb bb bb LA la LA la 4273894adsfadfbb bb bb bb bb b
b bb bb bb LA la LA la LA la 4273894adsfadfbb bb bb bb bb bb bb bb bb LA la
LA la LA la bb bb bb bb bb bb bb bb bb bb bb bb bb bb bb LA la LA la LA la
LA la LA la
-7
4273894

-7(y-8)(x-3)+5(x2)+16(x13)-7(y^6)-54<=0
bb bb bb bb bb bb bb bb bb bb bb bb 7-5-16-54>=0
+16(x13)-7(y6)+16(x^13)0<=0
bb bb bb bb bb bb -160>=0
Aby kontynuować, naciśnij dowolny klawisz . . .
Uklad rownan:
+5(x2)-7(y6)45>0
-7(y-8)(x-3)+120(y-2)+20(z7)3=0
+5(x^2)-12<0

Uklad rownan:
+120(y-2)+20(z7)34<0
+120(y-2)-7(y6)12>=0

Uklad rownan:
-7(y-8)(x-3)+5(x2)+16(x13)-7(y^6)-54<=0
-7(y-8)(x-3)+120(y-2)+20(z7)3=0
+120(y-2)+20(z7)34<0
-7(y-8)(x-3)+5(x2)+16(x13)-7(y^6)-54<=0

################ THE END ######################

Czyszcze po ukladzie rownan ... Wyczyszczone!
Czyszcze po ukladzie rownan ... Wyczyszczone!
Czyszcze po ukladzie rownan ... Wyczyszczone!

w czym prob?</quote>


no to pojechałem z nieobecnością.. chwila przerwy i prawie rok przeleciał

Pozostało 580 znaków

Odpowiedz

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0