# return -Zahl in C



## bmw4ever29 (10. Dezember 2015)

Hallo erstmal

Ich muss für die uni ein C Programm schreiben, welches bei einem Fehlerfall im "int main()" als rüchgabewert "returnvalue -4" zurückgeben soll. 
Ich hab bereits versucht "return -4;" zu verwenden, aber dann wird ~4260000 zurückgegeben. Vielleicht kann mir mal einer von euch helfen, ich wär euch sehr dankbar

MfG


----------



## 666mille (10. Dezember 2015)

Gib mal den kompletten Code!
Den habe ich gerade nochmal im Visual Studio als Consolenanwendung getestet und er gibt -4 zurück
int main()
{
    int i;
    i = 0;
    for (i = 0; i <= 10; i++)
    {
        if (i = 8)
            return -4;
    }
    return 0;
}


----------



## bingo88 (10. Dezember 2015)

Leider hängt das von der Plattform ab. Unter Linux sind beispielsweise nur returns zwischen 0 und 255 (8 Bit) möglich. Wenn du also return -4 in der main() machst, liefert dir ein "echo $?" nach Ausführung des Programms "252" als return Code. Die -4 werden quasi in den Wertebereich [0, 255] konvertiert.


----------



## xActionx (10. Dezember 2015)

Funktioniert bei mir unter Mint 17.3 ebenfalls problemlos.


```
#include <stdio.h>

int give_back(){
    int return_value = -4;
    return return_value;
}

int main(){
    printf("%i", giveback());
    
    return 0;
}
```



bingo88 schrieb:


> Leider hängt das von der Plattform ab. Unter Linux sind beispielsweise nur returns zwischen 0 und 255 (8 Bit) möglich. Wenn du also return -4 in der main() machst, liefert dir ein "echo $?" nach Ausführung des Programms "252" als return Code. Die -4 werden quasi in den Wertebereich [0, 255] konvertiert.



Das trifft aber nur auf unsigend ints zu. Ansonsten gibt Linux einen 8bit integer im Wertebereich von -128 bis 127 aus. --> https://de.wikipedia.org/wiki/Integer_(Datentyp)

Edit:
So habs jetzt in meiner ganzen Linux-Armee getestet. Arch, Kali2.0, Ubuntu14.04 & 15.10 und Mint 17.3. Geben mir alle -4 zurück.
Womit kompilierst du? Kannst du mit gdb umgehen?

MFG


----------



## lowskill (10. Dezember 2015)

@ xActionx: Es geht explizit um den Rückgabewert von main(), nicht von einer beliebigen Funktion.


----------



## xActionx (10. Dezember 2015)

lowskill schrieb:


> @ xActionx: Es geht explizit um den Rückgabewert von main(), nicht von einer beliebigen Funktion.



macht keinen unterschied welche Methode den Wert zurückgibt... Wenn du das ganze umstellst kommt bei mir übrigens ebenfalls -4 raus. Gerade durch den Debugger laufen lassen.

Integer-Funktion bleibt Integer-Funktion main() behandelt einen Integer ja nicht anders als 'int beliebige_methode()'

MFG


----------



## Zeiss (10. Dezember 2015)

Also, ich habe es gerade mal getestet:


```
#include <stdio.h>

int main (void) {

 return -4;
}
```

Danach:


```
heinrich@lenovo-t410:~/test123$ gcc retVal.c
heinrich@lenovo-t410:~/test123$ ./a.out ; echo $?
252
heinrich@lenovo-t410:~/test123$
```

Es ist echt komisch...


----------



## lowskill (10. Dezember 2015)

xActionx schrieb:


> Integer-Funktion bleibt Integer-Funktion main() behandelt einen Integer ja nicht anders als 'int beliebige_methode()'


Es geht darum, welchen Wert dein Programm nach seiner Beendigung zurückgibt und da Spielt eben auch das OS eine Rolle. Insofern macht es sehr wohl einen Unterschied, ob es sich um main() handelt oder nicht. Nichts für ungut, aber zumindest die bisherigen Beiträge könntest du sorgsam lesen, wenn es dir schon an Erfahrung mangelt.



Zeiss schrieb:


> Es ist echt komisch...


Ganz und gar nicht. Siehe den Beitrag von bingo88: http://extreme.pcgameshardware.de/programmierung-und-webdesign/418452-return-zahl-c-post7891936.html


----------



## xActionx (10. Dezember 2015)

Zeiss schrieb:


> Also, ich habe es gerade mal getestet:
> 
> 
> ```
> ...



Habe genau das gleiche Programm nur ohne void in der Main-Methode und bekomme mit diesem Aufruf -4 zurück. :\



lowskill schrieb:


> Es geht darum, welchen Wert dein Programm nach seiner Beendigung zurückgibt und da Spielt eben auch das OS eine Rolle. Insofern macht es sehr wohl einen Unterschied, ob es sich um main() handelt oder nicht. Nichts für ungut, aber zumindest die bisherigen Beiträge könntest du sorgsam lesen, wenn es dir schon an Erfahrung mangelt.



Wie willst du bitte beurteilen, dass es mir an Erfahrung mangelt? Du kennst weder mich noch meinen Programmierstil. 

Ich kann nichts dafür dass mein OS mir -4 zurück gibt und somit main() gleich behandelt wie alle anderen Methoden.

Muss jedoch anmerken, dass es mir unter Ubuntu 7.04 ebenfalls 252 zurück gibt.


----------



## Zeiss (10. Dezember 2015)

Naja, nicht desto trotz ist es Schwachsinn. Wenn ich in der main() eine -4 zurückgebe, dann will ich in der Bash auch eine -4 bekommen und nicht eine 256-4..


----------



## Zeiss (10. Dezember 2015)

xActionx schrieb:


> Habe genau das gleiche Programm nur ohne void in der Main-Methode und bekomme mit diesem Aufruf -4 zurück. :\



Und jetzt schau genauer Dein Programm und mein Programm an... Dein give_back() ist ein "Thema verfehlt", genau so wie printf(...). Es geht um Dein "return 0;" bzw. meinen "return -4"... LESEN!


----------



## xActionx (10. Dezember 2015)

Zeiss schrieb:


> Und jetzt schau genauer Dein Programm und mein Programm an... Dein give_back() ist ein "Thema verfehlt", genau so wie printf(...). Es geht um Dein "return 0;" bzw. meinen "return -4"... LESEN!



Wie gesagt auch mit dem exakt selben Aufruf aus deiner Main-Methode erhalte ich -4 und nich 252, zumindest bei einigen neueren Linux-Distros. Habe ich aber schon im vorherigen Post beschrieben... LESEN!

BTW: Es gilt Doppelposts zu vermeiden.

MFG


----------



## Zeiss (10. Dezember 2015)

Nochmal, Du hast es nicht geblickt um was es geht Kollege  Dein Programm hat mit der gestellten Fragestellung NICHTS zu tun.


----------



## xActionx (10. Dezember 2015)

Zeiss schrieb:


> Nochmal, Du hast es nicht geblickt um was es geht Kollege  Dein Programm hat mit der gestellten Fragestellung NICHTS zu tun.



Was für ein Zufall, habe nämlich inzwischen schon drei mal das gleiche Programm wie du benutzt...


```
#include <iostream>

int main(){
return -4;
}
```

und dann der Aufruf


```
./return ; echo $?
```

Komm mir schon blöd vor das nun ein drittes mal zu wiederholen, aber ich bekomme hier -4 zurück und nicht 252.
Dass das vorherige Programm theroetisch ein anderes Ergebnis liefern kann ist mir bewusst, verdeutlicht jetzt aber nochmal, dass ich trotzdem das gleiche zurück bekomme egal welche Methode ich aufrufe.

MFG


----------



## Muletto (10. Dezember 2015)

In Unixartigen Systemen, wird der Rückgabewert eines Programmes als ein unsigned 8 bit Wert dargestellt. Das heißt, sollte man eine negative Zahl in der main Funktion zurückgeben, dann hat das zur Folge, dass das zweier Komplement der Zahl verwendet wird. Da aber nur positive Zahlen verwendet werden, wird ein negativer Rückgabewert in der main Funktion anders von der Shell interpretiert. Wird z.B die -1 zurückgeben, dann erhält man in so einem Fall die 255.

Ich hoffe das hat euch etwas Klarheit verschafft. 

Gruß Muletto


----------



## Zeiss (10. Dezember 2015)

@xActionx: iostream ist C++ und nicht C.

@Muletto: Das ist schon klar, ist aber trotzdem irgendwie schwachsinnig.


----------



## Muletto (10. Dezember 2015)

@Zeiss: Ich glaube nicht, dass das jedem hier so klar ist. 
 Ob das schwachsinnig ist, kann jeder für sich selbst beurteilen. Nur in den meisten sollten die 256 Rückgabewerte an das OS, dem Programmierer sicher reichen.


----------



## Zeiss (10. Dezember 2015)

Ich meine dieses "Umwandlung" ist ziemlich schwachsinnig. Ich meine, wenn ich -1 returne, dann will ich doch auch -1 erhalten. Die 256 Rückgabewerte sind ja schon okay.


----------



## xActionx (10. Dezember 2015)

Zeiss schrieb:


> @xActionx: iostream ist C++ und nicht C.



fuu... stimmt verwechsel das öfters mal ^^

Bekomm den Compiler-flag wahrscheinlich am häufigsten...


----------



## Zeiss (10. Dezember 2015)

Passiert...


----------



## lowskill (10. Dezember 2015)

xActionx schrieb:


> Wie willst du bitte beurteilen, dass es mir an Erfahrung mangelt? Du kennst weder mich noch meinen Programmierstil.


Zum Beispiel, weil du nicht mal in der Lage bist/warst das eigentliche Problem zu erfassen. Abgesehen davon ist das keine Frage des "Programmierstils".


----------



## Zeiss (10. Dezember 2015)

Dafür hat er in der Signatur "C++ | Ruby | Java" stehen, da können wir einpacken


----------



## bingo88 (11. Dezember 2015)

In der glibc (bits/waitstatus.h) wird der return Code so ermittelt: 

```
#define     __WEXITSTATUS(status)   (((status) & 0xff00) >> 8)
```


----------



## Zeiss (11. Dezember 2015)

Okay, jetzt ist es klar, wie die 252 zustande kommen.

Danke Dir.


----------



## xActionx (11. Dezember 2015)

lowskill schrieb:


> Zum Beispiel, weil du nicht mal in der Lage bist/warst das eigentliche Problem zu erfassen. Abgesehen davon ist das keine Frage des "Programmierstils".



1. habe ich das Problem erfasst... und 2. kann man am Stil sehr wohl den Erfahrungslevel erkennen.



Zeiss schrieb:


> Dafür hat er in der Signatur "C++ | Ruby | Java" stehen, da können wir einpacken



Keine Ahnung was die Bemerkung soll, aber gut dass du immer schön objektiv bleibst 

Ich geb ja sogar zu, dass mein erster Post etwas vorbei am Topic war, alles was danach kam jedoch nicht und ich kann auch nur wiederholen, dass ich unter einigen Linux Distros -4 zurück bekomme kann mir das wer erklären?


----------



## bingo88 (11. Dezember 2015)

xActionx schrieb:


> Ich geb ja sogar zu, dass mein erster Post etwas vorbei am Topic war, alles was danach kam jedoch nicht und ich kann auch nur wiederholen, dass ich unter einigen Linux Distros -4 zurück bekomme kann mir das wer erklären?


Welche sind das denn? Bei mir erhalte ich unter Ubuntu 14.04 und 15.10 jeweils 252.


----------



## Zeiss (11. Dezember 2015)

Mein Ubuntu 15.10 liefert ebenfalls 252 zurück.


----------



## xActionx (11. Dezember 2015)

14.04 und 15.04 (sry nicht 15.10) liefern mir -4... 7.04 Live gibt 252 zurück. Laufen alle in ner VM.


----------



## Zeiss (11. Dezember 2015)

Faszinierend........


----------



## xActionx (11. Dezember 2015)

So habs jetzt nochmal unter Mint 17.03 versucht gibt mir -4 zurück...


----------



## DOcean (11. Dezember 2015)

unter Windows bekomm ich auch -4 zurück.

Würde man ja auch erwarte ist ja int main (..) und nicht uint main (..)


----------



## bingo88 (11. Dezember 2015)

DOcean schrieb:


> unter Windows bekomm ich auch -4 zurück.
> 
> Würde man ja auch erwarte ist ja int main (..) und nicht uint main (..)


Windows speichert das auch in einem min. 32 Bit Integer. Das ist daher nicht vergleichbar.



xActionx schrieb:


> So habs jetzt nochmal unter Mint 17.03 versucht gibt mir -4 zurück...


Post bitte mal deinen Code + den Compileraufruf inkl. aller Flags.


----------



## xActionx (11. Dezember 2015)

bingo88 schrieb:


> Windows speichert das auch in einem min. 32 Bit Integer. Das ist daher nicht vergleichbar.
> 
> 
> Post bitte mal deinen Code + den Compileraufruf inkl. aller Flags.




```
#include <stdio.h>

int main(){

return -4;
}
```


```
gcc -o return -w return.c
```


----------



## Zeiss (11. Dezember 2015)

Ist in der Bash was gesetzt? CFLAGS oder sowas?


----------



## bingo88 (11. Dezember 2015)

Hab deinen Code mal kopiert und mit deinem Compileraufruf unter Xubuntu 15.10 mit gcc 5.2.1 kompiliert. Ergebnis: 252 

Ist ein frisches OS, keine Basteleien an bash oder so vorgenommen, alles wie out of the box.


----------



## Zeiss (11. Dezember 2015)

Genau dasselbe wie bei mir auch.


----------



## xActionx (11. Dezember 2015)

Hmmm komisch das ganze... Am Bash hab ich nichts rumgefrickelt. Ist mir eigentlich auch nicht sooo wichtig würde mich nur mal interessieren woran das liegen könnte.


----------



## Zeiss (11. Dezember 2015)

Ja, das ist wirklich sehr komisch.

Poste mal den Output von "file return".


----------



## xActionx (11. Dezember 2015)

Zeiss schrieb:


> Ja, das ist wirklich sehr komisch.
> 
> Poste mal den Output von "file return".




```
return: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]= <checksum>, not stripped
```


----------



## Zeiss (11. Dezember 2015)

So sieht es bei mir aus:


```
heinrich@t410:~/dev$ file a.out 
a.out: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=d1b45012ae4a2934cd239f2459e8ba2ede6c17c3, not stripped
heinrich@t410:~/dev$
```


----------



## xActionx (11. Dezember 2015)

```
interpreter /lib64/ld-linux-x86-64.so.2
```

Das hier fehlt bei mir komplett, wobei das nichts damit zu tun haben dürfte...


----------



## bingo88 (11. Dezember 2015)

xActionx schrieb:


> ```
> return: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]= <checksum>, not stripped
> ```


Sieht bei mir genau so aus. Ich habe das jetzt auf drei verschiedenen Ubuntu-Maschinen versucht (14.04, 2x 15.10) und bei mir kommt immer 252 raus. Äußerst merkwürdig das Ganze...


----------



## lowskill (11. Dezember 2015)

Hängt es eventuell von der verwendeten Shell ab?


----------



## xActionx (12. Dezember 2015)

lowskill schrieb:


> Hängt es eventuell von der verwendeten Shell ab?



Keine Ahnung könnte ich mir vorstellen...


----------



## Muletto (12. Dezember 2015)

Ich kann mir gut vorstellen, dass irgendwo in den Shell Einstellungen, sowas in der Art vermerkt ist.

# Letzen Wert des zuletzt aufgerufenem Programmes speichern
returnValue=$?
((returnValue> 128)) && ((returnValue=returnValue-256))

Und tada, da hat man seine Minuszahl.

Gruß Muletto


----------



## DOcean (12. Dezember 2015)

interessant wäre mal Werte die nicht mehr in 8/16 Bit passen sowohl positiv als auch negativ

int sind ja fast immer 32Bit breit...


----------



## bingo88 (12. Dezember 2015)

Zumindest bei der glibc wird der Exitcode auf 8 Bit heruntergebrochen, da spielt der ursprüngliche Datentyp keine Rolle (siehe hier).


----------



## VikingGe (12. Dezember 2015)

*@xActionx* Poste doch mal die Binary, bitte. Auf nem topaktuellen Arch bekomme ich auch 252 raus (egal ob clang oder gcc, bash oder zsh), aber mich interessiert das jetzt.


----------



## bmw4ever29 (12. Dezember 2015)

Hallo leute

Hab vollkommen auf den Thread vergessen, sry. Aber nachdem ich das programm unter linux compiliert habe, habe ich als return wert 252 heraus bekommen. Nach absprache mit dem programmier Tutor war das richtig, insofern hab ich mich nur von den 40000000 verwirren lassem. Danke vielmals für eure antworten.

Gruß bmw4ever29


----------



## bockwurst90 (12. April 2016)

xActionx schrieb:


> ```
> interpreter /lib64/ld-linux-x86-64.so.2
> ```
> 
> Das hier fehlt bei mir komplett, wobei das nichts damit zu tun haben dürfte...



Nein hat es nicht. Das gehört zum ELF Format und sagt nur, welches Programm der Loader ist. Ein anderer Loader würde evtl. eine andere Struktur der Binary.


----------



## bockwurst90 (12. April 2016)

Ich kann euch gerne erklären, wieso ihr so verschieden Effekte beobachtet. Dazu muss man aber von jedem den Code haben. Man muss auch genau verstehen wie C und die Architektur funktioniert (implicit type conversion, endianess, program loader and interprocess communication...)


----------

