wyświetlanie kształtów

hej, pisze program wyświetlający kształty na podstawie zadanego pliku tekstowego ze współrzędnymi. mam problem z wyświetleniem ich.

wektor ksztalty przechowuje obiekty typu Shape. Funkcja ksztalt.add(...) dodaje kolejne wspolrzedne do obiektu ksztalt. nastepnie stworzony obiekt wrzucam push_backiem do wektora. Następnie probuje to wyswietlic funkcja window.attach, jednak jest chyba problem z odpowiednim zapisem parametru tej funkcji. Jezeli chce wyswietlic za pomoca funkcji window.attach(ksztalt) jeden obiekt to jest ok, ale jak chce wyswietlic wszystkie obiekty zapisane w wektorze ksztalty to program sie zatrzymuje. Jeżeli ktos cos zrozumie z moich tlumaczen to prosze o pomoc :P

	for (int i=0; i<info.size(); i=i+3)
    {

        if (info[i]==5)
        {
            Shape ksztalt(0,FL_BLACK,0);
            for(int j=0; j<info[i+1]; j++)
            {
                ksztalt.add(Point(ekran_y-100-((punkty[info[i+2]-info[i+1]+j]->x)-xmin)*k,100+((punkty[info[i+2]-info[i+1]+j]->y)-ymin)*k));
            }

            ksztalty.push_back(ksztalt);
            for(int d=ksztalty.size(); d<ksztalty.size()+1; d++)
            {
                window.attach(ksztalty[d-1]);
            }

        }
    }

            for(int d=ksztalty.size(); d<ksztalty.size()+1; d++)
            {
                window.attach(ksztalty[d-1]);
            }

Możesz wytłumaczyć co to ma robić?

Dobra, bez sensu ta pętlę zrobilem, mogło być:
d=kształty.size()
window.attach(kształt[d-1])

Chodzi o to żeby zaraz po dodaniu kształtu do wektora, narysowało mi to na ekranie

To teraz inna sprawa - czy ten block za if (info[i]==5) kiedykolwiek się wykona?

Tak :) sprawdzone, że do każdej pętli program "wchodzi"

Ok, teraz jeszcze raz - w którym momencie Ci się program "zatrzymuje"? I jakich bibliotek używasz? Co robi metoda "attach" (może zalinkuj dokumentację)?

to jest kod głowny, w zalaczniku pozostale pliki; program w bardzo duzej wersji roboczej :P

#include "GUI.h"

	#include <iostream>
#include <fstream>
#include <list>
#include <cstdlib>


using namespace std;

int main() {

string x;
string y;



//struct Point {
	//double x, y;
	//Point(double double1, double double2) : x(double1), y(double2) {}
//};

vector <Point*> punkty;
vector < Point* >::iterator it_tab = punkty.begin();

vector <double> info;
vector <Shape> ksztalty;
Shape ksztalt(0,FL_BLACK,0);

    int ekran_x=1300;
    int ekran_y=650;







    double ile_pkt=0;
    double ile_wszystkich_pkt=0;
    double xmin=0;
    double xmax=0;
    double ymin=0;
    double ymax=0;
    fstream plik; //obiekt typu fstream (uchwyt do pliku)

    plik.open("ObiektyTerenowe.txt"); //otwieramy plik: plik.txt (plik - nazwa pliku, txt - rozszerzenie)
    string linia;

if(plik.good() == true)
    {
        while(!plik.eof())
        {
            getline(plik, linia);
            if (linia[0] == '*')
            {
                string l=linia.substr(1,1);
                info.push_back(atof(l.c_str()));                   //zamiana na inta
                while (plik.peek() != '*' && !plik.eof())
                        {
                            getline(plik, linia);
                            if (linia[0] == 'P')
                            {
                                x = linia.substr(4,13);
                                y = linia.substr(16,13);
                                double wspx=atof(x.c_str());
                                double wspy=atof(y.c_str());

                                if(xmin==0)
                                {
                                    xmin=wspx;
                                }
                                if (ymin==0)
                                {
                                    ymin=wspy;
                                }
                                if(wspx<xmin)
                                {
                                    xmin=wspx;
                                }
                                if(wspx>xmax)
                                {
                                    xmax=wspx;
                                }
                                if(wspy<ymin)
                                {
                                    ymin=wspy;
                                }

                                {
                                    ymax=wspy;
                                }



                                punkty.push_back(new Point(wspx, wspy));
                                ile_pkt++;
                                ile_wszystkich_pkt++;
                            }
                        }
                        info.push_back(ile_pkt);
                            ile_pkt=0;
                            info.push_back(ile_wszystkich_pkt);

            }
    }
    plik.close();







    cout.precision(13);
//    for (int i=0; i<info.size(); i=i+3)
  //  {
    //    cout<< info[i] << endl;
      //  for(int j=0; j<info[i+1]; j++)
        //{
          //  cout << punkty[info[i+2]-info[i+1]+j]->x << "    " << punkty[info[i+2]-info[i+1]+j]->y << endl;
        //}

    //}
   // cout<< xmax-xmin << "     "  << "    " << ymax-ymin << "    " << ymin;
}

    double k;
    if((ekran_x-200)/(ymax-ymin)<(ekran_y-200)/(xmax-xmin))
    {
        k = (ekran_x-200)/(ymax-ymin);
    }
    else
    {
        k = (ekran_y-200)/(xmax-xmin);
    }

	Windows window(Point(0, 0), ekran_x, ekran_y, "Part3");                //punkt gorny lewy, szerokosc, wysokosc, nazwa
cout <<info.size();

    for (int i=0; i<info.size(); i=i+3)
    {
 
        if (info[i]==5)
        {
            Shape ksztalt(0,FL_BLACK,0);
            for(int j=0; j<info[i+1]; j++)
            {
                ksztalt.add(Point(ekran_y-100-((punkty[info[i+2]-info[i+1]+j]->x)-xmin)*k,100+((punkty[info[i+2]-info[i+1]+j]->y)-ymin)*k));
            }
 
            ksztalty.push_back(ksztalt);
            for(int d=ksztalty.size(); d<ksztalty.size()+1; d++)
            {
                window.attach(ksztalty[d-1]);
            }
 
        }
    }
punkty.clear();
info.clear();
ksztalty.clear();
    //Line line3(Point(ekran_y-100-((punkty[0]->x)-xmin)*k,100+(punkty[0]->y-ymin)*k), Point(10,10),0, FL_BLACK);
    //window.attach(line3);
    //Shape ksztalt(0, FL_BLACK, 0);
    //ksztalt.add(Point(100,5));
    //ksztalt.add(Point(30,30));
      //  ksztalt.add(Point(100,100));
    //ksztalt.add(Point(200,300));

   // window.attach(ksztalt);

	//Line line1(Point(0,h/4),Point(w,h/4),3,FL_BLACK);               //punkt poczatkowy, punkt koncowy, , kolor
	//Line line2(Point(w/2,0),Point(w/2,h/4),3,FL_BLACK);
	//window.attach(line1);
	//window.attach(line2);
	return Fl::run();
}

Oj... No rzeczywiście. "Roboczo". :P

punkty.clear();
info.clear();
ksztalty.clear(); 

Co to robi?

A tak poza tym, pierwsze z brzegu:
while(!plik.eof()) - może zamiast tego po prostu: while(getline(plik, linia))?

Nazwy zmiennych masz dość słabe - w ogóle najlepiej daruj sobie polskie nazwy.
Co do formatowania - jeśli nie potrafisz sam o nie zadbać (edytor/IDE powinno Ci w tym przecież pomagać... Czego używasz?) to użyj jakiegoś narzędzia do tego. W Netbeans masz Ctrl+Alt+F do automatycznego formatowania, możesz sobie ściągnąć Clang i tam masz clang-format, etc.

//    for (int i=0; i<info.size(); i=i+3)
  //  {
    //    cout<< info[i] << endl;
      //  for(int j=0; j<info[i+1]; j++)
        //{
          //  cout << punkty[info[i+2]-info[i+1]+j]->x << "    " << punkty[info[i+2]-info[i+1]+j]->y << endl;
        //}
 
    //}
   // cout<< xmax-xmin << "     "  << "    " << ymax-ymin << "    " << ymin;

Korzystaj ze skrótów klawiszowych - bez wątpienia Twój edytor (jeżeli jest cokolwiek warty) ma skrót do wykomentowania bloku. Notepad2 ma Ctrl+Q, Notepad++/Netbeans ma Ctrl+Shift+C, VS ma Ctrl+E,C i Ctrl+E,U, itd...

tamte trzy linijki czyszcza mi vectory na koniec dzialania programu. jesli chodzi o formatowanie to wole na poczatku skupic sie na dzialaniu programu, pozniej na wygladzie kodu; wiem ze powinno byc inaczej :P

Trochę bez sensu podejście, moim zdaniem. ;) "Najpierw zbuduję krzywe ściany, a potem - jak już dach położę - będę je prostował." :P
Jaką masz trudność w utrzymaniu ładnego formatowania? Jak wyżej - edytory dzisiaj na tyle pomagają, że o wcięcia nie powinieneś się w ogóle martwić - wciskasz Enter i jesteś na miejscu, nie? Czy nie?

Poza tym, porządnie wyglądający kod ułatwia wizualizację działania programu. To jest potrzebne nie tylko za miesiąc, jak wrócisz do tego kodu, ale nawet bardziej - właśnie teraz, kiedy z nim pracujesz. :P

A dlaczego czyścisz te vectory? To raz, a dwa - czy aby na pewno "na koniec działania programu"? Zastanów się dobrze.

przerzucilem na koniec :P usuwam, zeby nie zajmowaly pamieci po zakonczeniu programu

Czyli chcesz powiedzieć, że masz coś takiego?

punkty.clear();
info.clear();
ksztalty.clear();
return Fl::run();

No to się nie różni niczym od tego co miałeś powyżej. :P
Czyli jeszcze raz:

• dlaczego właściwie czyścisz te vectory? Bo przecież gdy wyjdą one poza swój zasięg, to automatycznie odpalą się ich destruktory i wszystkie obiekty przez nie przetrzymywane zostaną zwolnione (a co za tym idzie odpalą się ich destruktory).
• czy aby na pewno przed zakończeniem programu? Co Twoim zdaniem robi return Fl::run();?

W Windows ("Okna"? Co za okropnie myląca nazwa! :P) masz taki kod:

	vector<Shape*> shapes;
	void attach(Shape& s) { shapes.push_back(&s); }
	void draw() {
		Fl_Double_Window::draw();
		for(int i=0;i<shapes.size();i++)
			shapes[i]->draw();
	} 

Gdy wyczyścisz swój vector przetrzymujący kształty w main, to do czego Twoim zdaniem będą wskazywać wskaźniki w vectorze shapes w obiekcie window? Kiedy wywołana zostanie metoda draw() - zanim wyczyścisz te vectory, czy może już po tym fakcie?

Dobra, trochę się pogubilem, zatem rozumiem że powinienem usunąć czyszczenie wektorów :p

Pewnie tak. Ale powinieneś też zrozumieć dlaczego - bo inaczej to takie voodoo programming. Zrobiłeś "coś", nie działa, teraz "coś" usuwasz i działa - no i git. A dlaczego przedtem nie działało, a teraz działa? Voodoo, magia.

A to nie voodoo, tylko dangling pointer. :P

std::vector<int> v {1, 2, 3};
int* p = &v[1];
v.clear();
std::cout << *p; // oops!

Tak sobie myślę - może obiekt klasy Windows ("Okna"? Co za okropnie myląca nazwa! :P) powinien trzymać kopie kształtów, a nie wskaźniki? Wtedy możesz sobie czyścić do woli.