Das längste Thema

Glaub ich nicht, das Jahrzehnt geht ja immer von Jahr 0 bis 9.

Irgendwo hab ich gelesen das es nie das Jahr 0 gab. Jahrtausend begann doch auch erst 2001.

Offiziell zählt man anscheinend wirklich von 1. Ich halte es dennoch für groben Unfug

Quote from geekmonkey

[netcup] Felix P. vielen lieben Dank für mein Weihnachtspaket, ging leider bei dem Umzug etwas unter. Gerade in der Kiste auf der Terrasse entdeckt - war wohl ohne Nachricht am Ablageort hinterlegt worden haha.

War das der Paketzusteller, der gekündigt wurde, weil er Pakete auch gern mal auf dem Dach seines Fahrzeugs stehend auf den Balkon im 1. Stock geworfen hat? Was natürlich nicht immer beim ersten Versuch geklappt hat . Da kam gestern was im Fernsehen.

Hurra, nach mehr als ¼ Jahrhundert funktioniert das alte Turbo Pascal noch immer

hab' f. einen Bekannten eine VM mit einem blanken DOS und eben Turbo Pascal erstellt;

hier ein Testprogramm:

screenTPprog.png

und da das ja in einer VM auf einer aktuellen Hardware läuft

wird auch binnen 1-2 Sekunden das erwartete Ergebnis ausgegeben

sum: -32768

logisch, muss ja so sein, und jetzt kommts:

folgendes in C

#include <stdio.h>

int main( int argc, char* argv[ ] )
{
    short int nIter;
    long lSum = 0;

    for ( nIter = -32768; nIter <= 32767; nIter++ )
        lSum += nIter;

    printf( "sum: %ld\n", lSum );

    return 0;
}

lieferte eine sehr seltsame Überraschung;

eine Endlosschleife

und das sowohl beim uralten Turbo C, als auch beim Intel C/C++ compiler unter Linux

wie auch beim GNU C

und das egal ob 32-bit od. 64-bit

man glaubt es nicht,

das FORTRAN Pendant

      PROGRAM SumDemo
      INTEGER*2 nIter
      INTEGER*4 lSum
      lSum = 0
      DO nIter = -32768,32767,1
      lSum = lSum + nIter
      END DO
      WRITE ( *, * ) 'sum: ', lSum
      END

liefert das gewünschte Ergebnis;

was läuft da in C falsch?

passt doch

deffinition Zeitrechnung wenn Tag 0, auch 0 ist.

wir fangen um mitternacht an

zum jahreswechsel 20/21 ist dann schon das erste jahr vorbei

also sind wir morgen um diese zeit schon mitten im neuen Jahrzehnt.

Pber was wir uns streiten können ist ob wir uns im Jahrzent 2010, 2020, 2030 oder doch erst im 2000 befinden.

P.S. aber wir wissen alle, die Elektriker waren die ersten, noch viel älter als Steinmetze (Pyramiden) oder Zimmerleute (Arche), denn es steht schon in der Bibel als Gott Sprach es werde Licht, waren die Elektriker schon fertig.

Quote from LanOpa

also sind wir morgen um diese zeit schon mitten im neuen Jahrzehnt.

da würd ich mir ernsthaft Sorgen machen

Frohe Ostern

Quote from mfnalex

SFTP sollte automatisch funktionieren für User, die sich per SSH anmelden können.

und f. zusätzliche User ebenfalls möglich, falls rsshd installiert ist;

damit können User sich per sftp/scp anmelden, obwohl ihnen die Anmeldung per ssh verwehrt ist;

(habe ich bei mir f. den non-Root User so definiert)

Quote from mainziman

was läuft da in C falsch?

Gar nichts. Probier mal:

for ( nIter = -32766; nIter <= 32766; nIter++ ){

Ach so, bevor jemand fragt:

32767 + 1 = -32768

Quote from Loxley

Ach so, bevor jemand fragt:

32767 + 1 = -32768

Wie das halt so ist bei einem 2 Byte short int. Wie sollte der signed short int auch größer werden als 32767?

tab  Loxley klar ein 16-bit short int hat den Wertebereich -32768 ... 32767

aber in Pascal und FORTRAN geht das, wieso nicht in C?

oder ist das dem doch universellerem Syntax-Konstrukt von C geschuldet?

(in FORTRAN geht die auch mit floating-point)

Loxley Deine Schleife läuft aber nur von -32766 bis 32766

wie macht man in C eine Schleife auf Basis von 16-bit ints von -32768 bis 32767 die in keine Endlos-Schleife ausufert?

oder habe ich hier etwas 'entdeckt', was tickende Zeitbomben in vielen Anwendungen darstellt?

in C ergibt klarerweise das Code Snippet

short int nIter = 32767; nIter++;

hier den Wert -32768

analoges passiert auch in FORTRAN bzw. Turbo Pascal;

Das Problem ist nicht der Wertebereich, das „Problem“ ist die Schleife. Du gehst bis 32767, machst dann ein nIter++. Dabei gibt es einen Overflow und Du landest bei -32768. Damit wird Deine Abbruchbedingung „nIter > 32767“ (sic!) nie erfüllt (short signed int kann nicht größer 32767 werden) und Du hast eine Endlosschleife.

Quote from mainziman

wie macht man in C eine Schleife auf Basis von 16-bit ints von -32768 bis 32767 die in keine Endlos-Schleife ausufert?

while(nIter++<32767)

printf( "sum: %d\n", nIter );

Quote from Loxley

while(nIter++<32767)

printf( "sum: %d\n", nIter );

das ist aber eine Endlos-Schleife per se, weil ( nIter++ <= 32767 ) IMMER wahr ist;

ich hab es geändert, sieht jetzt so aus

#include <stdio.h>

int main( int argc, char* argv[ ] )
{
    short int nIter = -32768;
    long lSum = 0;

    do
    {
        lSum += nIter++;
    }
    while ( nIter > -32768 );

    printf( "sum: %ld\n", lSum );

    return 0;
}

und es wird das gewünschte Ergebnis geliefert;

das 'short' sollte man hier besser NIE entfernen,

weil dann macht das Programm evtl. was anderes

Und jetzt das Beispiel nochmal lesen… (Hint: < != <=)

Loxley stimmt es löst das Problem der Endlosschleife, bringt aber ein falsches Ergebnis; nämlich als Summe 0;

Guten Rutsch liebe Netcup-Freunde

Guten Rutsch an alle!

Quote from mfnalex

Guten Rutsch liebe Netcup-Freunde

Dir ebenfalls. Ich schau mir nachher noch das Feuerwerk an und mache vielleicht ein paar Bilder. Unsere Endlosschleife läuft ja nicht weg, die läuft endlos . Deswegen heißt sie ja so. Man könnte das nun natürlich auch trotzdem völlig unelegant mit einer Endlosschleife lösen, aus der man im richtigen Moment rausspringt. Trotzdem muss ich zugeben, dass das alles nicht so elegant und intuitiv ist wie in Fortran. Das liegt aber nur an der sehr speziellen Aufgabe und der Forderung, es muss mit 2-Byte short gearbeitet werden. Das ist mittlerweile wohl eh suboptimal in Zeiten der 64 Bit Prozessoren. Und je nach Repräsentation der negativen Zahlen in so manchem C überhaupt nicht machbar. Obwohl zumindest die erste Ausrede durch eine kleine Änderung der Aufgabe leicht zunichte gemacht werden kann.

#include <stdio.h>
int main( int argc, char* argv[ ] )
{
    short int nIter;
    long lSum = 0;
    for ( nIter = -32768; ; nIter++ ) {
        lSum += nIter;
        if (nIter == 32767)
            break;
    }
    printf( "sum: %ld\n", lSum );
    return 0;
}