MapleStory Finger Point

๐Ÿ”ต C,C++,C#/C++ (MFC) ๊ฐœ๋…์ •๋ฆฌ

C++ ๊ธฐ์ดˆ ์ •๋ฆฌ

HYEJU01 2024. 4. 8. 02:12

๋„ค์ž„์ŠคํŽ˜์ด์Šค namespace

์ด๋ฆ„์ด ๊ธฐ์–ต๋˜๋Š” ์˜์—ญ

ํ‘œ์ค€ ๊ตฌ์„ฑ ์š”์†Œ์ธ ํด๋ž˜์Šค, ํ•จ์ˆ˜, ๋ณ€์ˆ˜๋Š” std ๋ผ๋Š” ์ด๋ฆ„ ๊ณต๊ฐ„์— ์ €์žฅ๋จ

iostream ๋‚ด์˜ ์ •์˜๋ฅผ ์‚ฌ์šฉํ•˜๋ ค๋ฉด

  • std:: ์ ‘๋‘์–ด๋ฅผ ๋ถ™์—ฌ std๋ผ๋Š” ๋„ค์ž„์ŠคํŽ˜์ด์Šค์— ์žˆ๋‹ค๋Š” ๊ฒƒ์„ ์ปดํŒŒ์ผ๋Ÿฌ์—๊ฒŒ ์•Œ๋ ค์ค˜์•ผํ•œ๋‹ค.
  • ๊ฐ„๋‹จํ•˜๊ฒŒ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” using namespace std; ๋ฅผ ์ž…๋ ฅํ•ด์„œ ์ ‘๋‘์–ด๋ฅผ ๋ถ™์ด์ง€ ์•Š์•„๋„ ์‹คํ–‰์‹œํ‚ฌ ์ˆ˜ ์žˆ๋‹ค.

์ฃผ์„

  • // ์™€ /* */
  • ์—ฌ๋Ÿฌ์ค„ ์ฃผ์„์€ ์ค‘์ฒฉํ•ด์„œ ์‚ฌ์šฉํ•˜๋ฉด ์•ˆ๋จ.

Cout ๊ฐ์ฒด

  • ๋‹ค์–‘ํ•œ ๋ฐ์ดํ„ฐ ์ถœ๋ ฅ
  • << ์‚ฝ์ž…์—ฐ์‚ฐ์ž
  • cout << ์ถœ๋ ฅ๋ฐ์ดํ„ฐ ;

Cin ๊ฐ์ฒด

  • ๋‹ค์–‘ํ•œ ๋ฐ์ดํ„ฐ ์ž…๋ ฅ ๋ฐ›์Œ
  • ์ถ”์ถœ ์—ฐ์‚ฐ์ž

  • cin >> ์ €์žฅํ• ๋ณ€์ˆ˜;

C ํ‘œ์ค€์ž…์ถœ๋ ฅํ•จ์ˆ˜์™€ ์ฐจ์ด์ 

  • ๋ฐ์ดํ„ฐ ํ๋ฆ„์„ ์•Œ ์ˆ˜ ์žˆ์–ด์„œ ์ง๊ด€์ ์ด๊ณ 
  • ์ž…์ถœ๋ ฅ๋ฐ์ดํ„ฐ ํƒ€์ž…์„ ์ž๋™๋ณ€ํ™˜ํ•˜๋ฏ€๋กœ ํŽธ๋ฆฌํ•˜๊ณ  ์•ˆ์ „

๋ณ€์ˆ˜

๋ณ€์ˆ˜์˜ ์„ ์–ธ : ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ํ• ๋‹น๋ฐ›๋Š” ํ–‰์œ„๋ฅผ ๋ณ€์ˆ˜์˜ ์„ ์–ธ

๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™” : ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์— ์“ฐ๋ ˆ๊ธฐ ๊ฐ’์ด ์žˆ์„ ์ˆ˜๋„ ์žˆ์œผ๋‹ˆ ์ดˆ๊ธฐํ™”ํ•ด์ฃผ๋Š”๊ฑฐ

๊ธฐ๋ณธํƒ€์ž…

๐Ÿ€ c๋ž‘ ๋น„์Šทํ•จ

short

int

long

long long

float

double

long double

char

+) bool : 0์ด ์•„๋‹ˆ๋ฉด True

+) autoํ‚ค์›Œ๋“œ : ์ดˆ๊ธฐ๊ฐ’์— ๋งž์ถฐ ํƒ€์ž…์ด ์ž๋™ ์„ ์–ธ๋จ

C++ ์—ฐ์‚ฐ์ž

1. ๋ฒ”์œ„ ์ง€์ • ์—ฐ์‚ฐ์ž(scope resolution operator)

๋ฒ”์œ„ ์ง€์ • ์—ฐ์‚ฐ์ž(::)

๋ณ€์ˆ˜์˜ ์ด๋ฆ„ ์•ž์— ๋ถ™์ด๋ฉด ํ•ด๋‹น ๋ณ€์ˆ˜๋Š” ์ „์—ญ์œผ๋กœ ์‚ฌ์šฉํ•˜๋ผ๋Š” ์˜๋ฏธ

2. ๋ฉค๋ฒ„ ํฌ์ธํ„ฐ ์—ฐ์‚ฐ์ž(pointer-to-member operator)

. / →

3. typeid ์—ฐ์‚ฐ์ž

typeid(ํ‘œํ˜„์‹)

๊ฐ์ฒด์˜ ํƒ€์ž…์— ๊ด€ํ•œ ์ •๋ณด๋ฅผ ํ™•์ธ

์ œ์–ด๋ฌธ

์ œ์–ด๋ฌธ : ํ๋ฆ„์„ ์ œ์–ด

1.์กฐ๊ฑด๋ฌธ

  • if
  • if / else
  • if / else if / else ๋ฌธ
  • ์‚ผํ•ญ ์—ฐ์‚ฐ์ž , ์กฐ๊ฑด์‹ ? ๋ฐ˜ํ™˜๊ฐ’ 1 : ๋ฐ˜ํ™˜๊ฐ’ 2
  • switch๋ฌธ case , break

2.๋ฐ˜๋ณต๋ฌธ

์ดˆ๊ธฐ์‹, ์กฐ๊ฑด์‹, ์ฆ๊ฐ์‹

  1. while ๋ฌธ :: while(์กฐ๊ฑด์‹) {}
  2. do / while ๋ฌธ :: ์กฐ๊ฑด์‹์ด ๋’ค์—์žˆ์–ด์„œ ๋ฌด์กฐ๊ฑด ํ•œ๋ฒˆ ๋ฃจํ”„ํ•จ
  3. for ๋ฌธ
  4. ๋ฒ”์œ„ ๊ธฐ๋ฐ˜์˜ for ๋ฌธ :: for (int element : arr) ๋ฐฐ์—ด ๋ชจ๋“  ๊ฐ’ ์ถœ๋ ฅ

๋ฃจํ”„์˜ ์ œ์–ด

  • continue๋ฌธ
  • break๋ฌธ
  • goto๋ฌธ

๋ฐฐ์—ด

๋ฐฐ์—ด์˜ ๊ธธ์ด ์ž๋™ ์„ค์ •

int arr[] = {1, 2, 3}; //๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ๋”ฐ๋กœ ์ž…๋ ฅํ•˜์ง€ ์•Š์€ ๋ฐฐ์—ด์€ ์ดˆ๊ธฐํ™” ๋ฆฌ์ŠคํŠธ์˜ ๋ฐฐ์—ด ์š”์†Œ ๊ฐœ์ˆ˜์— ๋งž์ถฐ ์ž๋™์œผ๋กœ ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ ์„ค์ •๋ฉ๋‹ˆ๋‹ค.

๋ฐฐ์—ด ์ฃผ์˜

***๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ์„ ์–ธํ•  ๋•Œ์—๋Š” ๋ฐ˜๋“œ์‹œ ์ƒ์ˆ˜๋ฅผ ์‚ฌ์šฉ

***C++ ์ปดํŒŒ์ผ๋Ÿฌ๋Š” ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ์ „ํ˜€ ์‹ ๊ฒฝ ์“ฐ์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋‹ค์ฐจ์› ๋ฐฐ์—ด

2์ฐจ์› ๋ฐฐ์—ด

ํƒ€์ž… ๋ฐฐ์—ด์ด๋ฆ„[ํ–‰์˜๊ธธ์ด][์—ด์˜๊ธธ์ด];

***์—ด์˜ ๊ธธ์ด๋Š” ๋ฌด์กฐ๊ฑด ๋ช…์‹œํ•ด์•ผํ•จ

!https://s3-us-west-2.amazonaws.com/secure.notion-static.com/d17e7ed2-367b-4f0b-9050-b9144c749bcf/Untitled.png

ํฌ์ธํ„ฐ == ํฌ์ธํ„ฐ ๋ณ€์ˆ˜

๋ฉ”๋ชจ๋ฆฌ ์ฃผ์†Œ๊ฐ’์„ ์ €์žฅํ•˜๋Š” ๋ณ€์ˆ˜

int n = 100;

int *ptr = &n; /ptr ์€ n์˜ ์ฃผ์†Œ๊ฐ’ *ptr ์€ n์˜ ๊ฐ’

ํฌ์ธํ„ฐ์™€ ๋ฐฐ์—ด์˜ ๊ด€๊ณ„

C++์—์„œ๋Š” ๋ฐฐ์—ด์˜ ์ด๋ฆ„์„ ํฌ์ธํ„ฐ์ฒ˜๋Ÿผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์„ ๋ฟ๋งŒ ์•„๋‹ˆ๋ผ,

ํฌ์ธํ„ฐ๋ฅผ ๋ฐฐ์—ด์˜ ์ด๋ฆ„์ฒ˜๋Ÿผ ์‚ฌ์šฉํ•  ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค.

***C++๋กœ ํ”„๋กœ๊ทธ๋ž˜๋ฐํ•  ๋•Œ์—๋Š” ์–ธ์ œ๋‚˜ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ์— ์ฃผ์˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

๋ฉ”๋ชจ๋ฆฌ ๋™์ ํ• ๋‹น

  • ํƒ€์ž…* ํฌ์ธํ„ฐ์ด๋ฆ„ = new ํƒ€์ž…;

//๋ฐ์ดํ„ฐ์— ๋งž๋Š” ํฌ์ธํ„ฐ ์„ ์–ธ

//๋ฉ”๋ชจ๋ฆฌ ์ข…๋ฅ˜๋ฅผ ์ง€์ •ํ•˜๊ธฐ์œ„ํ•ด

  • delete ํฌ์ธํ„ฐ์ด๋ฆ„;

๋ฌธ์ž์—ด

  • "" ๋ฌธ์ž์—ด์ƒ์ˆ˜ (๋ฌธ์ž์—ด์˜ ๊ธธ์ด์— ์ œํ•œ์„ ๋‘์ง€ ์•Š์Œ)
  • NULL ๋ฌธ์ž == '\0' == 0 (์•„์Šคํ‚ค์ฝ”๋“œ) :: ๋ฌธ์ž์—ด ๋งˆ์ง€๋ง‰์— ์‚ฝ์ž…ํ•ด์คŒ
  • ๋„๋ฌธ์ž์˜ ์œ ๋ฌด๋กœ ๋ฌธ์žํ˜•๋ฐ์ดํ„ฐ๋ฐฐ์—ด ↔ ๋ฌธ์ž์—ด ๊ตฌ๋ถ„๊ฐ€๋Šฅ!!!
  • char address[20];
  • cout << "์ด๋ฆ„์ ์–ด์ฃผ์„ธ์š”" ;
  • cin >> name;
  • cout << name << "์ž…๋‹ˆ๋‹ค";
    • ๋‹จ์  :: ๋„์–ด์“ฐ๊ธฐ or ๋ฐฐ์—ดํฌ๊ธฐ ์ด์ƒ ๊ฐ’์€ ๋ฐ›์ง€ ๋ชปํ•จ
  • char address[20];
  • cout << "์ด๋ฆ„์ ์–ด์ฃผ์„ธ์š”" ;
  • cin >> get(name, 20).get();
  • cout << name << "์ž…๋‹ˆ๋‹ค";
    • ๋‹จ์  :: ๋ฐฐ์—ดํฌ๊ธฐ ์ด์ƒ ๊ฐ’์€ ๋ฐ›์ง€ ๋ชปํ•จ ๊บผ์ง
  • char address[20];
  • cout << "์ด๋ฆ„์ ์–ด์ฃผ์„ธ์š”" ;
  • cin >> get(name, 20).ignore(SIZE, '\n');
  • cout << name << "์ž…๋‹ˆ๋‹ค";
    • ๋‹จ์  :: ๋ฐฐ์—ดํฌ๊ธฐ ๊นŒ์ง€๋งŒ ๋ฐ›์Œ
  • char address[20];
  • cout << "์ด๋ฆ„์ ์–ด์ฃผ์„ธ์š”" ;
  • getline(cin, name);
  • cout << name << "์ž…๋‹ˆ๋‹ค";
    • ๋‹จ์  :: ํ•ด๊ฒฐ
  • ๋ฌธ์ž์—ด ์ฒ˜๋ฆฌํ•จ์ˆ˜๋„ ์žˆ๋Š”๋ฐ ๊ทธ๊ฑด ์•Œ์•„์„œ ์ฐพ์•„๋ณด๋„๋กใ…‡ใ…‡

string ํด๋ž˜์Šค

๋ฌธ์ž์—ด ๋ฐฐ์—ด๋ณด๋‹ค ํŽธ๋ฆฌํ•จ ใ…‹

๋ฌธ์ž์—ด์„ ํ•˜๋‚˜์˜ ํƒ€์ž…์ฒ˜๋Ÿผ ํ‘œํ˜„ ๊ฐ€๋Šฅ ใ…‹

string ํ—ค๋”ํŒŒ์ผ ํ•„์š”

std ๋„ค์ž„์ŠคํŽ˜์ด์Šค - > using ์ง€์‹œ์ž ์‚ฌ์šฉ or ๋„ค์ž„์ŠคํŽ˜์ด์Šค ์ฐธ์กฐ

string str1;

str1 = "C++ Hello";

string str2 = "C++"

  • string ๊ฐ์ฒด ๋ฌธ์ž์—ด๋„ ๋ฐฐ์—ด(์ธ๋ฑ์Šค)์ทจ๊ธ‰๊ฐ€๋Šฅ
  • ๊ธธ์ด๊ฐ€ ์ž๋™์กฐ์ ˆ๋จ
  • length() , size() ๋ฉ”์†Œ๋“œ ์ด์šฉ :: ๊ฐ์ฒด์˜ ๊ธธ์ด

๋ฌธ์ž์—ด ๋Œ€์ž… :: ๋Œ€์ž…์—ฐ์‚ฐ์ž (=) ๋กœ ์‰ฝ๊ฒŒ ๊ฐ€๋Šฅ

๋ฐฐ์—ด์‚ฌ์ด์˜ ์ถ”๊ฐ€ ๋˜๋Š” ๊ฒฐํ•ฉ ::: ๋ณตํ•ฉ ๋Œ€์ž… ์—ฐ์‚ฐ์ž(+=)๋‚˜ append() ๋ฉ”์†Œ๋“œ

?????????????????????? ๋ฌธ์ž์—ด์ž…์ถœ๋ ฅ

string ๊ฐ์ฒด๋ฅผ ์ด์šฉํ•œ ๋ฌธ์ž์—ด์˜ ์ž…๋ ฅ์—๋Š” cin ๊ฐ์ฒด๋ฅผ, ์ถœ๋ ฅ์—๋Š” cout ๊ฐ์ฒด๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํ•˜์ง€๋งŒ cin ๊ฐ์ฒด๋ฅผ ์ด์šฉํ•œ ๋ฌธ์ž์—ด์˜ ์ž…๋ ฅ์€ ํ•œ ๋‹จ์–ด ๋‹จ์œ„๋กœ ์ˆ˜ํ–‰๋ฉ๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ ๋ฌธ์ž์—ด์„ ํ•œ ํ–‰(line)์”ฉ ์ฝ๊ณ  ์‹ถ์„ ๋•Œ๋Š” getline() ํ•จ์ˆ˜

cout << "์ž์‹ ์˜ ์ด๋ฆ„์„ ์ ์–ด์ฃผ์„ธ์š” : ";

getline(cin, name);

getline() ํ•จ์ˆ˜๋Š” ์ฒซ ๋ฒˆ์งธ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ cin ๊ฐ์ฒด๋ฅผ, ๋‘ ๋ฒˆ์งธ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋ฌธ์ž์—ด์„ ์ €์žฅํ•  string ๊ฐ์ฒด ๋ณ€์ˆ˜๋ฅผ ์ „๋‹ฌ๋ฐ›์Šต๋‹ˆ๋‹ค.

string ๋ฉ”์†Œ๋“œ ๋Œ€ํ‘œ์ ์ธ ๋ฌธ์ž์—ด ์ฒ˜๋ฆฌ ํ•จ์ˆ˜

length() ๋ฉ”์†Œ๋“œ๋Š” ๋ฌธ์ž์—ด์˜ ๊ธธ์ด๋ฅผ ๋‚˜ํƒ€๋‚ด์ง€๋งŒ, size() ๋ฉ”์†Œ๋“œ๋Š” ํ•ด๋‹น string ๊ฐ์ฒด๊ฐ€ ๋ฉ”๋ชจ๋ฆฌ์—์„œ ์‹ค์ œ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋Š” ํฌ๊ธฐ๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค.

appned()

  1. ๋ฌธ์ž์—ด.append(์ถ”๊ฐ€ํ• ๋ฌธ์ž์—ด);                 // ์ถ”๊ฐ€ํ•  ๋ฌธ์ž์—ด์„ ๋งจ ๋์— ์ถ”๊ฐ€ํ•จ.

2. ๋ฌธ์ž์—ด.append(์ถ”๊ฐ€ํ• ๋ฌธ์ž์—ด, ์‹œ์ž‘์œ„์น˜, ๊ฐœ์ˆ˜); // ์ถ”๊ฐ€ํ•  ๋ฌธ์ž์—ด์˜ ์‹œ์ž‘ ์œ„์น˜๋ถ€ํ„ฐ ๊ฐœ์ˆ˜๋งŒํผ๋งŒ ๋งจ ๋์— ์ถ”๊ฐ€ํ•จ.

  1. ๋ฌธ์ž์—ด.append(๊ฐœ์ˆ˜, ์ถ”๊ฐ€ํ• ๋ฌธ์ž);             // ์ถ”๊ฐ€ํ•  ๋ฌธ์ž๋ฅผ ๊ฐœ์ˆ˜๋งŒํผ ๋งจ ๋์— ์ถ”๊ฐ€ํ•จ

find() ๋ฉ”์†Œ๋“œ

  1. ๋ฌธ์ž์—ด.find(์ฐพ์„๋ฌธ์ž์—ด);           // ์ธ๋ฑ์Šค 0๋ถ€ํ„ฐ ์ฐพ์„ ๋ฌธ์ž์—ด์„ ์ฐพ์•„, ๊ทธ ์‹œ์ž‘ ์œ„์น˜๋ฅผ ๋ฐ˜ํ™˜ํ•จ.

2. ๋ฌธ์ž์—ด.find(์ฐพ์„๋ฌธ์ž);             // ์ธ๋ฑ์Šค 0๋ถ€ํ„ฐ ์ฐพ์„ ๋ฌธ์ž๋ฅผ ์ฐพ์•„, ๊ทธ ์‹œ์ž‘ ์œ„์น˜๋ฅผ ๋ฐ˜ํ™˜ํ•จ.

  1. ๋ฌธ์ž์—ด.find(์ฐพ์„๋ฌธ์ž์—ด, ์‹œ์ž‘์œ„์น˜); // ์‹œ์ž‘ ์œ„์น˜๋ถ€ํ„ฐ ์ฐพ์„ ๋ฌธ์ž์—ด์„ ์ฐพ์•„, ๊ทธ ์‹œ์ž‘ ์œ„์น˜๋ฅผ ๋ฐ˜ํ™˜ํ•จ.

compare() ๋ฉ”์†Œ๋“œ

  1. str1.compare(str_02) == 0 // str1๊ณผ str2์ด ๊ฐ™์„ ๊ฒฝ์šฐ
  2. str1.compare(str_02) < 0  // str1์ด str2๋ณด๋‹ค ์‚ฌ์ „ ํŽธ์ฐฌ์ˆœ์œผ๋กœ ์•ž์— ์žˆ์„ ๊ฒฝ์šฐ
  3. str1.compare(str_02) > 0  // str1์ด str2๋ณด๋‹ค ์‚ฌ์ „ ํŽธ์ฐฌ์ˆœ์œผ๋กœ ๋’ค์— ์žˆ์„ ๊ฒฝ์šฐ

replace() ๋ฉ”์†Œ๋“œ

๋ฌธ์ž์—ด.replace(๋Œ€์ฒดํ• ๋ฌธ์ž์—ด์˜์‹œ์ž‘์œ„์น˜, ๋Œ€์ฒดํ• ๋ฌธ์ž์—ด์˜๊ธธ์ด, ์ƒˆ๋กœ์šด๋ฌธ์ž์—ด);

// ์ „๋‹ฌ๋œ ์‹œ์ž‘ ์œ„์น˜๋ถ€ํ„ฐ ๋ฌธ์ž์—ด์˜ ๊ธธ์ด๋งŒํผ์„ ์ œ๊ฑฐํ•œ ํ›„์—, ์ƒˆ๋กœ์šด ๋ฌธ์ž์—ด์„ ์‚ฝ์ž…ํ•จ.

capacity() ๋ฉ”์†Œ๋“œ์™€ max_size() ๋ฉ”์†Œ๋“œ

๊ตฌ์กฐ์ฒด

structure type

๋ฐฐ์—ด : ๊ฐ™์€ ํƒ€์ž…์˜ ๋ณ€์ˆ˜ ์ง‘ํ•ฉ

๊ตฌ์กฐ์ฒด : ๋‹ค์–‘ํ•œ ํƒ€์ž…์˜ ๋ณ€์ˆ˜ ์ง‘ํ•ฉ์„ ํ•˜๋‚˜์˜ ํƒ€์ž…์œผ๋กœ ๋‚˜ํƒ€๋ƒ„

๋ฉค๋ฒ„(๋ฉค๋ฒ„๋ณ€์ˆ˜) : ๊ตฌ์กฐ์ฒด๋ฅผ ๊ตฌ์„ฑํ•˜๋Š” ๋ณ€์ˆ˜

struct Book

{

   char title[30];
	char author[30];
int price;

};

struct ํ‚ค์›Œ๋“œ

book ๊ตฌ์กฐ์ฒด ์ด๋ฆ„

title, author,price ๋ฉค๋ฒ„๋ณ€์ˆ˜

1. struct Book web_book; //๊ตฌ์กฐ์ฒด ๋ณ€์ˆ˜ ์ƒ์„ฑ
2. Book web_book;  //struct ์ƒ๋žต๊ฐ€๋Šฅ

web_book.author //๊ตฌ์กฐ์ฒด ๋ฉค๋ฒ„ ์ ‘๊ทผํ•˜๊ธฐ
web_book = {"hi","hyeju",20000};

๊ตฌ์กฐ์ฒด ํ™œ์šฉ

ํ•จ์ˆ˜์˜ ์ธ์ˆ˜๋กœ ๊ตฌ์กฐ์ฒด ๋ฉค๋ฒ„ ๋ณ€์ˆ˜ ์ „๋‹ฌ

ํ•จ์ˆ˜์˜ ์ธ์ˆ˜๋กœ ๊ตฌ์กฐ์ฒด ์ฃผ์†Œ ์ง์ ‘ ์ „๋‹ฌ

const ํ‚ค์›Œ๋“œ ์‚ฌ์šฉํ•ด์„œ ์›๋ณธ๋ฐ์ดํ„ฐ ๋ณดํ˜ธํ•˜๊ธฐ

์ค‘์ฒฉ๋œ ๊ตฌ์กฐ์ฒด

struct Name

{

    string first;

    string last;

};

 

struct Friends

{

    Name first_name;

    string address;

    string job;

};

๊ตฌ์กฐ์ฒด ํฌ๊ธฐ

๋ฉค๋ฒ„ ๋ณ€์ˆ˜๋“ค์˜ ํฌ๊ธฐ์— ๋”ฐ๋ผ ๊ฒฐ์ •๋ฉ๋‹ˆ๋‹ค.

ํ”„๋กœ๊ทธ๋žจ์˜ ์†๋„ ํ–ฅ์ƒ์„ ์œ„ํ•ด

๋ฐ”์ดํŠธ ํŒจ๋”ฉ(byte padding)์ด๋ผ๋Š” ๊ทœ์น™

์ปดํŒŒ์ผ๋Ÿฌ๋Š” ๋ฉ”๋ชจ๋ฆฌ์˜ ์ ‘๊ทผ์„ ์‰ฝ๊ฒŒ ํ•˜๋ ค๊ณ  ํฌ๊ธฐ๊ฐ€ ๊ฐ€์žฅ ํฐ ๋ฉค๋ฒ„ ๋ณ€์ˆ˜๋ฅผ

๊ธฐ์ค€์œผ๋กœ ๋ชจ๋“  ๋ฉค๋ฒ„ ๋ณ€์ˆ˜์˜ ๋ฉ”๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ๋งž์ถ”๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

๊ณต์šฉ์ฒด์™€ ์—ด๊ฑฐ์ฒด

union ํ‚ค์›Œ๋“œ

๋ชจ๋“  ๋ฉค๋ฒ„ ๋ณ€์ˆ˜๊ฐ€ ํ•˜๋‚˜์˜ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ๊ณต์œ ํ•œ๋‹ค๋Š” ์ 

๊ณต์šฉ์ฒด๋Š” ํ•œ ๋ฒˆ์— ํ•˜๋‚˜์˜ ๋ฉค๋ฒ„ ๋ณ€์ˆ˜๋ฐ–์— ์‚ฌ์šฉํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

์ˆœ์„œ๊ฐ€ ๊ทœ์น™์ ์ด์ง€ ์•Š๊ณ , ๋ฏธ๋ฆฌ ์•Œ ์ˆ˜ ์—†๋Š” ๋‹ค์–‘ํ•œ ํƒ€์ž…์˜ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•  ์ˆ˜ ์žˆ๋„๋ก ์„ค๊ณ„๋œ ํƒ€์ž…์ž…๋‹ˆ๋‹ค.

ํฌ๊ธฐ๊ฐ€ ๊ฐ€์žฅ ํฐ ๋ฉค๋ฒ„ ๋ณ€์ˆ˜์˜ ํฌ๊ธฐ๋กœ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํ• ๋‹น

union ShareData

{

    unsigned char a;

    unsigned short b;

    unsigned int c;

};

์—ด๊ฑฐ์ฒด(enumerated types)๋Š” ์ƒˆ๋กœ์šด ํƒ€์ž…์„ ์„ ์–ธํ•˜๋ฉด์„œ

enum ํ‚ค์›Œ๋“œ

์ƒ์ˆ˜๊ฐ’์€ ๊ธฐ๋ณธ์ ์œผ๋กœ 0๋ถ€ํ„ฐ ~ ์•ž์˜ ๊ฐ’์— +1 ์”ฉ ์ฆ๊ฐ€

๋™์‹œ์— ๊ทธ ํƒ€์ž…์ด ๊ฐ€์งˆ ์ˆ˜ ์žˆ๋Š” ์ •์ˆ˜ํ˜• ์ƒ์ˆซ๊ฐ’๋„ ๊ฐ™์ด ๋ช…์‹œํ•ฉ๋‹ˆ๋‹ค.

enum Weather {SUNNY = 0, CLOUD = 10, RAIN = 20, SNOW = 30};

enum Weather {SUNNY = 0, CLOUD = 10, RAIN = 20, SNOW = 30};

 

int main(void)

{

    int input;

    Weather wt;

 

    cout << "์˜ค๋Š˜์˜ ๋‚ ์”จ๋ฅผ ์ž…๋ ฅํ•ด ์ฃผ์„ธ์š” : " << endl;

    cout << "(SUNNY=0, CLOUD=10, RAIN=20, SNOW=30)" << endl;

    cin >> input;

    wt = (Weather)input; //์•„๋งˆ๋„ ํ˜•๋ณ€ํ™˜์ธ๊ฐ€๋ด„ 

 

    switch (wt)

    {

        case SUNNY:

            cout << "์˜ค๋Š˜์˜ ๋‚ ์”จ๋Š” ์•„์ฃผ ๋ง‘์•„์š”!";

            break;

        case CLOUD:

            cout << "์˜ค๋Š˜์˜ ๋‚ ์”จ๋Š” ํ๋ฆฌ๋„ค์š”!";

            break;

        case RAIN:

            cout << "์˜ค๋Š˜์˜ ๋‚ ์”จ๋Š” ๋น„๊ฐ€ ์ฃผ๋ฃฉ์ฃผ๋ฃฉ ์˜ค๋„ค์š”!";

            break;

        case SNOW:

            cout << "์˜ค๋Š˜์˜ ๋‚ ์”จ๋Š” ํ•˜์–€ ๋ˆˆ์ด ๋‚ด๋ ค์š”!";

            break;

        default:

            cout << "์ •ํ™•ํ•œ ์ƒ์ˆซ๊ฐ’์„ ์ž…๋ ฅํ•ด ์ฃผ์„ธ์š”!";

            break;

    }

 

    cout << endl << "์—ด๊ฑฐ์ฒด Weather์˜ ๊ฐ ์ƒ์ˆซ๊ฐ’์€ " << SUNNY << ", " << CLOUD << ", "

        << RAIN << ", " << SNOW << "์ž…๋‹ˆ๋‹ค.";

    return 0;

}

ํ•จ์ˆ˜

C++ ํ”„๋กœ๊ทธ๋žจ์—์„œ ํ•จ์ˆ˜๋Š” ํŠน์ • ์ž‘์—…์„ ์บก์Šํ™”ํ•˜๋Š” ๋ฐ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

๋˜ํ•œ, ํ”„๋กœ๊ทธ๋žจ์„ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ํ•จ์ˆ˜๋กœ ๋‚˜๋ˆ„์–ด ์ž‘์„ฑํ•˜๋ฉด, ๋ชจ๋“ˆํ™”๋กœ ์ธํ•ด ์ „์ฒด์ ์ธ ์ฝ”๋“œ์˜ ๊ฐ€๋…์„ฑ์ด ์ข‹์•„์ง‘๋‹ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณ  ํ”„๋กœ๊ทธ๋žจ์— ๋ฌธ์ œ๊ฐ€ ๋ฐœ์ƒํ•˜๊ฑฐ๋‚˜ ๊ธฐ๋Šฅ์˜ ๋ณ€๊ฒฝ์ด ํ•„์š”ํ•  ๋•Œ์—๋„ ์†์‰ฝ๊ฒŒ ์œ ์ง€๋ณด์ˆ˜๋ฅผ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋Œ€๋žต ํ•˜๋‚˜์˜ ๊ธฐ๋Šฅ์„ ํ•˜๋‚˜์˜ ํ•จ์ˆ˜๋กœ ๋งŒ๋“œ๋Š” ๊ฒƒ์ด ๊ฐ€์žฅ ์ข‹์Šต๋‹ˆ๋‹ค.

ํ•จ์ˆ˜์˜ ์›ํ˜•์„ ์„ ์–ธํ•˜๋Š” ๊ฒƒ

#include <iostream>

using namespace std;  

 

int SmallNum(int, int);  

 

int main(void)

{

    int result;  

 

    result = SmallNum(4, 6);

    cout << " ๋‘ ์ˆ˜ ์ค‘ ๋” ์ž‘์€ ์ˆ˜๋Š” " << result << "์ž…๋‹ˆ๋‹ค." << endl;

    result = SmallNum(8, 6);

    cout << " ๋‘ ์ˆ˜ ์ค‘ ๋” ์ž‘์€ ์ˆ˜๋Š” " << result << "์ž…๋‹ˆ๋‹ค." << endl;

    result = SmallNum(2, 8);

    cout << " ๋‘ ์ˆ˜ ์ค‘ ๋” ์ž‘์€ ์ˆ˜๋Š” " << result << "์ž…๋‹ˆ๋‹ค." << endl;

    return 0;

}  

 

int SmallNum(int num1, int num2)

{

    if (num1 <= num2)

    {

        return num1;

    }

    else

    {

        return num2;

    }

}

์ธ์ˆ˜ ์ „๋‹ฌ ๋ฐฉ๋ฒ•

  1. ๊ฐ’์— ์˜ํ•œ ์ „๋‹ฌ(call by value)

๊ฐ€ใ…„ ๋ณต์‚ฌ

  1. ์ฐธ์กฐ์— ์˜ํ•œ ์ „๋‹ฌ(call by reference)

์ฐธ์กฐ์ž(reference)๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์ „๋‹ฌํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

main() ํ•จ์ˆ˜์˜ ์ธ์ˆ˜ ์ „๋‹ฌ

void(๋˜๋Š” int) main(int argc,char *argv[]);

์žฌ๊ท€ ํ˜ธ์ถœ(recursive call)

ํ•จ์ˆ˜ ๋‚ด๋ถ€์—์„œ ํ•จ์ˆ˜๊ฐ€ ์ž๊ธฐ ์ž์‹ ์„ ๋˜๋‹ค์‹œ ํ˜ธ์ถœํ•˜๋Š” ๊ฒƒ์„ ๋งํ•ฉ๋‹ˆ๋‹ค.

์ค‘๋‹จํ•˜๋„๋ก ์กฐ๊ฑด์ด ๋ณ€๊ฒฝ๋  ๋ช…๋ น๋ฌธ์„ ๋ฐ˜๋“œ์‹œ ํฌํ•จํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

์Šคํƒ ์˜ค๋ฒ„ํ”Œ๋กœ์šฐ(stack overflow)์— ์˜ํ•ด ์ข…๋ฃŒ๋  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์˜์‚ฌ ์ฝ”๋“œ(pseudo code) →

๋…ผ๋ฆฌ์ ์ธ ์žฌ๊ท€ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๊ตฌ์ƒํ•˜

์ฝ”๋“œ๋กœ ์˜ฎ๊ธฐ๊ฒŒํ•ด์คŒ

๋ž€ ํŠน์ • ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด์˜ ๋ฌธ๋ฒ•์— ๋งž์ถฐ ์ž‘์„ฑ๋œ ๊ฒƒ์ด ์•„๋‹Œ, ์ผ๋ฐ˜์ ์ธ ์–ธ์–ด๋กœ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ํ‘œํ˜„ํ•œ ์ฝ”๋“œ๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

ํ•จ์ˆ˜ ํฌ์ธํ„ฐ(function pointer)

ํ”„๋กœ๊ทธ๋žจ์—์„œ ์ •์˜๋œ ํ•จ์ˆ˜๋Š” ํ”„๋กœ๊ทธ๋žจ์ด ์‹คํ–‰๋  ๋•Œ ๋ชจ๋‘ ๋ฉ”์ธ ๋ฉ”๋ชจ๋ฆฌ์— ์˜ฌ๋ผ๊ฐ‘๋‹ˆ๋‹ค.

์ด๋•Œ ํ•จ์ˆ˜์˜ ์ด๋ฆ„์€ ๋ฉ”๋ชจ๋ฆฌ์— ์˜ฌ๋ผ๊ฐ„ ํ•จ์ˆ˜์˜ ์‹œ์ž‘ ์ฃผ์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ ์ƒ์ˆ˜(constant pointer) ๊ฐ€ ๋œ๋‹ค.

ํ•จ์ˆ˜์˜ ์‹œ์ž‘ ์ฃผ์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ํฌ์ธํ„ฐ ์ƒ์ˆ˜๋ฅผ ํ•จ์ˆ˜ ํฌ์ธํ„ฐ(function pointer)๋ผ๊ณ  ๋ถ€๋ฆ…๋‹ˆ๋‹ค.

ํฌ์ธํ„ฐ ์ƒ์ˆ˜(constant pointer)๋ž€ ํฌ์ธํ„ฐ ๋ณ€์ˆ˜๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๊ณ  ์žˆ๋Š” ์ฃผ์†Œ ๊ฐ’์„ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์—†๋Š” ํฌ์ธํ„ฐ๋ฅผ ์˜๋ฏธํ•˜๋ฉฐ,

์ƒ์ˆ˜ ํฌ์ธํ„ฐ(pointer to constant)๋ž€ ์ƒ์ˆ˜๋ฅผ ๊ฐ€๋ฅดํ‚ค๋Š” ํฌ์ธํ„ฐ๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

์ฆ‰ ํ•จ์ˆ˜์˜ ์›ํ˜•์„ ์•Œ์•„์•ผ๋งŒ ํ•ด๋‹น ํ•จ์ˆ˜์— ๋งž๋Š” ํ•จ์ˆ˜ ํฌ์ธํ„ฐ๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

ํ•จ์ˆ˜๋ฅผ ๋˜ ๋‹ค๋ฅธ ํ•จ์ˆ˜์˜ ์ธ์ˆ˜๋กœ ์ „๋‹ฌํ•  ๋•Œ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

double (*calc)(double, double) = NULL;
  1. typedef ํ‚ค์›Œ๋“œ

typedef double (*CalcFunc)(double, double); // ํ•จ์ˆ˜ ํฌ์ธํ„ฐ์— calcFunc์ด๋ผ๋Š” ์ƒˆ๋กœ์šด ์ด๋ฆ„์„ ๋ถ™์ž„.

2. auto ํ‚ค์›Œ๋“œ

auto ptr_func = calc;

์ฐธ์กฐ์ž(reference)

ํŠน์ • ๋ณ€์ˆ˜์˜ ์‹ค์ œ ์ด๋ฆ„ ๋Œ€์‹  ์‚ฌ์šฉํ• 

int ๋ณ€์ˆ˜์ด๋ฆ„;               // ๋ณ€์ˆ˜์˜ ์„ ์–ธ

int& ์ฐธ์กฐ์ž์ด๋ฆ„ = ๋ณ€์ˆ˜์ด๋ฆ„; // ์ฐธ์กฐ์ž ์„ ์–ธ

int&๋Š” intํ˜• ๋ณ€์ˆ˜์— ๋Œ€ํ•œ ์ฐธ์กฐ๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

๋Œ€์ƒ ๋ณ€์ˆ˜์™€ ๊ฐ™์€ ๋ฉ”๋ชจ๋ฆฌ ์œ„์น˜๋ฅผ ์ฐธ์กฐํ•˜

  1. ์ฐธ์กฐ์ž์˜ ํƒ€์ž…์€ ๋Œ€์ƒ์ด ๋˜๋Š” ๋ณ€์ˆ˜์˜ ํƒ€์ž…๊ณผ ์ผ์น˜ํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
  2. ์ฐธ์กฐ์ž๋Š” ์„ ์–ธ๊ณผ ๋™์‹œ์— ์ดˆ๊ธฐํ™”๋˜์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
  3. ์ฐธ์กฐ์ž๋Š” ํ•œ ๋ฒˆ ์ดˆ๊ธฐํ™”๋˜๋ฉด, ์ฐธ์กฐํ•˜๋Š” ๋Œ€์ƒ์„ ๋ณ€๊ฒฝํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

์ฐธ์กฐ์— ์˜ํ•œ ์ „๋‹ฌ(call by reference)์€ ์ฐธ์กฐ์ž๋ฟ๋งŒ ์•„๋‹ˆ๋ผ ํฌ์ธํ„ฐ๋ฅผ ์‚ฌ์šฉํ•ด๋„ ๋˜‘๊ฐ™์€ ๊ฒฐ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

C++์—์„œ ์ฐธ์กฐ์ž๋Š” ํฌ๊ธฐ๊ฐ€ ํฐ ๊ตฌ์กฐ์ฒด๋‚˜ ํด๋ž˜์Šค๋ฅผ ๋‹ค๋ฃฐ ๋•Œ์—๋งŒ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹์Šต๋‹ˆ๋‹ค.

C++์—์„œ ์ฐธ์กฐ์ž๋Š” ์ฃผ๋กœ ๊ตฌ์กฐ์ฒด์™€ ๊ฐ™์€ ์‚ฌ์šฉ์ž ์ •์˜ ํƒ€์ž…์„ ๋‹ค๋ฃฐ ๋•Œ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

๋””ํดํŠธ ์ธ์ˆ˜(default argument)

ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•  ๋•Œ ์ธ์ˆ˜๋ฅผ ์ „๋‹ฌํ•˜์ง€ ์•Š์œผ๋ฉด, ํ•จ์ˆ˜๋Š” ์ž๋™์œผ๋กœ ๋ฏธ๋ฆฌ ์ •์˜๋˜์–ด ์žˆ๋Š” ๋””ํดํŠธ ์ธ์ˆ˜๊ฐ’์„ ์‚ฌ์šฉํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

  1. ๋””ํดํŠธ ์ธ์ˆ˜๋Š” ํ•จ์ˆ˜์˜ ์›ํ˜•์—๋งŒ ์ง€์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  2. ๋””ํดํŠธ ์ธ์ˆ˜๋Š” ๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜์—ฌ ์ˆœ์„œ๋Œ€๋กœ๋งŒ ์ง€์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
  3. ๊ฐ€์šด๋ฐ ์ธ์ˆ˜๋“ค๋งŒ ๋ณ„๋„๋กœ ๋””ํดํŠธ ์ธ์ˆ˜๋ฅผ ์ง€์ •ํ•  ์ˆ˜๋Š” ์—†์Šต๋‹ˆ๋‹ค.

๋””ํดํŠธ ์ธ์ˆ˜๊ฐ€ ์„ค์ •๋œ ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•  ๋•Œ์—๋Š” ์ธ์ˆ˜์˜ ์ „๋‹ฌ์„ ๊ฑด๋„ˆ๋›ธ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

ํ•จ์ˆ˜ ์˜ค๋ฒ„๋กœ๋”ฉ(function overloading) ๋‹คํ˜•์„ฑ(polymorphism)์˜ ๊ตฌํ˜„์ž…๋‹ˆ๋‹ค.

๊ฐ™์€ ์ด๋ฆ„์˜ ํ•จ์ˆ˜๋ฅผ ์ค‘๋ณตํ•˜์—ฌ ์ •์˜ํ•˜๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.

ํ•จ์ˆ˜๋ฅผ ๋งค๊ฐœ๋ณ€์ˆ˜์˜ ํ˜•์‹์„ ์กฐ๊ธˆ์”ฉ ๋‹ฌ๋ฆฌํ•˜์—ฌ, ํ•˜๋‚˜์˜ ์ด๋ฆ„์œผ๋กœ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ฃผ๋Š” ๊ฒƒ

ํ•จ์ˆ˜ ์‹œ๊ทธ๋‹ˆ์ฒ˜(function signature)

ํ•จ์ˆ˜์˜ ์›ํ˜•์— ๋ช…์‹œ๋˜๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜ ๋ฆฌ์ŠคํŠธ๋ฅผ ๊ฐ€๋ฆฌํ‚ต๋‹ˆ๋‹ค.

๋งค๊ฐœ๋ณ€์ˆ˜์˜ ๊ฐœ์ˆ˜์™€ ๊ทธ ํƒ€์ž…์ด ๋ชจ๋‘ ๊ฐ™๋‹ค๋ฉด, ์ด ๋‘ ํ•จ์ˆ˜์˜ ์‹œ๊ทธ๋‹ˆ์ฒ˜๋Š” ๊ฐ™๋‹ค๊ณ  ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์„œ๋กœ ๋‹ค๋ฅธ ์‹œ๊ทธ๋‹ˆ์ฒ˜๋ฅผ ๊ฐ–๋Š” ์—ฌ๋Ÿฌ ํ•จ์ˆ˜๋ฅผ ๊ฐ™์€ ์ด๋ฆ„์œผ๋กœ ์ •์˜ํ•˜๋Š” ๊ฒƒ์ด๋ผ๊ณ  ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค

์ธ๋ผ์ธ ํ•จ์ˆ˜

ํ•จ์ˆ˜๋ฅผ ํ˜ธ์ถœํ•˜๋Š” ๋ฐ ๊ฑธ๋ฆฌ๋Š” ์‹œ๊ฐ„์€ ์ ˆ์•ฝ๋˜๋‚˜, ํ•จ์ˆ˜ ํ˜ธ์ถœ ๊ณผ์ •์œผ๋กœ ์ƒ๊ธฐ๋Š” ์—ฌ๋Ÿฌ ์ด์ ์„ ํฌ๊ธฐํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

v์ฝ”๋“œ๊ฐ€ ๋งค์šฐ ์ ์€ ํ•จ์ˆ˜๋งŒ์„ ์ธ๋ผ์ธ ํ•จ์ˆ˜๋กœ ์„ ์–ธํ•˜๋Š” ๊ฒƒ

inline ํ•จ์ˆ˜์˜์›ํ˜•

๋˜๋Š”

inline ํ•จ์ˆ˜์˜์ •์˜

inline ํ‚ค์›Œ๋“œ๋Š” ํ•จ์ˆ˜์˜ ์›ํ˜•์ด๋‚˜ ํ•จ์ˆ˜์˜ ์ •์˜ ์–ด๋Š ํ•œ ์ชฝ์—๋งŒ ํ‘œ๊ธฐํ•ด๋„ ๋˜๋ฉฐ, ์–‘์ชฝ ๋‹ค ํ‘œ๊ธฐํ•ด๋„ ์ƒ๊ด€์—†์Šต๋‹ˆ๋‹ค.

์žฌ๊ท€ ํ˜ธ์ถœ์ด ํ—ˆ์šฉ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋งคํฌ๋กœ ํ•จ์ˆ˜์™€ ์ธ๋ผ์ธ ํ•จ์ˆ˜

์ผ๋ฐ˜ ํ•จ์ˆ˜์™€๋Š” ๋‹ฌ๋ฆฌ ๋‹จ์ˆœ ์น˜ํ™˜๋งŒ์„ ํ•ด์ฃผ๋ฏ€๋กœ, ์ผ๋ฐ˜ ํ•จ์ˆ˜์™€ ๋˜‘๊ฐ™์€ ๋ฐฉ์‹์œผ๋กœ ๋™์ž‘ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋งคํฌ๋กœ ํ•จ์ˆ˜๋ฅผ ์ผ๋ฐ˜ ํ•จ์ˆ˜์ฒ˜๋Ÿผ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋ชจ๋“  ์ธ์ˆ˜๋ฅผ ๊ด„ํ˜ธ({})๋กœ ๊ฐ์‹ธ์•ผ๋งŒ ํ•ฉ๋‹ˆ๋‹ค.

#define SQR(X) X*X

#define SQR(X) X*X