์ฐ๋ฆฌ๊ฐ ์ผ๋ฐ์ ์ผ๋ก c ์ธ์ด๋ฅผ ์ปดํ์ผํ๊ธฐ ์ํด์๋ Visual Studio๋ CLion ์ ์ด์ฉํด์ Run ํน์ Debugging ์ ํ์์๋ค.
ํ์ง๋ง ๋ฆฌ๋ ์ค ํ๊ฒฝ์์๋ Visual Studio ๋ CLion ์ ์ค์นํ๊ธฐ๋ ๋งค์ฐ ๊น๋ค๋กญ๊ณ QT-Creator ๊ณผ ๊ฐ์ ํ๋ก๊ทธ๋จ์ ์ด์ฉํด์ผ ํ๋ค.
์ด๋ ๊ฒ IDE๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ์ ๋ ์๋๋ ๊ฒ์ ์๋์ง๋ง, ๊ทธ๊ฒ๋ณด๋ค ํฐ๋ฏธ๋์์ g++์ด๋ gcc ๋ช ๋ น์ด๋ฅผ ํตํด์ ์ปดํ์ผํ๋ ํธ์ด ์คํ๋ ค ๋ ํธํ ๋๊ฐ ์๋ค.
์ค๋์ ํฐ๋ฏธ๋์์ gcc ๋ก c ์ธ์ด๋ฅผ ์ปดํ์ผํ๊ณ object ํ์ผ์ ๋ง๋๋ ๊ฒ์ ๋ํด์ ์์๋ณผ ๊ฒ์ด๋ค.
๋ฆฌ๋ ์ค์์ c ์ธ์ด ์ปดํ์ผํ๊ธฐ
์ฐ์ gcc ๋ g++ ์ ์ค์นํด์ผ ํ๋ฏ๋ก ๋ค์๊ณผ ๊ฐ์ด apt๋ฅผ ํตํด์ g++, gcc ๋ฅผ ์ค์นํด์ฃผ์. apt-get ์ ์ฌ์ฉํด๋ ๋ฌด๋ฐฉํ๋ค
gcc๋ g++ ์ค์นํ๊ธฐ
$ sudo apt update
$ sudo apt install -y g++
$ sudo apt install -y gcc
$ sudo apt install -y vim
๊ทธ๋ฆฌ๊ณ ์์ฃผ ๊ฐ๋จํ ์์ค์ฝ๋๋ฅผ ์์ฑํด๋ณด์
c ๊ฐ๋จํ ์ถ๋ ฅ ํ๋ก๊ทธ๋จ ๋ง๋ค๊ธฐ
๊ฐ๋จํ๊ฒ printf()
๋ฅผ ์ด์ฉํด์ ์ถ๋ ฅ์ ํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค๊ณ ์คํ์์ผ๋ณด๋๋ก ํ์.
์ฐ์ vim ์ ์ด์ฉํด์ main.c ์ ๊ฐ๋จํ ์ถ๋ ฅ ํจ์๋ฅผ ์์ฑํด๋ณด์.
$ vim main.c
#include <stdio.h>
int main() {
printf("(main.c executed...) => gcc ๋ก c ์ธ์ด ์ปดํ์ผํ๊ธฐ๋ ๋งค์ฐ ์ฝ๋ค์");
return 0;
}
gcc ๋ฅผ ์ด์ฉํด์ ์ปดํ์ผํ๊ธฐ
gcc ๋ช ๋ น์ด๋ฅผ ํตํด์ ์ปดํ์ผ์ ํด๋ณด์
๊ฐ๋จํ๋ค. gcc [์์คํ์ผ]
์ ํํ๋ก ์์ฑํด์ฃผ๋ฉด default ๋ก a.out
์ด๋ผ๋ ํ์ผ์ด ์์ฑ๋ ๊ฒ์ด๋ค.
$ gcc main.c
๊ทธ๋ผ ls ๋ช ๋ น์ด๋ฅผ ํตํด์ ๋๋ ํ ๋ฆฌ ๋ด๋ถ ํ์ผ์ ํ์ธํด๋ณด๋ฉด, ํด๋น ๋๋ ํ ๋ฆฌ ์๋์ a.out ํ์ผ์ด ์์ฑ๋๋ค.
./a.out
์ ์ด์ฉํด์ out ํ์ผ์ ์คํ์ํฌ ์ ์๋ค
$ ls
a.out main.c
$ ./a.out
(main.c executed...) => gcc ๋ก c ์ธ์ด ์ปดํ์ผํ๊ธฐ๋ ๋งค์ฐ ์ฝ๋ค์
์ด๋ ๊ฒ ๊ฐ๋จํ๊ฒ gcc๋ฅผ ์ด์ฉํด์ out ํ์ผ์ ๋ง๋ค๊ณ ์ปดํ์ผํ๋ ๋ฐฉ๋ฒ์ ๋ํด์ ์์๋ณด์๋ค.
์ด๋ฒ์๋ ๋งํน์ ์ด์ฉํด์ ์ฌ๋ฌ ์์ค์ฝ๋๋ฅผ ๋ฌถ์ด๋ณด๋ ์์ ์ ํด๋ณด์
header ํ์ผ๋ก ๋๋์ด์ง ์์ค ์ฝ๋ ๋งํนํ์ฌ ์ปดํ์ผ ํ๊ธฐ
์ด์ ์กฐ๊ธ ๋ ๋์๊ฐ์ ํค๋ํ์ผ์ include ํ๋ main ํจ์๋ฅผ ์์ฑํ๊ณ ์ด๋ฅผ ์ปดํ์ผํด๋ณด์
$ tree
.
โโโ src
โโโ main.c
โโโ hello.h
โโโ hello.c
โโโ bye.h
โโโ bye.c
๋ก ๊ตฌ์ฑ๋ ๊ฒ์ธ๋ฐ, ์ฐ์ ํค๋ ํ์ผ๊ณผ ํจ๊ป ์ปดํ์ผ์ ํ๊ธฐ ์ํด์๋ ๋งํน์ ๋ํด์ ์์์ผ ํ๋ค.
๋งํน (Linking) ์ด๋?
์ฐ๋ฆฌ๊ฐ ์์ ๊ฐ์ ๊ตฌ์กฐ์์ main.c ๊ฐ hello.h ์ bye.h ๋ฅผ include ํด์ ์ฌ์ฉํ๊ณ Greeting ์ด๋ผ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ ๋ค๊ณ ๊ฐ์ ํด๋ณด์.
๊ทธ๋ผ main.c ์์๋ ์ค์ง์ ์ผ๋ก hello.h ์ bye.h ๋ฅผ ๋ก๋ํ ๊น?
์๋๋ค. ์ด์ ๋ธ๋ฆฌ ์ฝ๋๋ฅผ ๋ณธ๋ค๋ฉด main.c ์์๋ hello.h ์์ ๊ฐ์ ธ์จ ํจ์๊ฐ ์ด๋์ ์์นํด ์๋ค๋ ๊ฒ๋ง ์ฐ์ฐํ๋ค.
๊ทธ๋์ main.c ๋ฅผ ์ ๋๋ก ๋์์ํค๊ธฐ ์ํด์๋
hello.h์ bye.h ๋ฅผ ํ๋๋ก ํฉ์น๋ ๊ณผ์ง์ธ Linking์ด ํ์ํ๊ฒ ๋๋ค
๋งํน์ ์๋ก ๋ค๋ฅธ ํ์ผ์ ํฉ์ด์ง ํจ์๋ ํด๋์ค๋ฅผ ํ ๋ฐ ๋ฌถ์ด์ ๋งํฌํด์ฃผ๋ ์์ ์ ๋ปํ๋๋ฐ, ๋งํน ๊ณผ์ ์ ์ปดํ์ผ๋ฌ์๊ฒ Object ํ์ผ์ ํจ๊ป ์ ๋ฌํ๋ฉด์ ์ปดํ์ผ์ ํ๊ฒ ๋๋ค.
์ปดํ์ผ๊ณผ ๋งํน์ ํตํด์ Greeting ํ๋ก๊ทธ๋จ ๋ง๋ค๊ธฐ
์! ์ด์ ์ฐ๋ฆฌ๊ฐ ์๊ฐํ ์์ค ์ฝ๋๋ค์ ๊ตฌํํ๊ณ ์ด๋ค์ ๋งํนํ์ฌ ์ปดํ์ผ ํด๋ณด๋๋ก ํ์
main ํจ์์ ๊ฐ๊ฐ header ํ์ผ ์์ฑ ๋ฐ ๊ตฌํ
main ํจ์ ์์ฑ ๋ฐ ๊ตฌํํ๊ธฐ
#include <stdio.h>
#include "hello.h"
int main() {
say_hello();
say_bye();
return 0;
}
header ํ์ผ ์์ฑ ๋ฐ ๊ตฌํํ๊ธฐ
// hello.h
void say_hello():
// hello.c
#include <stdio.h>
#include "hello.h"
void say_hello() {
printf("(hello.h) => ์๋
ํ์ธ์! \n");
}
// bye.c
#include <stdio.h>
#include "bye.h"
void say_bye() {
printf("(bye.h) => ์๋
ํ ๊ฐ์ธ์! \n");
}
object ํ์ผ๋ก ๋ง๋ค์ด์ ๋งํน(Linking) ํ๊ธฐ
๋งํน ์ปดํ์ผ์ ์ํด์๋ ๋ฐ๋ก ์ปดํ์ผ์ ํ๋ ๊ฒ์ด ์๋๊ณ , ์ปดํ์ผ๋ฌ์๊ฒ ์ฐ๊ด๋ (๋งํฌ ํ ) ํ์ผ๋ค์ Object ํ์ผ๋ก ํจ๊ผ ์ ๋ฌํด์ผ ํ๋ฏ๋ก ๊ฐ๊ฐ object ํ์ผ๋ก ๋ง๋๋ ๊ณผ์ ์ ์ํํด๋ณด์
gcc ๋ช
๋ น์ -c
์ต์
์ ์ค๋ค๋ฉด ์ฃผ์ด์ง๋ ํ์ผ์ ์ปดํ์ผํด์ ๋ชฉ์ ํ์ผ(Object file) ์ ๋ง๋ค๋ผ๋ ๋ช
๋ น์ ํ ์ ์๋ค.
$ gcc -c main.c
$ gcc -c hello.c
$ gcc -c bye.c
$ gcc main.o hello.o bye.o -o Greeting
๊ทธ๋ฆฌ๊ณ ls ๋ช ๋ น์ ํตํด์ ์ ์ปดํ์ผ์ด ์๋ฃ๋์๋์ง ํ์ธํ๊ธฐ ์ํด ls ๋ช ๋ น์ ์ํํด๋ณด์
$ ls
main.c main.o hello.h hello.c hello.o bye.h bye.c bye.o Greeting
๊ทธ๋ผ ์ฐ๋ฆฌ๊ฐ ์์ฑํ๊ธฐ๋ก ํ Greeting ํ์ผ์ด ์ ๋ง๋ค์ด์ง ๊ฒ์ ๋ณผ ์ ์๋ค.
์คํ์์ผ๋ณด์!
$ ./Greeting
(hello.h) => ์๋
ํ์ธ์!
(bye.h) => ์๋
ํ ๊ฐ์ธ์!
๋๊ธ