๋ค์์คํ์ด์ค 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.๋ฐ๋ณต๋ฌธ
์ด๊ธฐ์, ์กฐ๊ฑด์, ์ฆ๊ฐ์
- while ๋ฌธ :: while(์กฐ๊ฑด์) {}
- do / while ๋ฌธ :: ์กฐ๊ฑด์์ด ๋ค์์์ด์ ๋ฌด์กฐ๊ฑด ํ๋ฒ ๋ฃจํํจ
- for ๋ฌธ
- ๋ฒ์ ๊ธฐ๋ฐ์ for ๋ฌธ :: for (int element : arr) ๋ฐฐ์ด ๋ชจ๋ ๊ฐ ์ถ๋ ฅ
๋ฃจํ์ ์ ์ด
- continue๋ฌธ
- break๋ฌธ
- goto๋ฌธ
๋ฐฐ์ด
๋ฐฐ์ด์ ๊ธธ์ด ์๋ ์ค์
int arr[] = {1, 2, 3}; //๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๋ฐ๋ก ์ ๋ ฅํ์ง ์์ ๋ฐฐ์ด์ ์ด๊ธฐํ ๋ฆฌ์คํธ์ ๋ฐฐ์ด ์์ ๊ฐ์์ ๋ง์ถฐ ์๋์ผ๋ก ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์ค์ ๋ฉ๋๋ค.
๋ฐฐ์ด ์ฃผ์
***๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ ์ธํ ๋์๋ ๋ฐ๋์ ์์๋ฅผ ์ฌ์ฉ
***C++ ์ปดํ์ผ๋ฌ๋ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ ํ ์ ๊ฒฝ ์ฐ์ง ์์ต๋๋ค.
๋ค์ฐจ์ ๋ฐฐ์ด
2์ฐจ์ ๋ฐฐ์ด
ํ์ ๋ฐฐ์ด์ด๋ฆ[ํ์๊ธธ์ด][์ด์๊ธธ์ด];
***์ด์ ๊ธธ์ด๋ ๋ฌด์กฐ๊ฑด ๋ช ์ํด์ผํจ
ํฌ์ธํฐ == ํฌ์ธํฐ ๋ณ์
๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ์ ์ ์ฅํ๋ ๋ณ์
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()
- ๋ฌธ์์ด.append(์ถ๊ฐํ ๋ฌธ์์ด); // ์ถ๊ฐํ ๋ฌธ์์ด์ ๋งจ ๋์ ์ถ๊ฐํจ.
2. ๋ฌธ์์ด.append(์ถ๊ฐํ ๋ฌธ์์ด, ์์์์น, ๊ฐ์); // ์ถ๊ฐํ ๋ฌธ์์ด์ ์์ ์์น๋ถํฐ ๊ฐ์๋งํผ๋ง ๋งจ ๋์ ์ถ๊ฐํจ.
- ๋ฌธ์์ด.append(๊ฐ์, ์ถ๊ฐํ ๋ฌธ์); // ์ถ๊ฐํ ๋ฌธ์๋ฅผ ๊ฐ์๋งํผ ๋งจ ๋์ ์ถ๊ฐํจ
find() ๋ฉ์๋
- ๋ฌธ์์ด.find(์ฐพ์๋ฌธ์์ด); // ์ธ๋ฑ์ค 0๋ถํฐ ์ฐพ์ ๋ฌธ์์ด์ ์ฐพ์, ๊ทธ ์์ ์์น๋ฅผ ๋ฐํํจ.
2. ๋ฌธ์์ด.find(์ฐพ์๋ฌธ์); // ์ธ๋ฑ์ค 0๋ถํฐ ์ฐพ์ ๋ฌธ์๋ฅผ ์ฐพ์, ๊ทธ ์์ ์์น๋ฅผ ๋ฐํํจ.
- ๋ฌธ์์ด.find(์ฐพ์๋ฌธ์์ด, ์์์์น); // ์์ ์์น๋ถํฐ ์ฐพ์ ๋ฌธ์์ด์ ์ฐพ์, ๊ทธ ์์ ์์น๋ฅผ ๋ฐํํจ.
compare() ๋ฉ์๋
- str1.compare(str_02) == 0 // str1๊ณผ str2์ด ๊ฐ์ ๊ฒฝ์ฐ
- str1.compare(str_02) < 0 // str1์ด str2๋ณด๋ค ์ฌ์ ํธ์ฐฌ์์ผ๋ก ์์ ์์ ๊ฒฝ์ฐ
- 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;
}
}
์ธ์ ์ ๋ฌ ๋ฐฉ๋ฒ
- ๊ฐ์ ์ํ ์ ๋ฌ(call by value)
๊ฐใ ๋ณต์ฌ
- ์ฐธ์กฐ์ ์ํ ์ ๋ฌ(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;
- typedef ํค์๋
typedef double (*CalcFunc)(double, double); // ํจ์ ํฌ์ธํฐ์ calcFunc์ด๋ผ๋ ์๋ก์ด ์ด๋ฆ์ ๋ถ์.
2. auto ํค์๋
auto ptr_func = calc;
์ฐธ์กฐ์(reference)
ํน์ ๋ณ์์ ์ค์ ์ด๋ฆ ๋์ ์ฌ์ฉํ
int ๋ณ์์ด๋ฆ; // ๋ณ์์ ์ ์ธ
int& ์ฐธ์กฐ์์ด๋ฆ = ๋ณ์์ด๋ฆ; // ์ฐธ์กฐ์ ์ ์ธ
int&๋ intํ ๋ณ์์ ๋ํ ์ฐธ์กฐ๋ฅผ ์๋ฏธํฉ๋๋ค.
๋์ ๋ณ์์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์น๋ฅผ ์ฐธ์กฐํ
- ์ฐธ์กฐ์์ ํ์ ์ ๋์์ด ๋๋ ๋ณ์์ ํ์ ๊ณผ ์ผ์นํด์ผ ํฉ๋๋ค.
- ์ฐธ์กฐ์๋ ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ๋์ด์ผ ํฉ๋๋ค.
- ์ฐธ์กฐ์๋ ํ ๋ฒ ์ด๊ธฐํ๋๋ฉด, ์ฐธ์กฐํ๋ ๋์์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค.
์ฐธ์กฐ์ ์ํ ์ ๋ฌ(call by reference)์ ์ฐธ์กฐ์๋ฟ๋ง ์๋๋ผ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํด๋ ๋๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค.
C++์์ ์ฐธ์กฐ์๋ ํฌ๊ธฐ๊ฐ ํฐ ๊ตฌ์กฐ์ฒด๋ ํด๋์ค๋ฅผ ๋ค๋ฃฐ ๋์๋ง ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
C++์์ ์ฐธ์กฐ์๋ ์ฃผ๋ก ๊ตฌ์กฐ์ฒด์ ๊ฐ์ ์ฌ์ฉ์ ์ ์ ํ์ ์ ๋ค๋ฃฐ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ฉ๋๋ค.
๋ํดํธ ์ธ์(default argument)
ํจ์๋ฅผ ํธ์ถํ ๋ ์ธ์๋ฅผ ์ ๋ฌํ์ง ์์ผ๋ฉด, ํจ์๋ ์๋์ผ๋ก ๋ฏธ๋ฆฌ ์ ์๋์ด ์๋ ๋ํดํธ ์ธ์๊ฐ์ ์ฌ์ฉํ๊ฒ ๋ฉ๋๋ค.
- ๋ํดํธ ์ธ์๋ ํจ์์ ์ํ์๋ง ์ง์ ํ ์ ์์ต๋๋ค.
- ๋ํดํธ ์ธ์๋ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ๋ถํฐ ์์ํ์ฌ ์์๋๋ก๋ง ์ง์ ํ ์ ์์ต๋๋ค.
- ๊ฐ์ด๋ฐ ์ธ์๋ค๋ง ๋ณ๋๋ก ๋ํดํธ ์ธ์๋ฅผ ์ง์ ํ ์๋ ์์ต๋๋ค.
๋ํดํธ ์ธ์๊ฐ ์ค์ ๋ ํจ์๋ฅผ ํธ์ถํ ๋์๋ ์ธ์์ ์ ๋ฌ์ ๊ฑด๋๋ธ ์ ์์ต๋๋ค.
ํจ์ ์ค๋ฒ๋ก๋ฉ(function overloading) ๋คํ์ฑ(polymorphism)์ ๊ตฌํ์ ๋๋ค.
๊ฐ์ ์ด๋ฆ์ ํจ์๋ฅผ ์ค๋ณตํ์ฌ ์ ์ํ๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
ํจ์๋ฅผ ๋งค๊ฐ๋ณ์์ ํ์์ ์กฐ๊ธ์ฉ ๋ฌ๋ฆฌํ์ฌ, ํ๋์ ์ด๋ฆ์ผ๋ก ์์ฑํ ์ ์๊ฒ ํด์ฃผ๋ ๊ฒ
ํจ์ ์๊ทธ๋์ฒ(function signature)
ํจ์์ ์ํ์ ๋ช ์๋๋ ๋งค๊ฐ๋ณ์ ๋ฆฌ์คํธ๋ฅผ ๊ฐ๋ฆฌํต๋๋ค.
๋งค๊ฐ๋ณ์์ ๊ฐ์์ ๊ทธ ํ์ ์ด ๋ชจ๋ ๊ฐ๋ค๋ฉด, ์ด ๋ ํจ์์ ์๊ทธ๋์ฒ๋ ๊ฐ๋ค๊ณ ํ ์ ์์ต๋๋ค.
์๋ก ๋ค๋ฅธ ์๊ทธ๋์ฒ๋ฅผ ๊ฐ๋ ์ฌ๋ฌ ํจ์๋ฅผ ๊ฐ์ ์ด๋ฆ์ผ๋ก ์ ์ํ๋ ๊ฒ์ด๋ผ๊ณ ํ ์ ์์ต๋๋ค
์ธ๋ผ์ธ ํจ์
ํจ์๋ฅผ ํธ์ถํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์ ์ฝ๋๋, ํจ์ ํธ์ถ ๊ณผ์ ์ผ๋ก ์๊ธฐ๋ ์ฌ๋ฌ ์ด์ ์ ํฌ๊ธฐํ๊ฒ ๋ฉ๋๋ค.
v์ฝ๋๊ฐ ๋งค์ฐ ์ ์ ํจ์๋ง์ ์ธ๋ผ์ธ ํจ์๋ก ์ ์ธํ๋ ๊ฒ
inline ํจ์์์ํ
๋๋
inline ํจ์์์ ์
inline ํค์๋๋ ํจ์์ ์ํ์ด๋ ํจ์์ ์ ์ ์ด๋ ํ ์ชฝ์๋ง ํ๊ธฐํด๋ ๋๋ฉฐ, ์์ชฝ ๋ค ํ๊ธฐํด๋ ์๊ด์์ต๋๋ค.
์ฌ๊ท ํธ์ถ์ด ํ์ฉ๋์ง ์์ต๋๋ค.
๋งคํฌ๋ก ํจ์์ ์ธ๋ผ์ธ ํจ์
์ผ๋ฐ ํจ์์๋ ๋ฌ๋ฆฌ ๋จ์ ์นํ๋ง์ ํด์ฃผ๋ฏ๋ก, ์ผ๋ฐ ํจ์์ ๋๊ฐ์ ๋ฐฉ์์ผ๋ก ๋์ํ์ง ์์ต๋๋ค.
๋งคํฌ๋ก ํจ์๋ฅผ ์ผ๋ฐ ํจ์์ฒ๋ผ ์ฌ์ฉํ๊ธฐ ์ํด์๋ ๋ชจ๋ ์ธ์๋ฅผ ๊ดํธ({})๋ก ๊ฐ์ธ์ผ๋ง ํฉ๋๋ค.
#define SQR(X) X*X
#define SQR(X) X*X