C99 ...

C99 가 먼지 궁금해서 문서를 서치해봤습니다
근데 괜찮은 문서를 발견해서...
해석도 개판이고 존대말 썼다가 반말 썼다... 머 그렇습니다
정정 사항 있으면 누가 문서로 번역해줬으면 좋겠군요...

C99 가 C++98처럼 바뀐점

배열의 최기화에 비상수를 사용할수 있다.
• {
• float x = (float)i; // Valid C90, C99, and C++
• int m[3] = { 1, 2, 3 }; // Valid C90, C99, and C++
• int g[2] = { 0, i }; // Invalid C90
}
c++ 의 // 와 같은 커맨트를 완벽하게 지원한다
흐름제어 블록안에서 로컬변수를 정의할수 있다
• for (int i = 0; i < SIZE; i++)
a[i] = i + 1;
digraphs의 지원( XML때문에 있는듯 합니다)
아래의 토큰은 동일한 의미이다
•
<: [
:> ]
<% {
%> }
%: #
%:%: ##

함수 내부에서 함수의 선언이 가능합니다
• /* No previous declaration of bar() is in scope */
•
• void foo(void)
• {
• bar(); /* Implicit declaration: extern int bar() */
}

타입을 자동으로 int로 해석하지 않습니다
• static sizes = 0; /* Implicit int, error */
•
• struct info
• {
• const char * name;
• const sz; /* Implicit int, error */
• };
•
• static foo(register i) /* Implicit ints, error */
• {
• auto j = 3; /* Implicit int, error */
•
• return (i + j);
}

선언을 statement 중간에 사용할수 있습니다
• void prefind(void)
• {
• int i;
•
• for (i = 0; i < SZ; i++)
• if (find(arr[i]))
• break;
•
• const char * s; /* Invalid C90, valid C99 and C++ */
•
• s = arr[i];
• prepend(s);
}

C99 vs C++98

C++ 프리 프로세서는 이러한 키워드를 인식합니다

•
and &&
and_eq &=
bitand &
bitor |
compl ~
not !
not_eq !=
or ||
or_eq |=
xor ^
xor_eq ^=

배열 파라미터에 한정자가 추가 되었습니다(재미난 내용입니다)
• extern void foo(int str[const]);
extern void foo(int *const str);
위에 것은 같은 표현입니다
• void baz(char s[static 10])
• {
• // s[0] thru s[9] exist and are contiguous
• ...
}
배열 s는 0-9까지의 인덱스를 갇습니다.
이것이 10바이트 단위로 통째로 복사되는것일수도 있습니다.
Sizeof()와 같은 연산이 가능할수도 있습니다. 정확한 내용이 궁금하네요

불린 타입이 추가
_Bool, (_Bool)0, (_Bool)1 <stdbool.h>
bool, false, true 와 같은 것으로 정해지지 않는 이유는 기존 코드와 호환성 때문인 것 같네요

‘a’(C99) != ‘a’(C++98)
c에선 ‘a’ 는 int 푠현 식입니다
memset(&src, ‘a’, sizeof(‘a’)) 는 예상치 못한 결과를 가질수 있다

• clog identifier (이해할수 없는 부분)
C99 declares clog() in <math.h> as the complex natural logarithm function.
C++ declares std::clog in <iostream> as the name of the standard error logging output stream (analogous to the stderr stream). This name is placed into the global namespace if the <math.h> header is included, and refers to the logarithm function. If <math.h> defines clog as a preprocessor macro name, it can cause problems with other C++ code.
// C++ code

#include <iostream>
using std::clog;

#include <math.h> // Possible conflict

void foo(void)
{
clog << clog(2.718281828) << endl;
// Possible conflict
}
Including both the <iostream> and the <cmath> headers in C++ code places both clog names into the std:: namespace, one being a variable and the other being a function, which should not cause any conflicts.
// C++ code

#include <iostream>
#include <cmath>

void foo(void)
{
std::clog << std::clog(2.718281828) << endl;
// No conflict; different types
}

void bar(void)
{
complex double (* fp)(complex double);

fp = &std::clog; // Unambiguous
}
It would appear that the safest approach to this potential conflict would be to avoid using both forms of clog within the same source file.
C99 는 내장 complex imaginary floating 타입을 갇는다

임시적인 정의타입 인스턴스를 만들수 있숩니다( 어째 내가 써놓고도 이해 안가는군요 아래 예제를 확인하세요)

• struct info
• {
• char name[8+1];
• int type;
• };
•
• extern void add(struct info s);
• extern void move(float coord[2]);
•
• void predef(void)
• {
• add((struct info){ "e", 0 }); // A struct literal
• move((float[2]){ +0.5, -2.7 }); // An array literal
}

C++의
• void predef2()
• {
• add(info("e", 0)); // Call constructor info::info()
}
이런 표현의 대용품이죠. 그래도 훌륭하네요. 100점

const linkage
• const int i = 1; // External linkage
•
• extern const int j = 2; // 'extern' optional
static const int k = 3; // 'static' required

c++에선 const가 있으면 파일내부 이름영역을 갇는다고 합니다

동적 sizeof 연산
쿠하~~~
• size_t dsize(int sz)
• {
• float arr[sz]; // VLA, dynamically allocated
•
• if (sz <= 0)
• return sizeof(sz); // Evaluated at compile time
• else
• return sizeof(arr); // Evaluated at runtime
}
뷰티풀 이란 말을 안할수 없네요
C++에선 지원하지 않습니다

C99의 프리프로세서는 매크로 인자를 비워둘수 있습니다

• #define ADD3(a,b,c) (+ a + b + c + 0)
•
• ADD3(1, 2, 3) => (+ 1 + 2 + 3 + 0)
• ADD3(1, 2, ) => (+ 1 + 2 + + 0)
• ADD3(1, , 3) => (+ 1 + + 3 + 0)
• ADD3(1,,) => (+ 1 + + + 0)
ADD3(,,) => (+ + + + 0)

C99 에선 enum 의 끝에 콤마를 붙일수 있다
enum Color { RED = 0, GREEN, BLUE, };

C99 는 16진수형식의 floating-point 리터럴 을 지원
float pi = 0x3.243F6A88p+03;

C99는 인라인 함수를 지원합니다

C99는 long long 타입을 지원

C99 _Pragma keyword
• #pragma FLT_ROUND_INF // Preprocessor pragma
•
_Pragma(FLT_ROUND_INF) // Pragma statement

__func__ 키워드 추가
함수 이름의 문자열 리터럴
개인적으로 VC의 __LINE__ 이 int 값인데 대하여 불만입니다 문자열 리터럴로 되어있는건 없는지…

가변인자 매크로 지원
• #define DEBUGF(f,...) \
• (fprintf(dbgf, "%s(): ", f), fprintf(dbgf, __VA_ARGS__))
•
• #define DEBUGL(...) \
• fprintf(dbgf, __VA_ARGS__)
•
• int incr(int *a)
• {
• DEBUGF("incr", "before: a=%d\n", *a);
• (*a)++;
• DEBUGL("after: a=%d\n", *a);
• return (*a);
}
C++은 지원하지 않습니다. 왜 지원안할까요

원문 http://david.tribble.com/text/cdiffs.htm#C90-aggreg-init