Was gehört zu einem Lehrmittel, um die ungerechtfertigten Annahmen zu demonstrieren, die Menschen in C / C ++ treffen?

Ich möchte ein kleines Lernwerkzeug für SO vorbereiten, das Anfängern (und fortgeschrittenen Programmierern) helfen soll, ihre ungerechtfertigten Annahmen in C, C ++ und ihren Plattformen zu erkennen und in Frage zu stellen.

Beispiele:

• "ganze Zahlen wickeln sich um"
• "Jeder hat ASCII"
• "Ich kann einen Funktionszeiger in einer Leere speichern *"

Ich dachte mir, dass ein kleines Testprogramm auf verschiedenen Plattformen ausgeführt werden könnte, das die "plausiblen" Annahmen ausführt, die nach unserer Erfahrung in SO normalerweise von vielen unerfahrenen / halb erfahrenen Mainstream-Entwicklern getroffen werden, und die Art und Weise aufzeichnet, wie sie auf verschiedenen Maschinen brechen.

Ziel ist es nicht, zu beweisen, dass es "sicher" ist, etwas zu tun (was unmöglich wäre, die Tests beweisen nur etwas, wenn sie brechen), sondern selbst dem verständnislosesten Individuum zu demonstrieren, wie unauffällig der Ausdruck ist brechen Sie auf einem anderen Computer ab, wenn dieser ein undefiniertes oder implementierungsdefiniertes Verhalten aufweist. .

Um dies zu erreichen, möchte ich Sie fragen:

• Wie kann diese Idee verbessert werden?
• Welche Tests wären gut und wie sollten sie aussehen?
• Würden Sie die Tests auf den Plattformen ausführen, die Sie in die Hände bekommen und die Ergebnisse veröffentlichen können, damit wir eine Datenbank mit Plattformen erhalten, wie sie sich unterscheiden und warum dieser Unterschied zulässig ist?

Hier ist die aktuelle Version für das Testspielzeug:

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include <stddef.h>
int count=0;
int total=0;
void expect(const char *info, const char *expr)
{
    printf("..%s\n   but '%s' is false.\n",info,expr);
    fflush(stdout);
    count++;
}
#define EXPECT(INFO,EXPR) if (total++,!(EXPR)) expect(INFO,#EXPR)

/* stack check..How can I do this better? */
ptrdiff_t check_grow(int k, int *p)
{
    if (p==0) p=&k;
    if (k==0) return &k-p;
    else return check_grow(k-1,p);
}
#define BITS_PER_INT (sizeof(int)*CHAR_BIT)

int bits_per_int=BITS_PER_INT;
int int_max=INT_MAX;
int int_min=INT_MIN;

/* for 21 - left to right */
int ltr_result=0;
unsigned ltr_fun(int k)
{
    ltr_result=ltr_result*10+k;
    return 1;
}

int main()
{
    printf("We like to think that:\n");
    /* characters */
    EXPECT("00 we have ASCII",('A'==65));
    EXPECT("01 A-Z is in a block",('Z'-'A')+1==26);
    EXPECT("02 big letters come before small letters",('A'<'a'));
    EXPECT("03 a char is 8 bits",CHAR_BIT==8);
    EXPECT("04 a char is signed",CHAR_MIN==SCHAR_MIN);

    /* integers */
    EXPECT("05 int has the size of pointers",sizeof(int)==sizeof(void*));
    /* not true for Windows-64 */
    EXPECT("05a long has at least the size of pointers",sizeof(long)>=sizeof(void*));

    EXPECT("06 integers are 2-complement and wrap around",(int_max+1)==(int_min));
    EXPECT("07 integers are 2-complement and *always* wrap around",(INT_MAX+1)==(INT_MIN));
    EXPECT("08 overshifting is okay",(1<<bits_per_int)==0);
    EXPECT("09 overshifting is *always* okay",(1<<BITS_PER_INT)==0);
    {
        int t;
        EXPECT("09a minus shifts backwards",(t=-1,(15<<t)==7));
    }
    /* pointers */
    /* Suggested by jalf */
    EXPECT("10 void* can store function pointers",sizeof(void*)>=sizeof(void(*)()));
    /* execution */
    EXPECT("11 Detecting how the stack grows is easy",check_grow(5,0)!=0);
    EXPECT("12 the stack grows downwards",check_grow(5,0)<0);

    {
        int t;
        /* suggested by jk */
        EXPECT("13 The smallest bits always come first",(t=0x1234,0x34==*(char*)&t));
    }
    {
        /* Suggested by S.Lott */
        int a[2]={0,0};
        int i=0;
        EXPECT("14 i++ is strictly left to right",(i=0,a[i++]=i,a[0]==1));
    }
    {
        struct {
            char c;
            int i;
        } char_int;
        EXPECT("15 structs are packed",sizeof(char_int)==(sizeof(char)+sizeof(int)));
    }
    {
        EXPECT("16 malloc()=NULL means out of memory",(malloc(0)!=NULL));
    }

    /* suggested by David Thornley */
    EXPECT("17 size_t is unsigned int",sizeof(size_t)==sizeof(unsigned int));
    /* this is true for C99, but not for C90. */
    EXPECT("18 a%b has the same sign as a",((-10%3)==-1) && ((10%-3)==1));

    /* suggested by nos */
    EXPECT("19-1 char<short",sizeof(char)<sizeof(short));
    EXPECT("19-2 short<int",sizeof(short)<sizeof(int));
    EXPECT("19-3 int<long",sizeof(int)<sizeof(long));
    EXPECT("20 ptrdiff_t and size_t have the same size",(sizeof(ptrdiff_t)==sizeof(size_t)));
#if 0
    {
        /* suggested by R. */
        /* this crashed on TC 3.0++, compact. */
        char buf[10];
        EXPECT("21 You can use snprintf to append a string",
               (snprintf(buf,10,"OK"),snprintf(buf,10,"%s!!",buf),strcmp(buf,"OK!!")==0));
    }
#endif

    EXPECT("21 Evaluation is left to right",
           (ltr_fun(1)*ltr_fun(2)*ltr_fun(3)*ltr_fun(4),ltr_result==1234));

    {
    #ifdef __STDC_IEC_559__
    int STDC_IEC_559_is_defined=1;
    #else 
    /* This either means, there is no FP support
     *or* the compiler is not C99 enough to define  __STDC_IEC_559__
     *or* the FP support is not IEEE compliant. */
    int STDC_IEC_559_is_defined=0;
    #endif
    EXPECT("22 floating point is always IEEE",STDC_IEC_559_is_defined);
    }

    printf("From what I can say with my puny test cases, you are %d%% mainstream\n",100-(100*count)/total);
    return 0;
}

Oh, und ich habe dieses Community-Wiki von Anfang an erstellt, weil ich dachte, dass die Leute mein Geschwätz bearbeiten wollen, wenn sie dies lesen.

UPDATE Vielen Dank für Ihre Eingabe. Ich habe einige Fälle aus Ihren Antworten hinzugefügt und werde sehen, ob ich einen Github dafür einrichten kann, wie Greg vorgeschlagen hat.

UPDATE : Ich habe dafür ein Github-Repo erstellt, die Datei lautet "gotcha.c":

• http://github.com/lutherblissett/disenchanter

Bitte antworten Sie hier mit Patches oder neuen Ideen, damit diese hier diskutiert oder geklärt werden können. Ich werde sie dann in gotcha.c zusammenführen.

Die Reihenfolge der Auswertung von Unterausdrücken, einschließlich

• die Argumente eines Funktionsaufrufs und
• Operanden von Operatoren (zB +, -, =, *, /), mit Ausnahme von:
  • die binären logischen Operatoren ( &&und ||),
  • der ternäre bedingte Operator ( ?:) und
  • der Kommaoperator ( ,)

ist nicht spezifiziert

Beispielsweise

  int Hello()
  {
       return printf("Hello"); /* printf() returns the number of 
                                  characters successfully printed by it
                               */
  }

  int World()
  {
       return printf("World !");
  }

  int main()
  {

      int a = Hello() + World(); //might print Hello World! or World! Hello
      /**             ^
                      | 
                Functions can be called in either order
      **/
      return 0;
  } 

sdcc 29.7 / ucSim / Z80

We like to think that:
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..19-2 short<int
   but 'sizeof(short)<sizeof(int)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
..25 pointer arithmetic works outside arrays
   but '(diff=&var.int2-&var.int1, &var.int1+diff==&var.int2)' is false.
From what I can say with my puny test cases, you are Stop at 0x0013f3: (106) Invalid instruction 0x00dd

printf stürzt ab. "O_O"

gcc 4.4@x86_64-suse-linux

We like to think that:
..05 int has the size of pointers
but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
but '(t=-1,(15<<t)==7)' is false.
..14 i++ is strictly left to right
but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
but 'sizeof(size_t)==sizeof(unsigned int)' is false.
..26 sizeof() does not evaluate its arguments
but '(i=10,sizeof(char[((i=20),10)]),i==10)' is false.
From what I can say with my puny test cases, you are 79% mainstream

gcc 4.4@x86_64-suse-linux (-O2)

We like to think that:
..05 int has the size of pointers
but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
but '(1<<bits_per_int)==0' is false.
..14 i++ is strictly left to right
but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
but 'sizeof(size_t)==sizeof(unsigned int)' is false.
..26 sizeof() does not evaluate its arguments
but '(i=10,sizeof(char[((i=20),10)]),i==10)' is false.
From what I can say with my puny test cases, you are 82% mainstream

clang 2.7@x86_64-suse-linux

We like to think that:
..05 int has the size of pointers
but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
but '(t=-1,(15<<t)==7)' is false.
..14 i++ is strictly left to right
but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
but 'sizeof(size_t)==sizeof(unsigned int)' is false.
..21a Function Arguments are evaluated right to left
but '(gobble_args(0,ltr_fun(1),ltr_fun(2),ltr_fun(3),ltr_fun(4)),ltr_result==4321)' is false.
ltr_result is 1234 in this case
..25a pointer arithmetic works outside arrays
but '(diff=&p1-&p2, &p2+diff==&p1)' is false.
..26 sizeof() does not evaluate its arguments
but '(i=10,sizeof(char[((i=20),10)]),i==10)' is false.
From what I can say with my puny test cases, you are 72% mainstream

open64 4.2.3@x86_64-suse-linux

We like to think that:
..05 int has the size of pointers
but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
but '(t=-1,(15<<t)==7)' is false.
..15 structs are packed
but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
but 'sizeof(size_t)==sizeof(unsigned int)' is false.
..21a Function Arguments are evaluated right to left
but '(gobble_args(0,ltr_fun(1),ltr_fun(2),ltr_fun(3),ltr_fun(4)),ltr_result==4321)' is false.
ltr_result is 1234 in this case
..25a pointer arithmetic works outside arrays
but '(diff=&p1-&p2, &p2+diff==&p1)' is false.
..26 sizeof() does not evaluate its arguments
but '(i=10,sizeof(char[((i=20),10)]),i==10)' is false.
From what I can say with my puny test cases, you are 75% mainstream

Intel 11.1@x86_64-suse-linux

We like to think that:
..05 int has the size of pointers
but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
but '(t=-1,(15<<t)==7)' is false.
..14 i++ is strictly left to right
but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
but 'sizeof(size_t)==sizeof(unsigned int)' is false.
..21a Function Arguments are evaluated right to left
but '(gobble_args(0,ltr_fun(1),ltr_fun(2),ltr_fun(3),ltr_fun(4)),ltr_result==4321)' is false.
ltr_result is 1234 in this case
..26 sizeof() does not evaluate its arguments
but '(i=10,sizeof(char[((i=20),10)]),i==10)' is false.
From what I can say with my puny test cases, you are 75% mainstream

Turbo C ++ / DOS / Kleiner Speicher

We like to think that:
..09a minus shifts backwards
but '(t=-1,(15<<t)==7)' is false.
..16 malloc()=NULL means out of memory
but '(malloc(0)!=NULL)' is false.
..19-2 short<int
but 'sizeof(short)<sizeof(int)' is false.
..22 floating point is always IEEE
but 'STDC_IEC_559_is_defined' is false.
..25 pointer arithmetic works outside arrays
but '(diff=&var.int2-&var.int1, &var.int1+diff==&var.int2)' is false.
..25a pointer arithmetic works outside arrays
but '(diff=&p1-&p2, &p2+diff==&p1)' is false.
From what I can say with my puny test cases, you are 81% mainstream

Turbo C ++ / DOS / Mittlerer Speicher

We like to think that:
..09a minus shifts backwards
but '(t=-1,(15<<t)==7)' is false.
..10 void* can store function pointers
but 'sizeof(void*)>=sizeof(void(*)())' is false.
..16 malloc()=NULL means out of memory
but '(malloc(0)!=NULL)' is false.
..19-2 short<int
but 'sizeof(short)<sizeof(int)' is false.
..22 floating point is always IEEE
but 'STDC_IEC_559_is_defined' is false.
..25 pointer arithmetic works outside arrays
but '(diff=&var.int2-&var.int1, &var.int1+diff==&var.int2)' is false.
..25a pointer arithmetic works outside arrays
but '(diff=&p1-&p2, &p2+diff==&p1)' is false.
From what I can say with my puny test cases, you are 78% mainstream

Turbo C ++ / DOS / Kompaktspeicher

We like to think that:
..05 int has the size of pointers
but 'sizeof(int)==sizeof(void*)' is false.
..09a minus shifts backwards
but '(t=-1,(15<<t)==7)' is false.
..16 malloc()=NULL means out of memory
but '(malloc(0)!=NULL)' is false.
..19-2 short<int
but 'sizeof(short)<sizeof(int)' is false.
..20 ptrdiff_t and size_t have the same size
but '(sizeof(ptrdiff_t)==sizeof(size_t))' is false.
..22 floating point is always IEEE
but 'STDC_IEC_559_is_defined' is false.
..25 pointer arithmetic works outside arrays
but '(diff=&var.int2-&var.int1, &var.int1+diff==&var.int2)' is false.
..25a pointer arithmetic works outside arrays
but '(diff=&p1-&p2, &p2+diff==&p1)' is false.
From what I can say with my puny test cases, you are 75% mainstream

cl65 @ Commodore PET (Vizemulator)

Ich werde diese später aktualisieren:

Borland C ++ Builder 6.0 unter Windows XP

..04 a char is signed
   but 'CHAR_MIN==SCHAR_MIN' is false.
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09 overshifting is *always* okay
   but '(1<<BITS_PER_INT)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..16 malloc()=NULL means out of memory
   but '(malloc(0)!=NULL)' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 71% mainstream

Visual Studio Express 2010 C ++ - CLR, Windows 7 64-Bit

(muss als C ++ kompiliert werden, da der CLR-Compiler kein reines C unterstützt)

We like to think that:
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..14 i++ is structly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 78% mainstream

MINGW64 (gcc-4.5.2-Vorlase)

- http://mingw-w64.sourceforge.net/

We like to think that:
..05 int has the size of pointers
   but 'sizeof(int)==sizeof(void*)' is false.
..05a long has at least the size of pointers
   but 'sizeof(long)>=sizeof(void*)' is false.
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..14 i++ is structly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
   but 'sizeof(size_t)==sizeof(unsigned int)' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 67% mainstream

64-Bit-Windows verwendet das LLP64-Modell: Beide intund longsind als 32-Bit definiert, was bedeutet, dass keines für einen Zeiger lang genug ist.

avr-gcc 4.3.2 / ATmega168 (Arduino Diecimila)

Die fehlgeschlagenen Annahmen sind:

..14 i++ is structly left to right
..16 malloc()=NULL means out of memory
..19-2 short<int
..21 Evaluation is left to right
..22 floating point is always IEEE

Der Atmega168 verfügt über einen 16-Bit-PC, Code und Daten befinden sich jedoch in separaten Adressräumen. Größere Atmegas haben einen 22-Bit-PC!.

gcc 4.2.1 unter MacOSX 10.6, kompiliert mit -arch ppc

We like to think that:
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..13 The smallest bits come always first
   but '(t=0x1234,0x34==*(char*)&t)' is false.
..14 i++ is structly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 78% mainstream

Vor langer Zeit unterrichtete ich C aus einem Lehrbuch, das hatte

printf("sizeof(int)=%d\n", sizeof(int));

als Beispielfrage. Er scheiterte für einen Studenten, weil die sizeofRenditen Werte des Typs size_t, nicht int, intauf dieser Implementierung 16 Bit war und size_twar 32, und es war Big-Endian. (Die Plattform war Lightspeed C auf 680x0-basierten Macintosh-Computern. Ich sagte, es ist lange her.)

Sie müssen die ++und --Annahmen berücksichtigen, die die Leute machen.

a[i++]= i;

Zum Beispiel ist es syntaktisch legal, führt aber zu unterschiedlichen Ergebnissen, abhängig von zu vielen Dingen, um sie zu begründen.

Jede Anweisung mit ++(oder --) und einer Variablen, die mehrmals vorkommt, ist ein Problem.

Sehr interessant!

Andere Dinge, die mir einfallen, könnten nützlich sein, um zu überprüfen:

• Gibt es Funktionszeiger und Datenzeiger im selben Adressraum? (Bricht in Maschinen mit Harvard-Architektur wie dem kleinen DOS-Modus ein. Ich weiß jedoch nicht, wie Sie darauf testen würden.)

• Wenn Sie einen NULL-Datenzeiger nehmen und ihn in den entsprechenden Integer-Typ umwandeln, hat er den numerischen Wert 0? (Pausen auf einigen wirklich alten Maschinen --- siehe http://c-faq.com/null/machexamp.html .) Das Gleiche gilt für den Funktionszeiger. Sie können auch unterschiedliche Werte sein.

• Verursacht das Inkrementieren eines Zeigers über das Ende seines entsprechenden Speicherobjekts hinaus und dann wieder zurück sinnvolle Ergebnisse? (Ich kenne keine Maschinen, auf denen dies tatsächlich funktioniert, aber ich glaube, die C-Spezifikation erlaubt es Ihnen nicht einmal , an Zeiger zu denken , die weder auf (a) den Inhalt eines Arrays noch auf (b) das Element verweisen unmittelbar nach dem Array oder (c) NULL. Siehe http://c-faq.com/aryptr/non0based.html .)

• führt der Vergleich zweier Zeiger mit unterschiedlichen Speicherobjekten mit <und> zu konsistenten Ergebnissen? (Ich kann mir vorstellen, dass dies auf exotischen segmentbasierten Maschinen nicht funktioniert. Die Spezifikation verbietet solche Vergleiche, sodass der Compiler berechtigt wäre, nur den versetzten Teil des Zeigers und nicht den Segmentteil zu vergleichen.)

Hmm. Ich werde versuchen, an etwas mehr zu denken.

Bearbeiten: Es wurden einige klarstellende Links zu den hervorragenden C-FAQ hinzugefügt.

Ich denke, Sie sollten sich bemühen, zwischen zwei sehr unterschiedlichen Klassen von "falschen" Annahmen zu unterscheiden. Eine gute Hälfte (Rechtsverschiebung und Vorzeichenerweiterung, ASCII-kompatible Codierung, Speicher ist linear, Daten- und Funktionszeiger sind kompatibel usw.) sind für die meisten C-Codierer ziemlich vernünftige Annahmen und können sogar als Teil des Standards enthalten sein Wenn C heute entworfen würde und wenn wir keinen alten IBM-Junk-Großvater hätten. Die andere Hälfte (Dinge im Zusammenhang mit Speicher-Aliasing, Verhalten von Bibliotheksfunktionen bei Überlappung von Eingabe- und Ausgabespeicher, 32-Bit-Annahmen wie Zeiger, die passen intoder die Sie verwenden könnenmalloc Ohne Prototyp ist diese Aufrufkonvention für variadische und nicht-variadische Funktionen identisch. ...) Entweder im Widerspruch zu Optimierungen, die moderne Compiler durchführen möchten, oder zur Migration auf 64-Bit-Maschinen oder andere neue Technologien.

Hier ist eine lustige: Was ist mit dieser Funktion falsch?

float sum(unsigned int n, ...)
{
    float v = 0;
    va_list ap;
    va_start(ap, n);
    while (n--)
        v += va_arg(ap, float);
    va_end(ap);
    return v;
}

[Antwort (rot13): Inevnqvp nethzragf borl gur byq X & E cebzbgvba ehyrf, juvpu zrnaf lbh pnaabg hfr 'sybng' (sei 'pune' sei 'fubeg') va in_net! Naq gur pbzcvyre vf erdhverq abg gb gerng guvf nf n pbzcvyr-gvzr reebe. (TPP qbrf rzvg n jneavat, gubhtu.)]

EXPECT("## pow() gives exact results for integer arguments", pow(2, 4) == 16);

Ein anderer befasst sich mit dem Textmodus in fopen. Die meisten Programmierer gehen davon aus, dass entweder Text und Binär identisch sind (Unix) oder dass der Textmodus \rZeichen hinzufügt (Windows). C wurde jedoch auf Systeme portiert, die Datensätze mit fester Breite verwenden, bei denen fputc('\n', file)in einer Textdatei Leerzeichen oder ähnliches hinzugefügt werden müssen, bis die Dateigröße ein Vielfaches der Datensatzlänge beträgt.

Und hier sind meine Ergebnisse:

gcc (Ubuntu 4.4.3-4ubuntu5) 4.4.3 auf x86-64

We like to think that:
..05 int has the size of pointers
   but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..14 i++ is strictly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
   but 'sizeof(size_t)==sizeof(unsigned int)' is false.
From what I can say with my puny test cases, you are 78% mainstream

Einige von ihnen können nicht einfach in C getestet werden, da das Programm wahrscheinlich bei Implementierungen abstürzt, bei denen die Annahme nicht zutrifft.

"Es ist in Ordnung, mit einer Variablen mit Zeigerwert etwas zu tun. Sie muss nur dann einen gültigen Zeigerwert enthalten, wenn Sie ihn dereferenzieren."

void noop(void *p); /* A no-op function that the compiler doesn't know to optimize away */
int main () {
    char *p = malloc(1);
    free(p);
    noop(p); /* may crash in implementations that verify pointer accesses */
    noop(p - 42000); /* and if not the previous instruction, maybe this one */
}

Gleiches gilt für Integral- und Gleitkommatypen (außer unsigned char), die Trap-Darstellungen haben dürfen.

"Ganzzahlige Berechnungen werden umgangen. Dieses Programm gibt also eine große negative Ganzzahl aus."

#include <stdio.h>
int main () {
    printf("%d\n", INT_MAX+1); /* may crash due to signed integer overflow */
    return 0;
}

(Nur C89.) "Es ist in Ordnung, am Ende von zu fallen main."

#include <stdio.h>
int main () {
    puts("Hello.");
} /* The status code is 7 on many implementations. */

Nun, die klassischen Portabilitätsannahmen, die noch nicht gemeint sind, sind

• Annahmen über die Größe integraler Typen
• Endianness

• Diskretisierungsfehler aufgrund von Gleitkommadarstellung. Wenn Sie beispielsweise die Standardformel verwenden, um quadratische Gleichungen zu lösen, oder endliche Differenzen, um Ableitungen zu approximieren, oder die Standardformel, um Varianzen zu berechnen, geht die Genauigkeit aufgrund der Berechnung von Differenzen zwischen ähnlichen Zahlen verloren. Der Gauß-Algorithmus zum Lösen linearer Systeme ist schlecht, da sich Rundungsfehler ansammeln. Daher werden QR- oder LU-Zerlegung, Cholesky-Zerlegung, SVD usw. verwendet. Das Hinzufügen von Gleitkommazahlen ist nicht assoziativ. Es gibt denormale, unendliche und NaN-Werte. a + b - a ≠ b .

• Zeichenfolgen: Unterschied zwischen Zeichen, Codepunkten und Codeeinheiten. Wie Unicode auf den verschiedenen Betriebssystemen implementiert ist; Unicode-Codierungen. Das Öffnen einer Datei mit einem beliebigen Unicode-Dateinamen ist mit C ++ nicht portabel möglich.

• Rennbedingungen, auch ohne Threading: Wenn Sie testen, ob eine Datei vorhanden ist, kann das Ergebnis jederzeit ungültig werden.

• ERROR_SUCCESS = 0

Fügen Sie eine Prüfung für ganzzahlige Größen hinzu. Die meisten Leute gehen davon aus, dass ein int größer als ein Short größer als ein Char ist. Diese können jedoch alle falsch sein:sizeof(char) < sizeof(int); sizeof(short) < sizeof(int); sizeof(char) < sizeof(short)

Dieser Code schlägt möglicherweise fehl (stürzt bei nicht ausgerichtetem Zugriff ab)

unsigned char buf[64];

int i = 234;
int *p = &buf[1];
*p = i;
i = *p;

Einige Dinge zu integrierten Datentypen:

• charund signed charsind tatsächlich zwei verschiedene Typen (im Gegensatz zu intund signed intdie sich auf denselben vorzeichenbehafteten Ganzzahltyp beziehen).
• Vorzeichenbehaftete Ganzzahlen sind nicht erforderlich, um das Zweierkomplement zu verwenden. Das Komplement und das Vorzeichen + die Größe eines Menschen sind ebenfalls gültige Darstellungen negativer Zahlen. Dies macht Bitoperationen mit negativen Zahlen implementierungsdefiniert .
• Wenn Sie einer vorzeichenbehafteten Ganzzahlvariablen eine Ganzzahl außerhalb des Bereichs zuweisen, ist das Verhalten implementierungsdefiniert .
• In C90 -3/5könnte zurückkehren 0oder -1. Eine Rundung gegen Null für den Fall, dass ein Operand negativ war, ist nur in C99 nach oben und C ++ 0x nach oben garantiert.
• Es gibt keine genauen Größengarantien für die eingebauten Typen. Der Standard deckt nur minimale Anforderungen ab, z. B. a inthat mindestens 16 Bit, a longhat mindestens 32 Bit, a long longhat mindestens 64 Bit. A floatkann mindestens 6 höchstwertige Dezimalstellen korrekt darstellen. A doublekann mindestens 10 höchstwertige Dezimalstellen korrekt darstellen.
• IEEE 754 ist für die Darstellung von Gleitkommazahlen nicht obligatorisch.

Zugegeben, auf den meisten Maschinen haben wir zwei Komplemente und IEEE 754-Floats.

Wie wäre es mit diesem:

Kein Datenzeiger kann jemals mit einem gültigen Funktionszeiger identisch sein.

Dies ist WAHR für alle flachen Modelle, MS-DOS TINY-, LARGE- und HUGE-Modelle, falsch für MS-DOS SMALL-Modelle und fast immer falsch für MEDIUM- und COMPACT-Modelle (abhängig von der Ladeadresse benötigen Sie ein wirklich altes DOS mach es wahr).

Ich kann dafür keinen Test schreiben

Und noch schlimmer: Zeiger, die in ptrdiff_t umgewandelt wurden, können verglichen werden. Dies gilt nicht für das MS-DOS LARGE-Modell (der einzige Unterschied zwischen LARGE und HUGE besteht darin, dass HUGE Compiler-Code zum Normalisieren von Zeigern hinzufügt).

Ich kann keinen Test schreiben, da die Umgebung, in der diese Bomben hart sind, keinen Puffer größer als 64 KB zuweist, sodass der Code, der dies demonstriert, auf anderen Plattformen abstürzt.

Dieser spezielle Test würde ein inzwischen nicht mehr funktionierendes System weitergeben (beachten Sie, dass dies von den Interna von malloc abhängt):

  char *ptr1 = malloc(16);
  char *ptr2 = malloc(16);
  if ((ptrdiff_t)ptr2 - 0x20000 == (ptrdiff_t)ptr1)
      printf("We like to think that unrelated pointers are equality comparable when cast to the appropriate integer, but they're not.");

BEARBEITEN: Auf die letzte Version des Programms aktualisiert

Solaris-SPARC

gcc 3.4.6 in 32 bit

We like to think that:
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09 overshifting is *always* okay
   but '(1<<BITS_PER_INT)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..13 The smallest bits always come first
   but '(t=0x1234,0x34==*(char*)&t)' is false.
..14 i++ is strictly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 72% mainstream

gcc 3.4.6 in 64 bit

We like to think that:
..05 int has the size of pointers
   but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09 overshifting is *always* okay
   but '(1<<BITS_PER_INT)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..13 The smallest bits always come first
   but '(t=0x1234,0x34==*(char*)&t)' is false.
..14 i++ is strictly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
   but 'sizeof(size_t)==sizeof(unsigned int)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 68% mainstream

und mit SUNStudio 11 32 Bit

We like to think that:
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..13 The smallest bits always come first
   but '(t=0x1234,0x34==*(char*)&t)' is false.
..14 i++ is strictly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
From what I can say with my puny test cases, you are 79% mainstream

und mit SUNStudio 11 64 Bit

We like to think that:
..05 int has the size of pointers
   but 'sizeof(int)==sizeof(void*)' is false.
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..13 The smallest bits always come first
   but '(t=0x1234,0x34==*(char*)&t)' is false.
..14 i++ is strictly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..17 size_t is unsigned int
   but 'sizeof(size_t)==sizeof(unsigned int)' is false.
From what I can say with my puny test cases, you are 75% mainstream

Sie können text-mode ( fopen("filename", "r")) verwenden, um jede Art von Textdatei zu lesen.

Während dies theoretisch gut funktionieren sollteftell() , werden in einigen Versionen der Windows-Standardbibliothek ftell()häufig ungültige Werte zurückgegeben , wenn Sie sie auch in Ihrem Code verwenden und Ihre Textdatei UNIX-artige Zeilenenden aufweist . Die Lösung besteht darin, stattdessen den Binärmodus zu verwenden ( fopen("filename", "rb")).

gcc 3.3.2 unter AIX 5.3 (ja, wir müssen gcc aktualisieren)

We like to think that:
..04 a char is signed
   but 'CHAR_MIN==SCHAR_MIN' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..13 The smallest bits come always first
   but '(t=0x1234,0x34==*(char*)&t)' is false.
..14 i++ is structly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..16 malloc()=NULL means out of memory
   but '(malloc(0)!=NULL)' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 71% mainstream

Eine Annahme, die einige in C ++ machen können, ist, dass a auf structdas beschränkt ist, was es in C kann. Tatsache ist, dass a in C ++ structwie a ist, classaußer dass es standardmäßig alles öffentlich hat.

C ++ Struktur:

struct Foo
{
  int number1_;  //this is public by default


//this is valid in C++:    
private: 
  void Testing1();
  int number2_;

protected:
  void Testing2();
};

Standard-Mathematikfunktionen auf verschiedenen Systemen liefern keine identischen Ergebnisse.

Visual Studio Express 2010 auf 32-Bit x86.

Z:\sandbox>cl testtoy.c
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 16.00.30319.01 for 80x86
Copyright (C) Microsoft Corporation.  All rights reserved.

testtoy.c
testtoy.c(54) : warning C4293: '<<' : shift count negative or too big, undefined
 behavior
Microsoft (R) Incremental Linker Version 10.00.30319.01
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:testtoy.exe
testtoy.obj

Z:\sandbox>testtoy.exe
We like to think that:
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..09a minus shifts backwards
   but '(t=-1,(15<<t)==7)' is false.
..14 i++ is structly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
..22 floating point is always IEEE
   but 'STDC_IEC_559_is_defined' is false.
From what I can say with my puny test cases, you are 78% mainstream

Über Codepad.org ( C++: g++ 4.1.2 flags: -O -std=c++98 -pedantic-errors -Wfatal-errors -Werror -Wall -Wextra -Wno-missing-field-initializers -Wwrite-strings -Wno-deprecated -Wno-unused -Wno-non-virtual-dtor -Wno-variadic-macros -fmessage-length=0 -ftemplate-depth-128 -fno-merge-constants -fno-nonansi-builtins -fno-gnu-keywords -fno-elide-constructors -fstrict-aliasing -fstack-protector-all -Winvalid-pch).

Beachten Sie, dass Codepad nicht hatte stddef.h. Ich habe Test 9 aufgrund eines Codepads entfernt und Warnungen als Fehler verwendet. Ich habe die countVariable auch umbenannt , da sie aus irgendeinem Grund bereits definiert wurde.

We like to think that:
..08 overshifting is okay
   but '(1<<bits_per_int)==0' is false.
..14 i++ is structly left to right
   but '(i=0,a[i++]=i,a[0]==1)' is false.
..15 structs are packed
   but 'sizeof(char_int)==(sizeof(char)+sizeof(int))' is false.
..19-3 int<long
   but 'sizeof(int)<sizeof(long)' is false.
From what I can say with my puny test cases, you are 84% mainstream

Wie wäre es mit einer Verschiebung nach rechts um übermäßige Beträge - ist dies nach dem Standard zulässig oder einen Test wert?

Gibt Standard C das Verhalten des folgenden Programms an:

void print_string (char * st)
{
  char ch;
  while ((ch = * st ++)! = 0)
    putch (ch); / * Angenommen, dies ist definiert * /
}}
int main (nichtig)
{
  print_string ("Hallo");
  return 0;
}}

Auf mindestens einem von mir verwendeten Compiler schlägt dieser Code fehl, es sei denn, das Argument für print_string ist "char const *". Erlaubt der Standard eine solche Einschränkung?

Einige Systeme erlauben es einem, Zeiger auf nicht ausgerichtete Ints zu erzeugen, andere nicht. Könnte einen Test wert sein.

Zu Ihrer Information: Für diejenigen, die ihre C-Kenntnisse in Java übersetzen müssen, sind hier einige Fallstricke.

EXPECT("03 a char is 8 bits",CHAR_BIT==8);
EXPECT("04 a char is signed",CHAR_MIN==SCHAR_MIN);

In Java ist char 16-Bit und signiert. Byte ist 8-Bit und signiert.

/* not true for Windows-64 */
EXPECT("05a long has at least the size of pointers",sizeof(long)>=sizeof(void*));

long ist immer 64-Bit, Referenzen können 32-Bit- oder 64-Bit-Referenzen sein (wenn Sie mehr als eine App mit mehr als 32 GB haben). 64-Bit-JVMs verwenden normalerweise 32-Bit-Referenzen.

EXPECT("08 overshifting is okay",(1<<bits_per_int)==0);
EXPECT("09 overshifting is *always* okay",(1<<BITS_PER_INT)==0);

Die Verschiebung wird maskiert, so dass i << 64 == i == i << -64, i << 63 == i << -1

EXPECT("13 The smallest bits always come first",(t=0x1234,0x34==*(char*)&t));

ByteOrder.nativeOrder () kann BIG_ENDIAN oder LITTLE_ENDIAN sein

EXPECT("14 i++ is strictly left to right",(i=0,a[i++]=i,a[0]==1));

i = i++ Ändert sich nie i

/* suggested by David Thornley */
EXPECT("17 size_t is unsigned int",sizeof(size_t)==sizeof(unsigned int));

Die Größe von Sammlungen und Arrays beträgt immer 32-Bit, unabhängig davon, ob die JVM 32-Bit oder 64-Bit ist.

EXPECT("19-1 char<short",sizeof(char)<sizeof(short));
EXPECT("19-2 short<int",sizeof(short)<sizeof(int));
EXPECT("19-3 int<long",sizeof(int)<sizeof(long));

char ist 16-Bit, short ist 16-Bit, int ist 32-Bit und long ist 64-Bit.