Arraygröße aus Dateiangabe initialisieren

pointercrash**

TTP schrieb:

Resultat: Der genannte Fehler
int tmp nix();
Resultat: Workaround was komischerweise läuft?

Bitte verschiebe Dein nix() mal hinter Zeile 33, da sollte es nicht stören.

TTP

naja wenn ich das verschiebe, dann macht es nicht so viel sinn, weil eigentlich soll die funktion aus einer datei meine variablen auslesen

deswegen bleibt mir ja nur das workaround oder?

Aber du hast recht, wenn ich mein nix() danach mache, meckert nichts

TTP schrieb:

naja wenn ich das verschiebe, dann macht es nicht so viel sinn...

bei den vor-c99 compilern müssen variablen immer am anfang einer funktion angelegt werden, also bevor 'aktiver' code hingeschrieben wird (deswegen zickt dein compiler bei dem funktionsaufruf rum). schiebste den funktionsaufruf einfach dahinter, das hat keine nachteile oder sowas.

so etwa:

int main()
{
    int x = 4;
    int y = 5;
    int s,l;
    TYPE **pp;

    nix();

    pp = PointerList (....
....

pointercrash**

Das geht so eigentlich nicht. Zuerst werden die Variablen angelegt, wenn Du sie danach mittels einer Funktion befüllen magst, gibt es kein Problem.
Nur kannst Du nicht eine Funktion, die einen int zurückliefert, mit einem davorgeschriebenen Irgendwas künstlich ruhigstellen.

Also

int meinwert
// alle anderen Variablen anlegen
meinwert = nix();
andererwert = etwas();
// ...
// Initialisierung fertig
// Der Code, der was tun soll:
LetsDoSomeThing(meinwert, deinwert, adererwert);

Also nicht Deklarationen und ausführbaren Code wüst mischen, das sind Exkursionen in die Chaos- und Duselzone, woll'n 'mer doch nicht!

TTP

~fricky schrieb:

TTP schrieb:

naja wenn ich das verschiebe, dann macht es nicht so viel sinn...

bei den vor-c99 compilern müssen variablen immer am anfang einer funktion angelegt werden, also bevor 'aktiver' code hingeschrieben wird (deswegen zickt dein compiler bei dem funktionsaufruf rum). schiebste den funktionsaufruf einfach dahinter, das hat keine nachteile oder sowas.

pointercrash() schrieb:

Das geht so eigentlich nicht. Zuerst werden die Variablen angelegt, wenn Du sie danach mittels einer Funktion befüllen magst, gibt es kein Problem.
Nur kannst Du nicht eine Funktion, die einen int zurückliefert, mit einem davorgeschriebenen Irgendwas künstlich ruhigstellen.

Ähm die Funktion soll meine X und meine Y Variable bestimmen, dann muss die doch davor kommen
und mit dem Workaround erreich ich das zum Glück.
Dann hab ich damit wohl den Compiler ausgetrickst

TTP schrieb:

Ähm die Funktion soll meine X und meine Y Variable bestimmen, dann muss die doch davor kommen

klar, zuerst legst du die variablen an, dann rufste deine funktion auf, die ihnen werte gibt und alles andere kann danach kommen.

TTP

ich bekomm es nicht hin

ich muss doch da global drauf zugreifen....
Ich verzweifel gerad....

typedef long TYP; 
TYP **PointerList (int width, int height) 
{ 
    int s;   
    TYP *p, **pp;     

    pp = malloc (width * (height * sizeof(TYP) + sizeof(TYP*))); 
    if (0 == pp) 
        return 0; 

    p = (TYP*)((char*)pp + width * sizeof(TYP*)); 

    for (s=0; s<width; s++) 
        pp[s] = p + s * height; 

    return pp; 
};

int main(void)
{
	int tmp1 = systemvariablen();
	int tmp2 = struktur();
	int tmp3 = erststart();

	TYP **pp = PointerList(lagerflaeche_breite, lagerflaeche_laenge); 
    if (0 == pp) 
    { 
		lagerarray_fehler();
    } 

	lagerflaeche();

	free (pp);
	system("PAUSE");
	return 0;
}

jetzt will ich in lagerflaeche auf pp zugreifen, geht aber nicht -.-
muss ich da den pointer übergeben? wie mach ich das richtig?
einfach

lagerflaeche(**pp);

und in lagerfläche dann

void lagerflaeche(TYP **pp)
{

}

oder wie? ich glaub langsam werd ich blöde bei dem thema...

EDIT: HILFE....

TTP

vor den main() kann ich das TYP **pp = PointerList(lagerflaeche_breite, lagerflaeche_laenge); ja nicht schreiben, da die variablen lagerfläche_breite und _länge ja nicht gesetzt sind o.O

TTP

~fricky schrieb:

TTP schrieb:

Ähm die Funktion soll meine X und meine Y Variable bestimmen, dann muss die doch davor kommen

klar, zuerst legst du die variablen an, dann rufste deine funktion auf, die ihnen werte gibt und alles andere kann danach kommen.

magst du mir nochmal ne hilfestellung dazu geben?

so aufrufen:

lagerflaeche (pp);

und so drauf zugreifen:

void lagerflaeche (TYPE **pp)
{
  pp[...][...] = irgendwas;  
  ...
}

^^vielleicht noch länge und breite mit an 'lagerflaeche' übergeben, oder das ganze in eine separate struct packen.

ach, noch was: in dieser PointerList-funktion könntest du die zeile:

p = (TYPE*)((char*)pp + width * sizeof(TYPE*));

gegen:

p = (TYPE*)pp + width;

austauschen.
^^macht das gleiche, sieht nur nicht mehr so doof aus.

TTP

juhu, geht... DANKE oh man da soll man drauf kommen...
so mal gucken ob ich die zugriffe jetzt auch richtig hinbekomme....

Ähm die größe muss ich nicht übergeben, hab ja die globalen variablen lagerflaeche_breite, lagerflaeche_laenge auf die ich nur zugreifen kann

Vielen Dank das ihr euch so viel Mühe macht mir das beizubiegen

TTP

jetzt muss ich das doch einmal realloc'en.

typedef long TYP; 
TYP **PointerList (int width, int height) 
{ 
    int s;   
    TYP *p, **pp;     

    pp = malloc (width * (height * sizeof(TYP) + sizeof(TYP*))); 
    if (0 == pp) 
        return 0; 

    p = (TYP*)((char*)pp + width * sizeof(TYP*)); 

    for (s=0; s<width; s++) 
        pp[s] = p + s * height; 

    return pp; 
};

int main(void)
{
    int tmp1 = systemvariablen();
    int tmp2 = struktur();
    int tmp3 = erststart();

    TYP **pp = PointerList(lagerflaeche_breite, lagerflaeche_laenge); 
    if (0 == pp) 
    { 
        lagerarray_fehler();
    } 

    lagerflaeche();

    free (pp);
    system("PAUSE");
    return 0;
} 

function repp(int height, int width)
{

}

ich will es erst auf die größe 1x1 festlegen und dann später nochmal auf die richtige größe ändern, damit ich das workaround wegbekomme.
Die Zeile

TYP **pp = PointerList(1,1);

ist mein 1. Schritt.
Wie muss ich die repp aufbauen? da muss ich doch bestimmt dann PointerList als zeiger übergeben oder?

geht das so einfach?

function repp(int height, int width, *pp)
{
    int s;
    pp = realloc (width * (height * sizeof(TYP) + sizeof(TYP*))); 
    if (0 == pp) 
        return 0; 

    p = (TYP*)((char*)pp + width * sizeof(TYP*)); 

    for (s=0; s<width; s++) 
        pp[s] = p + s * height; 

}

^^nee, du müsstest eine neue pointerlist aufbauen, alles aus der alten rüberkopieren und die alte dann free'n. was besseres fällt mir jedenfalls gerade nicht ein. wahrscheinlich ist es sinnvoller, 'ne einfache, verkettete liste zubenutzen. sowas ist flexibler als diese doofe pointerliste (deren einziger zweck es ist, mit p[][] drauf zuzugreifen).

TTP

wie mach ich denn ne neue?

TYP **pp = PointerList(lagerflaeche_breite, lagerflaeche_laenge); 

..
free(pp);
pp = PointerList(neuebreite, neuelaenge);

geht das so? hab´s jetzt gerad nicht getestet..

TTP

doch scheint zu gehn... danke nochmals fricky
jetzt sieht der code auch viel sauberer aus, auch wenn er es effektiv nicht ist mit dem zweimal pointerlist generieren, aber der compiler meckert nicht mehr...