사람들이 C / C ++에서하는 부당한 가정을 보여주는 교육 도구에는 무엇이 포함됩니까?

저는 초보자 (및 중급) 프로그래머가 C, C ++ 및 플랫폼에서 정당하지 않은 가정을 인식하고 이의를 제기하는 데 도움이되는 SO를위한 작은 교육 도구를 준비하고 싶습니다.

예 :

• "정수를 둘러싼 다"
• "모든 사람이 ASCII를 가지고 있습니다."
• "함수 포인터를 void *에 저장할 수 있습니다."

저는 소규모 테스트 프로그램이 다양한 플랫폼에서 실행될 수 있다고 생각했습니다.이 가정은 일반적으로 경험이 부족한 / 반 경험이없는 많은 주류 개발자가 만든 "그럴듯한"가정을 실행하고 다양한 시스템에서 중단되는 방식을 기록합니다.

이것의 목표는 무언가를하는 것이 "안전"하다는 것을 증명하는 것이 아니라 (불가능할 것이고, 테스트가 깨질 경우에만 어떤 것을 증명 함), 대신 가장 눈에 띄지 않는 표현을 가장 이해하기 어려운 개인에게 보여주기위한 것입니다. 정의되지 않았거나 구현 정의 된 동작이있는 경우 다른 시스템에서 중단됩니다. .

이를 달성하기 위해 다음과 같이 질문하고 싶습니다.

• 이 아이디어를 어떻게 개선 할 수 있습니까?
• 어떤 테스트가 좋으며 어떻게 표시되어야합니까?
• 손을 잡고 결과를 게시 할 수있는 플랫폼에서 테스트를 실행하여 결과를 게시하여 플랫폼 데이터베이스로 끝낼 수 있으며, 서로 어떻게 다른지, 왜이 차이가 허용되는지?

테스트 장난감의 현재 버전은 다음과 같습니다.

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

아, 그리고 나는 사람들이 이것을 읽을 때 내 blabber를 편집하고 싶어한다고 생각했기 때문에 처음부터이 커뮤니티 위키를 만들었습니다.

업데이트 귀하의 의견에 감사드립니다. 귀하의 답변에서 몇 가지 사례를 추가했으며 Greg가 제안한 것처럼 github를 설정할 수 있는지 확인할 것입니다.

업데이트 : 나는 이것을 위해 github repo를 만들었습니다. 파일은 "gotcha.c"입니다.

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

여기에서 패치 또는 새로운 아이디어로 답변 해주세요. 여기에서 논의하거나 명확히 할 수 있습니다. 그런 다음 gotcha.c로 병합합니다.

다음을 포함한 하위 표현식 평가 순서

• 함수 호출의 인수 및
• 연산자의 피연산자 (예를 들어, +, -, =, *, /)를 제외한 :
  • 이항 논리 연산자 ( &&및 ||),
  • 삼항 조건 연산자 ( ?:)
  • 쉼표 연산자 ( ,)

인 지정되지 않음

예를 들면

  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가 충돌합니다. "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

인텔 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 / 소형 메모리

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

터보 C ++ / DOS / 중간 메모리

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 / 컴팩트 메모리

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 (부스 에뮬레이터)

나중에 업데이트 할 예정입니다.

Windows XP의 Borland C ++ Builder 6.0

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

(CLR 컴파일러는 순수 C를 지원하지 않으므로 C ++로 컴파일해야 함)

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 프리 릴리즈)

-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 Windows가 LLP64 모델을 사용하여 비트 : 모두 int와 long32 비트 수단으로 정의되는 어느 포인터에 대해 충분히입니다.

avr-gcc 4.3.2 / ATmega168 (Arduino Diecimila)

실패한 가정은 다음과 같습니다.

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

Atmega168에는 16 비트 PC가 있지만 코드와 데이터는 별도의 주소 공간에 있습니다. 더 큰 Atmega에는 22 비트 PC가 있습니다!.

MacOSX 10.6의 gcc 4.2.1, -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

오래 전에 저는 교과서에서 C를 가르치고있었습니다.

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

샘플 질문으로. 때문에, 학생 실패 sizeof유형의 수율 값이 size_t아니라 int, int이 구현에 16 비트이고 size_t32이고, 그것은 빅 엔디안했다. (플랫폼은 680x0 기반 매킨토시의 Lightspeed C였습니다. 오래 전이라고 말했습니다.)

사람들이 하는 ++및 --가정 을 포함해야합니다 .

a[i++]= i;

예를 들어,는 구문 적으로 합법적이지만 추론 할 수없는 항목이 너무 많으면 다양한 결과를 생성합니다.

++(또는 --)과 두 번 이상 발생하는 변수가있는 문 은 문제입니다.

매우 흥미로운!

내가 생각할 수있는 다른 것들은 다음을 확인하는 데 유용 할 수 있습니다.

• 함수 포인터와 데이터 포인터가 동일한 주소 공간에 있습니까? (DOS 스몰 모드와 같은 Harvard 아키텍처 머신에서 중단됩니다. 어떻게 테스트할지 모르겠습니다.)

• NULL 데이터 포인터를 가져 와서 적절한 정수 유형으로 캐스트하면 숫자 값이 0입니까? (실제로 오래된 일부 기계에서 중단 --- http://c-faq.com/null/machexamp.html 참조 ) 함수 포인터도 마찬가지입니다. 또한 값이 다를 수 있습니다.

• 해당 저장소 개체의 끝을지나 포인터를 증가했다가 다시 되 돌리면 합리적인 결과가 발생합니까? (나는 이것이 실제로 깨지는 어떤 기계도 모르지만 C 스펙은 (a) 배열의 내용이나 (b) 요소를 가리 키지 않는 포인터에 대해 생각 조차 할 수 없다고 생각 합니다. 배열 바로 뒤 또는 (c) NULL. http://c-faq.com/aryptr/non0based.html 참조 )

• 서로 다른 저장소 개체에 대한 두 포인터를 <및>와 비교하면 일관된 결과가 생성됩니까? (나는 이것이 이국적인 세그먼트 기반 머신에서 깨지는 것을 상상할 수 있습니다. 스펙은 그러한 비교를 금지하므로 컴파일러는 세그먼트 부분이 아닌 포인터의 오프셋 부분 만 비교할 자격이 있습니다.)

흠. 좀 더 생각해 보겠습니다.

편집 : 우수한 C FAQ에 대한 명확한 링크를 추가했습니다.

나는 당신이 "잘못된"가정의 매우 다른 두 종류를 구별하기 위해 노력해야한다고 생각한다. 좋은 절반 (오른쪽 시프트 및 부호 확장, ASCII 호환 인코딩, 메모리는 선형, 데이터 및 함수 포인터가 호환 됨 등)은 대부분의 C 코더가 만들 수 있는 매우 합리적인 가정이며 표준의 일부로 포함될 수도 있습니다. C가 현재 설계되고 있고 기존 IBM 정크가없는 경우. 나머지 절반 (메모리 앨리어싱과 관련된 것, 입력 및 출력 메모리가 겹칠 때 라이브러리 함수의 동작, 포인터가 맞 int거나 사용할 수 있는 것과 같은 32 비트 가정)malloc 프로토 타입이 없으면이 호출 규칙은 가변 및 비가 변 함수에 대해 동일합니다. ...) 현대 컴파일러가 수행하려는 최적화와 충돌하거나 64 비트 시스템 또는 기타 새로운 기술로의 마이그레이션과 충돌합니다.

여기에 재미있는 것이 있습니다.이 기능에 어떤 문제가 있습니까?

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

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

또 다른 하나는 fopen. 대부분의 프로그래머는 텍스트와 바이너리가 같거나 (Unix) 텍스트 모드가 \r문자를 추가 (Windows) 한다고 가정합니다 . 그러나 C는 고정 너비 레코드를 사용하는 시스템으로 이식되었습니다 fputc('\n', file). 텍스트 파일에서 파일 크기가 레코드 길이의 배수가 될 때까지 공백이나 무언가를 추가하는 것을 의미합니다.

그리고 내 결과는 다음과 같습니다.

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

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

그들 중 일부는 가정이 유지되지 않는 구현에서 프로그램이 충돌 할 가능성이 있기 때문에 C 내부에서 쉽게 테스트 할 수 없습니다.

"포인터 값 변수로 무엇이든 할 수 있습니다. 역 참조 할 경우 유효한 포인터 값만 포함하면됩니다."

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

unsigned char트랩 표현을 가질 수 있는 정수 및 부동 소수점 유형 (제외 ) 과 동일 합니다.

"정수 계산이 둘러싸여 있습니다. 따라서이 프로그램은 큰 음의 정수를 인쇄합니다."

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

(C89 만 해당) "끝에서 떨어져도 괜찮습니다 main."

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

아직 의미가없는 고전적인 이식성 가정은

• 정수 유형의 크기에 대한 가정
• 엔디안

• 부동 소수점 표현으로 인한 이산화 오류. 예를 들어 표준 공식을 사용하여 2 차 방정식을 풀거나 유한 차분을 근사화하거나 표준 공식을 사용하여 분산을 계산하는 경우 유사 숫자 간의 차이 계산으로 인해 정밀도가 손실됩니다. 선형 시스템을 해결하는 Gauß 알고리즘은 반올림 오류가 누적되기 때문에 나쁘기 때문에 QR 또는 LU 분해, Cholesky 분해, SVD 등을 사용합니다. 부동 소수점 수의 추가는 연관성이 없습니다. 비정규, 무한 및 NaN 값이 있습니다. a + b − a ≠ b .

• 문자열 : 문자, 코드 포인트 및 코드 단위의 차이. 다양한 운영 체제에서 유니 코드를 구현하는 방법 유니 코드 인코딩. C ++에서는 임의의 유니 코드 파일 이름을 가진 파일을 이식 가능한 방식으로 열 수 없습니다.

• 스레딩이없는 경우에도 경쟁 조건 : 파일이 있는지 여부를 테스트하면 결과가 언제든지 유효하지 않을 수 있습니다.

• ERROR_SUCCESS = 0

정수 크기 확인을 포함합니다. 대부분의 사람들은 int가 short보다 크다고 생각하고 char보다 크다고 생각합니다. 그러나 다음은 모두 거짓 일 수 있습니다.sizeof(char) < sizeof(int); sizeof(short) < sizeof(int); sizeof(char) < sizeof(short)

이 코드는 실패 할 수 있습니다 (정렬되지 않은 액세스에 충돌)

unsigned char buf[64];

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

내장 데이터 유형에 대한 몇 가지 사항 :

• char그리고 signed char두 가지 유형은 (는 달리 실제로 int하고 signed int있는 같은 부호있는 정수 유형 참조).
• 2의 보수를 사용하는 데 부호있는 정수는 필요하지 않습니다. 1의 보수와 부호 + 크기도 음수의 유효한 표현입니다. 이것은 음수를 포함하는 비트 연산을 구현 정의 합니다.
• 범위를 벗어난 정수를 부호있는 정수 변수에 할당하는 경우 동작은 구현 정의 입니다.
• C90에서 -3/5반환 할 수 0또는 -1. 한 피연산자가 음수 인 경우 0으로 반올림하는 것은 C99에서 위쪽으로, C ++ 0x에서 위쪽으로 만 보장됩니다.
• 내장 유형에 대한 정확한 크기 보장은 없습니다. 같은 표준은 최소한의 요구 사항을 포함 int갖고 적어도 16 비트 A는 long갖고 적어도 A는, 32 개 비트를 long long갖고 적어도 64 비트. A float는 6 개 이상의 최상위 10 진수를 올바르게 나타낼 수 있습니다. A double는 최소 10 개의 최상위 10 진수를 올바르게 나타낼 수 있습니다.
• IEEE 754는 부동 소수점 숫자를 나타내는 데 필수가 아닙니다.

물론, 대부분의 컴퓨터에는 2의 보수와 IEEE 754 부동이 있습니다.

이건 어때:

데이터 포인터는 유효한 함수 포인터와 같을 수 없습니다.

이것은 모든 플랫 모델, MS-DOS TINY, LARGE 및 HUGE 모델의 경우 TRUE, MS-DOS SMALL 모델의 경우 false, MEDIUM 및 COMPACT 모델의 경우 거의 항상 false입니다 (로드 주소에 따라 다름, 정말 오래된 DOS가 필요합니다. 사실로 만드십시오).

이것에 대한 테스트를 작성할 수 없습니다

그리고 더 나쁜 것은 ptrdiff_t로 캐스트 된 포인터를 비교할 수 있다는 것입니다. 이것은 MS-DOS LARGE 모델에 해당되지 않습니다. LARGE와 HUGE의 유일한 차이점은 HUGE가 포인터를 정규화하기 위해 컴파일러 코드를 추가한다는 것입니다.

이 폭탄이 터지는 환경은 64K보다 큰 버퍼를 할당하지 않기 때문에 테스트를 작성할 수 없으므로이를 보여주는 코드가 다른 플랫폼에서 충돌 할 수 있습니다.

이 특정 테스트는 현재 없어진 하나의 시스템을 통과합니다 (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.");

편집 : 프로그램의 마지막 버전으로 업데이트 됨

Solaris-SPARC

32 비트의 gcc 3.4.6

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

64 비트의 gcc 3.4.6

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

및 SUNStudio 11 32 비트

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

및 SUNStudio 11 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.
..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

텍스트 모드 ( fopen("filename", "r"))를 사용하여 모든 종류의 텍스트 파일을 읽을 수 있습니다.

이 동안 해야 잘 이론 연구에서, 당신은 또한 사용하는 경우 ftell()코드에서, 그리고 텍스트 파일을 UNIX 스타일의 라인 엔딩을 가지고, 윈도우 표준 라이브러리의 일부 버전에서, ftell()종종 잘못된 값을 반환합니다. 해결책은 대신 바이너리 모드 ( fopen("filename", "rb"))를 사용하는 것입니다.

AIX 5.3의 gcc 3.3.2 (예, 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

어떤 사람들이 C ++에서 할 수 있다는 가정은 a struct가 C에서 할 수있는 일로 제한된다는 것입니다. 사실 C ++에서 a struct는 class기본적으로 모든 것이 공개된다는 점을 제외하면 a와 같습니다 .

C ++ 구조체 :

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


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

protected:
  void Testing2();
};

다른 시스템의 표준 수학 함수는 동일한 결과를 제공하지 않습니다.

32 비트 x86의 Visual Studio Express 2010.

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

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)를 통해 .

Codepad에는 stddef.h. 경고를 오류로 사용하는 코드 패드로 인해 테스트 9를 제거했습니다. 나는 또한 count어떤 이유로 이미 정의되었으므로 변수의 이름을 변경했습니다 .

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

과도한 양만큼 오른쪽으로 이동하는 것은 어떻습니까? 표준에서 허용합니까 아니면 테스트 할 가치가 있습니까?

표준 C는 다음 프로그램의 동작을 지정합니까?

void print_string (char * st)
{
  char ch;
  while ((ch = * st ++)! = 0)
    퍼치 (ch); / * 이것이 정의되었다고 가정 * /
}
int main (void)
{
  print_string ( "Hello");
  반환 0;
}

내가 사용하는 하나 이상의 컴파일러에서 print_string에 대한 인수가 "char const *" 가 아니면 해당 코드는 실패합니다 . 표준이 그러한 제한을 허용합니까?

일부 시스템에서는 정렬되지 않은 'int'에 대한 포인터를 생성 할 수 있고 다른 시스템은 그렇지 않습니다. 테스트할만한 가치가 있습니다.

참고로, C 기술을 Java로 번역해야하는 사람들을 위해 몇 가지 문제가 있습니다.

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

Java에서 char은 16 비트이며 서명됩니다. 바이트는 8 비트이며 부호가 있습니다.

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

long은 항상 64 비트이고 참조는 32 비트 또는 64 비트 일 수 있습니다 (32GB를 초과하는 앱이 두 개 이상있는 경우) 64 비트 JVM은 일반적으로 32 비트 참조를 사용합니다.

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

시프트는 i << 64 == i == i << -64, i << 63 == i << -1이되도록 마스킹됩니다.

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

ByteOrder.nativeOrder ()는 BIG_ENDIAN 또는 LITTLE_ENDIAN 일 수 있습니다.

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

i = i++ 절대 변하지 않는다 i

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

콜렉션 및 배열의 ​​크기는 JVM이 32 비트인지 64 비트인지에 관계없이 항상 32 비트입니다.

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 비트, short는 16 비트, int는 32 비트, long은 64 비트입니다.