Struct in Funktion dessen Größe in einer anderen F. definiert wird



  • Hallo miteinander,

    ich möchte in einer Funktion auf ein Struct zugreifen, dessen Größe aber in einer anderen Funktion Festgelegt wird.

    Die Funktion sieht, gekürzt, wiefolgt aus:

    sp_counter=0; //startpunkte
    	ep_counter=0; //endpunkte
    
    	for (int row = 0; row < 18; row++) {
    		for (int col = 0; col < 22; col++) {
    			switch(map[col][row]) {
    				case 2: //eingang nach unten
    					startpoints[sp_counter].x_pos = col;
    					startpoints[sp_counter].y_pos = row;
    					startpoints[sp_counter].dir = 12;
    					sp_counter++;
    					break;
    
    				...
    
    				case 6: //ausgang nach oben
    					endpoints[ep_counter].x_pos = col;
    					endpoints[ep_counter].y_pos = row-1;
    					ep_counter++;
    					break;
    				...
    			}
    		}
    	}
    

    Das Problem ist, dass die Anzahl der Eingänge und Ausgänge in einer anderen Funktion ermittelt wird. Irgendwie scheint das Problem recht simpel zu sein, aber ich komm einfach nicht drauf, wie man das löst 😕
    Kann mir von Euch vielleicht jemand helfen?



  • Poste mal etwas mehr von der Funktion und die Definition dieses structs und der anderen Typen. Sonst muss man zuviel raten.



  • Ja, ich wollte Euch nicht mit zu viel unsinnigem Code verwirren, aber da war ich wohl etwas zu übereifrig 😉
    hier einmal der zusammenhängende code:

    struct Startpoint {
    	int x_pos;
    	int y_pos;
    	int dir;
    };
    
    struct Endpoint {
    	int x_pos;
    	int y_pos;
    };
    
    int count_entrys(int map[22][18]) {
    	int counter=0;
    	for (int row = 0; row < 18; row++) {
    		for (int col = 0; col < 22; col++) {
    			if(map[col][row] == 2 || map[col][row] == 3 || map[col][row] == 4 || map[col][row] == 5) counter++;
    		}
    	}
    	return counter;
    }
    
    int count_exits(int map[22][18]) {
    	int counter=0;
    	for (int row = 0; row < 18; row++) {
    		for (int col = 0; col < 22; col++) {
    			if(map[col][row] == 6 || map[col][row] == 7 || map[col][row] == 8 || map[col][row] == 9) counter++;
    		}
    	}
    	return counter;	
    }
    
    void set_portals() { 
    	sp_counter=0;
    	ep_counter=0;
    
    	for (int row = 0; row < 18; row++) {
    		for (int col = 0; col < 22; col++) {
    			switch(map[col][row]) {
    				case 2: //eingang nach unten
    					startpoints[sp_counter].x_pos = col;
    					startpoints[sp_counter].y_pos = row;
    					startpoints[sp_counter].dir = 12;
    					sp_counter++;
    					break;
    				case 3: //eingang nach links
    					startpoints[sp_counter].x_pos = col;
    					startpoints[sp_counter].y_pos = row;
    					startpoints[sp_counter].dir = 13;
    					sp_counter++;
    					break;
    				case 4: //eingang nach oben
    					startpoints[sp_counter].x_pos = col;
    					startpoints[sp_counter].y_pos = row;
    					startpoints[sp_counter].dir = 10;
    					sp_counter++;
    					break;
    				case 5: //eingang nach rechts
    					startpoints[sp_counter].x_pos = col;
    					startpoints[sp_counter].y_pos = row;
    					startpoints[sp_counter].dir = 11;
    					sp_counter++;
    					break;
    				case 6: //ausgang nach oben
    					endpoints[ep_counter].x_pos = col;
    					endpoints[ep_counter].y_pos = row-1;
    					ep_counter++;
    					break;
    				case 7: //ausgang nach rechts
    					endpoints[ep_counter].x_pos = col;
    					endpoints[ep_counter].y_pos = row+1;
    					ep_counter++;
    					break;
    				case 8: //ausgang nach unten
    					endpoints[ep_counter].x_pos = col;
    					endpoints[ep_counter].y_pos = row+1;
    					ep_counter++;
    					break;
    				case 9: //ausgang nach links
    					endpoints[ep_counter].x_pos = col-1;
    					endpoints[ep_counter].y_pos = row;
    					ep_counter++;
    					break;
    			}
    		}
    	}
    }
    

    das ist in der header-datei drinn und nun folgt der code in der main.cpp

    entry_count = count_entrys(map);
    	exit_count = count_exits(map);
    	abs_crittercount=critters_per_channel*entry_count;
    	Startpoint startpoints[entry_count];
    	Endpoint endpoints[exit_count];
    
    	set_portals();
    


  • mist, ich komm immer noch nicht drauf, aber das wäre der code, der mit dem problem zusammen hängt. Die Fehlermeldung ist wiefolgt:

    4 In file included from main.cpp 
      In function `void set_portals()': 
    173 `startpoints' undeclared (first use this function) 
    (Each undeclared identifier is reported only once for each function it appears in.)
    197 invalid types `int[int]' for array subscript
    198 invalid types `int[int]' for array subscript
    202 invalid types `int[int]' for array subscript
    203 invalid types `int[int]' for array subscript
    207 invalid types `int[int]' for array subscript
    208 invalid types `int[int]' for array subscript
    212 invalid types `int[int]' for array subscript
    213 invalid types `int[int]' for array subscript
    


  • 173 `startpoints' undeclared (first use this function)
    

    Sagt ja bereits alles. Man müsste die Fehlermeldung eben lesen. 😉

    Übrigens würde ich statt der magischen Nummern 2 bis 9 ein enum einsetzen und aussagekräftige Konstanten definieren. Dann kannst du das als eigenen Typ ansprechen und brauchst auch die Kommentare bei den case -Marken nicht.

    Überlege dir ausserdem, ob du gewisse Aktionen zusammenfassen kannst, dein switch ist nicht besonders schön.



  • also das problem mit dem startpoint ist doch das was ich nicht lösen kann. bin schon des lesens möchtig. bloß wie mach ich das, dass ich etwas in dieser funktion verändern kann, dass mit einer anderen funktion erst erstellt wird?

    ansonsten vielen dank für die anregungen. ich les mich da mal rein 🙂



  • startpoints ist im Gültigkeitsbereich der Funktion set_portals nicht bekannt:
    `startpoints' undeclared

    die anderen fehler rühren daher, dass der compiler einfachmal annimmt startpoints sei vom typ int.

    Wenn set_portals mit startpoints arbeiten soll, musst du der Funktion z.b. eine referenz darauf übergeben.

    Ich hab dein Programm nicht versucht nachzuvollziehen, weil es einfach nicht zu verstehen ist. Daher nur ein paar vorschläge wie eine Funktion aussehen könnte.

    #include <vector>
    
    struct Startpoint;
    struct Endpoint; 
    typedef std::vector<Startpoint> spv;
    typedef std::vector<Endpoint> epv;
    
    void tuwas(spv & sp, epv & ep)
    {
    	Endpoint neuer_endpunkt;
    	ep.push_back(neuer_endpunkt);
    	Startpoint neuer_startpunkt;
    	sp.push_back(neuer_estartpunkt);
    	// .....
    }
    
    template<typename SIter, typename EIter>
    void nochwas(SIter first_sp, SIter last_sp, EIter first_ep, EIter last_ep)
    {
    	std::for_each(first_sp, last_sp, /*... tudiesoderdas...*/ );
            std::copy(first_ep, last_ep, /*woandershin */);
            // was weiss ich
    }
    
    int main()
    {
    	spv startpoints;
    	epv endpoints;
    	// ...
    	tuwas(startpoints, endpoints);
    	nowas(startpoints.begin(), startpoints.end(), endpoints.begin(), endpoints.begin()+2);
    }
    


  • Danke für die Hilfe, aber ich verstehe wiederum Deinen Code nicht 😕

    Für den Fall, dass Dein Code nicht mein Problem lösen würde, wenn ich ihn verstehen würde formulier ich mein Problem mal etwas allgemeiner:

    Eine Funktion erstellt anhand einiger Parameter n Objekte.
    Eine andere Funktion soll n Objekten des Typs manipulieren.

    Ich hoffe, dass ich dieses Mal meinen Code verständlich gemacht habe und mir jemand helfen kann.

    void startpunkte_erstellen() {
    	Startpunkt startpunkte[anzahl_der_startpunkte]
    	for(int i=0; i>anzahl_der_startpunkte; i++) {
    		startpunkte[i].x_pos = 10+i*32; //32 ist die größe eines startpunktes
    		startpunkte[i].y_pos = 10;
    	}
    }
    
    void gegner_erstellen() {
    	Gegner gegnergruppe[anzahl_der_gegner];
    	for(int i=0; i>anzahl_der_gegner; i++) {
    		gegnergruppe[i].setze_parameter(startpunkt[i].x_pos, anderer werte);
    	}
    }
    
    void neue_runde() {
    	for(int i=0; i>anzahl_der_gegner; i++) {
    		gegnergruppe[i].setze_parameter(startposition, anderer werte);
    	}
    }
    


  • Suchst du zufällig std::vector?

    Fast2



  • ich kenne mich mit vector leider nicht aus, muss ich wohl nachholen, da brotbernd schon in seinem Beispiel vector benutzt hat.
    Momentan weiß ich leider nicht inwiefern mir ein Vektor da weiter hilft. Aber wie gesagt: ich les mich da mal rein.

    Vielen dank für die hilfe!



  • Gute Einführung in std::vector und den Rest der STL: Artikel



  • Vielen Dank! Ich wühl mich mal da durch 😉


Anmelden zum Antworten