printf() — 형식화된 문자 출력

형식

#include <stdio.h>
int printf(const char *format-string, argument-list);

언어 레벨

ANSI

스레드세이프

로케일 감지

이 함수의 작동은 현재 로케일의 LC_CTYPE 및 LC_NUMERIC 범주에 영향을 받을 수 있습니다. LOCALETYPE(*LOCALEUCS2) 또는 LOCALETYPE(*LOCALEUTF)가 컴파일 명령에서 지정되면 현재 로케일의 LC_UNI_CTYPE 범주에 영향을 받을 수도 있습니다. 자세한 정보는 CCSID 및 로케일 이해의 내용을 참조하십시오.

설명

printf() 함수는 표준 출력 스트림 stdout에 일련의 문자와 값의 형식을 지정하고 출력합니다. 퍼센트 기호(%)로 시작하는 형식 사양은 format-string 다음에 오는 argument-list의 출력 형식을 판별합니다. format-string은 초기 시프트 상태에서 시작하고 끝나는 멀티바이트 문자 스트링입니다.

format-string은 왼쪽에서 오른쪽으로 읽힙니다. 첫 번째 형식 스펙이 없는 경우, format-string 다음의 첫 번째 인수의 값이 형식 스펙에 따라 변환되고 출력됩니다. 두 번째 형식 스펙으로 format-string 다음의 두 번째 인수가 변환되고 출력되는 방식으로 format-string의 끝까지 적용됩니다. 형식 스펙보다 더 많은 인수가 있는 경우, 추가 인수는 평가되고 무시됩니다. 모든 형식 스펙에 인수가 충분한 경우 결과는 정의되지 않습니다.

형식 스펙의 형식은 다음과 같습니다.

구문 도표 읽기시각적 구문 도표 생략
>>-%--+-------+--+-------+--+--------------+--+----+--type-----><
      '-flags-'  '-width-'  '-.--precision-'  +-h--+         
                                              +-L--+         
                                              +-l--+         
                                              +-ll-+         
                                              +-H--+         
                                              +-D--+         
                                              '-DD-'         

사용되지 않은 다음 인수가 아닌 argument-list에서 format-string 다음의 n번째 인수에 변환이 적용될 수 있습니다. 이 경우, 변환 문자 %는 %n$로 대체되며, 여기서 n은 1에서 NL_ARGMAX까지 범위의 십진 정수로, argument-list에 인수 위치를 지정합니다. 이 기능은 특정 언어에 적합한 순서로 인수를 선택하는 형식 스트링의 정의에 제공됩니다.

대체 형식 스펙의 형식은 다음과 같습니다.
구문 도표 읽기시각적 구문 도표 생략
>>-%--arg-number$--+-------+--+-------+--+--------------+------->
                   '-flags-'  '-width-'  '-.--precision-'   

>--+----+--type------------------------------------------------><
   +-h--+         
   +-L--+         
   +-l--+         
   +-ll-+         
   +-H--+         
   +-D--+         
   '-DD-'         

대안으로서 인수 리스트에서 특정 항목이 이전 다이어그램에서 설명한 형식 스펙을 사용하여 지정될 수 있습니다. 이 형식 스펙과 이전 형식 스펙은 printf()에 대한 동일 호출에서 혼합될 수 있습니다. 그렇지 않으면, 예측 불가능한 결과가 발생할 수 있습니다.

arg-number는 양의 정수 상수로, 여기서 1은 argument-list의 첫 번째 항목을 참조합니다. Arg-number는 argument-list의 항목 수보다 클 수 없으며, 그렇지 않은 경우 결과가 정의되지 않습니다. Arg-number도 NL_ARGMAX보다 크지 않을 수도 있습니다.

변환 스펙의 %n$ 양식을 포함하는 형식 스트링에서, argument-list에서 숫자가 지정된 인수는 필요한 따라 여러 번 형식 스트링에서 참조될 수 있습니다.

변환 스펙의 %n$ 양식을 포함하는 형식 스트링에서, 필드 폭이나 정밀도는 시퀀스 *m$로 표시될 수 있으며, 여기서 m은 1에서 NL_ARGMAX까지 범위의 십진 정수로 다음과 같은 정밀도나 필드 폭을 포함한 정수 인수의 인수 리스트(형식 인수 다음)에 위치를 지정합니다.

printf("%1$d:%2$.*3$d:%4$.*3$d\n", hour, min, precision, sec);

format-string은 각각 번호를 지정한 인수 스펙(즉, %n$ 및 *m$) 또는 번호를 지정하지 않은 인수 스펙(즉, % 및 *)을 포함할 수 있으며, 보통 두 개 모두를 포함하지 않습니다. 이에 대한 유일한 예외는 %%를 %n$ 양식과 혼합될 수 있다는 점입니다. format-string 스트링에서 번호가 지정된 인수 스펙과 번호가 지정되지 않은 인수 스펙의 혼용 결과는 정의되지 않습니다. 번호가 지정된 인수 스펙이 사용될 때, n번째 인수를 지정하면 첫 번째에서부터 (n-1)번째까지, 모든 선행 인수가 스트링 형식 스트링에 지정되어야 합니다.

형식 스펙의 각 필드는 단일 문자이거나 특정 형식 옵션을 지정하는 수입니다. type 문자는 마지막 옵션 형식 필드 다음에 표시되며, 연관된 인수가 문자, 스트링, 숫자 또는 포인터로 해석되는지 여부를 판별합니다. 가장 단순한 형식 스펙은 퍼센트 기호와 type 문자(예: %s)를 포함합니다.

다음 선택적 필드는 형식 지정의 다른 면을 제어합니다.
필드
설명
flags
부호, 공백, 소수점, 8진 및 16진 접두부의 출력과 인쇄 행 정렬 및 wchar_t 정밀도 장치의 시맨틱.
width
최소 바이트의 출력.
precision
표 2의 내용을 참조하십시오.
h, l, ll, L, H, D, DD
예상된 인수 크기:
h
인수가 short int 또는 unsigned short intd, i, o, u, x, Xn 유형의 접두부.
l
인수가 long int 또는 unsigned long int임을 지정하는 d, i, o, u, x, Xn 유형의 접두부.
ll
인수가 long long int 또는 unsigned long long int임을 지정하는 d, i, o, u, x, Xn 유형의 접두부.
L
인수가 long double임을 지정하는 a, A, e, E, f, F, g 또는 G 유형의 접두부.
H
인수가 _Decimal32임을 지정하는 a, A, e, E, f, F, g 또는 G 유형의 접두부.
D
인수가 _Decimal64임을 지정하는 a, A, e, E, f, F, g 또는 G 유형의 접두부.
DD
인수가 _Decimal128임을 지정하는 a, A, e, E, f, F, g 또는 G 유형의 접두부.

형식 스펙의 각 필드는 아래에서 상세하게 논의됩니다. 퍼센트 기호(%)가 형식 필드로서 의미가 없는 문자 다음에 오면 작동이 정의되지 않습니다. 이 작동에 대한 한 예외는 %%입니다. 퍼센트 기호 문자를 출력하려면 %%를 사용합니다.

type 문자와 해당 의미는 다음 테이블에 제공됩니다.

표 1. 유형 문자
문자 인수 출력 형식
a 부동 소수점 십진이 아닌 부동 소수점의 경우, 양식 [-]0xh.hhhhp[sign]ddd인 부호 있는 값으로, 여기서, h는 단일 16진수 이며 hhhh는 하나 이상의 16진수이며, ddd는 하나 이상의 10진수이며 sign은 + 또는 -입니다. 소수점 다음의 16진 자릿수는 요청된 자릿수와 동일합니다.

10진 부동 소수점의 경우, 정밀도가 없으면 f 또는 e 스타일 포맷은 다음 기준을 기반으로 사용됩니다.

  • 값의 quantum exponent가 0보다 작거나 같지만 -(n+5)보다 크거나 같은 경우 f 스타일 포맷이 사용됩니다. 수의 quantum exponent은 quantexp64() 함수를 호출하여 판별될 수 있습니다. 소수점이 무시되면 n은(후행 영 포함) 10진수의 자릿수입니다. 예를 들면 다음과 같습니다.

    0.000005

    contains 1 digit in the digit sequence, n = 1

    0.0000050

    순번에서 2자리를 포함하며, n = 2

    12.30

    순번에서 4자리를 포함하며, n = 4

    정밀도는 값의 quantum exponent의 값과 동일합니다.

  • 값의 quantum exponentf 스타일 기준을 충족시키지 않을 때 e 스타일 포맷팅이 사용됩니다. 정밀도는 n-1과 동일합니다. 십진 부동 소수값의 e 스타일 포맷은 두 지수가 있는 십진이 아닌 부동 소수점 값의 e 스타일 포맷과 동일합니다. a) 값이 0과 같으면 지수는 값의 quantum exponent와 동일하며, b) 지수는 필요한 최소 자릿수로 지정됩니다(예: 선행 0을 포함하지 않는 지수). 예를 들면 다음과 같습니다.

    0.0000000은 0e-7를 생성합니다.

    -1870은 -1.87e+3을 생성합니다.

정밀도 수정자가 존재하고 적어도 값의 정밀도만큼 크면, 변환은 마치 정밀도 수식자가 누락된 것과 같습니다. 정밀도 수정자가 존재하고 값의 정밀도보다 적으면, 값은 정밀도 수정자에서 지정한 자릿수로 먼저 반올림됩니다. 정밀도 수정자가 없는 것처럼 결과가 변환됩니다.
A 부동 소수점 대문자 알파벳 문자가 소문자 알파벳 문자대신 사용되는 점을 제외하고 형식과 동일합니다.
d, i 정수 부호가 있는 십진 정수.
u 정수 부호가 없는 십진 정수.
o 정수 부호가 없는 8진 정수.
x 정수 abcdef를 사용한 부호가 없는 16진 정수.
X 정수 ABCDEF를 사용한 부호가 없는 16진 정수.
D(n,p) P팩형 10진수 형식 [-] dddd.dddd가 있으며, 여기서 소수점 다음의 자릿수는 해당 스펙의 정밀도와 동일합니다. 정밀도가 없으면 기본값은 p입니다. 정밀도가 0(영)이고 # 플래그가 지정되지 않으면 소수점 문자가 표시되지 않습니다. np가 *이면, 인수 리스트의 인수가 값을 제공합니다. np는 인수 리스트에서 형식이 지정되는 값보다 앞에 표시됩니다. 소수점 앞에 최소 하나의 문자가 표시됩니다. 값은 적절한 자릿수로 반올림됩니다.
f 부동 소수점 양식 [-]dddd.dddd의 부호가 있는 값으로, 여기서 dddd는 하나 이상의 십진수입니다. 소수점 앞의 자릿수는 숫자의 크기에 따라 다릅니다. 소수점 다음의 자릿수는 요청된 자릿수와 동일합니다.2
F 부동 소수점 대문자 알파벳 문자가 소문자 알파벳 문자 대신 사용되는 점을 제외하고 f 포맷과 동일합니다.2
e 부동 소수점 양식 [-]d.dddd e[sign]ddd의 부호 있는 값으로, 여기서 d는 단일 십진수이며, dddd는 하나 이상의 십진수이며, ddd는 2 이상의 십진수이며 sign은 + 또는 -입니다.2
E 부동 소수점 대문자 알파벳 문자가 소문자 알파벳 문자 대신 사용되는 점을 제외하고 e 포맷과 동일합니다.2
g 부동 소수점 f 또는 e 형식으로 출력된 부호 있는 값. 값의 지수가 -4보다 적거나 precision보다 크거나 같을 때만 e 형식이 사용됩니다. 하나 이상의 수가 다음에 표시되는 경우 후행 0(영)이 잘리며 소수점이 표시됩니다.2
G 부동 소수점 대문자 알파벳 문자가 소문자 알파벳 문자 대신 사용되는 점을 제외하고 g 포맷과 동일합니다.2
c 문자(바이트) 단일 문자.
s 스트링 첫 번째 널 문자(\0) 또는 precision에 도달할 때까지 출력된 문자(바이트).
n 정수에 대한 포인터 stream 또는 버퍼에 지금까지 작성한 문자 수(바이트)입니다. 이 값은 주소가 인수로 부여되는 정수에 저장됩니다.
p 포인터 출력 가능한 문자의 시퀀스로 변환된 포인터. 다음 중 하나일 수 있습니다.
  • 공백 포인터
  • 시스템 포인터
  • 호출 포인터
  • 프로시저 포인터
  • 열린 포인터
  • 일시중단 포인터
  • 데이터 포인터
  • 레이블 포인터
lc 또는 C 와이드 문자 wctomb()에 대한 호출처럼 (wchar_t) 문자는 멀티바이트 문자로 변환되며, 이 문자가 출력됩니다.1
ls 또는 S 와이드 문자 첫 번째 (wchar_t) 널 문자 (L\0) 또는 정밀도가 도달될 때까지 (wchar_t) 문자는 wcstombs()에 대한 호출처럼 멀티바이트 문자로 변환되며, 이 문자가 출력됩니다. 인수가 널 스트링이면, (null)이 출력됩니다.1
참고:
  1. 자세한 정보는 wctomb() 함수에 대한 문서 또는 wcstombs() 함수에 대한 문서를 참조하십시오. 또한 와이드 문자에서 추가 정보를 찾을 수 있습니다.
  2. H, D 또는 DD 형식 크기 지정자가 사용되지 않으면 15개의 출력의 유효 숫자만이 보증됩니다.
다음 리스트는 IBM® i 포인터의 인쇄된 값의 형식을 표시하고, 인쇄된 값의 구성요소의 간단한 설명을 제공합니다.

공백 포인터:
SPP:Context:Object:Offset:AG

        컨텍스트: 유형, 하위유형 및 컨텍스트의 이름
        오브젝트: 유형, 하위유형 및 오브젝트의 이름
        오프셋: 간격 내 오프셋
        AG:      활성 그룹 ID

시스템 포인터:  SYP:Context:Object:Auth:Index:AG

        컨텍스트: 유형, 하위유형 및 컨텍스트의 이름
        오브젝트: 유형, 하위유형 및 오브젝트의 이름
        Auth: 권한
        색인: 포인터와 연관된 색인
        AG:      활성 그룹 ID

호출 포인터:  IVP:Index:AG

        색인: 포인터와 연관된 색인
        AG:      활성 그룹 ID

프로시저 포인터:  PRP:Index:AG

        색인: 포인터와 연관된 색인
        AG:      활성 그룹 ID

일시중단 포인터:  SUP:Index:AG

        색인: 포인터와 연관된 색인
        AG:      활성 그룹 ID

데이터 포인터:  DTP:Index:AG

        색인: 포인터와 연관된 색인
        AG:      활성 그룹 ID

레이블 포인터:  LBP:Index:AG

        색인: 포인터와 연관된 색인
        AG:      활성 그룹 ID

NULL 포인터:  NULL

다음 제한사항은 IBM i 운영 체제에서 포인터 출력과 스캔에 적용됩니다.
  • 포인터가 동일한 활성 그룹에서 출력되고 다시 스캔되면, 다시 스캔 포인터는 출력된 포인터와 동일하게 비교됩니다.
  • scanf() 제품군 함수가 다른 활성 그룹에서 출력되었던 포인터를 스캔하는 경우, scanf() 제품군 함수는 포인터를 널로 설정합니다.
  • 포인터가 teraspace 환경에서 출력되면 포인터의 16진 값이 출력됩니다. 이 결과는 %#p를 사용할 때와 동일합니다.

%#p 형식 지정자는 %p 형식 지정자보다 더 나은 성능을 가지고 있습니다.

IBM i 포인터 사용에 대한 자세한 정보는 ILE C/C++ Programmer's Guide를 참조하십시오.

INFINITY 또는 NaN(Not-a-Number)의 부동 소수점 값이 a, e, f 또는 g 포맷을 사용하여 포맷되는 경우, 출력 스트링은 infinity 또는 nan입니다. INFINITY 또는 NaN(Not-a-Number)의 부동 소수점 값이 A, E, F 또는 G 포맷을 사용하여 포맷되는 경우, 출력 스트링은 INFINITY 또는 NAN입니다.

flag 문자와 해당 의미는 다음과 같습니다(둘 이상의 flag가 포맷 스펙에 표시될 수 있음에 주의).

플래그 의미 기본값
- 필드 폭 내 결과를 좌측 정렬합니다. 우측 정렬합니다.
+ 출력값이 부호 있는 유형인 경우 부호(+ 또는 -)를 출력 값 앞에 추가합니다. 부호는 음부호 값(-)에 대해서만 표시됩니다.
blank(' ') 출력값이 부호 있고 양수인 경우 공백을 출력 값 앞에 추가합니다. 모두 표시된 경우 + 플래그가 blank 플래그를 대체하며 양수의 부호가 있는 값은 부호로 출력됩니다. 공백이 없습니다.
# o, x 또는 X 포맷으로 사용되면, # 플래그는 0(영)이 아닌 출력 값 앞에 0, 0x 또는 0X를 추가합니다. 접두부가 없습니다.
D(n,p), a, A, e, E, f 또는 F 형식으로 사용된 경우, # 플래그는 모든 경우에 소수점을 포함하도록 출력 값을 강제 실행합니다. 숫자가 다음에 나타나는 경우에만 소수점이 표시됩니다.
g 또는 G 포맷으로 사용되는 경우, # 플래그는 모든 경우에 소수점을 포함하도록 출력 값을 강제 실행하며 후행 0의 잘림을 방지합니다. 숫자가 다음에 나타나는 경우에만 소수점이 표시됩니다. 후행 0(영)이 잘립니다.
ls 또는 S 포맷으로 사용되는 경우, # 플래그로 문자의 크기에 상관없이 문자에서 정밀도를 측정합니다. 예를 들어, 1바이트 문자가 출력되고 있다면 4의 정밀도는 4바이트를 출력합니다. 2바이트 문자가 출력되고 있다면 4의 정밀도는 8바이트를 출력합니다. 정밀도는 출력될 최대 개수의 바이트를 표시합니다.
p 포맷으로 사용하면 # 플래그는 포인터를 16진수로 변환합니다. teraspace 환경에서가 아닌 경우 이 16진 숫자는 다시 포인터로 변환될 수 없습니다. 출력 가능한 문자의 시퀀스로 변환된 포인터.
0 d, i, D(n,p) o, u, x, X, a, A, e, E, f, F, g, 또는 G 포맷과 함께 사용되면, 0 플래그는 선행 0이 필드 너비에 대한 출력을 채웁니다. 정밀도가 정수에 대해 지정되거나 - 플래그가 지정된 경우 0 플래그는 무시됩니다. 공간 채우기. D(n,p)를 채우는 공간이 없습니다.

# 플래그는 c, lc, d, i, u 또는 s 유형과 함께 사용되지 않아야 합니다.

Width는 출력된 최소 문자수를 제어하는 음수가 아닌 십진 정수입니다. 출력 값의 문자 수(바이트)가 지정된 width보다 작으면, 최소 너비에 도달할 때까지 공백이 왼쪽이나 오른쪽에 추가됩니다(- 플래그가 지정되는지 여부에 따라).

Width로 값이 잘리지는 않습니다. 출력 값에서 문자 수(바이트)가 지정된 width 보다 크거나 width가 지정되지 않으면, 값의 모든 문자가 출력됩니다(precision 스펙에 따라).

ls 또는 S 유형의 경우, width는 바이트로 지정됩니다. 출력 값의 바이트 수가 지정된 너비보다 작으면, 최소 너비가 도달될 때까지 1바이트 공백이 왼쪽이나 오른쪽에 추가됩니다(- 플래그가 지정되는지 여부에 따라).

width 스펙은 별표(*)일 수 있으며, 이 경우 인수 리스트의 인수가 값을 제공합니다. width 인수는 인수 리스트에서 형식이 지정되는 값 앞에 표시되어야 합니다.

Precision은 마침표 앞에 오는 음수가 아닌 십진 정수로, 출력될 문자의 수나 소수 자리의 수를 지정합니다. width 스펙과 달리, precision으로 출력값을 자르거나 부동 소수점이나 팩 십진 값으로 반올림합니다.

precision 스펙은 별표(*)일 수 있으며, 이 경우 인수 리스트의 인수가 값을 제공합니다. precision 인수는 인수 리스트에서 형식이 지정되는 값 앞에 표시되어야 합니다.

precision가 생략되면 precision 값과 기본값의 해석은 다음 테이블에서 표시된대로 type에 따라 생략됩니다.

표 2. 정밀도 값
유형 의미 기본값

  a
  A

십진이 아닌 부동 소수점의 경우, precision은 소수점 다음에 출력될 16진 숫자를 지정합니다.

십진 부동 소수점의 경우, precision은 출력될 유효 숫자의 수를 지정합니다.

십진이 아닌 십진 부동 소수점의 경우, 기본 precision은 값의 정확한 표현에 충분합니다. precision이 0이면 소수점이 출력되지 않습니다. 십진 부동 소수점의 경우, 기본 precision은 값의 정확한 표현에 충분합니다. 사용된 형식에 자세한 정보는 표 1의 내용을 참조하십시오.

   i
   d
   u
   o
   x
   X

Precision은 출력될 숫자의 최소값을 지정합니다. 인수에서 숫자의 수가 precision보다 작으면, 출력 값은 왼쪽이 0으로 채워집니다. 자릿수가 precision을 초과하면 값이 잘리지 않습니다. precision0이거나 전체가 생략된 경우, 또는 마침표(.)가 다음에 오는 숫자 없이 표시되는 경우, precision이 1로 설정됩니다.

   f
   F
   D(n,p)
   e
   E

Precision은 소수점 다음에 출력될 자릿수를 지정합니다. 출력된 마지막 숫자는 반올림됩니다. f, F, eE를 위한 기본 precision은 6입니다. D(n,p)를 위한 기본 precisionp입니다. precision0이거나 마침표가 다음에 오는 수가 없이 표시되면 소수점이 출력됩니다.

   g
   G

Precision은 출력된 최대 개수의 유효 숫자를 지정합니다. 모두 유효 숫자가 출력됩니다. 기본 precision은 6입니다.

   c

영향을 미치지 않습니다. 문자가 출력됩니다.

   lc

영향을 미치지 않습니다. wchar_t 문자는 변환되고 결과로 생기는 멀티바이트 문자가 출력됩니다.

   s

Precision은 출력될 최대 개수의 문자(바이트)를 지정합니다. precision을 초과한 문자(바이트)은 출력되지 않습니다. 널 문자를 만날 때까지 문자가 출력됩니다.

   ls

Precision은 출력될 최대 개수의 바이트를 지정합니다. precision을 초과한 바이트는 출력되지 않습니다. 그러나 멀티바이트 무결성은 항상 보존됩니다. wchar_t 문자는 변환되고 결과로 생기는 멀티바이트 문자가 출력됩니다.

리턴값

printf() 함수는 출력된 바이트 개수를 리턴합니다. errno의 값은 다음으로 설정될 수 있습니다.
의미
EBADMODE
지정되는 파일 모드는 유효하지 않습니다.
ECONVERT
변환 오류가 발생했습니다.
EIOERROR
회복 불가능한 I/O 오류가 발생했습니다.
EIORECERR
회복 가능한 I/O 오류가 발생했습니다.
EILSEQ
유효하지 않은 멀티바이트 문자 순서입니다.
EPUTANDGET
읽기 조작 후 허용되지 않는 쓰기 조작이 발생했습니다.
ESTDOUT
stdout를 열 수 없습니다.
참고: printf() function 함수에 대한 기수 문자는 로케일에 민감합니다. 기수 문자는 형식 유형 D(n,p),, A, e, E, f, F, g 그리고 G를 위한 형식 스트링 매개변수의 # 플래그 문자를 위해 사용될 소수점입니다.

이 예는 다양한 형식으로 데이터를 출력합니다.
#include <stdio.h>                                               
#include <stdlib.h>                                              
                                                                 
int main(void)                                                   
{                                                                
    char ch = 'h', *string = "computer";                         
    int count = 234, hex = 0x10, oct = 010, dec = 10;            
    double fp = 251.7366;                                        
    wchar_t wc = (wchar_t)0x0058;                                
    wchar_t ws[4];                                                       
                                                     
    printf("1234567890123%n4567890123456789\n\n", &count);          
    printf("Value of count should be 13; count = %d\n\n", count);   
    printf("%10c%5c\n", ch, ch);                                    
    printf("%25s\n%25.4s\n\n", string, string);                     
    printf("%f    %.2f    %e    %E\n\n", fp, fp, fp, fp);           
    printf("%i    %i     %i\n\n", hex, oct, dec);                   
}                                                                   
/*****************  Output should be similar to:  ***************** 
                                                                    
234   +234    000234     EA    ea     352                           
                                                                    
12345678901234567890123456789                                       
                                                                    
Value of count should be 13; count = 13                             
 
                                                                      
  h    h                                                              
          computer                                                    
              comp                                                    
                                                                      
251.736600    251.74    2.517366e+02    2.517366E+02                  
                                                                      
16    8     10                                                        
 
*******************************************************************/  

printf()를 사용하는 예

     #include <stdio.h>
     #include <stdlib.h>
     #include <locale.h>
     /* This program is compiled with LOCALETYPE(*LOCALEUCS2) and             */
     /* SYSIFCOPT(*IFSIO)                                               */
     /* We will assume the locale setting is the same as the CCSID of the */
     /* job.  We will also assume any files involved have a CCSID of      */
     /* 65535 (no convert).  This way if printf goes to the screen or     */
     /* a file the output will be the same.                               */
    int main(void)
    {
        wchar_t wc = 0x0058;     /* UNICODE X */
        wchar_t ws[4];
        setlocale(LC_ALL,
         "/QSYS.LIB/EN_US.LOCALE"); /* a CCSID 37 locale */
        ws[0] = 0x0041;        /* UNICODE A   */
        ws[1] = (wchar_t)0x0042;        /* UNICODE B   */
        ws[2] = (wchar_t)0x0043;        /* UNICODE C   */
        ws[3] = (wchar_t)0x0000;
        /* The output displayed is CCSID 37  */
        printf("%lc   %ls\n\n",wc,ws);
        printf("%lc   %.2ls\n\n",wc,ws);

        /* Now let's try a mixed-byte CCSID example  */
        /* You would need a device that can handle mixed bytes to  */
        /* display this correctly.                         */

        setlocale(LC_ALL,
        "/QSYS.LIB/JA_JP.LOCALE");/* a CCSID 5026 locale */

        /* big A means an A that takes up 2 bytes on the screen   */
        /* It will look bigger then single byte A                 */
        ws[0] = (wchar_t)0xFF21;        /* UNICODE big A   */
        ws[1] = (wchar_t)0xFF22;        /* UNICODE big B   */
        ws[2] = (wchar_t)0xFF23;        /* UNICODE big C   */
        ws[3] = (wchar_t)0x0000;
        wc = 0xff11;                    /* UNICODE big 1   */

        printf("%lc   %ls\n\n",wc,ws);

        /* The output of this printf is not shown below and it   */
        /* will differ depending on the device you display it on,*/
        /* but if you looked at the string in hex it would look  */
        /* like this:  0E42F10F404040400E42C142C242C30F          */
        /* 0E is shift out, 0F is shift in, and 42F1 is the      */
        /* big 1 in CCSID   5026  */

        printf("%lc   %.4ls\n\n",wc,ws);

        /* The output of this printf is not shown below either. */
        /* The hex would look like:                             */
        /* 0E42F10F404040400E42C10F                             */
        /* Since the precision is in bytes we only get 4 bytes  */
        /* of the string.         */

        printf("%lc   %#.2ls\n\n",wc,ws);

        /* The output of this printf is not shown below either. */
        /* The hex would look like:                             */
        /* 0E42F10F404040400E42C142C20F                         */
        /* The # means precision is in characters reguardless   */
        /* of size.  So we get 2 characters of the string.      */
    }
 /*****************  Output should be similar to:  *****************


 X     ABC

 X     AB

 *******************************************************************/
 

printf()를 사용하는 예

 #include <stdio.h>
 #include <stdlib.h>
 #include <locale.h>
 /* This program is compile LOCALETYPE(*LOCALE)  and               */
 /* SYSIFCOPT(*IFSIO)    */
 int main(void)
 {
     wchar_t wc = (wchar_t)0x00C4;     /*  D */
     wchar_t ws[4];
     ws[0] = (wchar_t)0x00C1;        /* A   */
     ws[1] = (wchar_t)0x00C2;        /* B   */
     ws[2] = (wchar_t)0x00C3;        /* C   */
     ws[3] = (wchar_t)0x0000;
     /* The output displayed is CCSID 37  */
     printf("%lc   %ls\n\n",wc,ws);

     /* Now let's try a mixed-byte CCSID example  */
     /* You would need a device that can handle mixed bytes to  */
     /* display this correctly.                         */

     setlocale(LC_ALL,
     "/QSYS.LIB/JA_JP.LOCALE"); /* a CCSID 5026 locale */

     /* big A means an A that takes up 2 bytes on the screen   */
     /* It will look bigger than single byte A                 */

     ws[0] = (wchar_t)0x42C1;        /* big A   */
     ws[1] = (wchar_t)0x42C2;        /* big B   */
     ws[2] = (wchar_t)0x42C3;        /* big C   */
     ws[3] = (wchar_t)0x0000;
     wc = 0x42F1;                    /* big 1   */

     printf("%lc   %ls\n\n",wc,ws);

     /* The output of this printf is not shown below and it   */
     /* will differ depending on the device you display it on,*/
     /* but if you looked at the string in hex it would look  */
     /* like this:  0E42F10F404040400E42C142C242C30F          */
     /* 0E is shift out, 0F is shift in, and 42F1 is the      */
     /* big 1 in CCSID   5026  */

     printf("%lc   %.4ls\n\n",wc,ws);

     /* The output of this printf is not shown below either. */
     /* The hex would look like:                             */
     /* 0E42F10F404040400E42C10F                             */
     /* Since the precision is in bytes we only get 4 bytes  */
     /* of the string.         */

     printf("%lc   %#.2ls\n\n",wc,ws);

     /* The output of this printf is not shown below either. */
     /* The hex would look like:                             */
     /* 0E42F10F404040400E42C142C20F                         */
     /* The # means precision is in characters regardless   */
     /* of size.  So we get 2 characters of the string.      */
 }
 /*****************  Output should be similar to:  *****************


 D     ABC


 *******************************************************************/