Arrays übergeben

Nick H.

Moin

ich probier jetzt seit einer halben Stunde irgendwie an eine funktion Array zu übergeben:

Die Funktion soll den Spaß annehmen:

void init(char *name[], short *buffer[])
{
}

und hier soll das ganze "abgschickt" werden

const short buffer[] = {0,0};
const char name[] = "LeafGL";
init(name, buffer);

und dazu kommt das buffer als Zeiger oder Referenz übergeben werden muss
das Teil wird später rießen groß

ich glaub das ging so
init(&name, &buffer);

Ausländer

hi,
versuch mal so:

void init( const char *name,const short *buffer) // nicht *name[] sondern *name
{
}

int main(int argc, char **argv)
{
   const short buffer[] = {0,0};      // const ?????
   const char name[] = "LeafGL";      // dann koennen die Werten im Funktion
   init(name, buffer);                // nicht verändert werden
   return 0;
}

damit übergibst du die Adressen von buffer und name (aus main) an die Funktion init().
in der Funktion kannst du auf die Arrays mittels name und buffer zugreifen, die Inhalte ändern kannst du aber nicht da die const sind.

Nick H.

danke das funktioniert schonmal
nächstes Problem:

wenn ich nun in der init Funktion:
init(const char *name,const short *buffer)
{
}

den buffer global machen will, so das er in der ganzen Datei gilt
wie geht das?

ich hab einfach mal das probiert:

short buffer[10];
short *pbuffer = buffer;

init(const char *name,const short *buffe)
{
*pbuffer = *buffe
}

hab auch schon nen Haufen anderes Zeug probiert, aber irgendwie ist das mit den Zeigern und Referenzen ein totales durcheinander

Ausländer

hi,

also wenn du den buffer global machst:

#include <stdio.h>

short buffer[10];

void init(const char * name)
{
    // auf buffer kannst jetzt einfach so zugreifen da global ist
    // also du brauchst auch keine Adresse mehr zu übergeben
}
int main( int argc, char *argv[])
{
   const char name[] = "LeafGL";      // dann koennen die Werten im Funktion 
   init(name);                // nicht verändert werden 
   return 0; 
}

Erkläre lieber was du vor hast, dann kann mann ja sehen was in deinem Fall auch besser passt, vieleicht ist es doch besser, den buffer local zu deklarieren und dann die Adressen/Zeiger zu übegeben???
Oder oder oder?????

Nick H.

also nochmal von vorn:

ich hab eine Datei die ist das letztendliche Programm
und eine andere die ist die Grafikschnittstelle

in dem eigentlichen Programm wird berechnet welcher Pixel welche Farbe haben muss
und dieser rießen Array muss dann irgendwie zur Schnittstelle gelangen, ohne das ich ihn komplett kopieren muss (da das viel zu lange dauert)

also übergebe ich von der eigentlichen Datei den Zeiger des Arrays an eine Funktion der anderen Datei
die Funktion muss nun irgendwie diesen Buffer global machen, damit der überall in der Schnittstelle nutzbar ist
das hab ich bis jetzt aber nur geschafft, in dem ich den ganzen Array kopiert hab

c.rackwitz

http://www.ecst.csuchico.edu/~beej/guide/ipc/
Beej's Guide to Unix IPC

oder willst du shared memory?

du weisst, jeder prozess hat eigenen virtuellen speicher. ein pointer kann fuer jeden prozess was anderes bedeuten.

Nick H.

was soll mir das denn bringen?
das muss doch irgendwie mit Zeigern oder Referenzen funktionieren

c.rackwitz

also was nun, hast du zwei programme oder eines?

hast du ahnung von pointern? wenn nicht, guck dir den pointer-artikel an.

Nick H.

ich red von zwei Dateien (weiß nicht wie man das fachlich ausdrückt)
die ich aber in eine exe kompiliere

c.rackwitz

nennen wir die mal "module" (kenne die richtige bezeichnung auch nicht).

hast du ahnung von pointern? wie lange machst du schon c?

Nick H.

soo lange mach ich c noch nich, das Problem is aber eher das ich davor Java gemacht hab
und jetzt verwechsel ich alles
versteh allerdings nich was das mit der Frage zu tun hat

irgendwo muss es doch ein Code Stück zu finden geben bei dem jemand einfach nur einen Array las Zeiger oder Referenz übergibt
hat keiner sowas?

icepacker

dein problem ist unklar

meinst du das: http://www.pronix.de/pronix-726.html