Problem z dostaniem sie do zmiennej klasy bazowej

class pole;
//static int rozmiar;
// jeszcze klasy dzedziczce po klasie pole 1 2 3 w zaleznosci od zmiany pol, ale jak to zrobic??
class plansza 
{
private:
int rozmiar;
 
public:

  pole** tablica;		//dlaczego tutaj sie cuiagle czepia???
	
public:
	plansza();
	plansza(int wymiar);
	~plansza();
//	void ustaw_rozmiar(int wymiar);
	void wyswietl();
	friend class pole;
	int GetRozmiar();
};
plansza::plansza()
{
	int a;
	cout<<"Podaj wymiar planszy do grania"<<endl;
	cout<<"Twoj wybor:"<<endl;
	cin>>a;
	
	for(int i=0;i<a;i++)
	{
		for(int j=0;j<a;j++)
		{
			tablica= new pole();
		}
	}
}
plansza::plansza(int wymiar)
{
	int a;
	a = wymiar;
		for(int i=0;i<a;i++)
	{
		for(int j=0;j<a;j++)             // Dlaczego nie wywyoluje konstruktora na pole??
		{
			tablica= new pole();
		}
	}
}

//void plansza::ustaw_rozmiar(int wymiar)
//{
//	rozmiar=wymiar;
//}
int plansza::GetRozmiar(){
return rozmiar;
}

void plansza::wyswietl()
{
	for(int i=0;i<rozmiar;i++)
	{
		for(int j=0;j<rozmiar;j++)
		{
			printf("%d ", pole::stan);		//czemu tutaj jest błąd i jak powinno być poprownie
		}
		printf("\n");
	}
}
////////////////////////     KLASA POLE
class pole : public plansza
{
protected:
	int typ; // 0,1,2
	int stan;  //1,0 

public:
	
	pole();
	~pole();
};

pole::pole()
{
	typ=rand()%3;
	stan=rand()%2;
} 

ostream& operator<<(ostream& wyjscie, pole& rozm)
{
	wyjscie<< rozm.GetRozmiar()<<endl;
}
ostream& operator<<(ostream& wyjscie, pole** tablica)
{
	wyjscie<<plansza::tablica ;			//Jak zapisac stan gry z obiektow pole.
} 

//

Prosze o pomoc i wytłumaczenie tych błedów.

Ale jakich błędów? W tym kodzie praktycznie nie ma poprawnej linijki. Człowieku! Ty nie masz totalnie pojęcia o tym co próbujesz napisać!
Co więcej, nie dość że nie umiesz języka w którym próbujesz pisać, to jeszcze nie rozumiesz podstawowych zależności logicznych. Od kiedy pole jest szczególnym przypadkiem planszy? o_O

No dobrze. Przeciez ten problem jest w dziale dla poczatkujacych wiec wiadomo, ze nie bedzie dobrze. Ja tutaj staram sie to napisać po prostu i tyle.

O co ci chodzi z tym "szczegolnych przypadkiem klasy pole?"

Dziedziczenie to relacja "jest typu" lub "jest szczególnym przypadkiem". Pole raczej nie jest szczególnym przypadkiem czy rodzajem planszy. Tu dziedziczenie po prostu się nie nadaje.

Tworzenie tych tablic dwuwymiarowych też masz źle, brakuje alokacji pamięci na wskaźniki do tych pól.
Skoro alokujesz pamięć w konstruktorze, to destruktor powinien ją zwalniać.
Konstruktor w nie powinien pobierać danych od użytkownika, tym powinna się zająć klasa odpowiedzialna za interfejs.
Operatory << mają zwracać referencję do strumienia, u Ciebie nic nie zwracają co skończy się wysypaniem programu.
Polu rozmiar nie przypisujesz żadnej wartości w konstruktorach.
Zapisywanie musisz sobie sam opracować(jakiś format pliku), samo z siebie nie będzie działać(C++ nie ma serializacji).

#include <iostream>
#include <stdlib.h>
#include <fstream>
#include <windows.h>
#include <time.h>
#include <cstdlib>
#include <fstream>

using namespace std;
class pole;
//static int rozmiar;
// jeszcze klasy dzedziczce po klasie pole 1 2 3 w zaleznosci od zmiany pol, ale jak to zrobic??
class plansza 
{
private:
int rozmiar;
 
public:

  pole* tablica;		//dlaczego tutaj sie cuiagle czepia???
	
public:
	plansza();
	plansza(int wymiar);
	~plansza();
	void wyswietl();
	friend class pole;
	int GetRozmiar();
};
plansza::plansza()
{

	rozmiar = 0;

}
//plansza::~plansza(){
//	delete plansza::tablica;
//}
plansza::plansza(int wymiar)
{
	int a;
	a = wymiar;
		for(int i=0;i<a;i++)
	{
		for(int j=0;j<a;j++)
		{
			tablica= new pole();
		}
	}
}

int plansza::GetRozmiar(){
return rozmiar;
}

void plansza::wyswietl()
{
	for(int i=0;i<rozmiar;i++)
	{
		for(int j=0;j<rozmiar;j++)
		{
			printf("%d ", *plansza::tablica);		//czemu tutaj tak??, dobrze to jest?(zapewne nie)
		}
		printf("\n");
	}
}
////////////////////////     KLASA POLE
class pole : public plansza
{
protected:
	int typ; // 0,1,2
	int stan;  //1,0  

public:
	int GetStan();
	pole(){typ = 0, stan = 0;};
	~pole();
};

int pole::GetStan(){
	return stan;
}
//pole::pole()
//{
//	typ =rand()%3;
//	stan=rand()%2;
//} 

ostream& operator<<(ostream& wyjscie, pole& rozm)
{
	wyjscie<< rozm.GetRozmiar()<<endl;
	return wyjscie;
}
//ostream& operator<<(ostream& wyjscie, pole** tablica)
//{
//	wyjscie<<plansza::tablica ;			//Jak zapisac stan gry z obiektow pole.
//}
  

No dobra, zostalo to poprawione to o czym wspomniałeś i teraz już wyrzuca jeden error, kiedy chce inicjalizować obiekty POLE w tablicy. Pewnie tutaj jest jakaś praca na wzkaznikach, ale jak to powinno dokładnie wyglądać? Czemu konstruktor do "POLE" nie chce sie wywołać??

Proszę o odpowiedz

Nie umiesz alokować pamięci. DOCZYTAJ jak to się robi, a nie kombinuj! To co ty tam napisałeś przy wypisywaniu też jest BEZ SENSU. W każdym obiegu pętli wypisujesz *plansza z którym NIC NIE ROBISZ. Czemu oczekujesz że wypisze ci to kolejne elementy planszy? o_O Poza tym nie umiesz odwoływać się do pól obiektów klasy.
Na prawdę tak trudno jest przeczytać te 2 strony dowolnego kursu?

Z tym odwływaniem sie do tej rzeczy co ja chce konkretnie do STANU obiektu pole no to nie powinno byc tak ze odwoluje sie do planszy->potem do pola-> i potem do funkcji ktora zwraca mi stan obiektu?

A z tym alokowaniem pamieci to jak powinno byc poprawnie? Na zajeciach robilem uzywajac slowa "NEW" i wszytko mi wychodzilo jak chcialem dodac np obiekt inny do listy jednokierunkowej.

Licze na pomoc w tym, bo wy sie znacie a zwlaszcza widze Ty Shalom. Nie możesz mi podpowiedziec, pokazac jak ten kawałek kodu powienien wyglądać? Wiesz ja sie ucze C++ a to zadanie pewnie dla niektorych jest łatwe, ale jak widac dla mnie nie. Jak tworze sobie obiekt typu plansza to w nim jak widac chce utworzyc obiektu typu Pole tak duzo jaki podam rozmiar planszy. Wydaje mi sie ze w obiekcie Plaszna musi byc jakas tablica ktora bedzie przechowywac wzkazniki do obiektow typu pole otworzonych po podaniu rozmiaru. Tez chyba musze miec wzkaznik ktorym bede sie poruszac po tej tablicy, wiec to chyba musi byc wzkaznik na wzkazniki na obiekty..?

Mozesz przedstawic to na tym moim kodzie i pomoc mi w poprawieniu jego?

Pomoze ktos?

Przecież koledzy Ci już pomogli. Ten kod jest źle od a do z.

• Alokacja pamięci na tablicę jest źle. Nie wiadomo nawet, czy to ma być alokacja na tablicę z dwoma wymiarami. Wskaźnik jest pojedynczy a pętle masz dwie, które zajmują się głównie produkcją wycieku pamięci.
• Pole rozmiar nie jest inicjalizowane w konstruktorze z argumentem.
• wyswietl robi jakąś bzdurę. *plansza::tablica co to w ogóle jest Twoim zdaniem i dlaczego uważasz, że jest to typu int?
• Dlaczego pole dziedziczy po plansza? Przecież plansza składa się z pól a pole nie jest rodzajem planszy.
• Deklarujesz metody, potem je komentujesz. Destruktor jest Ci potrzebny, skoro alokujesz jakąś pamięć - powinieneś ją zwolnić.
• Po co Ci ta deklaracja przyjaźni?
• ostream& operator<<(ostream& wyjscie, pole** tablica) co to w zasadzie ma być? Wyżej masz ten operator dla pole.
• Jeżeli operatora << masz zamiar używać do wypisywania na ekran a stan programu chcesz zapisywać do pliku w innym formacie stwórz sobie odpowiednie metody save i load.
  I inne kosmetyczne:
• W C++ chyba najczęściej przyjmuje się, że nazwy klas zaczynają się wielką litera.
• Nagłówki biblioteki standardowej C to <ctime> i <cstdlib> (ten to masz dwa razy).

Zastanów się nad tymi pytaniami/uwagami. W zasadzie to suma tych, które już są w tym wątku wyżej. Potrafisz na nie odpowiedzieć sam sobie? W końcu to Ty jesteś autorem tego kodu!

żal.pl

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <ctime>
#include <windows.h>

using namespace std;

class Pole
{
private:
    int typ;
    int stan;
public:
    int getStan() const;
    Pole()
    {
        typ = 0, stan = 0;
    };
    ~Pole() {}
    friend ostream& operator<<(ostream& wyjscie, const Pole& rozm);
};

int Pole::getStan() const
{
    return stan;
}

ostream& operator<<(ostream& wyjscie, const Pole& pole)
{
    wyjscie << pole.getStan();
    return wyjscie;
}


class Plansza
{
private:
    int rozmiar;
    Pole** tablica;
public:
    Plansza(int wymiar);
    ~Plansza();
    void wyswietl();
    int getRozmiar();
};

Plansza::Plansza(int wymiar)
{
    rozmiar = wymiar;
    tablica = new Pole*[wymiar];
    for(int i=0; i<wymiar; i++)
    {
        tablica[i] = new Pole[wymiar];
    }
}

Plansza::~Plansza()
{
    for(int i=0; i<rozmiar; i++)
    {
        delete[] tablica[i];
    }
    delete[] tablica;
}

int Plansza::getRozmiar()
{
    return rozmiar;
}

void Plansza::wyswietl()
{
    for(int i=0; i<rozmiar; i++)
    {
        for(int j=0; j<rozmiar; j++)
        {
            cout<<tablica[i][j];
        }
        cout<<"\n";
    }
}

int main(int argc, char* argv[])
{
    Plansza* p = new Plansza(10);
    p->wyswietl();
    delete p;
    return 0;
}

Ten stan i typ zrobiłbym jako enumy a nie inta, ale pewnie to olejesz bo przecież jesteś zbyt leniwy żeby poczytać o tym co to enum...

#include <iostream>
#include <cstdlib>
#include <fstream>
#include <ctime>
#include <windows.h>
 
using namespace std;
 
class Pole
{
private:
    int typ;
    int stan;
public:
    int getStan() const;
	int getTyp() const;
    Pole()
    {
        typ = rand()%3; 
		stan = rand()%2;
    };
    ~Pole() {}
    friend ostream& operator<<(ostream& wyjscie, const Pole& rozm);
	/*friend void sprawdz_wspolrz(int x, int y);*/
};
 
int Pole::getStan() const
{
    return stan;
}
int Pole::getTyp() const
{
	return typ;
}
 
ostream& operator<<(ostream& wyjscie, const Pole& pole)
{
    wyjscie << pole.getStan();
	/*printf("\t");
	wyjscie <<pole.getTyp();*/
    return wyjscie;
}
//--------------------------------------FUNKCJAA WSPOLRZEDNA SPRAWDZAJACA


 
 
class Plansza
{
private:
    int rozmiar;
    Pole** tablica;
public:
    Plansza(int wymiar);
    ~Plansza();
    void wyswietl();
    int getRozmiar();
	friend void sprawdz_wspolrz(int x, int y);
};
 
Plansza::Plansza(int wymiar)
{
    rozmiar = wymiar;
    tablica = new Pole*[wymiar];
    for(int i=0; i<wymiar; i++)
    {
        tablica[i] = new Pole[wymiar];   // wpisz tutaj [wymiar]
    }
}
 
Plansza::~Plansza()
{
    for(int i=0; i<rozmiar; i++)
    {
        delete[] tablica[i];
    }
    delete[] tablica;
}
 
int Plansza::getRozmiar()
{
    return rozmiar;
}
 
void Plansza::wyswietl()
{
    for(int i=0; i<rozmiar; i++)
    {
        for(int j=0; j<rozmiar; j++)
        {
            cout<<tablica[i][j];			//przeciążony operator do wypisywania stanu
        }
        cout<<"\n";
    }
}
//
//void sprawdz_wspolrz(int x, int y)
//{
//	if(Plansza->tablica[x]->Pole.getTyp()==0)
//	{
//	}
//	else if(Plansza->tablica[x]->Pole.getTyp()==1)
//	{
//	}
//	else if (Plansza->tablica[x]->Pole.getTyp()==2)
//	{
//	}
//	//Plansza::tablica[x][y]::Pole::getTyp

};
////////////////////////////////////////////////////////KLASA ZASADY**********************************************************
class zasady
{
protected:
	 void wysw_zasady();	

public:
	
	 void zasady0();
};

void zasady::wysw_zasady()
{
	printf("Prosze o stosowanie sie do wymienionych zasad gry i informacji. Powodzenia!");
	printf("\n");
}
void zasady::zasady0()
{
	wysw_zasady();
}

class zasady_dal:public zasady
{
	public:
		void zasady0();
};

void zasady_dal::zasady0()
{
	cout<<"Zasady gry sa proste:\n"<<endl;
	cout<<"Rozmiar planszy podaje uzytkownik. Plansza jest N x N"<<endl;
	cout<<"Przejscie planszy polega zapelnieniu planszy 0 lub 1"<<endl;
	cout<<"Plansza zawiera [bonusy] ktore zmieniaja inaczej sasiadow"<<endl;
	cout<<"\n";
}
 
///////////////////////MENU1*****************************************************************
int menu1()
{
	int wybor;
	cout<<"Wybierz opcje:\n 1-NOWA GRA\n 2-WCZYTAJ GRE\n 3-Zakoncz"<<endl;
	cout<<"Twoj wybor:"<<endl;
	cin>>wybor;
	return wybor;
}
/////////////////////////////MENU2********************************************************************
int menu2()
{
	int wybor;
	cout<<"Wybierz opcje:\n1-Podaj wspolrzedne\n2-Zapisz i Zakoncz"<<endl;
	cout<<"Twoj wybor:"<<endl;
	cin>>wybor;
	return wybor;
}
 
int main(int argc, char* argv[])
{///////////////WYŚWIETLANIE ZASAD*******************************************************************
	zasady *pb;
	zasady_dal k;
	pb=&k;					//Rzutowanie w gorę aby dostać sie do klasy bazowaej ("ZASADY")
	k.zasady0();
	pb->zasady::zasady0();
	system("pause");
	system("cls");
///////////////**************************************************************************************************
	
	
	int wybor_gracz;
	wybor_gracz=menu1();

	if(wybor_gracz==1)
	{
	int a;
	cout<<"Podaj rozmiar planszy:"<<endl;
	cin>>a;
	srand(time(NULL));
    Plansza* p = new Plansza(a);
    p->wyswietl();

	cout<<"Podaj wspolrzedne pola od 0 do "<<a-1<<endl;
	int x,y;
	cin>>x;
	cin>>y;   //funlcja pobierajaca dane

	/////////Zmienienie
	system("cls");

	int m=menu2();

	while(m!=2)
	{
		p->wyswietl();
		cout<<"Podaj wspolrzedne pola od 0 do "<<a-1<<endl;
		cin>>x;
		cin>>y;
		m=menu2();
	}
	////////zapisanie 
	return 0;

	}
	else if(wybor_gracz==2)
	{
		////////////wczytaj gre
		////////////wyświetl

	}
	else if(wybor_gracz==3)
	{
		cout<<"Zakonczono program!"<<endl;
		system("pause");
		return 0;
	}
return 0;
}






 

Dzieki za wczescniejsza pomoc. Jeszcze chcialbym abyscie mi pomogli zmienic wartosci planszy pol podanych za pomoca wspolrzednych. Tworze funckje (chyba poprawnie) friend ktora ma dostep do PLANSZY i ona powinna sie odwolac przez tablice do konkretnego pola i zmienic siebie na poczatek na przeciwny stan, tylko jak to zrobic? Tam oczywiscie jest belkot w ciele funckji. Jak on powinien wygladac konkretnie?
Prosze was o pomoc i wyrozumialosc.