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?!