O que pertence a uma ferramenta educacional para demonstrar as suposições injustificadas que as pessoas fazem em C / C ++?

Eu gostaria de preparar uma pequena ferramenta educacional para SO, que deve ajudar programadores iniciantes (e intermediários) a reconhecer e desafiar suas suposições injustificadas em C, C ++ e suas plataformas.

Exemplos:

• "números inteiros"
• "todo mundo tem ASCII"
• "Eu posso armazenar um ponteiro de função em um vazio *"

Imaginei que um pequeno programa de teste pudesse ser executado em várias plataformas, que executam as suposições "plausíveis" que, a partir de nossa experiência em SO, geralmente são feitas por muitos desenvolvedores mainstream inexperientes / semiexperientes e registram a maneira como eles quebram em diversas máquinas.

O objetivo disso não é provar que é "seguro" fazer algo (o que seria impossível de fazer, os testes provam qualquer coisa se eles quebrarem), mas demonstrar até mesmo ao indivíduo mais compreensivo como a expressão mais discreta quebrar em uma máquina diferente, se ela tiver um comportamento indefinido ou definido pela implementação. .

Para conseguir isso, gostaria de perguntar:

• Como essa ideia pode ser melhorada?
• Quais testes seriam bons e como eles deveriam ser?
• Você executaria os testes nas plataformas nas quais você pode colocar as mãos e publicar os resultados, para que possamos terminar com um banco de dados de plataformas, como elas diferem e por que essa diferença é permitida?

Aqui está a versão atual do brinquedo de teste:

#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;
}

Ah, e eu criei este wiki da comunidade desde o início, porque achei que as pessoas querem editar minha tagarelice quando lêem isso.

ATUALIZAÇÃO Obrigado pela sua contribuição. Adicionei alguns casos de suas respostas e verei se posso configurar um github para isso, como Greg sugeriu.

UPDATE : Eu criei um repositório no Github para isso, o arquivo é "gotcha.c":

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

Responda aqui com correções ou novas idéias, para que possam ser discutidas ou esclarecidas aqui. Vou fundi-los em gotcha.c então.

A ordem de avaliação das subexpressões, incluindo

• os argumentos de uma chamada de função e
• operandos de operadores (por exemplo, +, -, =, *, /), com a excepção de:
  • os operadores lógicos binários ( &&e ||),
  • o operador condicional ternário ( ?:) e
  • o operador de vírgula ( ,)

é não especificado

Por exemplo

  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 trava. "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 / Memória pequena

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 / Memória Média

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

Memória Turbo C ++ / DOS / Compacta

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 (vice-emulador)

Vou atualizá-los mais tarde:

Borland C ++ Builder 6.0 no 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 de 64 bits

(deve ser compilado como C ++ porque o compilador CLR não suporta C puro)

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 (pré -elas gcc-4.5.2)

- 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

O Windows de 64 bits usa o modelo LLP64: Ambos inte longsão definidos como 32 bits, o que significa que nenhum é longo o suficiente para um ponteiro.

avr-gcc 4.3.2 / ATmega168 (Arduino Diecimila)

As suposições com falha são:

..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

O Atmega168 possui um PC de 16 bits, mas o código e os dados estão em espaços de endereço separados. Atmegas maiores têm um PC de 22 bits !.

gcc 4.2.1 no MacOSX 10.6, compilado com -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

Há muito tempo, eu estava ensinando C de um livro que tinha

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

como uma pergunta de amostra. Ele falhou para um aluno, porque sizeofgera valores do tipo size_t, não int, intnesta implementação tinha 16 bits e size_t32, e era big-endian. (A plataforma era o Lightspeed C em Macintoshes baseados em 680x0. Eu disse isso há muito tempo.)

Você precisa incluir os ++e --suposições que as pessoas fazem.

a[i++]= i;

Por exemplo, é sintaticamente legal, mas produz resultados variados, dependendo de muitas coisas para raciocinar.

Qualquer declaração que tenha ++(ou-- ) e uma variável que ocorra mais de uma vez é um problema.

Muito interessante!

Outras coisas em que posso pensar podem ser úteis para verificar:

• existem indicadores de função e dados no mesmo espaço de endereço? (Quebras nas máquinas de arquitetura de Harvard, como o modo pequeno do DOS. Porém, não sei como você testaria isso.)

• se você pegar um ponteiro de dados NULL e o converter no tipo inteiro apropriado, ele possui o valor numérico 0? (Quebra em algumas máquinas realmente antigas - consulte http://c-faq.com/null/machexamp.html .) O mesmo vale para o ponteiro de função. Além disso, eles podem ter valores diferentes.

• incrementar um ponteiro após o final do seu objeto de armazenamento correspondente e, em seguida, voltar novamente, causa resultados razoáveis? (Eu não conheço nenhuma máquina na qual ele realmente interrompa, mas acredito que a especificação C não permite que você pense em ponteiros que não apontam para (a) o conteúdo de uma matriz ou (b) o elemento imediatamente após a matriz ou (c) NULL. Consulte http://c-faq.com/aryptr/non0based.html .)

• comparar dois ponteiros com diferentes objetos de armazenamento com <e> produz resultados consistentes? (Eu posso imaginar essa quebra em máquinas exóticas baseadas em segmentos; as especificações proíbem essas comparações, para que o compilador tenha o direito de comparar apenas a parte deslocada do ponteiro, e não a parte do segmento.)

Hmm. Vou tentar pensar um pouco mais.

Edit: Adicionado alguns links de esclarecimento para o excelente C FAQ.

Eu acho que você deve fazer um esforço para distinguir entre duas classes muito diferentes de suposições "incorretas". Uma boa metade (deslocamento à direita e extensão de sinal, codificação compatível com ASCII, memória é linear, ponteiros de dados e funções são compatíveis etc.) são suposições bastante razoáveis ​​para a maioria dos codificadores C criar e podem até ser incluídas como parte do padrão se C estivesse sendo projetado hoje e se não tivéssemos o legado de sucata IBM herdado. A outra metade (coisas relacionadas ao alias de memória, comportamento das funções da biblioteca quando a memória de entrada e saída se sobrepõe, suposições de 32 bits como as que os ponteiros se encaixamint ou que você pode usarmalloc sem um protótipo, essa convenção de chamada é idêntica para funções variadas e não variadas, ...) conflitam com as otimizações que os compiladores modernos desejam executar ou com a migração para máquinas de 64 bits ou outra nova tecnologia.

Aqui está uma divertida: O que há de errado com esta função?

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;
}

[Resposta (rot13): Inevnqvp nethzragf borl gur byq X&E cebzbgvba ehyrf, juvpu zrnaf lbh pnaabg hfr 'sybng (seja' pune 'seja' 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);

Outro é sobre o modo de texto no fopen. A maioria dos programadores assume que texto e binário são iguais (Unix) ou que o modo de texto adiciona \rcaracteres (Windows). Mas C foi portado para sistemas que usam registros de largura fixa, nos quais fputc('\n', file)em um arquivo de texto significa adicionar espaços ou algo até que o tamanho do arquivo seja múltiplo do comprimento do registro.

E aqui estão meus resultados:

gcc (Ubuntu 4.4.3-4ubuntu5) 4.4.3 no 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

Alguns deles não podem ser facilmente testados a partir do C, porque o programa provavelmente trava nas implementações em que a suposição não se aplica.

"Não há problema em fazer qualquer coisa com uma variável com valor de ponteiro. Ele só precisa conter um valor de ponteiro válido se você a derereçar."

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 */
}

O mesmo ocorre com os tipos de ponto flutuante e integral (que não sejam unsigned char), que podem ter representações de trap.

"Cálculos inteiros são contornados. Portanto, este programa imprime um número inteiro negativo grande."

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

(Somente C89.) "Não há problema em cair no final de main."

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

Bem, as suposições clássicas de portabilidade ainda não mencionadas são

• suposições sobre tamanho de tipos integrais
• endianness

• Erros de discretização devido à representação de ponto flutuante. Por exemplo, se você usar a fórmula padrão para resolver equações quadráticas, ou diferenças finitas para aproximar derivadas, ou a fórmula padrão para calcular variações, a precisão será perdida devido ao cálculo das diferenças entre números semelhantes. O algoritmo de Gauß para resolver sistemas lineares é ruim, porque os erros de arredondamento se acumulam; portanto, utiliza-se decomposição QR ou LU, decomposição de Cholesky, SVD etc. A adição de números de ponto flutuante não é associativa. Existem valores anormais, infinitos e NaN. a + b - a ≠ b .

• Strings: diferença entre caracteres, pontos de código e unidades de código. Como o Unicode é implementado nos vários sistemas operacionais; Codificações Unicode. Abrir um arquivo com um nome de arquivo Unicode arbitrário não é possível com o C ++ de maneira portátil.

• Condições de corrida, mesmo sem encadeamento: se você testar se existe um arquivo, o resultado poderá se tornar inválido a qualquer momento.

• ERROR_SUCCESS = 0

Inclua uma verificação para tamanhos inteiros. A maioria das pessoas assume que um int é maior que um short e maior que um char. No entanto, tudo isso pode ser falso:sizeof(char) < sizeof(int); sizeof(short) < sizeof(int); sizeof(char) < sizeof(short)

Esse código pode falhar (falha no acesso não alinhado)

unsigned char buf[64];

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

Algumas coisas sobre os tipos de dados internos:

• char e signed char na verdade, são dois tipos distintos (diferentes inte signed intque se referem ao mesmo tipo inteiro assinado).
• números inteiros assinados não precisam usar o complemento de dois. O complemento e a magnitude do sinal + também são representações válidas de números negativos. Isso torna as operações de bits que envolvem números negativos definidos pela implementação .
• Se você atribuir um número inteiro fora do intervalo a uma variável inteira assinada, o comportamento será definido pela implementação .
• Em C90, -3/5poderia retornar 0ou -1. O arredondamento para zero no caso de um operando ser negativo é garantido apenas em C99 para cima e C ++ 0x para cima.
• Não há garantias de tamanho exato para os tipos internos. O padrão cobre apenas requisitos mínimos, como um intcom pelo menos 16 bits, um longcom pelo menos 32 bits e um long longcom pelo menos 64 bits. A floatpode pelo menos representar 6 dígitos decimais mais significativos corretamente. A doublepode pelo menos representar 10 dígitos decimais mais significativos corretamente.
• O IEEE 754 não é obrigatório para representar números de ponto flutuante.

É certo que, na maioria das máquinas, teremos dois complementos e flutuadores IEEE 754.

Que tal este:

Nenhum ponteiro de dados pode ser o mesmo que um ponteiro de função válido.

Isso é VERDADEIRO para todos os modelos simples, modelos MS-DOS TINY, LARGE e HUGE, falso para o modelo SM-DOS SMALL e quase sempre falso para os modelos MÉDIO e COMPACTO (depende do endereço de carregamento, você precisará de um DOS realmente antigo). faça verdade).

Não posso escrever um teste para isso

E pior: os ponteiros convertidos para ptrdiff_t podem ser comparados. Isso não é verdade para o modelo MS-DOS LARGE (a única diferença entre LARGE e HUGE é HUGE adiciona código do compilador para normalizar os ponteiros).

Não consigo escrever um teste porque o ambiente em que essa bomba é difícil não aloca um buffer maior que 64K, portanto o código que a demonstra falha em outras plataformas.

Esse teste em particular passaria em um sistema agora extinto (observe que depende dos elementos internos do malloc):

  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.");

EDIT: Atualizado para a última versão do programa

Solaris-SPARC

gcc 3.4.6 em 32 bits

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 em 64 bits

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

e com o SUNStudio 11 de 32 bits

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

e com o SUNStudio 11 de 64 bits

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

Você pode usar o modo de texto ( fopen("filename", "r")) para ler qualquer tipo de arquivo de texto.

Embora isso , em teoria, funcione bem, se você também usar ftell()no seu código e seu arquivo de texto tiver terminações de linha no estilo UNIX, em algumas versões da biblioteca padrão do Windows, ftell()retornará frequentemente valores inválidos. A solução é usar o modo binário ( fopen("filename", "rb")).

gcc 3.3.2 no AIX 5.3 (sim, precisamos atualizar o gcc)

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

Uma suposição de que alguns podem fazer em C ++ é que a structé limitado ao que pode fazer em C. O fato é que, em C ++, a structé como a classexceto que tem tudo público por padrão.

Estrutura C ++:

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


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

protected:
  void Testing2();
};

As funções matemáticas padrão em sistemas diferentes não fornecem resultados idênticos.

Visual Studio Express 2010 em x86 de 32 bits.

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

Via 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).

Observe que o Codepad não possui stddef.h. Eu removi o teste 9 devido ao codepad usando avisos como erros. Também renomei a countvariável, pois ela já estava definida por algum motivo.

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

Que tal mudar de posição em quantidades excessivas - isso é permitido pelo padrão ou vale a pena testar?

O Padrão C especifica o comportamento do seguinte programa:

void print_string (char * st)
{
  char ch;
  while ((ch = * st ++)! = 0)
    putch (ch); / * Suponha que isso esteja definido * /
}
int main (vazio)
{
  print_string ("Olá");
  retornar 0;
}

Em pelo menos um compilador que eu uso, esse código falhará, a menos que o argumento para print_string seja um "char const *". O padrão permite tal restrição?

Alguns sistemas permitem produzir indicadores para int desalinhados e outros não. Pode valer a pena testar.

Para sua informação, para aqueles que precisam traduzir suas habilidades em C para Java, aqui estão algumas dicas.

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

Em Java, char é de 16 bits e assinado. byte é de 8 bits e assinado.

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

long é sempre de 64 bits, as referências podem ser de 32 ou 64 bits (se você tiver mais de um aplicativo com mais de 32 GB). As JVMs de 64 bits normalmente usam referências de 32 bits.

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

O deslocamento é mascarado para que i << 64 == i == i << -64, i << 63 == i << -1

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

ByteOrder.nativeOrder () pode ser BIG_ENDIAN ou LITTLE_ENDIAN

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

i = i++ nunca muda i

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

O tamanho das coleções e matrizes é sempre de 32 bits, independentemente de a JVM ser de 32 ou 64 bits.

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 é 16 bits, curto é 16 bits, int é 32 bits e longo é 64 bits.