시리즈:쉽게 배우는 프로그래밍 입문/C 편집하기

{{:시리즈:쉽게 배우는 프로그래밍 입문}}

=== 준비 ===
C 언어를 공부할 때는 준비물은 '이론상으로' 단 두 가지만 있으면 된다. 바로 코드를 작성할 텍스트 편집기와, 그 코드를 프로그램으로 만들어주는 컴파일러가 그것이다. [[문서 편집기]]는 [[메모장]](윈도우), vi(멀티 플랫폼), gedit(리눅스), kate(리눅스), mousepad(리눅스), 비주얼 스튜디오 코드(멀티 플랫폼) 등을 일컬으며, 컴파일러는 대표적으로 gcc(멀티 플랫폼)가 있다. 그러나 이 두 가지만으로 프로그래밍을 하는 것은 매우 불편하므로, 보통은 통합 개발환경(IDE)을 사용한다. 이건 '문서 편집기와 컴파일러와 이것저것 유용한 기능이 들어 있는 프로그램'으로, 프로그래밍을 더욱 편하게 할 수 있게 해 준다. 또한 이것이 입문자에게도 쉬운 방법이기에, 대개 이 방법으로 많이 배운다.

== 윈도우 ==
IDE는 [[윈도우 7]] 이상에서라면 Visual Studio Community를 다운로드 받아 설치하자. 이클립스나 코드블럭을 사용해도 된다.

== 리눅스 ==
[[리눅스]]에서는 두 가지 방법이 있는데, 

첫 번째는 이클립스를 사용하는 것. 다만 이클립스는 원래 Java 프로그래밍에 쓰이는 IDE라서 C 언어에는 쓸 수 없는데, 이것을 C 언어에 사용하기 위해서는 이클립스 CDT라는 플러그인이 필요하다. 또한 앞서 언급한 컴파일러인 GCC의 설치도 필요하다. 즉 리눅스에서는 이클립스와 이클립스CDT와 GCC를 모두 설치해야 한다. 설치하는 방법은 아래 문단에 적혀있다.

두 번째 방법은 코드 블럭(Code::Blocks)을 사용하는 것이다. 코드블럭을 설치 하려면 sudo apt-get install libsdl1.2-dev codeblocks 를 입력하면 끝이다. 이클립스보다 간단한가? 이클립스는 따로 플러그인이 필요하지만, Code::Blocks은 애초에 C, C++을 기준으로 만들어진거라 플러그인<del>그런거 없다</del>이 필요 없다.

[[OS X]]의 경우에는 [[Xcode]]를 다운 받으면 된다. 리눅스와 달리 초반에 터미널을 이용하는 것이 좀 귀찮다. Xcode를 다운 받은 후, 런치패드>>기타 응용프로그램>>터미널 선택 한 후에 xcode-select --install 을 입력한 후에 엔터를 누른다. 그 후에 뭔가 하라는 인스톨은 안하고 별 이상한 것들이 나오는데, 그냥 쭉 내려서 agree를 하면 그때부터 설치하겠냐는 창이 뜬다. 설치를 누르고 기다리고 있으면 사용이 가능해진다. 리눅스에서는 gcc로 컴파일을 하는데 OS X에서는 clang도 사용할 수 있다. 리눅스에서도 clang을 설치하면 사용할 수 있다.

=== IDE 설치하기 ===
==== 비주얼 스튜디오 ====

[https://visualstudio.microsoft.com/ko/downloads/ Microsoft Visual studio 2019 공식 다운로드 사이트]

일단 위 사이트에서 Visual Studio Community(커뮤니티)를 다운로드받자. 이거 이외에는 개인이 돈주고 사야 정식으로 사용가능한 판들이다.

그리고 그냥 설치하면 된다.

==== 이클립스(CDT) ====
===== 리눅스 =====
[[파일:이클립스1.png|링크=Special:FilePath/이클립스1.png]]
[[파일:이클립스2.png|링크=Special:FilePath/이클립스2.png]]
[[파일:Gcc.png]]

시냅틱 패키지 관리자에서 eclipse와 eclipse-cdt와 gcc를 검색하여 설치한다. 이게 끝이다(...)

또 다른 방법으로 터미널을 열고 
sudo apt-get install eclipse eclipse-cdt gcc
또는
sudo apt install eclipse eclipse-cdt gcc
라고 입력하는 방법도 있다. 농담이 아니라 이걸로 끝이다(...) {{ㅊ|그러니까 여러분 모두 리눅스 쓰세요}}

==== XCode ====
앱스토어에서 찾아서 무료로 받자.

=== 프로젝트 만들기 ===
==== 비주얼 스튜디오 ====
다음은 Visual Studio 2013 의 Win32 콘솔 응용 프로그램의 프로젝트 만들기 과정이다.

[[파일:프로젝트생성-1.PNG|링크=Special:FilePath/프로젝트생성-1.PNG]]

1. 화면 상단의 파일 - 새로 만들기 - 프로젝트를 클릭한다. ( 단축키는 {{키|Ctrl}}+{{키|Shift}}+{{키|N}}이며, 펼쳐진 파일 탭의 가려진 뒷부분에는 새 프로젝트 만들기가 따로 있다. )

[[파일:프로젝트생성-2.PNG|링크=Special:FilePath/프로젝트생성-2.PNG]]

2. 위 과정을 마치고 나면 다음과 같은 창이 뜬다. 이 중에서 Win32 콘솔 응용 프로그램을 클릭하고 이름을 정한 다음 확인을 누른다.

[[파일:프로젝트생성-3.PNG|링크=Special:FilePath/프로젝트생성-3.PNG]]

3. 추가 옵션에서 빈 프로젝트를 체크하고 마침을 누른다.

==== 이클립스(CDT) ====
==== XCode ====
[[파일:XCode C 1.png|링크=Special:FilePath/XCode C 1.png]]
1. Create a new Xcode project를 누른다.
[[파일:XCode C 2.png|링크=Special:FilePath/XCode C 2.png]]
2. OSX-Application-Command line tool 선택 후 next
[[파일:XCode C 3.png|링크=Special:FilePath/XCode C 3.png]]
3.Language-C 선택후 나머지 란은 알맞게 채워 넣는다.

=== [[Hello, World!]]===
<syntaxhighlight lang=c>
#include <stdio.h>

int main(void)
{
    printf("Hello, World!\n");
    return 0;
}
</syntaxhighlight>

또는

<syntaxhighlight lang=c>
#include <stdio.h>

int main(void)
{
    puts("Hello, World!");
    return 0;
}
</syntaxhighlight>

참고로 main(void)의 void는 생략이 가능하다. 엄밀한 의미에서는 다르지만, 그냥 차이가 없다고 받아들이는게 지금은 편하다.

=== 컴파일하기 ===
==== 유닉스 환경에서 CLI로 컴파일 ====
매우 간단하다. 위에 적힌 Hello World의 코드를 그대로 텍스트 편집기(gedit, kate, mousepad, vi 등)로 작성하고 파일을 저장한다. 파일 확장자는 .c로 한다. 이 파일을 소스코드라고 한다. 가장 많이 쓰는 텍스트 편집기는 vi(vim)이다. 대부분의 유닉스 시스템에는 vi 또는 vim이 설치되어 있을 것이다.
<syntaxhighlight lang=console>
$ vi test.c
    혹은
$ vim test.c
</syntaxhighlight>
로 소스코드를 작성할 수 있다.

프로젝트의 규모가 커지면 make파일을 이용하기도 하는데 [[CMAKE]]참조

본격적인 컴파일 과정은 다음과 같다.
[[파일:컴파일1.png|링크=Special:FilePath/컴파일1.png]]

이것이 우리가 컴파일할 소스코드다. 이 파일이 /home/gabriel/Hive에 test.c라는 이름으로 저장되어 있다고 치면


[[파일:컴파일2.png|링크=Special:FilePath/컴파일2.png]]

터미널을 키고
<syntaxhighlight lang=console>
$ cd /home/gabriel/Hive
라고 입력하여 저장되어 있는 디텍토리에 들어간다. 그리고 다음 명령어를 입력한다.

$ cc 파일이름(파일이름이 test.c라면 cc test.c라고 입력한다)
</syntaxhighlight>
이렇게 할 경우 a.out이라는 파일이 생성되었을 것이다. 이것이 바로 컴파일된 파일이다.
마지막으로
<syntaxhighlight lang=console>
$ ./a.out
</syntaxhighlight>

이라고 터미널에 입력하면 컴파일된 파일을 실행할 수 있다. 만약 gcc가 설치되어 있다면 cc 대신에 gcc라는 명령어를 사용할 수도 있다. 차이점은 cc는 유닉스 시스템에 기본으로 내장되어 있는 컴파일러이고, gcc는 별도로 설치하는 컴파일러라는 것이다. 업계에서는 gcc의 사용 빈도가 높으므로, gcc에 익숙해지는 게 좋다.
<syntaxhighlight lang=console>
$ gcc test.c
</syntaxhighlight>
라는 명렁어를 사용하면, cc를 썻을 때 처럼 a.out이라는 이름의 파일이 생성된다. 만약 a.out이라는 파일 이름이 마음에 들지 않는다면
<syntaxhighlight lang=console>
$ gcc -o result test.c
</syntaxhighlight>
라는 명령어를 쳐보자. 이렇게하면 이름이 result인 파일이 생성된다.<!-- 또한
$ gcc -ansi test.c
혹은
$ gcc -ansi -o result test.c
라는 명령어도 알아두는 것이 좋다. 이렇게하면 ANSI 표준으로 컴파일된다. 쉽게 말하자면 옛날 표준으로 컴파일이 된다는 것인데, C언어는 특성상 개발자들이 옛 표준인 ANSI를 매우매우매우 사랑하므로 이왕이면 ANSI 표준에 맞게 코딩하는 습관을 기르는 게 좋다. 그러므로 ANSI 표준으로 컴파일해주는 이 명령어를 애용하여서 평소에 익혀두자.
-->
=== 코드 분석하기 ===
자 Hello World를 출력해보신 입문자분들! 무슨 뜻인지도 모르고 코드를 쳤을 거라 생각한다. 이제 코드를 한줄 한줄 해석해 보겠다.

자 우선 프로그램을 만들때 쓰일 부품(함수나 기타 등등...)들이 무엇인지 알아야 컴파일러에게 알려줘야 한다. 초보적인 텍스트를 출력하는 것이므로 많은 부품은 필요하지 않다. 기본적인 부품들이 들어 있는 파일을 포함시켜야 한다. 따라서 다음과 같은 문장을 써준다. #include는 컴파일러에 포함되어 있는 전처리기가 컴파일하기 전에 필요한 라이브러리들을 포함해주는 역할을 한다. 쉽게 말해 필요한 모든 참고도서를 포함한다고 생각해도 된다.

<syntaxhighlight lang=c>
#include <stdio.h>
</syntaxhighlight>
 
그 다음, 프로그램이 시작되는 지점을 알려줘야 한다. C언어에서는 프로그램이 시작할 때  main이라는 함수에서 시작하게 된다. 아직 프로그래밍에서의 함수에 대해서 배우지는 않았겠지만, 수학의 함수는 알고 있을 것이다.
<syntaxhighlight lang=c>
int main(void)
{
    return 0;
}
</syntaxhighlight>
함수의 중괄호'''{'''와 '''}''' 사이는 해당 함수가 어떤 동작을 하는 지 정의하는 곳이다. 또한 '''('''와 ''')''' 안에는 함수의 입력값이 어떠한 형태(자료형, Data Type)인지를 명시하는 곳이다. 함수의 이름 앞에 놓여 있는 단어는 함수의 출력값이 어떠한 형태인지를 명시하는 곳이다. 따라서 int main(void)는 출력이 int인<ref>int가 정확히 어떤 뜻인지는 아래에 나온다.</ref> 형태이고, 입력값이 없는(void) 함수이며, 중괄호 안에 적혀 있는 대로 함수값이 정의됨을 알 수 있다.
자 이제 Hello, World를 출력하는 코드를 main함수의 정의 부분(중괄호)에 넣어주면 된다. Hello, World를 출력하는 코드는 다음과 같다.
<syntaxhighlight lang=c>
printf("Hello, World!\n");
</syntaxhighlight>
printf라는 것 또한 함수이다. 소괄호 안에 쌍따옴표로 둘러 쌓여 있는 Hello, World!\n를 볼 수 있다. 함수를 선언하거나 정의할 때 소괄호는 '입력의 형태'를 뜻하지만, 여기에서처럼 함수를 '사용'(호출이라고 한다)할 때는 '입력값'을 뜻한다. 즉 "Hello, World\n"가<ref>C언어에서 쌍따음표는 '문장(문자열)'을 뜻한다. 그리고 '\n'은 '개행'을 뜻하는 문자로 취급된다. 또한 \n은 한 글자로 취급되므로 주의하자.</ref> printf함수의 입력값으로서 들어간 것이다.
또한 C언어에서는 코드 한문장 한문장을 ;으로 끝내게 되어 있다.
따라서 printf("Hello, World!\n")을 한뒤 해당 명령이 끝났다는 뜻에서 ;를 붙여 준다.
앞에서 말한 #include로 필요한 참고도서를 포함하지 않았다면 컴파일러가 printf가 무슨 함수인지를 몰라 오류가 난다. <nowiki><stdio.h></nowiki> 꺽쇠괄호 안에 써있는 stdio.h 파일에 printf, scanf같은 함수가 어떤 것인지 적혀있는데 stdio.h가 빠지면 이 함수들이 작동하지 않게 된다.<ref>함수마다 포함시켜야 하는 라이브러리가 다른데 나중에 깊게 파헤쳐보자.</ref>

=== 변수 ===
==== 변수가 뭔가요? ====
==== 변수명으로 사용할 수 없는 이름들? ====
C언어에서 특별한 의미를 갖고 있어서 변수 이름으로 사용할 수 없는 이름들이 있습니다. 이것을 '''식별자'''(키워드)라고 합니다.
* auto
* break
* case
* char
* const
* continue
* default
* do
* double
* else
* enum
* extern
* float
* for
* goto
* if
* inline
* int
* long
* register
* restrict
* return
* short
* signed
* sizeof
* static
* struct
* switch
* typedef
* union
* unsigned
* void
* volatile
* while
* _Bool
* _Complex
* _Imaginary
하지만 C언어는 대소문자를 구별하므로 Float라던가 Int같은 변수명은 사용이 가능합니다.

==== 자료형 ====
<!-- 해당 챕터에서는 기본적인 자료형만 소개하고 자주 안쓰이는 자료형은 현재 난이도 단계의 다음단계에서 설명합시다-->
===== 정수형 =====
소숫점 이하가 없는 정수. 깔끔하게 떨어지며, 연산도 간결하기 때문에 정수형 연산은 CPU에서 그렇게 연산 능력을 소모하지는 않는다.
*; char
*: '''char'''acter, 즉 문자 하나를 나타낼 수 있다는 뜻에서 온 자료형<ref>문자를 나타낸다고 했지만 사실은 정수형의 일종으로 그저 1바이트만큼의 숫자를 나타낼 수 있는 형식이다.</ref>이다. 길이는 1바이트, 즉 8비트로 가장 짧은 자료형이다. 부호가 있는 경우 -128부터 127까지, 부호가 없는 경우 0부터 255까지 나타낼 수 있다.

*; short
*: '''short''' integer. 짧은 정수형이란 뜻으로, 일반적인 컴파일러에서는 2바이트(16비트)로 처리된다. 부호가 있는 경우 -32768부터 32767까지, 부호가 없는 경우 0부터 65535까지 나타낼 수 있다.

*; int
*: '''int'''eger. 정수형의 대표주자로, 가장 널리 쓰이는 자료형이다. 일반적인 컴파일러에서는 4바이트(32비트)<ref>32비트 컴퓨터 시절부터 컴파일러가 4바이트(32비트)로 처리했으며, 이 전통은 호환성 때문에 64비트 컴퓨터까지 이어저, 64비트 컴퓨터에서 컴파일러를 돌리더라도 8바이트가 아니라 4바이트로 할당하게 된다.</ref>로 처리된다. 부호가 있는 경우 -2147483648부터 2147483647까지, 부호가 없는 경우 0부터 4294967297까지 나타낼 수 있다.

*; long
*: '''long''' integer. 긴 정수형이란 뜻이다. long의 경우는 다소 복잡한데,
*:# 32비트 환경의 컴파일러에서는 일반적으로 int형과 동일하게 4바이트(32비트)로 할당된다.
*:# 64비트 환경의 컴파일러에서는 컴파일러에 따라 4바이트, 또는 8바이트(64비트)를 할당한다. 8바이트를 할당하는 경우 범위는 부호가 있는 경우 -9223372036854775808부터 9223372036854775807, 부호가 없는 경우 0부터 18446744073709551615까지 나타낼 수 있다.

===== 실수형(부동소수점형) =====
'''실수형'''. 부동소수점이란 뜻은 부동(浮動/float), 즉 소숫점이 떠서 다닌단 뜻이다. <del>움직이지 않는단 뜻이 아니다!</del> 일반적으로 실수를 나타낼때 쓰는데, 부동소수점이란 표현을 사용하는 이유는 표현 원리 자체가 지수 형태([가수]×2<sup>[지수]</sup>) 형태이기 때문이다. <!--제대로 구조를 뜯으면 꽤 복잡하기 때문에 CPU에도 부담이 많이 가고, 표현법상 정확도 한계가 있기 때문에 가능하면 줄이는 게<ref>하지만 나중에 그래픽스 분야에 들어가면 GPU를 활용하고, GPU는 부동소수점 연산에 특화되어 있기 때문에 싫어도 이걸 쓸 수밖에 없게 된다.</ref> 좋기는 하다.-->
*; float
*: (single-precision) '''float'''ing point. 단정도 부동소수점이란 뜻으로, 4바이트(32비트) 길이를 갖는다. 부호 비트로 1비트, 지수 비트로 8비트(-128 ~ 127), 가수 비트로 23비트(0 ~ 8388608)를 가진다.

*; double
*: '''double'''-precision floating point. 배정도 부동소수점이란 뜻으로, 단정도의 2배 길이, 즉 8바이트(64비트) 길이를 갖는다. 부호 비트로 1비트, 지수 비트로 11비트(-1024 ~ 1023), 가수 비트로 52비트(0 ~ 4503599627370496)를 가진다.

===== 부호없는 자료형? =====
C언어에서 기본 자료형들은 첫번째 비트를 부호 기호로 쓴다(1이면 음수, 0이면 양수 2의 보수 방식으로).
이 첫번째 비트를 부호 기호로 쓰지 않고 그냥 수를 세는데 사용해서 양수쪽으로 데이터 표현을 두배로 늘릴 수 있는데, 이를 부호없는 자료형이라 한다.
부호없는 자료형들은 각 자료형 앞에 '''unsigned''' 키워드를 붙이면 된다. 
그러나 '''unsigned'''는 비교 연산 등에서 익숙한 프로그래머가 아니면 틀리기 쉽기 때문에 이해가 완벽하지 않다면 줄이는 것이 좋다.

=== 배열 ===

예를 들어 30개의 문자를 입력받는 코드를 만들어야 한다고 칠때, char q,w,e,r,t,y,u...... 같은 선언을 일일이 하려면 <del>손가락이</del>귀찮지 않나요?<del>뭐 이렇게 하고 싶을때도 있겠지만 말이죠....</del> 그럴때는
<syntaxhighlight lang=c>
int i[30];//정수
</syntaxhighlight>

또는 (int는 숫자(정수)를 사용할 때)

<syntaxhighlight lang=c>
char c[30];//문자
</syntaxhighlight>

을 쓰면 쉽게 할 수 있어요.(꼭 i나 c가 아니어도 내가 하고 싶은걸로 하면 돼요.)

<syntaxhighlight lang=c>
int i[30];
</syntaxhighlight>
이런식으로 배열을 선언해주면 30개의 i변수를 한번에 선언해주게 됩니다. 첫 번째 i변수는 i[0]이고 다섯 번째 i변수는 i[4], 30번째 i변수는 i[29] 이런식으로 변수가 생성되는거죠 <del>30번째가 변수는 i[30]가 아닙니다!</del> 이런식으로 변수 번호를 혼동하면 참조할 때 존재하지 않는 변수가 참조되어 쓰레기 값이 나옵니다. <del>ex)-38488323(의미없는 숫자)</del>

[[추가 바람]]

=== 형변환 ===
=== printf가 뭐죠? ===
====형식====
[[파일:Printf.svg|Printf]]

printf(const char *format, ...);

====서식 문자====
{| class="wikitable" style="text-align: center;"
|-
! 포맷 스트링
! 의미 / 출력 방식
|-
| %c || 문자
|-
| %d || 부호있는 10진수
|-
| %u || 부호없는 10진수
|-
| %o || 부호있는 8진수
|-
| %x, %X || 부호없는 16진수 (x는 소문자, X는 대문자)
|-
| %s || 문자열
|-
| %p || 포인터 주소
|-
| %% || %
|-
|}

{| class="collapsible collapsed"
|-
! 전체 설명 보기
|-
| printf 함수는 사실 포맷 스트링을 받는 부분까지만 인자가 정해져 있고, 그 이후는 ...을 통해 가변 길이 인자로 받게 된다. 이 과정에서 형식은 무시되고 void * 형태로 넘어가기 때문에, 포맷 스트링을 사용해 표시할 형식을 지정해주면 그 표시할 형식에 맞춰서 자료의 길이를 추정하고 그만큼을 읽어내는 것이다. 때문에 포맷 스트링과 맞지 않는 자료 형식을 사용할 경우 오작동을 일으킬 가능성이 있다.

printf의 포맷 스트링 형식은 사실 다음과 같다:
 %[플래그][표시길이][.정확도][데이터길이]종류

; 플래그 (Flags)
: 플래그는 부호 관련 옵션이다. 여러 개를 붙이는 것도 가능하다.
{| class="wikitable"
|-
! 문자
! 의미
|-
| -<br />(빼기) || 숫자의 경우에도 왼쪽 정렬을 하도록 한다. 이 기호가 없는 경우 기본값은 뒤의 표시 길이보다 짧아 여유가 생기는 경우 오른쪽 정렬이다.
|-
| +<br />(더하기) || 양수일 경우에 +를 붙인다. 이 기호가 없는 경우 기본값은 양수의 경우 기호는 공간 없이 생략된다.
|-
| &nbsp;<br />(공백) || 양수일 경우에 기호가 들어갈 공간만큼 공백을 붙인다. 이 기호가 없는 경우 기본값은 양수의 경우 기호는 공간 없이 생략된다.
|-
| 0<br />(숫자 0) || 표시 길이보다 숫자 자리수가 짧아 빈 공간이 남는 경우 남는 공간을 전부 0으로 채운다. 이 기호가 없는 경우 기본값은 남는 공간을 공백으로 채우게 된다.
|-
| #<br />(해시 기호) || 주어진 포맷 스트링의 다른 형태를 사용한다. g, G의 경우 따라 붙는 0이 생략되지 않는다. f, F, e, E, g, G에 대해서는 항상 10진수 소숫점이 붙게 된다. o, x, X에 대해서는 각각 0이 아닌 숫자가 추가된다.
|-
|}
; 표시길이 (Width)
: 숫자 값이 들어간다. 해당 포맷 스트링의 값이 표시될 최소한의 길이를 지정한다. 보통은 넉넉하게 길이를 잡고 여유 공간을 둬서 탭처럼 보이게 하기 위해 쓴다. 위의 플래그로 여유가 생겼을 때 여유 공간의 표시 방법을 조정할 수 있다.
; 정확도 (Precision)
: 점으로 시작하며, 숫자 값이 들어간다. 해당 포맷 스트링의 값이 표시될 최대한의 길이를 지정하는데 쓰인다. 말은 이렇긴 한데, 보통 부동소수점 형의 경우 자릿수를 지정하는데 쓰이며, 문자열 형의 경우 이 길이까지만 표시하라는 지정자가 된다.
: 위에 쓰인 표시길이와 정확도는 각 포맷 스트링의 값이 표시될 최소/최대치를 지정하는 것인데, 이를 포맷 스트링에서 직접 입력하지 않고, 인자로 받아 쓰는 방법도 존재한다. *를 쓰면 인자에서 값을 읽어 그 길이를 사용하게 된다.
<syntaxhighlight lang="c">
printf("%*d",  5, 123); // "  123"을 출력한다.
printf("%.*s", 5, "abcdefg"); // "abcde"를 출력한다.
</syntaxhighlight>
; 데이터길이 (Length)
: 인자의 길이를 추정하도록 도와주는 옵션이다. 보통 캐스팅을 하고 쓰지 않으면 읽을 바이트 수를 오인해서 결과를 잘못 표시할 수 있는데, 이 포맷 스트링을 쓰는 경우 길이를 강제하기 때문에 사실상 printf 내에서 캐스팅과 같은 효과를 낸다.
{| class="wikitable"
|-
! 문자
! 의미
|-
| hh || 정수형 포맷에서 char에서 int로 확장된 정수형 인자를 받도록 한다.
|-
| h || 정수형 포맷에서 short에서 int로 확장된 정수형 인자를 받도록 한다.
|-
| l || 정수형 포맷에서는 long 크기의 정수형 인자를 받도록 한다.<br />부동소수점형 포맷에서는 double 크기의 부동소수점형 인자를 받도록 한다.
|-
| ll || 정수형 포맷에서 long long 크기의 정수형 인자를 받도록 한다.
|-
| L || 부동소수점형 포맷에서 long double 크기의 부동소수점형 인자를 받도록 한다.
|-
| z || 정수형 포맷에서 size_t 크기의 정수형 인자를 받도록 한다.
|-
| j || 정수형 포맷에서 intmax_t 크기의 정수형 인자를 받도록 한다.
|-
| t || 정수형 포맷에서 ptrdiff_t 크기의 정수형 인자를 받도록 한다.
|-
! colspan="2" | ''C99 이전에 추가된 확장 옵션 (주로 Win32/Win64에서 지원하던 방법)''
|-
| ''I'' || 부호 있는 정수 포맷에서 ptrdiff_t 크기의 정수형 인자를 받도록 한다. 부호 없는 정수 포맷에서는 size_t 크기의 정수형 인자를 받도록 한다.
|-
| ''I32'' || 정수형 포맷에서 형식 인자와 상관 없이 32 비트 크기의 정수형 인자를 받도록 한다.
|-
| ''I64'' || 정수형 포맷에서 형식 인자와 상관 없이 64 비트 크기의 정수형 인자를 받도록 한다.
|-
! colspan="2" | ''C99 이전에 추가된 확장 옵션 (주로 BSD에서 지원하던 방법)''
|-
| ''q'' || 정수형 포맷에서 형식 인자와 상관 없이 64 비트 크기의 정수형 인자를 받도록 한다.
|-
! colspan="2" | ''C99 이후 확장 옵션''
|-
| colspan="2" | 이 옵션들은 기존 플랫폼에서는 형식 인자만으로는 길이를 동일하게 읽을 수 있는 방법이 없었다. 32비트에서 long이 32비트, 64에서 long이 64비트이므로 l의 길이가 달라졌으나, 이 형식들은 그 제약을 무시하도록 한다. C99 제정 이전에 Win32/Win64에서 사용되던 I32, I64 옵션과 비슷한 옵션들이다.

기본적인 사용법은 '''PRI_32''', '''PRI_64'''로 _ 부분에는 d, i, u, x를 넣을 수 있으며 각각 포맷 스트링의 종류 항과 연동된다.
|-
|}
; 종류 (Type)
: 필수 항이다. 가장 핵심이 되는 부분이며, 인자를 무슨 형태로 처리할지 결정해주는 부분이다.
{| class="wikitable" 
|-
! 문자
! 의미
|-
| d, i || '''int''' 형대로 부호 있는 10진수 정수형으로 출력한다. 출력에서는 %d와 %i가 동일하게 사용되나, 입력(scanf)에서는 %d는 10진수만의 입력을 받으나, %i는 첨두자에 따라 0x 첨자로 16진수를, 0 첨자로 8진수를 인식하도록 한다.
|-
| u || '''unsigned''' 형대로 부호 없는 10진수 정수형으로 출력한다.
|-
| o || '''unsigned''' 형대로 부호 없는 8진수 정수형으로 출력한다.
|-
| x, X || '''unsigned''' 형대로 부호 없는 16진수 정수형으로 출력한다. x와 X의 차이는 A부터 F까지의 값에 대해 소문자를 사용할지, 대문자를 사용할지를 결정하는 것 뿐이다.
|-
| a, A || '''unsigned''' 형대로 부호 없는 16진수 정수형으로 앞에 0x를 붙여서 출력한다. a와 A의 차이는 첨두 기호 0X와 A부터 F까지의 값에 대해 소문자를 사용할지, 대문자를 사용할지를 결정하는 것 뿐이다.
|-
| f, F || '''double''' 형대로 부동소수점 형식으로 출력한다. f와 F의 차이는 오류 값(NaN)이나 무한대(Infinity)의 경우에 소문자를 사용할지, 대문자를 사용할지를 결정하는 것 뿐이다.
|-
| e, E || '''double''' 형을 받아서 출력하되, 이를 지수 표현식(가수×기수<sup>지수</sup>, 여기서는 가수×10<sup>지수</sup>을 [-]d.ddd e±ddd로 출력)으로 출력하도록 한다. e와 E의 차이는 중간에 지수부를 시작되는 기호인 e를 대문자로 쓸지만 결정해준다. 지수부는 항상 최소 2자리 수 이상이 출력된다.
|-
| g, G || 크기에 따라서 정확도가 높은 쪽으로 e, f 또는 E, F를 사용하도록 결정한다.
|-
| c || '''char''' 형대로 문자 하나를 출력한다. ASCII 코드로 대응된다.
|-
| s || NULL로 끝나는 문자열을 출력한다. 무조건 다음 NULL까지 읽기 때문에 반드시 출력하려는 문자열에는 NULL이 있어야한다.
|-
| p || '''void *''' 형을 받아 메모리 공간의 포인터 주소를 출력한다.
|-
| n || 아무것도 출력하지 않는다. '''int''' 형만큼 포인터를 이동시킨다.
|-
| % || % 기호를 출력한다.
|-
|}
|-
|}

====사용 예====
=====소스=====
<syntaxhighlight lang='c'>
#include <stdio.h>
int main(void)
{
    printf("%d\n",10);
    printf("%o\n",10);
    printf("%x\n",14);
    printf("%X\n",14);
    printf("%c\n",'a');
    printf("%c\n",96);
    printf("%s\n","hello world");
    return 0;
}
</syntaxhighlight>

=====결과=====
10

12

e

E

a

a

hello world

==== 입력 형식 ===
=== C언어로 계산을 하자 - 연산자 ===
C언어에서 사용할 수 있는 연산자는 다음과 같다. 상식선에서 알고 있던 연산자도 있고, 대체 이런 걸 어디다 쓰지 싶은 것들도 있다. 이걸 달달 외우는 건 나중에 시험볼 때나(!) 하고 지금은 뭐가 있는지 등을 의자에 기대고 구경이나 해보자.

# '''산술 연산자'''
#: 우리가 알고 있는 덧셈 뺄셈...등등이다. 다음 연산에는 값이 두 개 필요하다.
#:* <code>*</code> : 곱하기
#:* <code>/</code> : 나누기
#:* <code>+</code> : 더하기
#:* <code>-</code> : 빼기
#:* <code>%</code> : 나머지. 나누기를 한 다음, 그 나머지 값을 의미한다.
#: 아래부턴 단항 연산, 즉 값 하나에 대한 연산이다.
#:* <code>+</code> : 수를 양수로 만든다. 대단한 건 아니고, +5 처럼 '값이 양수이다' 또는 '값을 양수로 한다'.
#:* <code>-</code> : 수를 음수로 만든다.
#:* <code>++</code> : 1 증가
#:* <code>--</code> : 1 감소
#: 1 증가/감소 연산자는 변수의 앞에 쓰는 것과 뒤에 쓰는 게 다른 의미를 갖는다. 변수 앞, 그러니까 <code>++a</code>은 'a를 1 증가시키고, 그 값을 쓴다'는 의미이지만 변수 뒤(<code>a++</code>)에 쓰면 '값은 a의 값을 쓸 건데, 나중에 1을 증가시킬 거야'란 뜻이다. 이 연산자가 이렇게 복잡해진 이유는, 한 번에 두 가지 기능(값을 가져오는 것과 값을 바꾸는 것)을 동시에 하느라 그렇다. 1을 증가/감소시킬 일이 하도 많다보니 코드를 조금이라도 짧게 줄여보고자 이<del>따위</del> 연산자들이 등장했다...값을 바꾸기도 해야 하니 당연하지만 변수만 가능하다. <code>5++</code> 같은 건 불가능하다. 5는 5지 어떻게 6이 되겠어.
# '''논리 연산자'''
#: 두 값을 비교할 때 사용한다.
#:* <code>==</code> : 같다
#:* <code>!=</code> : 다르다
#:* <code><</code>, <code><=</code>, <code>></code>, <code>>=</code> : 수학 시간에 쓰는 그것들인데, ≤를 <=로 쓴다.
#:* <code>&&</code> : 논리 AND
#:* <code>||</code> : 논리 OR
#:* <code>!</code> : 논리 NOT. 말 그대로 '아니다'라는 뜻.
# '''비트 연산자'''
#: 값을 비트 단위로 조작한다. 일반적인 경우에는 쓸 일이 많지 않으며, 비트 단위로 무언가를 하는 경우(하드웨어에 무슨 신호를 보낸다거나) 등에 쓰인다.
#:* <code><<</code> : 왼쪽 {{키|Shift}}
#:* <code>>></code> : 오른쪽 {{키|Shift}}
#:* <code>~</code> : 비트 NOT. 비트를 반전시킨다. 단항 연산이다.
#:* <code>&</code> : 비트 AND
#:* <code>|</code> : 비트 OR
#:* <code>^</code> : 비트 XOR
# '''대입 연산자'''
#: 말 그대로 오른쪽의 결과를 왼쪽의 변수에 대입할 때 사용한다. 상수에는 값을 집어넣을 수 없으므로(당연히 3에다 5를 집어넣을 수 없으므로), 왼쪽에는 변수가 필요하다.
#:* <code>=</code> : 그냥 대입
#: 다음은 복합 대입 연산자라고 한다. 기존 값에 산술 연산이나 비트 연산을 한 결과를 대입하고 싶을 때 사용한다.
#:* <code>+=</code>, <code>-=</code>, <code>*=</code>, <code>/=</code>, <code>&=</code> : 기존값에 더해서/빼서/곱해서/나눠서/나머지를 대입.
#:* <code>&=</code>, <code>|=</code>, <code>^=</code>, <code><<=</code>, <code>>>=</code> : 기존값에 AND/OR/XOR/왼쪽 {{키|Shift}}/오른쪽 {{키|Shift}} 해서 대입.
#: 뭔가 복잡해 보이지만, 사실상 코드를 짧게 줄여 쓰기 위한 것들이다. 예를 들어 <syntaxhighlight lang="C">a += b;</syntaxhighlight> 는 <syntaxhighlight lang="C">a = a + b;</syntaxhighlight>의 줄임 형식이다.
# '''참조 연산자'''
#: 값 그 자체가 아니라, 값이 가리키고 있는 위치를 '참조'하는 연산자이다. 아직 설명 안 된 부분도 있으니까, 잘 모르겠다면 지금은 '이런 것도 있구나' 하고 넘어가도 좋다.
#:* <code>[]</code> : [[#배열|배열 첨자]]. 배열의 몇 번째를 가리킬 때 쓰는 그거다.
#:* <code>*</code> : [[#포인터|포인터]] 참조. 아직 설명 안 한 부분이다. 일단 넘어가자.
#:* <code>&</code> : 값의 주소. 마찬가지로 [[#포인터|포인터]]에 설명이 있다.
#:* <code>.</code> : [[#구조체|구조체]] 멤버.
#:* <code>-></code> : 포인터 구조체 멤버. 마찬가지로 [[#구조체|구조체]]에서 설명한다.
#: <del>대체 이게 다 뭐냐...</del>

==== 연산자 우선순위 ====
연산자들 사이에는 우선순위가 있다. 상식적으로 생각해봐도 곱하기를 더하기보다 먼저 한다는 것은 알 수 있다. 하지만 덧셈, 뺄셈과 비트 연산, 논리 연산, 대입 연산이 섞여버리면? 보는 사람도 머리가 아프겠지만 컴퓨터 역시 규칙이 필요하다. 그래서 위의 연산자들을 전부 표 하나에 때려넣고 우선순위를 정해두었다. 동급의 연산자는 '''왼쪽부터''' 연산한다. 편의상 '연산자'는 아니지만 비교를 위해 들어간 것들도 있다.

# '''괄호'''. <del>최종보스</del> 괄호가 쳐져 있으면 무조건 먼저 계산한다. <del>당연하잖아.</del> 괄호는 '이걸 먼저 계산해라'고 알려주는 역할을 한다.
# <code>++</code>(변수 뒤), <code>--</code>(변수 뒤), <code>[]</code>(배열 첨자), <code>.</code>(구조체 멤버), <code>-></code>(포인터 구조체 멤버), <code>()</code>(함수 호출. printf()할 때의 그 괄호다.)
# <code>++</code>(변수 앞), <code>--</code>(변수 앞), <code>+</code>(양수 표기), <code>-</code>(음수 표기), <code>!</code>(논리 NOT), <code>~</code>(비트 NOT), <code>*</code>(포인터 참조), <code>&</code>(값의 주소).<br />바로 밑에서 설명할 '''형변환'''도 이 레벨이다. 이 레벨의 연산자들은 전부 단항 연산자들이며, 오른쪽에서 왼쪽으로 계산된다는 특징이 있다. <code>++a</code>나 <code>!a</code> 처럼.
# <code>*</code>(곱하기), <code>/</code>(나누기), <code>%</code>(나머지) <del>신난다 드디어 아는 게 나왔어!</del>
# <code>+</code>(더하기), <code>-</code>(빼기)
# <code><<</code>(왼쪽 {{키|Shift}}), <code>>></code>(오른쪽 {{키|Shift}})
# 크기를 비교할 때 쓰는 논리 연산자들. <code><</code>, <code><=</code>, <code>></code>, <code>>=</code>
# 같냐 다르냐를 비교하는 논리 연산자들. <code>==</code>(같다), <code>!=</code>(다르다)
# <code>&</code>(비트 AND)
# <code>^</code>(비트 XOR)
# <code>|</code>(비트 OR)
# <code>&&</code>(비교 AND)
# <code>||</code>(비교 OR)
# 대입 연산자들. <code>=</code>, <code>+=</code> 등등. 이것도 오른쪽의 결과를 왼쪽 변수에 대입하는 거니까 계산 방향은 오른쪽에서 왼쪽이다.
# <code>,</code>(쉼표). 계산을 나열할 때 쓴다.
<del>헉헉 힘들다</del>

==== 주의점 ====
우선 다음 코드를 봐 보자.
<syntaxhighlight lang="C">
int a = 9; int b = 2; double res; //앞의 두개의 변수는 정수형, 나머지 하나는 실수형 변수.
res = a / b;
printf("res = %f", res);
</syntaxhighlight>
자, 그럼 res의 출력값은?

'4.5요!'라고 말했다면 당신은 훌륭하게 낚이신거다. 여기서 res가 출력하는 값은 4.0이다. 왜일까? 위의 연산자 우선순위를 생각해보자. 대입(<code>=</code>)보다 나누기(<code>/</code>)가 먼저니까 <code>a / b</code>를 먼저 한다. 정수 9를 정수 2로 나누었으니까 값은 4이고('''!!!!'''), 그걸 실수형 변수에 넣어야 하니까 4.0으로 바꿔서 res에 대입한다. 아니 왜 9를 2로 나누는데 4가 되나요! 라고 말하고 싶은 당신! 화내지 말고, 컴퓨터가 어떻게 생각하는지 들여다 보자.
# 9를 2로 나눈다.
# 9는 정수다. 2도 정수다. 그럼 나눈 결과도 당연히 정수가 되어야 마땅하다.
# 나누면 대충 어... 4.xxxx가 되는거 같은데. 이걸 정수로 하면? 4가 되겠네.
# 4를 res에 넣자. 근데 res는 실수형인데?
# 그럼 4를 4.0으로 바꿔서 넣지 뭐.
이 과정을 거쳐 결국 4.0이 나오게 된다.

하지만 위의 저 코드를 만든 사람은 4.5가 나오기를 기대하고 만들었을 것이다. 그럼 어떻게 해야 4.5가 나오게 할 수 있을까? 해답은 '''형변환'''을 쓰는 것이다. 변수 앞에, 괄호를 치고 자료형을 쓰면 그 변수를 해당 자료형으로 임시로 바꿔준다.
<syntaxhighlight lang="C">
int a = 9; int b = 2; double res; 
res = (double) a / b; //a를 일시적으로 실수형으로 인식하도록 만든다.
printf("res = %f", res);
</syntaxhighlight>
위의 우선순위 리스트에서, 2번째 레벨에 있던 형변환을 사용한다. 나누기는 레벨 4니까, 9 나누기 2를 하기 전에 먼저 9를 9.0으로 바꿔주는 것이다. 이번에도 마찬가지로 컴퓨터의 사고 방식을 들여다보자.
# 먼저, 9를 9.0으로 바꾼다.
# 9.0 나누기 2를 해야하네? 근데 이 둘은 형태가 다른데? 둘 중 하나를 바꿔야하네?
# 실수를 정수로 바꾸면 소수점 밑이 다 잘려버리잖아. 안되겠다. 2를 2.0으로 바꿔야겠어.
# 9.0 나누기 2.0은 4.5지.
# res에 들어갈 값은 4.5야. 간단하군!

=== 조건문 ===
조건문은 조건에 따라 두 가지 혹은 그 이상의 실행 경로를 실행할 수 있게 하는 것을 말한다. C언어에는 조건문으로 두 경로 중 하나를 선택하는 if-else문과 여러경로 중 하나를 선택하는 switch문이 있다.

====if-else문====
<syntaxhighlight lang = 'c'>
if (조건)
{
    내용 1
}
else
{
    내용 2
}
</syntaxhighlight>

조건의 내용이 참이면 내용 1을, 거짓이면 내용 2를 실행한다.

else는 없어도 된다. 예를 들어,

<syntaxhighlight lang = 'c'>
if (조건)
{
    내용 1
}
</syntaxhighlight>

조건이 참이면 내용 1을 실행하고 거짓이면 실행하지 않고 넘어간다.

<syntaxhighlight lang = 'c'>
if (a >= 0)
{
    printf("%d", a);
}
else
{
    printf("%d", -1 * a);
}
</syntaxhighlight>

만약 a가 0 이상이라면 그대로 출력하고 미만이라면 -1을 곱해서 출력하라는 의미이다.
또한, {}를 생략해도 된다.

<syntaxhighlight lang = 'c'>
if (a >= 0)
    printf("%d", a);
else
    printf("%d", -1 * a);
</syntaxhighlight>

즉, 이렇게 써도 된다. 하지만 {}를 생략할 경우 코드 한 줄만 if-else문의 범위에 들어가진다.

<syntaxhighlight lang = 'c'>
if (a >= 0)
    printf("%d", a);
else
    a = -1 * a;
printf("%d", a);
</syntaxhighlight>

이렇게 작성하면, 조건이 거짓일때 a = -1 * a;만을 실행하고 빠져나온 다음 printf("%d", a);를 실행한다. 조건이 참일때는 printf("%d", a);를 실행한 다음 빠져나온 다음 밑의 printf("%d", a);를 실행하게 된다. 이렇게 꼬일 수도 있으니 {}를 생략할 때에는 가독성을 위해 들여쓰기를 생활화하자.

if-else문을 중첩해서 사용할 수도 있다.

<syntaxhighlight lang = 'c'>
if (조건 1)
{
    내용 1
}
else
{
    if (조건 2)
    {
        내용 2
    }
    else
    {
        내용 3
    }
}
</syntaxhighlight>

이 경우, 조건 1이 참이면 내용 1을 실행한다. 거짓이면 안으로 들어가고, 조건 2가 참이면 내용 2를, 거짓이면 내용 3을 실행한다.

<syntaxhighlight lang = 'c'>
if (조건 1)
{
    내용 1
}
else if (조건 2)
{
    내용 2
}
else
{
    내용 3
}
</syntaxhighlight>

{}를 생략해서 이렇게 작성할 수도 있다.

====switch문====
여러 조건들중 하나를 선택할 때 사용한다.
=====형식=====
<syntaxhighlight lang=C>
switch(수식)
{
    case 0 :  //0일때 실행
    case 1 :  //1일때 실행
    case 2 :  //2일때 실행
    case 3 :  //3일때 실행
    case 4 :  //4일때 실행
    default : //아무것도 아닐때 실행
}
</syntaxhighlight>

수식은 정수, 실수,음수 전부 가능하다.

default 의경우 있어도 되고 없어도 된다.
=====소스=====
<syntaxhighlight lang=c>
switch(num)
{
    case 0 : printf("num = 0");
    case 1 : printf("num = 1");
    case 2 : printf("num = 2");
    case 3 : printf("num = 3");
    case 4 : printf("num = 4");
    default : printf("맞는 수가 없습니다" );
}
</syntaxhighlight>

=====결과=====


(만약 num이 3인경우 )

num = 3num = 4맞는 수가 없습니다

=====위와같이 동작하는 이유=====
위와같이 switch문의 경우 그와 일치하는 부분부터 마지막 까지 실행을 한다.

만약 한 가지만 실행하려면 break문과 함께 써주면 된다.
=====소스=====
<syntaxhighlight lang=c>
switch(num)
{
    case 0 : printf("num = 0");break;
    case 1 : printf("num = 1");break;
    case 2 : printf("num = 2");break;
    ase 3 : printf("num = 3");break;
    case 4 : printf("num = 4");break;
    default : printf("맞는 수가 없습니다" );
}
</syntaxhighlight>

=====결과=====


(만약 num이 3인경우 )

num = 3

=== 반복문 ===
반복문은 특정 부분을 반복해서 실행하는 것을 말한다.

C언어에는 while문, for문, do-while문이 있다.

====while문====
<syntaxhighlight lang=c>
while (조건문)
{
    문장
}
</syntaxhighlight>

while문을 만나면 먼저 조건문을 검사한다. 조건문의 내용이 참이면 문장을 실행하고, 거짓이면 실행하지 않고 넘어간다. 문장의 내용을 모두 실행한 뒤에 다시 조건문을 검사한다. 계속 반복하다가 조건문이 거짓이 되면 빠져나온다. 주의할 점은 실수로 코드를 잘못짜서 조건문의 변수가 계속 바뀌지 않는다면 영원히 반복되어 <del>무한루프</del> 조건문을 잘 설정하는게 중요하다.

====for문====
<syntaxhighlight lang=c>
for (초기식; 조건식; 변환식)
{
    문장
}
</syntaxhighlight>

for문을 만나면 먼저 초기식을 실행한다. 조건식이 참이면 문장을 실행하고 거짓이면 실행하지 않고 넘어간다. 문장을 실행한 뒤, 변환식을 실행한 다음 조건식을 검사하고 참이면 실행, 거짓이면 넘어가기를 조건식이 거짓이 될 때까지 반복한다. 식들은 생략할 수 있지만 세미콜론은 생략할 수 없다.

<syntaxhighlight lang=c>
for (초기식; ; 변환식)
{
    문장
}
</syntaxhighlight>

조건식을 생략하면 이런 모습이 된다. 모든 식을 다 비우는 경우는 자동으로 무한 루프가 된다.<ref>보통 많이 쓰는 while(1)의 경우 컴파일러가 최적화해주지 않으면 1을 비교하면서 돌아버리기 때문에 비교 연산이 전혀 없이 순수하게 루프만 도는 for (;;)를 선호하는 사람들도 있다.</ref>

<syntaxhighlight lang=c>
for ( ; ; )
{
// Infinite loops
}
</syntaxhighlight>

BASIC 등 여타 언어의 for문보다 덜 직관적이라고 생각할 수 있는데, 오히려 논리적으로 간명하고 확장성이 뛰어난 면이 있다. 예를 들어 ‘1/1 + 1/2 + … + 1/N이 100을 넘는 최초의 N’과 같은 것을 찾을 수 있다.

머릿속에서 다음 코드와 같다고 생각해도 된다.
<syntaxhighlight lang=c>
초기식
while (조건식)
{
    문장
    변환식
}
</syntaxhighlight>

====do-while문====
<syntaxhighlight lang=c>
do{
    문장
}while (조건식);
</syntaxhighlight>

while문과 유사하지만 조건식을 먼저 검사하지 않고 중괄호 안의 내용을 먼저 검사한 뒤에 조건식을 검사한다.그러나 최초 한번은 반드시 실행되는 만큼 꼭 필요할 때 사용해야 한다.

==== break ====
현재 실행하고 있는 반복문을 빠져나온다. 반복문이 여러 개 중첩되어 있으면 가장 가까운 반복문을 하나 빠져나온다.

<syntaxhighlight lang = "c">
while (true)
{
    내용 1
while (true)
{
    내용 2
    break;
}
}
</syntaxhighlight>

내용 1을 실행한 다음 while문 안으로 들어가 내용 2를 실행, 바로 빠져나와 다시 내용 1을 실행, 내용 2를 실행을 무한 반복한다.

=== 포인터 ===
보통 C 프로그래밍을 시작한 초보자가 가장 이해하고 배우기 힘들어하는 부분. <s>터닝포인터</s><ref>취소선을 표시했지만 정말 이 부분에서 C언어를 포기하는 사람들이 급증한다. 과장 조금 보태서 포인터를 완벽하게 이해한다면 C언어를 거의 다 이해했다고 할 수 있을 정도이다.</ref>

먼저 '''포인터'''(Pointer)라는 개념부터 설명하자. 이름에서부터 알 수 있듯이, 포인터는 '''가리키는 것'''(Point+er)을 의미한다. 다시 말해서, 변수는 변수인데, 화살표처럼 생긴 변수라고 이해하면 된다. 복잡하다면 그냥 변수의 메모리의 주소를 저장하는 상자(주소록)라고 생각해주자.

그러면, 우리가 무언가를 가리킬 때 필요한게 무엇인지 잘 생각해보자. 다른 정보는 없어도 그 대상이 위치한 곳이 어딘지를 알아야하지 않을까? 바로 포인터 변수는 자신이 가리키는 대상의 위치, 즉 '''메모리 상의 주소'''를 가지고 있는 변수가 되겠다. 제어판 하드웨어 관리자에 들어가면 0x00000어쩌고 써있는 걸 본적이 있을 것이다. 그게 바로 메모리 주소다. 즉, 포인터 값 그 자체는 내가 가리키는 주소를 의미한다는 것이다.

그렇다면, 포인터 변수를 표기하는 방법을 조금 더 살펴보자. 이 표기법 때문에 많이 헷갈리곤 하는데, 다음 표를 잘 보면서 이해해보자.

{| class="wikitable"
|+ 포인터 관련 표기법
|-
! 기호
! 의미
! 사용례
! 해석
|-
| '''*''' (포인터 참조<ref name="pointer">C++에서는 '''포인터'''는 포인터고, 참조자는 오히려 역참조 기호를 사용한다. 하지만 여기서는 C를 기준으로 설명하고 있기에, C에서 사용되는 개념을 단어로 표현한 것이므로, C++을 동시에 진행한다면 헷갈리지 않도록 주의하자.</ref>)
| '''포인터 변수가 가리키는 대상'''을 불러온다.
| *a = 5;
| a라는 포인터 변수가 가리키는 위치에 있는 대상의 값을 5로 바꾼다.
|-
| '''&''' (포인터 역참조<ref name="pointer" />)
| '''해당 변수가 위치한 곳'''을 불러온다.
| a = &b;
| a라는 포인터 변수가 b가 위치한 곳을 가리키도록 바꾼다.
|-
|}

이 부분이 많이 헷갈릴 것이다. 일단 변수를 선언하는 것 부터가 문제가 될 수 있다.

{| class="wikitable"
|+ 선언 순서에 따른 코드 해석
|-
! 사용한 코드
! 실제 받아들여지는 코드
! 의미
|-
| '''int''' a;
| '''int''' (a);
| '''int'''형을 가진 변수 a를 선언한다.
|-
| '''int''' *a;
| '''int''' (*a);
| '''int *'''형을 가진 변수 a를 선언한다.
|-
| '''int''' *a, b;
| '''int''' (*a), b;
| '''int *'''형을 가진 변수 a와 '''int'''형을 가진 변수 b를 선언한다.
|-
| '''int''' *a, *b;
| '''int''' (*a), (*b);
| '''int *'''형을 가진 변수 a와 b를 선언한다.
|-
|}

보다시피, 포인터 참조자 *는 우선순위가 낮기 때문에, 포인터형 변수를 선언하고자 할 때는 이런 부분에 주의해야 한다. 다음은 포인터 표기법을 썼을 때 자료형이 어떻게 되는지를 나타낸 것이다.

{| class="wikitable"
|-
! colspan="4" | 전제 조건
|-
| colspan="4" | <syntaxhighlight lang="c">
int a = 5;
int *b;
int **c;
b = &a;
c = &b;
</syntaxhighlight>
|-
! 표기법
! 실제 자료형
! 나타내는 값
|-
| a
| '''int'''
| style="background-color: #ffeeee;" | 5
|-
| &a
| '''int *'''
| style="background-color: #eeffee;" | 0x00aea6a0
|-
| b
| '''int *'''
| style="background-color: #eeffee;" | 0x00aea6a0 (''= &a'')
|-
| *b
| '''int'''
| style="background-color: #ffeeee;" | 5 (''a 그 자체'')
|-
| &b
| '''int **'''
| style="background-color: #eeeeff;" | 0x00aea698
|-
| c
| '''int **'''
| style="background-color: #eeeeff;" | 0x00aea698 (''= &b'')
|-
| *c
| '''int *'''
| style="background-color: #eeffee;" | 0x00aea6a0 (''= &a'', ''b 그 자체'')
|-
| **c
| '''int'''
| style="background-color: #ffeeee;" | 5 (''a 그 자체'')
|-
| &c
| '''int ***'''
| style="background-color: #ffffee;" | ''0x00aea690''
|-
|}

잘 보면 알겠지만, 변수 선언과는 반대로, *를 앞에 붙일 수록 자료형에서 *이 떨어지는 걸 알 수 있다. 반대로, &는 앞에 하나 붙일 수 있는데, 이를 붙이는 경우 *이 하나 붙는 걸 알 수 있다.

그러면, 이제 실제로 포인터를 이용해 값을 바꾸는 과정을 통해 포인터의 동작 원리를 알아보자.
{| class="wikitable" 
|+ 동작 과정
|-
! rowspan="2" style="width: 6em;"  | 코드
! rowspan="2" style="width: 15em;" | 해석/의미
! colspan="5" | 변수 내부의 값
|-
! a
! b
! p
! q
! pp
|-
| 
'''int''' a = 5; <br />
'''int''' b = 10; <br />
'''int''' *p; <br />
'''int''' *q; <br />
'''int''' **pp; <br />
| 다음과 같이 변수 선언을 먼저 해뒀다고 가정해보자.
| style="text-align: right;" | 5<br />''&a: 0x00aea6a0''
| style="text-align: right;" | 10<br />''&b: 0x00aea69c''
| style="text-align: right;" | (초기화 안 됨)<br />''&p: 0x00aea698''
| style="text-align: right;" | (초기화 안 됨)<br />''&p: 0x00aea690''
| style="text-align: right;" | (초기화 안 됨)<br />''&pp: 0x00aea688''
|-
| a = 3;
| a의 값을 3으로 바꾼다.
| style="text-align: right;" | 3
| style="text-align: right;" | 10
| style="text-align: right;" | (초기화 안 됨)
| style="text-align: right;" | (초기화 안 됨)
| style="text-align: right;" | (초기화 안 됨)
|-
| p = &a;
| p<ref name="pintp">'''int *'''형</ref>에게 a<ref name="pint">'''int'''형</ref>를 가리키도록 한다.
| style="text-align: right;" | <span style="color: red;">'''3'''</span>
| style="text-align: right;" | 10
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*p''': '''3'''</span>
| style="text-align: right;" | (초기화 안 됨)
| style="text-align: right;" | (초기화 안 됨)
|-
| *p = 7;
| p<ref name="pintp" />가 가리키는 대상의 값(a<ref name="pint" />)을 7로 바꾼다.
| style="text-align: right;" | <span style="color: red;">'''7'''</span>
| style="text-align: right;" | 10
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*p''': '''7'''</span>
| style="text-align: right;" | (초기화 안 됨)
| style="text-align: right;" | (초기화 안 됨)
|-
| q = p;
| q<ref name="pintp" />에 p<ref name="pintp" />의 값을 넣도록 한다.
| style="text-align: right;" | <span style="color: red;">'''7'''</span>
| style="text-align: right;" | 10
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*p''': '''7'''</span>
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*q''': '''7'''</span>
| style="text-align: right;" | (초기화 안 됨)
|-
| *q = 5;
| q<ref name="pintp" />가 가리키는 대상의 값(a<ref name="pint" />)을 5로 바꾼다.
| style="text-align: right;" | <span style="color: red;">'''5'''</span>
| style="text-align: right;" | 10
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*p''': '''5'''</span>
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*q''': '''5'''</span>
| style="text-align: right;" | (초기화 안 됨)
|-
| q = &b;
| q<ref name="pintp" />에게 b<ref name="pint" />를 가리키도록 한다.
| style="text-align: right;" | <span style="color: red;">'''5'''</span>
| style="text-align: right;" | <span style="color: blue;">'''10'''</span>
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*p''': '''5'''</span>
| style="text-align: right;" | ''0x00aea69c''<br /><span style="color: blue;">'''*q''': '''10'''</span>
| style="text-align: right;" | (초기화 안 됨)
|-
| pp = &p;
| pp<ref name="pintpp">'''int **'''형</ref>에게 p<ref name="pintp" />를 가리키도록 한다.
| style="text-align: right;" | <span style="color: red;">'''5'''</span>
| style="text-align: right;" | <span style="color: blue;">'''10'''</span>
| style="text-align: right;" | <span style="color: green;">'''''0x00aea6a0'''''</span><br /><span style="color: red;">'''*p''': '''5'''</span>
| style="text-align: right;" | ''0x00aea69c''<br /><span style="color: blue;">'''*q''': '''10'''</span>
| style="text-align: right;" | ''0x00aea698''<br /><span style="color: green;">'''*pp''' : '''''0x00aea6a0'''''</span>, <span style="color: red;">'''**pp''': '''5'''</span>
|-
| **pp = 3;
| ''pp<ref name="pintpp" />가 가리키는 대상(p<ref name="pintp" />)''이 가리키는 대상(a<ref name="pint" />)의 값을 3으로 바꾼다.
| style="text-align: right;" | <span style="color: red;">'''3'''</span>
| style="text-align: right;" | <span style="color: blue;">'''10'''</span>
| style="text-align: right;" | <span style="color: green;">'''''0x00aea6a0'''''</span><br /><span style="color: red;">'''*p''': '''3'''</span>
| style="text-align: right;" | ''0x00aea69c''<br /><span style="color: blue;">'''*q''': '''10'''</span>
| style="text-align: right;" | ''0x00aea698''<br /><span style="color: green;">'''*pp''' : '''''0x00aea6a0'''''</span>, <span style="color: red;">'''**pp''': '''3'''</span>
|-
| *pp = q;
| pp<ref name="pintpp" />가 가리키는 대상(p<ref name="pintp" />)의 값을 q<ref name="pintp" />로 바꾼다.
| style="text-align: right;" | <span style="color: red;">'''3'''</span>
| style="text-align: right;" | <span style="color: blue;">'''10'''</span>
| style="text-align: right;" | <span style="color: green;">'''''0x00aea69c'''''</span><br /><span style="color: blue;">'''*p''': '''10'''</span>
| style="text-align: right;" | ''0x00aea69c''<br /><span style="color: blue;">'''*q''': '''10'''</span>
| style="text-align: right;" | ''0x00aea698''<br /><span style="color: green;">'''*pp''' : '''''0x00aea69c'''''</span>, <span style="color: blue;">'''**pp''': '''10'''</span>
|-
| q = &a;
| q<ref name="pintp" />에게 a<ref name="pint" />를 가리키도록 한다.
| style="text-align: right;" | <span style="color: red;">'''3'''</span>
| style="text-align: right;" | <span style="color: blue;">'''10'''</span>
| style="text-align: right;" | <span style="color: green;">'''''0x00aea69c'''''</span><br /><span style="color: blue;">'''*p''': '''10'''</span>
| style="text-align: right;" | ''0x00aea6a0''<br /><span style="color: red;">'''*q''': '''3'''</span>
| style="text-align: right;" | ''0x00aea698''<br /><span style="color: green;">'''*pp''' : '''''0x00aea69c'''''</span>, <span style="color: blue;">'''**pp''': '''10'''</span>
|-
|}

다소 이해가 복잡할 수 있지만, 쓰여진 코드와 변수 값이 변하는 과정을 보고 이해하도록 노력해보자.

그렇다면 이런 기능을 어디다가 쓸 수 있을까?

{| class="wikitable collapsible collapsed"
|-
! 고급 설명 열기
|-
|
[삭제가능. 쓰고 나서보니 초보자가 배우기 보다, 자바 세대에 언어를 시작한, 중급 C언어 프로그래머들이 이거다 하고 이해할 만한 이슈를 적어 놓은듯.]

int *foo 를 선언해보자. 그렇다면 이 문장에서 변수명은 foo이고 foo만 실제 값을 가질 수 있다.
이 문장은 foo가 정수 값이 아닌 메모리 주소를 가진다는 뜻이며, 실제 정수 값은 이 해당 메모리 주소에 있는 셀에 존재한다.
때문에 이 정수 값을 엑세스 하려면 *foo로 해당 메모리 셀에 있는 정수에 엑세스 하게 되는 것이다.

int foo = 123;
CPU register(foo) 가 123을 가짐.

int *foo = 123;
CPU register(foo) 가 임의의 0x000F00BA 값을 가짐 (주소)
해당 주소 값에 해당 하는 셀 값을 (*foo) 읽으면, 해당 셀에는 123이 들어 있음.



int **foo1 가 선언 되었을 때 이 변수는 foo1이다.
int *foo2 가 선언 되었을 때 이 변수는 foo2다.
int foo3 가 선언 되었을 때 이 변수는 foo3이다.

다만
int foo1는 이 변수에 정수 값을 담겠다는 뜻이다.
int *foo2는 이 변수에 주소를 따라가면 정수 값이 나오는 주소값을 담겠다는 뜻이다.
int **foo3는 이 변수에 "주소를 따라가면 정수 값이 나오는 주소"를 값으로 하는 주소 값을 담겠다는 뜻이다.

&foo1 은 foo1 변수의 주소 값이다.
&foo2 는 foo2 변수의 주소 값이다.
&foo3 은 foo3 변수의 주소 값이다.



포인터는 예시를 보는 것이 오히려 도움이 된다.
포인터는 직관적이고 쉽기 때문에 어렵게 생각하기 때문에 이해가 가지 않는 것이다.

예시
void foo(int *bar)   // input: *foo = 123;
// 매개변수의 경우 스택에 저장됨.
{
	int **a = &bar;
	int *b = bar;
	int c = *bar;
        // local 변수의 경우 스택에 저장됨. (따라서 c b a bar 연속적으로 스택 주소에 변수가 선언됨.)

	printf("%d, %d, %d\n\n", **a, *b, c);   // output: 123, 123, 123

	printf("%d, %x, %x\n\n", *bar, bar, &bar);

	printf("%d, %x, %x, %x\n", **a, *a, a, &a);
	printf("%d, %x, %x\n", *b, b, &b);
	printf("%d, %x\n", c, &c);
}

결과
123, 123, 123

123, adfb08, adfafc

123, adfb08, adfafc, adfaf8
123, adfb08, adfaf4
123, adfaf0



---

C언어 이전 어셈블리 언어 수준에서는 직관적이고 간단하면서 당연히 이렇게 동작하는, 해야만 한다고 생각하는 코드였다. 프로그래밍을 처음 접할 때 C언어로 시작한 사람들이 이해를 못하는 경우가 발생하여 쉬운 것이 어려운 부분이라 둔갑 되는 경우가 발생한다.

레지스터 eax에 메모리 주소가 들어 있다고 하자.
그렇다면 이 eax에 있는 메모리 주소 값을 CPU가 타고 들어가 그 메모리 셀의 값을 ecx 레지스터에 복사하고자 한다면 mov ecx, [eax] 를 사용해야한다.
상위 언어인 C언어로 표현하자면, int ecx = *eax;
mov ecx, [eax]
int ecx = *eax;

레지스터 eax에 값이 들어 있다고 하자.
그렇다면 이 eax에 있는 값을 ecx 레지스터에 복사하고자 한다면 mov ecx, eax를 사용해야한다.
상위 언어인 C언어로 표현하자면, int ecx = eax;
mov ecx, eax
int ecx = eax;

만약 메모리 주소를 CPU가 알고 있어서 메모리 셀에 있는 값에 엑세스를 할 때, 해당 메모리 주소를 레지스터에 저장하고 싶으면 lea edx, [eax] 를 사용해야 한다.
상위 언어인 C언어로 표현하자면, int *edx = &eax;
lea edx, [eax]
int *edx = &eax;

때문에 C언어 포인터 사용에 있어서 모호함이 없다.
|}

=== 함수 ===
==== 매개변수 ====
===== Call By Value =====
===== Call By Reference =====

=== 동적할당 ===

=== 구조체 ===
구조체는 와플틀과 같은 역할을 한다. 구조체는 서로 다른 형식이나 크기의 변수들을 모은 변수 집단. 문자열 배열, 정수, 실수형 변수를 구조체라는 것에 한데 모아 한 묶음으로 만들 수 있다. 배열은 '사람1, 사람2, 사람3, 사람4' 처럼 성격이 같은 변수의 묶음 구조체는 '키, 몸무게, MBTI'같이 성격이 서로 다른 변수의 묶음이다.

구조체는 int처럼 struct 키워드를 앞에 적어준다.
<syntaxhighlight lang = c>
// 이렇게 책을 나타내는 구조체를 만든다.
struct book {
    int id;
    char title[100];
    char author[100];
}
</syntaxhighlight>
이 구조체는 바로 쓸 수는 없고 구조체 변수를 따로 생성해야 한다. 변수 선언 전까지 구조체는 빵틀에 불과하다.
<syntaxhighlight lang = c>
int main(void)
{
    struct book book1; //책 1
    struct book book2; //책 2
}
//이런식으로 책 변수(구조체)를 만들어 줄 수 있다.
</syntaxhighlight>
이렇게 구조체를 만들고 변수까지 만들어줬다. 필요할 때 구조체 변수에 각 하위 변수(멤버)에 값을 넣어주면 된다.
<syntaxhighlight lang = c>
    book1.id = 10;
    strcpy(book1.author, "어니스트 헤밍웨이")
    strcpy(book1.titile, "노인과 바다")
</syntaxhighlight>
이렇게 '.' 마침표를 찍어 book1의 저자, book1의 제목 변수에 접근할 수가 있다. 멤버가 문자열인 경우는 book1.id처럼 바로 대입해 줄 수는 없고 strcpy나, scanf 같은 함수를 
이용해서 값을 넣어줘야 한다. 문자열은 그냥 넣을 수 없게 되어 있는데 이 두 함수들은 문자열을 넣을 수 있게 하는 장치가 있는 것 같다.

book1.id같은 구조체의 멤버들은 변수 취급이 가능하다. 값을 불러올 때도 book1.id로 쓰면 된다.
==== 구조체 포인터 ====
==== 포인터를 멤버로 가지는 구조체 ====
=== 공용체 ===
공용체도 구조체와 비슷한데 같은 메모리 영역을 여러 개의 변수들이 공유할 수 있게 한다.
<syntaxhighlight lang = C>
union abc {
    char a;
    int b;
    float c;
}
</syntaxhighlight>

=== 열거형 ===

=== typedef ===
'''사용자 정의 자료형'''
<syntaxhighlight lang = C>
typedef unsigned char uchar;
typedef long double ldouble;

</syntaxhighlight>
unsigned char이나 long double은 자료형 이름이 너무 길어서 불편하다면 위와 같이 uchar, ldouble로 줄여 쓸 수 있다.

바로 위에서 배운 구조체나 공용체도 따로 자료형으로 만들어버릴 수 있다.
<syntaxhighlight lang = C>
struct student{
    char name[8];
    int id;
}

typedef struct student STUDENT;
</syntaxhighlight>
이제 struct student a1이 아니라

STUDENT a1로 구조체 변수를 만들어낼 수가 있다.

<syntaxhighlight lang = C>
typedef struct student{
    char name[8];
    int id;
} STUDENT; 
</syntaxhighlight>
student 자료형 정의는 위처럼 쓸 수도 있다.

=== 파일 입출력 ===
<syntaxhighlight lang = C>
FILE * 변수이름 = fopen("파일이름", "설정");

FILE * fin = fopen("fin.txt", "r");
FILE * fout = fopen("fout.txt", "w");
FILE * fa = fopen("fa.txt", "a");
</syntaxhighlight>
'변수이름'에는 사용할 이름을 넣어주고, '파일이름'에는 사용할 파일의 이름을 넣어준다. '설정'에는 파일을 어떻게 사용할 것인지 넣어준다.

w : 쓰기 모드
r : 읽기 모드
a : 이어쓰기 모드

쓰기 모드일 때 대상 파일이 없다면 파일을 새롭게 만들지만, 읽기 모드일 때 대상 파일이 없다면 오류를 뱉어낸다.

=== 헤더파일, 소스파일 ===
=== 고급 과정 ===
====전처리기====
=====#define=====
<nowiki>#</nowiki>define은 특정한 문자(이름)를 찾아 다른 형태(토큰)로 바꾼다. 두 줄 이상으로 작성하고 싶을 때에는 '\' 를 이용하면 된다.

<syntaxhighlight lang=c>
#define 이름 토큰
</syntaxhighlight>

작성
<syntaxhighlight lang=c>
#define Int_Max 2147483647
int max = Int_Max;
</syntaxhighlight>

결과
<syntaxhighlight lang=c>
int max = 2147483647;
</syntaxhighlight>

함수와 비슷한 형태로 작성하면 함수같이 사용할 수도 있다.

<syntaxhighlight lang=c>
#define 이름(인자) 토큰
</syntaxhighlight>

작성
<syntaxhighlight lang=c>
#define Sum(X, Y) X + Y
int sum = Sum(1, 2);
</syntaxhighlight>

X나 Y가 아니라 다른 것을 사용해도 상관없다. 수도 상관없다.

결과
<syntaxhighlight lang=c>
int sum = 1 + 2;
</syntaxhighlight>

=====#undef=====
<nowiki>#</nowiki>define으로 정의된 매크로를 무효화한다.

작성
<syntaxhighlight lang=c>
#define PI 3.141592
int pi = PI;
#undef PI
int pi = PI;
</syntaxhighlight>

결과
<syntaxhighlight lang=c>
int pi = 3.141592;
int pi = PI;
</syntaxhighlight>
int pi = PI; 부분에서 오류를 뱉어낸다. #undef로 무효화된 매크로는 그 밑으로 더 이상 작동하지 않는다. 사용 위치에 주의할 필요가 있다.

=====#include=====
특정 파일의 내용을 가져와서 포함시킨다.

<syntaxhighlight lang = c>
#include <stdio.h>
int main(void)
{
    printf("Hello, World!");
    return 0;
}
</syntaxhighlight>

위 소스 코드에서, #include <stdio.h>의 위치에 stdio.h 헤더파일의 내용이 옮겨진다. printf함수는 stdio.h 헤더파일 내에 선언되어 있는 함수이다.

<syntaxhighlight lang = c>
#include <헤더파일>
#include "헤더파일"
</syntaxhighlight>

이렇게 두 가지 모양으로 쓸 수 있는데, <>는 컴파일러에 지정되어 있는 폴더에서 헤더파일을 찾고, ""는 소스 코드 파일이 있는 폴더에서 헤더파일을 찾는다.
=====조건부 컴파일=====
조건이 참이냐 거짓이냐에 따라 컴파일 되는 부분을 정할 수 있다. 조건문과 비슷하다. #if는 if, #else는 else, #elif는 else if와 같으며 #endif는 여기까지가 조건부 컴파일이라는 의미이다.
======#if======
<syntaxhighlight lang = c>
#if 조건
내용1
#endif
내용2
</syntaxhighlight> 조건은 일반 변수를 적을 수가 없다. 조건의 내용이 참일 경우 #if ~ #endif까지의 내용(내용1)을 컴파일 한다. 하지만 내용1만이 컴파일 되는 것이 아니라 내용2역시 컴파일 된다.
======#else======
<syntaxhighlight lang = c>
#if 조건
내용1
#else
내용2
#endif
</syntaxhighlight>
조건이 참이면 내용1을, 거짓이면 내용2를 컴파일 한다.
======#elif======
<syntaxhighlight lang = c>
#if 조건1
내용1
#elif 조건2
내용2
#endif
</syntaxhighlight>
조건1이 참이면 내용1을 컴파일 한 다음 #endif를 만나고 끝마친다. 거짓이면 내려간다. #elif를 만나고 조건2가 참이면 내용2을 컴파일 하고, 거짓이면 내려가 #endif를 만나 끝마친다.
======#endif======
조건부 컴파일을 끝마친다.
=====#ifdef=====
<syntaxhighlight lang = c>
#ifdef 식별자
</syntaxhighlight>
if defined. #if와 쓰임새가 같은데 만약 식별자가 정의된 경우 참, 아닌 경우 거짓이다.
=====#ifndef=====
<syntaxhighlight lang = c>
#ifndef 식별자
</syntaxhighlight>
if not defined. #ifdef의 반대이다. 식별자가 정의된 경우 거짓, 아닌 경우 참이다.
=====#error=====
=====##=====
=====#pragma=====
컴파일러에게 명령을 전달한다.

<syntaxhighlight lang=c>
#pragma 명령
</syntaxhighlight>

컴파일러마다 다르니 자세한 것은 [[추가바람]]

[[분류:프로그래밍 시리즈|C]]
{{각주}}