Problem z klasą abstrakcyjną i jej pochodnymi

0

Witam!
Mam problem z programem. Działa poprawnie, lecz jest jedna rzecz, którą muszę poprawić, gdyż jest ona niezgodna z pewnymi zasadami, a przynajmniej ja tak to zinterpretowałem. Mianowicie w klasie głównej (Image) pierwsze trzy zmienne są publiczne i odwołuję się do nich później, a powinny być prywatne, publiczna natomiast powinna być funkcja zapisu piksela, którą miałem w poprzednim programie, tylko troszkę inaczej ona musi teraz wyglądać i tu właśnie mam problem. Poprzedni program jest pod tym linkiem:
http://4programmers.net/Forum/viewtopic.php?id=133324&start=20
A to kod obecnego programu:

#include <iostream.h>
#include <math.h>
typedef unsigned char byte;

class Image
{
public:
   byte *tab;							//tablica przechowujaca wartosci pikseli obrazu
   int width;
   int height;
   void alloc(int width, int height)				//utworzenie tablicy
        {
			this->width = width;
            this->height = height;
			tab = new byte[width*height];
        }
   void dealloc()						//zniszczenie tablicy
        {
            delete [] tab;
        }
   Image()							//konstruktor
		{
			alloc(0, 0);
		}
   Image(int width, int height)					//konstruktor
		{
			alloc(width, height);
		}
   ~Image()							//destruktor
		{
			dealloc();
		}
   int getWidth() const						//zwraca width
		{
			return width;
		}
   int getHeight() const					//zwraca height
		{
			return height;
		}
   void fillInImage(byte value)					//nadaje ten sam kolor wszystkim pikselom
		{
			for (int i=0; i<width*height; i++)
				{
							tab[i] = value;
				}
		}
   void print() 						//wyswietlenie obrazka
		{
			for (int i=0; i<width*height; i++)
				{
							cout<<tab[i]<<" ";
							if(i%width==width-1)
							cout<<"\n";
				}
		}
};

class Shape 
{
	public:
	virtual void draw(Image& stab, byte color) = 0;		//funkcja rysujaca figure
	virtual void drawWithBorder(Image& stab, byte color, byte colorborder) = 0;	//funkcja rysujaca figure i obramowanie
	virtual ~ Shape()					//destruktor
	{}
};

class Rectangle : public Shape
{
public:
	int x1,y1,szerokosc,wysokosc;

	Rectangle(int x11, int y11, int szer, int wys):	//konstruktor
	x1(x11),
	y1(y11),
	szerokosc(szer),
	wysokosc(wys)
	{};

	void draw( Image& stab, byte color)
	{
	char obwod;
	int w;
	int h;
	int x2=x1+szerokosc-1;
	int y2=y1+wysokosc-1;

	for(w=0;w<stab.width;w++)
		for(h=0;h<stab.height;h++)
		{
			if(  (w>=x1&&w<=x2)  &&  (h>=y1&&h<=y2)  )
			stab.tab[(h-1)*stab.width+(w-1)]=color;
		}
	}

	void drawWithBorder( Image& stab, byte color, byte colorborder)
	{
	char obwod;
	int w;
	int h;
	int x2=x1+szerokosc-1;
	int y2=y1+wysokosc-1;
 
	for(w=0;w<stab.width;w++)
		for(h=0;h<stab.height;h++)
		{
			if((1+w>=x1&&w<=x2+1)  &&  (1+h>=y1&&h<=y2+1) )
			stab.tab[(h-1)*stab.width+(w-1)]=colorborder;
			if(  (w>=x1&&w<=x2)  &&  (h>=y1&&h<=y2)  )
			stab.tab[(h-1)*stab.width+(w-1)]=color;
		}
	}

};

class Square : public Shape
{
public:
	int x1,y1,bok;

	Square(int x11,int y11,int boki):						//konstruktor
	x1(x11),
	y1(y11),
	bok(boki)
	{};

	void draw( Image& stab, byte color)
	{
	int w;
	int h;
	int x2=x1+bok-1;
	int y2=y1+bok-1;

	for(w=0;w<stab.width;w++)
		for(h=0;h<stab.height;h++)
		{
			if(  (w>=x1&&w<=x2)  &&  (h>=y1&&h<=y2)  )
			stab.tab[(h-1)*stab.width+(w-1)]=color;
		}
	}

	void drawWithBorder( Image& stab, byte color, byte colorborder)
	{
	int w;
	int h;
	int x2=x1+bok-1;
	int y2=y1+bok-1;

	for(w=0;w<stab.width;w++)
		for(h=0;h<stab.height;h++)
		{
			if((1+w>=x1&&w<=x2+1)  &&  (1+h>=y1&&h<=y2+1) )
			stab.tab[(h-1)*stab.width+(w-1)]=colorborder;
			if(  (w>=x1&&w<=x2)  &&  (h>=y1&&h<=y2)  )
			stab.tab[(h-1)*stab.width+(w-1)]=color;
		}
	}
};

class Circle : public Shape
{
public:
	int x,y,r;
	
	Circle(int x1, int y1, int r1):							//konstruktor
	x(x1),
	y(y1),
	r(r1)
	{};

	void draw(Image& stab, byte color)
	{
		for (int a=r;a>0;a=a-1)
		{
			for(int z=1;z<360;z=z+1 )
			{
			int h,w;
			h=(int)(a*sin((3.14/180)*z)+(y-1));
			w=(int)(a*cos((3.14/180)*z)+(x-1));
			if(h>=0&&w>=0&&h<stab.height&&w<stab.width)
				{
					stab.tab[h*stab.width+w]=color;
				}
			}
		}
	}

	void drawWithBorder(Image& stab, byte color, byte colorborder)
	{
		for (int a=r;a>0;a=a-1)
		{
			for(int z=1;z<360;z=z+1 )
			{
			int h,w;
			h=(int)(a*sin((3.14/180)*z)+(y-1));
			w=(int)(a*cos((3.14/180)*z)+(x-1));
			if(h>=0&&w>=0&&h<stab.height&&w<stab.width)
				{
					stab.tab[h*stab.width+w]=color;
					h=(int)((r+1)*sin((3.14/180)*z)+(y-1));
        			w=(int)((r+1)*cos((3.14/180)*z)+(x-1));
					stab.tab[h*stab.width+w]=colorborder;
				}
			}
		}
	}
};

int main()
{
	char obwod;

	cout<<endl<<"Zostanie stworzony obiekt o wymiarach:"<<endl;
	Image tab(30, 30);

	cout<<endl<<"Width = "<<tab.getWidth();
	cout<<endl<<"Height = "<<tab.getHeight()<<endl;

	cout<<endl<<"Wypelnimy tlo jednolitym kolorem (kropkami), a nastepnie narysujemy figury."<<endl<<endl;
	tab.fillInImage('.');

	Shape *wsk;
	Rectangle r(8,5,15,6);								//okreslenie polozenia i rozmiaru prostokota
	Circle c(21,21,6);								//okreslenie srodka i promienia kola
	Square s(5,18,5);								//okreslenie polozenia i rozmiaru kwadratu

	cout<<"Czy narysowac takze obramowania figur? t/n: ";
	cin>>obwod;

	switch (obwod)
	{
	case 't':
	wsk= &r;
	wsk -> drawWithBorder(tab,'R','*');							//wypelnienie prostokota
	wsk= &c;
	wsk -> drawWithBorder(tab,'C','*');							//wypenienie kola
	wsk= &s;
	wsk -> drawWithBorder(tab,'S','*');							//wypelnienie kwadratu
	case 'n':
	wsk= &r;
	wsk -> draw(tab,'R');								//wypelnienie prostokota
	wsk= &c;
	wsk -> draw(tab,'C');								//wypenienie kola
	wsk= &s;
	wsk -> draw(tab,'S');								//wypelnienie kwadratu
	}

	cout<<endl;
	tab.print();						//wywoluje funkcje print
	
	return 0;
}

Oczywiście robiłem już pierwsze próby stworzenia funkcji zapisu piksela która zastąpiłaby późniejsze "grzebanie" w tablicy "tab", ale są one mierne w tej chwili :-/. Czy mógłby mi ktoś pomóc?

0

Mianowicie w klasie głównej (Image) pierwsze trzy zmienne są publiczne i odwołuję się do nich później, a powinny być publiczne,

Co jest zupełnie bez sensu, bo po co są metody getWidth i getHeight, jeśli od razu można odwołać się do składowych width i height?

0

No właśnie w tym problem, że width, height i *tab maja być prywatne tak jak we wcześniejszym programie, ale jeśli chodzi o to co jest wewnątrz funkcji draw to trochę pomógł mi kolega, ja sobie to zrobiłem po swojemu, ale jednak same wzory są jego i tam są odwołania do tablicy "tab", co muszę zmienić i przysporzyło mi to troszkę problemów.

PS. Zrobiłem błąd w pierwszym poście, dotyczący tego, co powinno być prywatne, a co publiczne, ale już poprawiłem.

0

No, ale w czym problem. Robisz je prywatne, a poza klasą Image pobierasz ich wartości za pomocą getWidth() getHeight().
Poza tym pisz konkretnie z czym masz problem, bo mało jest masochistów, którzy będą porównywać dwa duże kody tylko po to by domyśleć się w czym problem.

0

O to chodzi?

class Image
{
private:
   byte*	tab;                                                        
   int 		width;
   int 		height;
   
public:

	int getWidth()const { return width; }
	int getHeight()const { return height; }
	
	void setPixel(int x,int y,byte c)
	{
		if(x < 0 || x >= width || y < 0 || y >= height)return;
		tab[(width * y) + x] = c;
	}

	...
};

Popraw metode alloc:

void alloc(unsigned int w,unsigned int h)
{
	width = w;
	height = h;
	
	if(tab) delete[] tab;
	w *= h;
	tab = w ? new byte[w] : NULL;
}

...

Image() :tab(NULL), width(0),height(0)
{}

Image(int width, int height) :tab(NULL)
{
	alloc(width, height);
}

Usuń dealloc, bo jest zbędna i niebezpieczna. Zamiast niej daj w destruktorze alloc(0,0)

0
MarekR22 napisał(a)

No, ale w czym problem. Robisz je prywatne, a poza klasą Image pobierasz ich wartości za pomocą getWidth() getHeight().
Poza tym pisz konkretnie z czym masz problem, bo mało jest masochistów, którzy będą porównywać dwa duże kody tylko po to by domyśleć się w czym problem.

Problemu z width i height nie mam tylko z tablicą.

0x666: Dzięki, zaraz sprawdzę czy na pewno tak mi będzie działało, ale o to chodziło. A co do alloc i dealloc to ze względów poszerzania wiedzy chętnie przerobię tamt, ale zmieniać nie będę, bo miałem się oprzeć na poprzednim programie, w nim tak zrobiłem i dostałem 5, więc nie będę się z prowadzącym kłucił ;-P .

EDIT:

Wymyśliłem sobie coś takiego dla prostokąta i kwadratu, bo dla koła będę musiał zrobić troszkę zmienioną funkcję:

void setPixelRect(int x,int y, byte c)
{
tab[(x-1)*width+(y-1)]=c;
}

i wtedy wewnątrz pętli for w funkcji draw wstawiam:

setPixelRect(h, w, color);

Chyba, że mogę podawać parametry funkcji w ten sposób:

setPixelRect(h-1, w-1, color);

Wtedy miałbym już tylko jedną funkcję setPixel.

Czy mój tok myślenia jest dobry?

0

Jak to dla koła inaczej ? Źle kombinujesz. Obrazek to obrazek, nie ważne co jest na nim rysowane. Proponuję taki operator:

class Image
{
//...
       
        //proponuje olać sprawdzanie współrzędnych, żadna tablica tego nie robi a jakoś sobie radzimy
        //w przypadku spitolonego kodu (zły indeks) przynajmniej może na jakiś access violation się trafi, a nie będzie wyglądać jakby wszystko było w porządku
        //void setPixel(int x,int y,byte c)

        byte* operator[](int y) { return width * y; }
};

//uzycie
byte piksel = image[wiersz][kolumna];
image[wiersz][kolumna] += piksel;

Poza tym proponuje iść w tym kierunku:
Shape - dodać jakieś wspolne pola (pola, a nie osobne metody rysujące) każdego wspólnego elementu jak obramowanie, wypełnienie:

class Shape
{
protected: 
   byte brushColor;
   bs brushStyle;
   byte penColor;
   ps penStyle;
   //...
public:  
   byte getBrushColor() { return brushColor; }
   void setBrushColor(byte value) { brushColor = value; }
   //...
   
public:   
   //tylko jedna metoda, niech sposób rysowania określają parametry
   //dzięki temu można utworzyć Shape o specyficznych cechach i malować
   //go kiedy chcemy, a cechy będą zapamiętane, nie trzeba będzie ich
   //za każdym razem podawać 
   virtual void draw(Image& image) = 0;                
};

class Rectangle : public Shape
{
private:
   int left, top;
   int width, height;
//...
public:
   virtual void draw(Image& image) 
   {
      if(brushStyle != bsNone)
      {
         for(int y = 0; y < height; y++)
            for(int x = 0; x < width; x++)
               image[top + y][left + x] = brushColor;
      }
      
      if(penStyle != psNone)
      {
         for(int y = 0; y < height; y++)
         {
            image[top + y][left] = penColor;
            image[top + y][left+width-1] = penColor;
         }
         for(int x = 0; x < height; x++)
         {
            image[top][left + x] = penColor;
            image[top+height-1][left+x] = penColor;
         }
      }      
   } 
}
0

adf88 wielkie dzięki, na Ciebie zawsze mogę liczyć :) i od razu mi się rozjaśnia sytuacja.

Teraz tak co do tych pól "byte brushColor" i "byte penColor" to wszystko rozumiem, ich uzycie w funkcji "draw" także, no i w funkcji main użyję wtedy np. dla prostokąta "setBrushColor(R)", tylko co to jest "brushStyle" i "penStyle", jak tego użyć i co to za typy "bs" i "ps"?

Jeśli chodzi o tą pierwsza część to jakoś nie potrafię zrozumieć co mam zmienić w swojej klasie Image. Co to jest operator, piksel i image? Nie rozumiem czemu napisałeś "użycie" po czym tak naprawdę słowa operator tam nie ma. Jak to się ma do mojej tablicy "byte *tab" ? Wybacz mój cienki umysł w tych sprawach [glowa] , ale chyba zauważyłeś już, że zadaję dużo pytań, żeby coś w pełni, dobrze zrozumieć ;-P

0

Teraz tak co do tych pól "byte brushColor" i "byte penColor" to wszystko rozumiem, ich uzycie w funkcji "draw" także, no i w funkcji main użyję wtedy np. dla prostokąta "setBrushColor(R)", tylko co to jest "brushStyle" i "penStyle", jak tego użyć i co to za typy "bs" i "ps"?
bs i ps to propozycja stylów wypełnienia/linii. Na pewno potrzebujesz stylów takich jak: brak wypełnienia (nazwałem bsNone), jednolite wypełnienie kolorem, brak linii (nazwałem psNone), linia ciągła. Do tych stylów możesz dołożyć jakieś desenie, linie przerywane itp. Ewentualnie jak nic nie będziesz dokładać to możesz zamienić bs i ps na bool'a (jest lub nie ma wypełnienia/linii).

Co to jest operator
hmmm :) na pewno wiesz, tu jest lista wraz z kolejnością wykonania: http://www.cppreference.com/wiki/operator_precedence

Przeładowałem operator [] (indekser), tu masz odnośnie przeładowywania:
http://www.parashift.com/c++-faq-lite/operator-overloading.html

image to obiekt klasy Image. Przeładowałem operator [] w ten sposób, że zwraca wskaźnik na pierwszy piksel wskazanej linii np.

Image image;
byte* linia = image[3]; //w zmiennej 'linia' będzie wskaźnik na pierwszy piksel czwartej linii

Na takiej linii można znów użyć operatora [] (już nie przeładowanego) aby dostać się do konkretnego piksela np.

byte piksel = linia[1]; //w zmiennej 'piksel' będzie drugi piksel czwartej linii

Obydwie operacje można wykonać na raz:

Image image;
int x, y;
//...
byte piksel = image[y][x]; //w zmiennej 'piksel' znajdzie się wartość piksela z wiersza 'y' i kolumny 'x'

identycznie można zapisywać wartości pikseli:

image[y][x] = piksel;

czego przykład napisałem również w klasie Rectangle

0

Czyli skoro nie będę miał deseni mogę po prostu zrobić "bool penStyle", "brushStyle" w ogóle wywalić, bo wypełnienie ma być zawsze, wybór dotyczy tylko ramki, natomiast wewnątrz funkcji draw umieścić pętle "if( penStyle() ) {...}" ? No i oczywiście w funkcji main umieścić wybór z ramka/bez ramki w ten sposób, że wpisanie 1 będzie oznaczało wykonanie ramki, a wpisanie 0 - brak ramki?

Co do operatora to rozumiem, że ma on zastapić funkcję setPiksel, tylko troszkę nie rozumiem jego użycia, bo jeśli napiszę funkcję setPiksel, to później do niej się odwołuję za pomocą jej nazwy, gdyż nie mogę odwołać się bezpośrednio do tablicy (jest prywatna), a tu widzę ze nazwa "operator" jest tylko raz w klasie Image. Jakoś nie potrafię zrozumieć po co ona w takim razie tam jest, bo "image[y][x]=color" w ogóle się do niego nie odwołuje, tzn na pewno się mylę, ale chcę wiedzieć, czego mój umysł nie ogarnął ;-).

0

Czyli skoro nie będę miał deseni mogę po prostu zrobić "bool penStyle", "brushStyle" w ogóle wywalić, bo wypełnienie ma być zawsze, wybór dotyczy tylko ramki, natomiast wewnątrz funkcji draw umieścić pętle "if( penStyle() ) {...}" ? No i oczywiście w funkcji main umieścić wybór z ramka/bez ramki w ten sposób, że wpisanie 1 będzie oznaczało wykonanie ramki, a wpisanie 0 - brak ramki?
Tak. Tylko wtedy wypada zmienić nazwę ze "Style" na coś sensowniejszego.

Co do operatora to rozumiem, że ma on zastapić funkcję setPiksel, tylko troszkę nie rozumiem jego użycia, bo jeśli napiszę funkcję setPiksel, to później do niej się odwołuję za pomocą jej nazwy, gdyż nie mogę odwołać się bezpośrednio do tablicy (jest prywatna), a tu widzę ze nazwa "operator" jest tylko raz w klasie Image. Jakoś nie potrafię zrozumieć po co ona w takim razie tam jest, bo "image[y][x]=color" w ogóle się do niego nie odwołuje, tzn na pewno się mylę, ale chcę wiedzieć, czego mój umysł nie ogarnął ;-).
Oj nie poczytało się o operatorach ...
Do operatorów nie odwołujemy się po nazwie bo to by było bez sensu, tylko po symbolu np. + - () [] / >> < = . -> itd.

Image image;
image[y]; //<-- tu wywołujesz przeładowany operator[] który zwraca wskaźnik na linię numer 'y'

Check this out:

class Test
{
public: 
   void operator[](const string &parametr) 
   { 
      cout << "wywołałeś operator [] jako parametr podajac '" << parametr << "'\n"; 
   }
   void operator()(int a, int b) 
   { 
      cout << "wywołałeś operator () jako parametr podajac '" << a << "' i '" << b << "'\n"; 
   }
   void operator bool()
   { 
      cout << "wywołałeś operator bool()\n"; 
   }
};

Test test;

test["dupa"]; //operator tablicowy
test(1, 2); //operator funkcyjny
(bool)test; //operator rzutowania

Każdy operator można w ten sposób przeładować, nawet takie operatory jak "new", "delete", "sizeof" ...

0

Z moich osobistych doświadczeń wynika, że sizeof() nie da się przeładować, ale może coś źle robię.

0
winerfresh napisał(a)

Z moich osobistych doświadczeń wynika, że sizeof() nie da się przeładować, ale może coś źle robię.
Racja. Nie można przeładować:

  • class member access (.)
  • pointer to member (.*)
  • scope resolution (::)
  • conditional expression (? :)
  • sizeof
0

Dzięki wielkie. Zrobiłem to trochę bardziej po swojemu, ale bardzo się opierałem na Twoich radach. Jednak wciąż nie działa tak jak powinno, tzn. kompiluje się, ale nie wyświetla tego co powinno i nie mogę znaleźć błędu.

#include <iostream.h>
#include <stdlib.h>
typedef unsigned char byte;

class Image
{
public:
   byte **tab;							//tablica przechowujaca wartosci pikseli obrazu
   int width;
   int height;
   void alloc(int width, int height)				//utworzenie tablicy
        {
		this->width = width;
        this->height = height;
		tab = new byte*[width];
        for (int i=0; i<width; ++i)
        tab[i] = new byte[height];
        }
   void dealloc()						//zniszczenie tablicy
        {
        for(int i=0; i<width; ++i)
        delete [] tab[i];
        delete [] tab;
        }
   Image()							//konstruktor
		{
		alloc(0, 0);
		}
   Image(int width, int height)					//konstruktor
		{
		alloc(width, height);
		}
   ~Image()							//destruktor
		{
		dealloc();
		}
   int getWidth() const						//zwraca width
		{
		return width;
		}
   int getHeight() const					//zwraca height
		{
		return height;
		}
   void putPixel(int x, int y, byte value)
        {
        if(x>width || y>height)
                   {
		           cout<<"Blad! Podane indeksy wykraczaja poza obszar obrazu.";
		           cout<<"Wpisz indeksy maksymalnie do ["<<getWidth()<<"]["<<getHeight()<<"].";
                   }
        else
            tab[x][y] = value;
        }
   void fillInImage(byte value)					//nadaje ten sam kolor wszystkim pikselom
		{
		for (int i=0; i<width; i++)
            {
		         for(int j = 0; j<height; j++)
                 {
                         tab[i][j] = value;
                 }
           }
		}
   void print() 						//wyswietlenie obrazka
		{
		for (int i=0; i<width; i++)
            {
		    for(int j = 0; j<height; j++)
                    {
		            cout<<tab[i]<<" ";
                    if(i%width==width-1)
                    cout<<"\n";
                    }
              }
		}
	/*int operator[](int y)
		{
		return width*y;
		}*/
};

class Shape 
{
protected:
	byte brushColor;
	bool pen;
	byte penColor;
public:
	void setBrushColor(byte color)
		{
		brushColor = color;
		}
	byte getBrushColor()
		{
		return brushColor;
		}
	void setPenColor(byte color)
		{
		penColor = color;
		}
	byte getPenColor()
		{
		return penColor;
		}
	void setPen(bool p)
	     {
         pen = p;
         }
    bool getPen()
         {
         return pen;
         }
	virtual void draw(Image& image) = 0;		//funkcja rysujaca
	virtual ~ Shape()					//destruktor
	{}
};

class Rectangle : public Shape
{
private:
	int x,y,width,height,ramka;

public:
	Rectangle(int x, int y, int width, int height)	//konstruktor
	{
	this->x = x;
	this->y = y;
	this->width = width;
	this->height = height;
	}

	virtual void draw( Image& image)
		{
		for(int j=0; j<height; j++)
			for(int i=0; i<width; i++)
				{
                image.putPixel(y+j,x+i,brushColor);
				/*image[y+j][x+i]=brushColor;*/
				}		
		if(getPen())
			{
			for(int j=0; j<height; j++)
				{
                image.putPixel(y+j,x,penColor);
                image.putPixel(y+j,x+width-1,penColor);
				/*image[y+j][x]=penColor;
				image[y+j][x+width-1]=penColor;*/
				}
			for(int i=0; i<width; i++)
				{
                image.putPixel(y,x+i,penColor);
                image.putPixel(y+height-1,x+i,penColor);
				/*image[y][x+i]=penColor;
				image[y+height-1][x+i]=penColor;*/
				}
			}
		}

};

int main()
{
	bool p;

	cout<<endl<<"Zostanie stworzony obiekt o wymiarach:"<<endl;
	Image tab(30, 30);

	cout<<endl<<"Width = "<<tab.getWidth();
	cout<<endl<<"Height = "<<tab.getHeight()<<endl;

	cout<<endl<<"Wypelnimy tlo jednolitym kolorem (kropkami), a nastepnie narysujemy figury."<<endl<<endl;
	tab.fillInImage('.');

	cout<<"Czy narysowac takze obramowania figur? 1-tak/0-nie: ";
	cin>>p;
	
	Shape *wsk;
	Rectangle r(8,5,15,6);								//okreslenie polozenia i rozmiaru prostokota
	
	
	wsk= &r;
	wsk -> setBrushColor('R');
	wsk -> setPen(p);
	wsk -> setPenColor('#');
	wsk -> draw(tab);								//wypelnienie prostokota

	cout<<endl;
	tab.print();						//wywoluje funkcje print
	
	system("Pause");
	return 0;
}

PS. Dla ułatwienia czytania kodu wywaliłem to co było związane z kołem i kwadratem.

0

#include <iostream.h>
#include <stdlib.h>
Tak było kilka standardów temu. Obecnie c++ tak działa:

//nagłówki C++ bez .h
#include <iostream>

//nagłówki C normalnie z .h lub tak
#include <cstdlib>

//zaznaczamy, ze korzystamy z przestrzeni nazw std
using namespace std;

for (int i=0; i<width; i++)
{
for(int j = 0; j<height; j++)
{
cout<<tab[i]<<" ";
if(i%width==width-1)
cout<<"\n";
}
Zamieniłeś tablicę na dwuwymiarową, ale już tego nie uwzględniłeś przy wypisywaniu:

for (int i=0; i<height; i++)
{
   for(int j = 0; j<width; j++)
   {
      cout<<tab[j][i]<<" ";
   }
   cout<<endl;
}

No i koszmarnie formatujesz wcięcia, tak to powinno wyglądać:
http://pastebin.4programmers.net/179329

Jeszce jedna rzecz. Nie jest to błędem, ale w tablicy dwuwymiarowej powinieneś trzymać raczej wiersze niż kolumny. Tak działa konsola (wierszami), tak działają bitmapy ... Pierwszy indeks powinien być numerem wiersza, drugi numerem kolumny.

0

Dzięki adf88 :-) Zmieniłem wszystko tak jak mówiłeś, łącznie z trzymaniem się wierszy w tablicy, co zawsze robiłem tylko zmylił mnie ten operator. Miałem małe problemu z kołem, ale poradziłem sobie, zmieniłem jeszcze kilka rzeczy i jest super.

*quetz: "kontynuacja", ale juz o innym zadaniu: http:*4programmers.net/Forum/viewtopic.php?id=137936

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