Przeładowanie operatora = i klasa pochodna

0

Hej

Jutro mam kolokwium i męczę się z przeładowywaniem operatorów ;)
Mam dosyć długi program (kod na dole) w którym mam dwie klasy bazową Stos i pochodną DwaStosy.
W treści zadania mam takie coś: "Zdefiniuj w klasie Stos operator konwersji jej obiektu do postaci obiektu klasy pochodnej DwaStosy." Wydaje mi się że chodzi po prostu o to żeby za pomocą operatora = zrobić z obiektu Stos obiekt DwaStosy w którym jeden stos będzie po prostu zdublowany (u mnie stos to tabela int stos[rozmiar]).

dopisałem takie coś w klasie Stos

 
	DwaStosy operator=(Stos a)
	{
		DwaStosy b;
		for(int i=0;i<rozmiar;i++)
		{
			b.stos[i]=a.stos[i];
			b.stos2[i]=a.stos[i];
		}
		b.ile=a.ile;
		b.ile2=a.ile;
		return b;
	}

ale wyrzuca mi kupę błędów :/
jak zrobić żeby było dobrze? Będę bardzo wdzięczny za pomoc!

Tutaj cały kod

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <cstring>

using namespace std;

#pragma warning(disable:4996);

class Stos
{
public:
	static const int rozmiar=5;
	int stos[rozmiar];
	int ile;

	void dodaj(int, int*, int&);
	void usun(int*, int&);
	void dzialaj();
	bool czy_pusty(int ile)
	{
		if(ile==0)return 1;
	}
	bool czy_pelny(int ile)
	{
		if(ile==rozmiar)return 1;
	}
	
	Stos()
	{
		for(int i=0;i<rozmiar;i++)stos[i]=0;
		ile=0;
	}
	~Stos(){};

	void wyswietl(int[],int);
	void oproznij(int &);
	virtual void pojemnosc();
	void szczytowy();

	DwaStosy operator=(Stos a)//PRZEŁADOWANIE O KTÓRYM MÓWIE!
	{
		DwaStosy b;
		for(int i=0;i<a.rozmiar;i++)
		{
			b.stos[i]=a.stos[i];
			b.stos2[i]=a.stos[i];
		}
		b.ile=a.ile;
		b.ile2=a.ile;
		return b;
	}

};
void Stos::oproznij(int &ile){ile=0;}

void Stos::pojemnosc()
{
	cout<<"Ogolna pojemnosc stosu to "<<rozmiar<<endl;
	cout<<"Zostalo miejsca na wprowadzenie "<<rozmiar-ile<<" danych"<<endl;
}

void Stos::szczytowy()
{
	if(ile==0)cout<<"Stos jest pusty, nie ma szczytowego elementu"<<endl;
	else
	cout<<"Szczytowy element to: "<<stos[ile-1]<<endl;
}


void Stos::wyswietl(int stos[],int ile)
{
	for(int i=0;i<ile;i++)
	{
		cout<<stos[i]<<"\t";
	}
	cout<<endl;
}

void Stos::dzialaj()
{
	while(1)
	{
		cout<<"(D)odaj do stosu \t (U)sun ze stosu \t (W)yswietl \t (K)oniec."<<endl;
		cout<<"(S)zczytowy element \t (O)proznij \t (P)ojemnosc"<<endl<<endl;
		char dzialanie;
		cin>>dzialanie;
		if(dzialanie=='d'||dzialanie=='D')
		{
			cout<<"Podaj liczbe ktora dodac do stosu: ";
			int tymczas;
			cin>>tymczas;
			dodaj(tymczas,stos,ile);
		}
		else if(dzialanie=='s'||dzialanie=='S')
		{
			szczytowy();
		}
		else if(dzialanie=='o'||dzialanie=='O')
		{
			oproznij(ile);
			cout<<"Stos zostal oprozniony"<<endl;
		}
		else if(dzialanie=='p'||dzialanie=='P')
		{
			pojemnosc();
		}
		else if(dzialanie=='u'||dzialanie=='U')
		{
			cout<<"Odpalam wiec funkcje usun"<<endl;
			usun(stos,ile);
		}
		else if(dzialanie=='w'||dzialanie=='W')wyswietl(stos,ile);
		else if(dzialanie=='k'||dzialanie=='K') break;
		else cout<<"podales zla komende"<<endl;
	}
}

void Stos::dodaj(int co, int *stos, int &ilee)
{
	if(czy_pelny(ilee)!=1)
	{
		stos[ilee]=co;
		ilee++;
		if(czy_pelny(ilee)==1)cout<<"Wlasnie zapelniles stos!"<<endl;
	}
	else
	{
		cout<<"Stos jest pelny, nie mozna nic dodac"<<endl;
	}
}

void Stos::usun(int *stos, int &ilee)
{
	if(czy_pusty(ilee)!=1)
	{
		stos[ilee-1]=0;
		ilee--;
		if(czy_pusty(ilee)==1)cout<<"Stos wlasnie stal sie pusty"<<endl;
	}
	else cout<<"Stos jest pusty, nie mozesz nic zabrac"<<endl;
}



class DwaStosy : public Stos
{
public:
	int stos2[rozmiar];
	int ile2;

	void dodaj_pare(int, int);
	void usun_pare();
	void szczytowe();
	void pojemnosc();
	DwaStosy();
	
	void dzialaj2()


};

void DwaStosy::dzialaj2()
	{
		while(1)
		{
			cout<<"d1 - dodaj do stos \t d2 - dodaj do stos2 \t d12 - dodaj do obu stosow"<<endl
				<<"u1 - usun ze stos \t u2 - usun ze stos 2 \t u12 - usun z obu stosow"<<endl
				<<"p - pojemnosc \t s - szczytowy \t o - oproznij oba"<<endl
				<<"w - wyswietl \t k - koniec"<<endl;
			char tym[5]={0};
			cout<<"podaj komende ";
			cin>>tym;
			if(tym[2]=='2'&&tym[1]=='1'&&tym[0]=='d')
			{
				cout<<"Podaj dwie liczby oddzielone spacja: ";
				int tym1, tym2;
				cin>>tym1>>tym2;
				dodaj_pare(tym1,tym2);
			}
			else if(tym[1]=='1'&&tym[0]=='d')
			{
				cout<<"Podaj liczbe (do stos): ";
				int tym;
				cin>>tym;
				dodaj(tym,stos,ile);
			}
			else if(tym[1]=='2'&&tym[0]=='d')
			{
				cout<<"Podaj liczbe (do stos2): ";
				int tym;
				cin>>tym;
				dodaj(tym,stos2,ile2);
			}
			else if(tym[2]=='2'&&tym[1]=='1'&&tym[0]=='u')
			{
				cout<<"Usowam z obu stosow"<<endl;
				usun_pare();
			}
			else if(tym[1]=='1'&&tym[0]=='u')
			{
				cout<<"Usuwam ze stos"<<endl;
				usun(stos,ile);
			}
			else if(tym[1]=='2'&&tym[0]=='u')
			{
				cout<<"Usuwam ze stos2"<<endl;
				usun(stos2,ile2);
			}
			else if(tym[0]=='p')
			{
				pojemnosc();
			}
			else if(tym[0]=='w')
			{
				cout<<"Stos 1: \t";
				wyswietl(stos,ile);
				cout<<"Stos 2: \t";
				wyswietl(stos2,ile2);
			}
			else if(tym[0]=='s')
			{
				szczytowe();
			}
			else if(tym[0]=='o')
			{
				oproznij(ile);
				oproznij(ile2);
			}
			else if(tym[0]=='k')
			{
				cout<<"koncze program";
				break;
			}
			else 
			{		
				cout<<"blad"<<endl;
			}
		}
	}

void DwaStosy::dodaj_pare(int co1, int co2)
{
	dodaj(co1,stos,ile);
	dodaj(co2,stos2,ile2);
}

void DwaStosy::usun_pare()
{
	usun(stos,ile);
	usun(stos2,ile2);
}

void DwaStosy::szczytowe()
{
	cout<<"Sczytowy element w stos to: "<<stos[ile-1]<<endl<<
		"Szczytowy element w stos2 to: "<<stos2[ile2-1]<<endl;
}

void DwaStosy::pojemnosc()
{
	cout<<"Oba stosy maja pojemnosc "<<rozmiar<<endl;
	if((rozmiar-ile)<(rozmiar-ile2))cout<<"Pierwszy stos jest wiekszy (bardziej zapelniony i ma pojemnosc "<<rozmiar-ile<<endl;
	else cout<<"Drugi stos jest wiekszy (bardziej zapelniony) i ma pojemnosc "<<rozmiar-ile2<<endl;
}

DwaStosy::DwaStosy()
{
	ile=0; ile2=0;
	for(int i=0;i<rozmiar;i++)
	{
		stos[i]=0; stos2[i]=0;
	}
}



int main()
{
	Stos a;
	a.dzialaj();//tutaj chcial bym sobie wpisac dane do Stos a

	DwaStosy b;//tutaj chciał bym stworzyć obiekt DwaStosy b
	b=a;//tutaj chciał bym przepisać i podwoić stos a i zapisać go w obiekcie b (VS podkreśla znak =)
	b.dzialaj2();//a z tej funkcji chciał bym wyświetlić wszystko żeby sprawdzić czy działa


	system("pause");
	return 0;
}
 
0
  1. Operator przypisania powinien zwracac referencje (*this)
  2. Powinies sprawdzac, czy nie przypisujesz do samego siebie
  3. Musisz usunac obiekty dynamiczne (delete)
  4. Tworzysz od nowa obiekty dynamiczne o rozmiarach obiektow dynamicznych z obiektu podanego w argumencie
  5. Obiekt podany w argumencie powinien byc stala referencja
  6. Kopiujesz obiekty dynamiczne
  7. Kopiujesz reszte obiektow.
  8. zwracasz (*this).
class Foo
{
public:
    Foo(float a, int sz): a(a), x(new int[sz]) { ; }
    ~Foo() { delete[] sz; }

    Foo& operator=(const Foo& f)
    {
        if(this == &f)
            return *this;
        
        delete[] x;
        x = new int[f.sz];
        memcpy(x, f.x, f.sz*sizeof(int));
        
        a = f.a;
        sz = f.sz;
        
        return *this;
    }

    int* x;
    float a;
    int sz;
};
0

Nie masz w tym stosie części dynamicznej więc nie potrzebujesz przeładowania operatora =

0

Z tego co rozumiem to operator = może jedynie przepisywać z klasy do takiej samej klasy.
Treść zadania brzmi "Zdefiniuj w klasie Stos operator konwersji jej obiektu do postaci obiektu klasy pochodnej DwaStosy." może tu jednak chodzi o coś innego niż mi się wydaje? po wpisaniu w google operator konwersji oznacza bardziej operator rzutowania, próbowałem przeładować () ale też nic z tego nie wychodzi :/

1

Więc zadano ci zrobić: operator DwaStosy()const { ... }

0

Walczę dalej ;)

Nie radziłem sobie w rozbudowanym programie więc napisałem mega prosty który ma tylko używać tego operatora konwersji
i niestety nie działa...

#include <iostream>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

#pragma warning(disable:4996);

class baza
{
public:
	int a;

	baza(int co)
	{
		a=co;
	};

	baza::operator pochodna()
	{
		return pochodna(a,1);
	}

};



class pochodna : public baza
{
public:
	int b;

	pochodna(int co1, int co2):baza(co1),b(co2)
	{
		
	};



};


int main()
{
	baza aaa(11);
	pochodna bbb=aaa;

	cout<<"bbb.a = "<<bbb.a<<"\tbbb.b = "<<bbb.b<<endl;



	system("pause");
	return 0;
 
1
#include <iostream>
using namespace std;
 
class pochodna; // musi być wcześniejsza deklaracja
 
class baza
  {
   public:
   int a;
 
   baza(int a):a(a) {} 
   operator pochodna()const; // bo tu jest użyta deklaracja, jednak nie da się tu podać definicji bo pochodna jeszcze nie zadeklarowana
  };
 
class pochodna:public baza
  {
   public:
   int b;
 
   pochodna(int a,int b):baza(a),b(b) {}
  };

baza::operator pochodna()const
  {
   return pochodna(a,a*2); // dopiero tu można zdefiniować
  }
 
 
int main()
  {
   baza a(7);
   pochodna b=a;
 
   cout<<"b.a="<<b.a<<"; b.b="<<b.b<<';'<<endl;
   cin.get();
   return 0;
  }

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