für structB in structA speicherbereich allocieren

[24dan]

Hallo ... die Structuren sehen so aus:

struct B
{
	struct B *next;		//	Pointer auf das nächste B 
	int i_b1;		 
};	

struct A
{
	struct A *next;		//	Pointer auf das nächste B
	int i_a1;	
	struct B *b;	
	
};

das Allocieren des Speichers habe ich so gelöst:

1               struct B *b;
2		struct A *a;
3
4		b = (struct B *) malloc ( sizeof ( struct B ) );
5		b->a = (b->struct A *) malloc ( sizeof ( b->struct A *) );
6
7		b->a->next = 0; 
8		b->next = 0;

nun bekomme ich aber wegen Zeile 5 eine Fehlermeldung:

...
smaragd.cpp:48: error: expected unqualified-id before 'struct'
smaragd.cpp:48: error: expected `)' before 'struct'
...

Kann es sein das ich mit der Allocierung von A schon Speicher für B habe??? Dumm da hätte ich auch früher drauf kommen können.
hmmmmm

Kann jemand einen Tip geben?

[awehrm]

Keine Garantie aber probier das mal:

b->next = (struct A *) malloc ( sizeof (struct A) );

[24dan]

Keine Garantie aber probier das mal:

b->next = (struct A *) malloc ( sizeof (struct A) );

Hallo, sorry ich hatte in meinem Post noch Fehler entdeckt.
Ich denke das die Funktion von Dir doch Speicherbereich für das nächste Element von A reserviert oder?

Ich suche aber die Möglichkeit Speicherbereich von Stuktur B in A zu allocieren.

[awehrm]

Müsste der eine Kommentar nicht auch anders lauten?
Naja, guck dir das mal an:

struct B
{
	struct B *next;		//	Pointer auf das nächste B 
	int i_b1;		 
};	

struct A
{
	struct A *next;		//	Pointer auf das nächste A
	int i_a1;	
	struct B *b;	
	
};	

int main()
{
  struct A a;

  a->b=(struct B *)malloc(sizeof(struct B)); 
}

[anda_skoa]

Man könnte sich da ein bischen bei OOP bedienen und "Konstruktoren" benutzen

struct B* new_B()
{
    struct B* b = (struct B) malloc(sizeof(struct B));
    b->next = 0;
    b->i_b1 = 0; // oder anderer Initialwert

    return b;
}

struct A* new_A()
{
    struct A* a = (struct A) malloc(sizeof(struct B));
    a->next = 0;
    a->i_a1 = 0; // oder anderer Initialwert
    a->b = new_B();
    
    return a;
} 

struct A* new_A_for_B(struct B* b)
{
    struct A* a = (struct A) malloc(sizeof(struct B));
    a->next = 0;
    a->i_a1 = 0; // oder anderer Initialwert
    a->b = b;
    
    return a;
}

Ciao,
_

[24dan]

@awehm
Mensch danke,..... (erstaunt) ... das funktioniert.

Okay: Was passiert da jetzt genau?

1. Ich habe zwei Stukturen auf die ich einen Pointer beim erstellen setze.

// headerfile.inhalt
struct A{ bla.., struct A *next, struct B *b, bla..};
struct B{ bla..., struct B *next, bla...};

//main.inhalt
struct A *a;
struct B *b;

2. Ich allociere Speicher für die Struktur A und dann setze ich einen Pointer für das nächste Element vom Typ Struktur A auf NULL somit erhalte ich die Grundlage für eine verkettete Liste.

a = (struct A *) malloc ( sizeof ( struct A ) );
a->next = 0;

3. Jetzt kommt der spannende Teil: Ich allociere Speicherbereich für meine Struktur B in der Struktur A um damit vollkommen dynamische Speicherverwaltungsfreiheit und eine beste Performence zur Laufzeit zu erhalten. (Hope so...?)

a->b = (struct B *) malloc ( sizeof ( struct B ) );
a->b->next = 0;

So, warum das alles? Hauptsächlich um schnell und effizient zur Laufzeit zu werden.

[peschmae]

Also der mit "vollkommen dynamische Speicherverwaltungsfreiheit und eine beste Performence zur Laufzeit zu erhalten" könnte aus einer Werbebroschüre kommen.

Malloc ist nämlich grundsätzlich eine eher aufwändige Operation.

Im Vergleich zu was möchtest du denn überhaupt schnell(er) werden?

MfG Peschmä

[24dan]

@anda_skoa

Das ist also folgendermaßen von mir verstanden worden:
Hier erschaffen wir mit new() zwei Objekte (like struct in C)
Wir nennen Sie A und B. Wobei in A B gleich mit erschaffen wird?

struct B* new_B()
{
    struct B* b = (struct B) malloc(sizeof(struct B));
    b->next = 0;
    b->i_b1 = 0; // oder anderer Initialwert

    return b;
}

struct A* new_A()
{
    struct A* a = (struct A) malloc(sizeof(struct B));
    a->next = 0;
    a->i_a1 = 0; // oder anderer Initialwert
    a->b = new_B();
    
    return a;
}

FRAGEN:
1. Wie kann ich diese Objekte den in main verwalten?

int main (void){
struct B* new_B();
struct A* new_A();
b->i_b1 = 2;
a->i_a1 = 12;
cout << b.i_b1 << a.i_a1 << endl;
return 0;
}

2. Wie kann ich den jetzt z.B bei je einem A 7 x ein neues B erstellen?
Also eine Verkettete Liste vom Typ A die im Ersten Element eine Verkettet Liste von z.B 7 Elementen vom Typ B enthält. Im Zweiten Element der Verketteten Liste vom Typ A soll dann eine Verkettete Liste mit 12 Elementen erstellt werden. and so on...

|| Das ist eine Verkurzte Form von /\ dem?
\/

struct A* new_A_for_B(struct B* b)
{
    struct A* a = (struct A) malloc(sizeof(struct B));
    a->next = 0;
    a->i_a1 = 0; // oder anderer Initialwert
    a->b = b;
    
    return a;
}

[24dan]

@peschmae

Im Vergleich zu was möchtest du denn überhaupt schnell(er) werden?

Ich möchte schneller werden zu:
1. Structuren auf die ich ohne pointer zugreife
2. Arrays von Structuren (Denn bei den Daten die ich verwalten möchte weiss ich nicht wieviele es sind und möchte nicht einen Array mit [Ueberschlagswert+10%] allocieren.)

[anda_skoa]

Das ist also folgendermaßen von mir verstanden worden:
Hier erschaffen wir mit new() zwei Objekte (like struct in C)
Wir nennen Sie A und B. Wobei in A B gleich mit erschaffen wird?

Korrekt. Die Erzeugung von B in A ist nur eine Variante, man könnte in new_A() auch a->b auf 0 setzen.

Das ist eine Definitionsfrage, also wie ein "leeres" A auszusehen hat

FRAGEN:
1. Wie kann ich diese Objekte den in main verwalten?

int main (void){
struct B* new_B();
struct A* new_A();
b->i_b1 = 2;
a->i_a1 = 12;
cout << b.i_b1 << a.i_a1 << endl;
return 0;
}

int main (void){
struct B* b = new_B(); // new_B() ist eine Funktion die aufgerufen werden muß
struct A* a = new_A(); // ebenso new_A();
b->i_b1 = 2;
a->i_a1 = 12;
cout << b.i_b1 << a.i_a1 << endl;
return 0;
}

2. Wie kann ich den jetzt z.B bei je einem A 7 x ein neues B erstellen?

Direkt in etwa so

a->b->next = new_B();
e->b->next->next = new_B();
//usw

Allerding wäre da vermutlich auch eine Funktion angebracht, etwa so

struct B* append_B(struct B* chain, int data)
{
    for (; chain->next != 0; chain = chain->next) {};

    chain->next = new_B();
    chain->next->i_b1 = data;

    return chain->next;
}

|| Das ist eine Verkurzte Form von /\ dem?
\/

struct A* new_A_for_B(struct B* b)
{
    struct A* a = (struct A) malloc(sizeof(struct B));
    a->next = 0;
    a->i_a1 = 0; // oder anderer Initialwert
    a->b = b;
    
    return a;
}

Das ist für den Fall, daß man ein A nicht mit einem leeren B erzeugen will, sondern mit einem vorhandenen.
Es ist nur ein weiteres Beispiel, wie man einen "Konstruktor" machen kann, es hängt wie oben erwähnt von der Verwendung der Datenstrukturen ab.

Ciao,
_

[24dan]

Allerding wäre da vermutlich auch eine Funktion angebracht, etwa so

struct B* append_B(struct B* chain, int data)
{
1   for (; chain->next != 0; chain = chain->next) {};
2
3    chain->next = new_B();
4    chain->next->i_b1 = data;
5
6    return chain->next;
}

ZEILE:
1 hier wird geschaut ob schon ein Strukturelement vorhanden ist, wenn nein== 0 dann speichere den Pointer auf das vorhergehende Element???
3 hier wird ein Neues B an die Liste gehängt
4 hier werden Daten weggeschrieben ins neue Element
6 gibt den Pointer aufs neuen Element zurück :
Ich könnte also auch nach

int data=12;
struct B *aktuell, *b;
 
aktuell = append_B( b, data)
data++;
aktuell->i_b1 = data;

der Funktion die Daten in die Elemente des Strukturelement speichern.

[anda_skoa]

ZEILE:
1 hier wird geschaut ob schon ein Strukturelement vorhanden ist, wenn nein== 0 dann speichere den Pointer auf das vorhergehende Element???

Es wird ans Ende der Liste gewandert.
Man könnte das auch so schreiben, vielleicht ist das leichter lesbar:

while (chain->next != 0)
{
    chain = chain->next;
}

Muß man nicht machen, wenn man vorgibt, daß das letzte Element übergeben wird.

3 hier wird ein Neues B an die Liste gehängt
4 hier werden Daten weggeschrieben ins neue Element
6 gibt den Pointer aufs neuen Element zurück :

Alle korrekt

Ich könnte also auch nach der Funktion die Daten in die Elemente des Strukturelement speichern.

Natürlich, das war wieder nur ein Beispiel wie man es machen könnte
Die Idee ist, daß man alle üblichen Sachen immer in den Funktionen macht, weil man die dann nicht immer wieder schreiben muß und damit Fehlerquellen (Vertipper, etc) verringert.

Ciao,
_

[24dan]

Vielen Dank für die ausführliche Unterstützung.

Wenn ich jetzt z.B einen Text mit x Sätzen und y Wörtern hätte und die Daten:
Satzanzahl, SatzPosImText, Worte, bla. bla. ->Struct A zuordnen würde und:
WortImKlarText, WortInCodierterForm, bla. bla. ->Struct B zuordne würde das so gelöst werden können.
Frage: Ob man da noch was anderes als Structs/Objekte wählen sollte.

Vorteil hier ist:
Ich kann ans individuell die Listen je nach:
1) Anzahl der Worte eines Satzes -> Struct A
2) Anzahl der Buchstaben eines Wortes -> Struct B
erweitern/anpassen und erhoffe mir damit eine bessere Speicherverwaltung/Performence.

Habe ich etwas wesentliches bei der Überlegung übersehen?

[anda_skoa]

Das ist eine schwierige Frage, weil das stark davon abhängt, welche Aufgaben du anschließend mit den Daten lösen möchtest.

Wenn zum Beispiel der Text nicht verändert werden soll, könnte es besser sein, nur eine Liste von Sätzen zu haben und in den Satzstrukturen über Indexarrays zu speichern, wo Worte des Satzes beginnen und aufhören.

Wenn man hingegen die Wortreihenfolge in Sätzen ändern können soll, ist es wahrscheinlich besser jedes Wort in einer zweiten Struktur zu speichern.

Ciao,
_

[24dan]

Okay eventuell muss in Abhängigkeit der Buchstabenanzahl die Positionen des Wortes im Satz verändert werden. Naja ich werde erstmal versuchen mit den Objekten zu arbeiten.
Danke für den Tip.