Pointer auf Struktur an Funktion übergeben???

[frosch03]

Morgen zusammen,

habe follgende Frage:

Angenommen in der Funktion1 wird eine Struktur

deklariert. Ausserdem wird ein pointer auf diese

Struktur deklariert.

Und jetzt soll in einem Funktionsaufruf (z.B. von

Funktion2) der Pointer mit übergeben werden.

Kann das funktionieren? (Wenn ja, ab welchem Standart)

Und wenn nicht, was müsste man tun, damit sowas

funktioniert? (z.B. Struktur vorher bekannt machen

oder etwas derartiges?)

Freue mich auf jede info dazu!

gruß Frosch03

[HELLmut]

das geht schon, du übergibst einfach einen pointer auf dein struct. ist also genauso zu handhaben wie jeder andere pointer auch, und der dateityp worauf er zeigt ist deine struktur.

z.b.:

struct struktur{int a;int b; ...};

void funktion2(struktur *p_struct);

int main()

{

...

funktion2(p_zeiger);

...

}

void funktion2(struktur *p_struct)

{

...

}

alles klar?

[Klotzkopp]

Original geschrieben von frosch03

Angenommen in der Funktion1 wird eine Struktur

deklariert. Ausserdem wird ein pointer auf diese

Struktur deklariert.

Und jetzt soll in einem Funktionsaufruf (z.B. von

Funktion2) der Pointer mit übergeben werden.

Kann das funktionieren?

Nein, weil Funktion2 den Typ der Struktur nicht kennen kann.

Und wenn nicht, was müsste man tun, damit sowas

funktioniert? (z.B. Struktur vorher bekannt machen

oder etwas derartiges?)

Genau, die Struktur muss außerhalb der beiden Funktionen deklariert werden.

[frosch03]

Ok,

das hört sich ja schon garnicht so schlecht an ;-)

Wenn ich jetzt meine struktur vorher schon bekannt

mache, kann ich dann von einer globalen struktur

sprechen? Oder trifft das erst zu, wenn ich auch

variablen von dem typ der struktur global deklariere?

anonsten auf jeden fall n dank an euch beide ;-)

gruß Frosch03

[Klotzkopp]

Original geschrieben von frosch03

Wenn ich jetzt meine struktur vorher schon bekannt

mache, kann ich dann von einer globalen struktur

sprechen? Oder trifft das erst zu, wenn ich auch

variablen von dem typ der struktur global deklariere?

Außerhalb der beiden Funktionen muss nicht zwangsläufig global sein. Wenn die Funktionen z.B. in einer Klasse deklariert sind, kann die Struktur auch lokal bezüglich dieser Klasse deklariert werden.

Ich würde die Struktur dann global nennen, wenn ihre Deklaration global ist. Der Gültigkeitsbereich der erzeugten Instanzen ist da irrelevant.

[frosch03]

Jetzt muss ich nochmal nachfragen ;-)

wo ist es denn sinnvoll die struktur bekannt zu

machen? oder wo wird soetwas häufig gemacht?

ach ja, das ganz soll sich auf C beziehen.

gruß Frosch03

[gugelhupf]

Original geschrieben von Klotzkopp

Nein, weil Funktion2 den Typ der Struktur nicht kennen kann.

Versteh ich jetzt nicht ganz. Wenn in Foo1 die Struktur auf dem Heap allokiert wird steht doch ein gültiger Pointer zur Verfügung ?!

Dass man das so nicht lösen sollte ist ein anderes Thema, geschweige denn so einen Heappointer auf eine andere Foo2 zu übergeben *würg*

[gugelhupf]

#include <iostream.h>

void foo2(void*);

void foo1()

{

struct test

{

int x;

char str;

};

test* par1=new test;

par1->x=10;

par1->str='H';

foo2(par1);

delete par1;

}

void foo2(void* strp)

{

cout << *((char*)strp+4) << "\r\n";

cout << *((int*)strp);

}

int main()

{

foo1();

return 0;

}

Soviel zum Beitrag: "Programmierung unter aller Sau"

Aber gehen tut fast alles....

[Klotzkopp]

Original geschrieben von gugelhupf

Soviel zum Beitrag: "Programmierung unter aller Sau"

Aber gehen tut fast alles....

Klar geht das. Aber Du kommst dafür in die Programmiererhölle

[gugelhupf]

Original geschrieben von Klotzkopp

Klar geht das. Aber Du kommst dafür in die Programmiererhölle

Das ist zu wenig Strafe ! :cool: :cool: :cool:

Give me five....

[StarLord]

Original geschrieben von Klotzkopp

Nein, weil Funktion2 den Typ der Struktur nicht kennen kann.

Natürlich geht es und natürlich muss die Funktion den Aufbau der Struktur kennen... was sollte das ganze sonst bringen?

Wenn es nicht gehen würde wäre Windows ganz schön aufgeschmissen: ist zwar hier OT, aber habt ihr euch schon mal die SetupAPI-Funktionen angeschaut? Da wird einem von Strukturen und Zeiger auf Strukturen richtig schlecht...

In dem 1. geposteten Beispiel fehlt übrigens der Address-Operator: funktion2(&p_zeiger) sollte es wohl heißen sonst haut das mit dem Pointer nicht so ganz hin.

Gruß,

StarLord

[gugelhupf]

Original geschrieben von StarLord

In dem 1. geposteten Beispiel fehlt übrigens der Address-Operator: funktion2(&p_zeiger) sollte es wohl heißen sonst haut das mit dem Pointer nicht so ganz hin.

Gruß,

StarLord

Natürlich geht es !

Kopier es , compilier es und schau die Adressen im Debugger nach !

[gugelhupf]

*grmpf*

sorry starLord...hast das andere beispiel gemeint

*entschuldigungsag*

[StarLord]

Original geschrieben von gugelhupf

*grmpf*

sorry starLord...hast das andere beispiel gemeint

*entschuldigungsag*

Jetzt muss ich auch noch meinen Lieblingsspruch abändern damit ich dazu Worte finde: "Wer zählen kann hat Vorteile im Leben!"

Macht aber nix, jeder macht mal Fehler.

Gruß,

StarLord

[Klotzkopp]

Original geschrieben von StarLord

Natürlich geht es und natürlich muss die Funktion den Aufbau der Struktur kennen... was sollte das ganze sonst bringen?

Es ging nicht darum, ob man Zeiger auf Strukturen als Funktionsparameter übergeben kann, das steht wohl außer Frage. frosch03 wollte wissen, ob man einen Zeiger auf eine Struktur, die in einer Funktion deklariert ist, an eine andere Funktion übergeben kann.

[nic_power]

Original geschrieben von Klotzkopp

Es ging nicht darum, ob man Zeiger auf Strukturen als Funktionsparameter übergeben kann, das steht wohl außer Frage. frosch03 wollte wissen, ob man einen Zeiger auf eine Struktur, die in einer Funktion deklariert ist, an eine andere Funktion übergeben kann.

Natuerlich geht das und die Zielfunktion muss auch nicht den Aufbau der Struktur kennen. Du musst in der Zielfunktion nur ein "void *" bzw "char *" als Parameter deklarieren. Ohne diese Mechanismen waere C ziemlich unbrauchbar, da malloc und free beispielsweise nicht funktionieren wuerden. Malloc/Free fuehren Adresslisten zur Speicherverwaltung, wie die Strukturen aussehen ist dabei voellig unerheblich.

Nic

[StarLord]

Original geschrieben von Klotzkopp

Es ging nicht darum, ob man Zeiger auf Strukturen als Funktionsparameter übergeben kann, das steht wohl außer Frage. frosch03 wollte wissen, ob man einen Zeiger auf eine Struktur, die in einer Funktion deklariert ist, an eine andere Funktion übergeben kann.

Auch das geht, solange er die Struktur (bzw den Zeiger auf die Struktur) als "static" deklariert, damit beim verlassen des Anweisungsblockes die Struktur-Daten nicht gelöscht werden bzw der Zeiger verloren geht. Die Main-Funktion ist übrignes auch nur eine Funktion... sagt ja schon der Name.

Gruß,

StarLord

[frosch03]

das hört sich jetzt aber doch interesannt an!

wenn du mir jetzt vielleicht noch so ein paar zeilen

code schreiben könntest währe ich echt glücklich ;-)

gruß Frosch03

[StarLord]

Ok, hier ein lauffähiges Beispiel (DOS Borland C Compiler):

#include <stdio.h>

#include <conio.h>


// Struktur definition muss für beide Funktionen vorhanden sein, daher mal global

struct my_struct {

  int a;

  int b;

};


// Funktionen definieren

void main     ( void );

void funktion1( void );

void funktion2( struct my_struct *p_struct );


void main() {

  clrscr();

  funktion1();

  while(!kbhit()); getch();

}


void funktion1( void ) {

  static struct my_struct test_struktur;


  test_struktur.a = 100;

  test_struktur.b = 2000;

  funktion2(&test_struktur);

}


void funktion2(struct my_struct *p_struct) {

  printf("p_struct:\n\ta= %d\n\tb= %d", p_struct->a, p_struct->;

}

[/code]

Alles klar, oder wolltest du es anders haben?

Gruß,

StarLord

[frosch03]

Oki Doki,

das tut jetzt soweit bei mir auch.

was mich jetzt noch interresiert ist die idee von nic_power:

Natuerlich geht das und die Zielfunktion muss auch nicht den Aufbau der Struktur kennen. Du musst in der Zielfunktion nur ein "void *" bzw "char *" als Parameter deklarieren.

wie das jetzt funzen soll ist mir noch nicht so ganz klar.

ich hatte das schon mal probiert, aber naja, irgendwie

gab es halt fehler beim compilieren. Danach war ich für

ne woche im urlaub und jetzt denk ich mich halt wieder

rein ;-)

also,

Gruß Frosch03

[Crush]

Man müßte schon mit RTTI arbeiten um das Problem zu lösen, bzw. eine spezielle Klasse schreiben, die das "aufspüren" von unbekannten Structs übernimmt und entsprechend static_castet (was allerdings gefährlich ist). Mit einer Struktur alleine hat man fast keine Chance etwas zu erreichen. Objekte jedoch halten noch weitere Kennzeichnungen bereit, die man bestimmt irgendwie direkt abfragen könnte. Also entweder typgerecht serialisieren oder vom void aus einlesbare Kennungen setzen, wie ein 4-Byte-String der den Typ oder einen "Schlußstrich" beinhaltet und danach die Daten (z.B. wie bei IFF-"ILBM"-Files).

Allerdings wie Klotzkopp sagte: Ist kein empfehlenswerter Stil (Rambo hätte das Problem mit voids gelöst), unübersichtlich, unsinnig. Wenn ich von der Seite bequem aufs Pferd steigen kann versuche ich doch nicht absichtlich mich an den Ohren über den Kopf auf den Sattel zu ziehen und geh auch noch das Risiko ein, daß mir in den dicken Zeh gebissen wird. =8-)

Ein (nase)weiser Spruch zum Abschluß: Eine Struktur ist eine Klasse ohne Methoden!!! Warum also nicht gleich ein Objekt draus machen?

[nic_power]

Original geschrieben von Crush

Allerdings wie Klotzkopp sagte: Ist kein empfehlenswerter Stil (Rambo hätte das Problem mit voids gelöst), unübersichtlich, unsinnig. Wenn ich von der Seite bequem aufs Pferd steigen kann versuche ich doch nicht absichtlich mich an den Ohren über den Kopf auf den Sattel zu ziehen und geh auch noch das Risiko ein, daß mir in den dicken Zeh gebissen wird. =8-)

Wie schon weiter oben erwaehnt, so pauschal kann man diese Aussage nicht treffen. Es kommt auf den Anwendungszweck an. Moechtest Du in der Zielfunktion auf die einzelnen Struktur-Elemente zugreifen, dann hast Du recht. Geht es aber beispielsweise darum, eine Speicherverwaltung zu implementieren, ist dies die gaengige Vorgehensweise. Die C-Bibliothek macht heftigst Gebrauch davon und das Wissen ueber das Struktur-Layout ist an dieser Stelle voellig ueberfluessig, einzig und allein der Wert des Pointers zaehlt.

Nic

[Klotzkopp]

Original geschrieben von Crush

Ein (nase)weiser Spruch zum Abschluß: Eine Struktur ist eine Klasse ohne Methoden!!! Warum also nicht gleich ein Objekt draus machen?

Weil der Fragesteller dieses Threads darauf hingewiesen hat, dass es um C geht

Wo wir gerade davon reden, hat noch jemand was zu frosch03s letzter Frage zu sagen?

[nic_power]

Original geschrieben von Klotzkopp

Weil der Fragesteller dieses Threads darauf hingewiesen hat, dass es um C geht

Wo wir gerade davon reden, hat noch jemand was zu frosch03s letzter Frage zu sagen?

Aber ja doch (Mini-Simple-Beispiel fuer angehende malloc/free Implementierer) .

int main()

{

  allocPtr();

}


int allocPtr()

{

  struct x{

    char a;

    char b;

  } *p;

  funcPtr(p);

}


funcPtr(void *ptr)

{


  ...

 }

[frosch03]

hey das sieht nett aus ;-)

das probier ich gleich mal aus .....

//hätt ich auch selber drauf kommen können, naja egal

BTW: Währe es totaler unsinn dieses Forum noch weiter aufzuteilen

in einen C und C++ Bereich?

n schönen abend noch

gruß Frosch03