Knifflige CPP-Datenübergabe;

anfaenger Gast #2758140
Lesenswert?
• ▲
▼ 
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 ...

  }
/*------------------------------------------------------------*/
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Murkser Gast #2758146
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Rolf M. #2758200
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
anfaenger Gast #2758351
Lesenswert?
• ▲
▼ 
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)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Rudi Gast #2758360
Lesenswert?
• ▲
▼ 
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 :-)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
anfaenger Gast #2758373
Lesenswert?
• ▲
▼ 
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 :-)
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren