Knifflige CPP-Datenübergabe;

[anfaenger (Gast)]

Hallo,
ich habe hier Probleme bei der Konvertierung eines CPP-Sourcecodes der 
früher mit einem Borland-Compiler übersetzt wurde und jetzt mit dem 
GNU-Compiler übersetzt werden soll.
Der Borland-Compiler hat den Code geschluckt, der GNU Compiler (unter 
Eclipse) bringt diese Fehlermeldung :

>"error: cannot convert `short unsigned int (*)[30]' to `short unsigned >int*' for 
argument `6' to `int "

Situation : In Funktion A ist die Variable "unsigned short 
Messwerttyp[MAXSIGS]={0}" definiert, die an die Funktion B übergeben und 
dort verändert wird und so an die Funktion A zurückgegeben wird (bei der 
realen Funktion ist die Variable das 6. Element des Funktionsaufrufes)

Hat jemand eine Idee, wie der Code verändert werden kann, damit er auch 
vom GNU CPP-Compiler akzeptiert wird ?

/*------------------------------------------------------------*/
void funktion_B(unsigned short *typ)
  {
    unsigned short typtemp;

    typtemp = 1;
    *typ=typtemp;  // unsigned short typtemp;
    +typ++;
    // ... und weiter
  }
/*------------------------------------------------------------*/

void funktion_A()
  {
    unsigned short Messwerttyp[MAXSIGS]={0};  // in "global.h" :
                                              // #define MAXSIGS 30
    funktion_B(&Messwerttyp)
    // ... weiter in der Funktion ...

  }
/*------------------------------------------------------------*/

[anfaenger (Gast)]

Korrektur der Fehlermeldung :

>"error: cannot convert `short unsigned int (*)[30]' to `short unsigned
>int*' for  argument `6' to `int "

[Murkser (Gast)]

Das ist nicht die Fehlermeldung zu dem Programm, welches Du uns hier 
zeigst, sondern zu irgend einem anderen Programm, daß irgendwie 
vielleicht ähnlich ist. Du willst es uns also schwerer als notwendig 
machen, Dir zu helfen.

Versuch es dennoch mal mit funktion_B(&Messwerttyp[0])

Murkser

[Tim T. (tim_taylor)]

Oder wie wärs mit:

funktion_B(Messwerttyp)

[Rolf M. (rmagnus)]

Murkser schrieb:
> as ist nicht die Fehlermeldung zu dem Programm, welches Du uns hier
> zeigst, sondern zu irgend einem anderen Programm, daß irgendwie
> vielleicht ähnlich ist.

Abgesehen davon, daß es sich laut Fehlermeldung um Argument 6 handelt, 
die Funktion aber nur einen einzigen Parameter hat, ergibt die 
Fehlermeldung durchaus einen Sinn. Aber du hast schon recht, daß man 
immer den Code posten sollte, der die Fehlermeldung produziert hat und 
nicht sowas ähnliches.

anfaenger schrieb:
> void funktion_B(unsigned short *typ)

Ok, funktion_B erwartet also einen Zeiger auf unsigned short.

>     unsigned short Messwerttyp[MAXSIGS]={0};  // in "global.h" :
>                                               // #define MAXSIGS 30
>     funktion_B(&Messwerttyp)

Messwerttyp ist ein Array aus 30 unsigned short. &Messwerttyp ist daher 
ein Zeiger auf ein Array aus 30 unsigned short (`short unsigned int 
(*)[30]'). Da die Funktion aber einen Zeiger auf unsigned short will 
(`short unsigned int*'), passen die Typen nicht zusammen. Wie von 
Murkser vorgeschlagen, brauchst du die Adresse des ersten Elements, oder 
du kannst wie von Tim vorgeschlagen die implizite Konvertierung eines 
Arrays in einen Zeiger auf sein erstes Element nutzen.

[anfaenger (Gast)]

Erst mal vielen Dank für die Antworten.

ich werde es mit "funktion_B(&Messwerttyp[0])" versuchen und dann 
Bescheid sagen, ob es geklappt hat.

Mit "funktion_B(Messwerttyp)" würden doch in Funktion B geänderte Werte 
nicht zurückgegeben ? (oder habe ich da was falsch verstanden)

Die Originalfuntion hat wie gesagt etliche Parameter, ich habe daher der 
Übersichtlichkeit halber für das Beispiel nur den problematischen 
herausgezogen, das Beispiel ist so aber schon korrekt (nur die Nummer 
des Arguments in der Fehlermeldung stimmt daher nicht, bezogen auf das 
Beispiel müsste es 1 statt original 6 heissen)

[Rudi (Gast)]

Wenn du ein Array an eine Funktion übergibst "function_B(Messwerttyp)" 
wird automatisch die Adresse des ersten Elements übergeben, weswegen der 
Volksmund auch oft sagt: Array = Zeiger.
Damit sollte es bei dir aber klappen und ist (für mich) besser lesbar 
als &Messwerttyp[0].

Mal davon abgesehn, dass die Benennung deiner Variable als "Messwerttyp" 
für das Programmveständnis nicht eben förderlich ist. Den ein Typ ist 
(eigentlich) was anderes...
Aber das musst du wissen :-)

[anfaenger (Gast)]

Rudi schrieb:
> Mal davon abgesehn, dass die Benennung deiner Variable als "Messwerttyp"
> für das Programmveständnis nicht eben förderlich ist. Den ein Typ ist
> (eigentlich) was anderes...
> Aber das musst du wissen :-)

Thx, aber das Programm ist nicht von mir, ich muss es nur von BCC 
(Borland) auf GCC (GNU) konvertieren und den Namen für das Beispiel habe 
ich direkt aus dem Code übernommen.
Ich dachte immer, nur Char-Arrays (Strings) können so übergeben werden, 
wenn man Änderungen in einer Funktion ausserhalb zurückbekommen will.
Wieder was gelernt :-)