๋ชฉ์ฐจ
- ๋ฐฐ์ด
- ์ ์ธ
- ์ด๊ธฐํ
- ์ ๊ทผ
- ๋ค์ฐจ์ ๋ฐฐ์ด
- ํฌ์ ํ๋ ฌ ํํ
- ์ฃผ์์ ํฌ์ธํฐ
- ํฌ์ธํฐ
- ํน์ง
- ์ ์ฝ
- ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
- ๋์ ๋ฐฐ์ด(vector)
- ๋ฌธ์์ด
- ์ ์ธ
- ์ด๊ธฐํ
- ํจ์
๋ฐฐ์ด / ๋ฌธ์์ด
๋ฐฐ์ด
๋ฐฐ์ด์ด๋ ๋จ์ผ ์๋ณ์๋ก _๊ฐ์ ์๋ฃํ_์ ์ฌ๋ฌ ๋ณ์๋ฅผ ์ ๊ทผํ ์ ์๊ฒ ํด์ฃผ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
์ ์ธ
c++์์๋ int arr[3];
์ ๊ฐ์ด ์๋ฃํ ๋ฐฐ์ด์ด๋ฆ[๋ฐฐ์ด ๊ธธ์ด];
๋ก ๋ณ์๋ฅผ ์ ์ธํ๋ค. ์ด ๋, ๋๊ดํธ ๋ด์ ์์์ ๊ฐฏ์๋ '์ปดํ์ผ ํ์ ์์'์ฌ์ผํ๋ค. ์์ค์ฝ๋๋ฅผ ์ปดํ์ผํ ๋, ๊ณ ์ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์์์ผํ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ ๋งคํฌ๋ก ๊ธฐํธ ์์ (ex_ #define ARRAY_LEN 5
)๋ ์ด๊ฑฐ์(ex_enum A{ARRAY_LEN = 5}
)๋ ๋ฐฐ์ด์ ๊ธธ์ด๋ก ์ฌ์ฉํ ์ ์๋ค. const
๋ํ ์ปดํ์ผ ์ ๊ณ ์ ๋๋ ์์์ด๋ฏ๋ก ์ฌ์ฉ๊ฐ๋ฅํ๋ค.
c#์์๋ readonly์ const๊ฐ ๊ตฌ๋ถ๋์ด ์คํ์๊ฐ / ์ปดํ์ผ ์๊ฐ์ ๊ณ ์ ๋๋ ์์๋ฅผ ๋ง๋ค์ง๋ง c++์์๋ const๋ง ์กด์ฌํ๋ค.
์๋ ์ ์ธ๋์ด ์๋ ๋ณ์๋ฅผ const ๋ณ์๋ก ๋ค์ ๋ฐ๋๋ค๋ฉด, c++์์๋ ์คํ์๊ฐ ์์๋ก ์ฒ๋ฆฌ๋๋ค. ๋ฐ๋ผ์ ์ด ๊ฒฝ์ฐ์๋ ๋ฐฐ์ด์ ๊ธธ์ด๋ก ์ฌ์ฉํ ์ ์๋ค.
ex_
int tmp = 5; const int len = tmp; // len์ด ๋ฐํ์ ์์
์ด๊ธฐํ
๋ฐฐ์ด์ ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํํด์ค ์๋ ์๊ณ , ๋ฐ๋ก ์งํํ ์๋ ์๋ค. ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํ๋ฅผ ํด์ค๋ค๋ฉด, ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ ๋ ฅํ ํ์ ์์ด ์ด๊ธฐํ๋ ์์์ ๊ฐฏ์๋ก ๊ธธ์ด๊ฐ ๊ฒฐ์ ๋๋ค.
ex_int arr[]={1,2,3}; // ๊ธธ์ด 3
๋ฐฐ์ด์ ์์๋ค์ ์ด๊ธฐํ์ ๋ํ ๋ณ๋ค๋ฅธ ์ฝ๋๊ฐ ์์ผ๋ฉด ์ฐ๋ ๊ธฐ๊ฐ์ผ๋ก, ์ด๊ธฐํํด์ค ์์๊ฐ ํ๋๋ผ๋ ์๋ค๋ฉด ๋๋จธ์ง ์์๋ค์ 0์ผ๋ก ์ด๊ธฐํ๋๋ค.
ex_
int arr[5]={1,2,3}; // 1,2,3,0,0
int arr[5]; // ์ฐ๋ ๊ธฐ ๊ฐ
int arr[5]={0}; // 0,0,0,0,0
๋ฐฐ์ด์ ๊ธฐ๋ณธ๊ฐ์ ์ฑ์ฐ๋ ์ฌ๋ฌ ๋ฐฉ์์ ์๋์ ๊ธ์ ์ ๋ฆฌํด๋์๋ค.
์ ๊ทผ
๊ฐ ์์๋ค์ 0๋ถํฐ ์์ํ๋ offset์ ์ด์ฉํ์ฌ arr[0]
,arr[1]
๊ณผ ๊ฐ์ด ์ ๊ทผํ๋ค.
๋ค์ฐจ์ ๋ฐฐ์ด
๋ฐฐ์ด์ ์ฐจ์์ ๋๋ ค๊ฐ๋ฉฐ ์ฌ์ฉํ ์ ์๋ค. ์ ์ธ์ int arr[2][5]
์ ๊ฐ์ด n์ฐจ์์ ๊ฒฝ์ฐ n๊ฐ์ ๋๊ดํธ๋ฅผ ์ฌ์ฉํ์ฌ ๋ํ๋ด๋ฉฐ, ๋งจ ์์ ๋๊ดํธ ์์ ๊ธธ์ด ์ ์ธ ๋ชจ๋ ๊ธธ์ด๋ฅผ ํ์ํด๋์ด์ผํ๋ค.
ex_ int arr[][5]; // ์๋ต๋ ๊ธธ์ด๋ ์ด๊ธฐํ ์ ๊ฒฐ์ ๋๋ค.
์ค์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋ ๋๋ 1์ฐจ์ ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฉ๋ชจ๋ฆฌ ์์์ ์ฐ์ํด์ ์ ์ฅ๋๋๋ฐ, ์ด ๋ ๋ค์ ์๋ ๋๊ดํธ๋ฅผ ์ฐ์ ์ ์ผ๋ก ๋ฐฐ์น๋๋ค. ์์ ์์ ์์๋ ํ ์ฐ์ ์์ ๋ฐฉ์์ผ๋ก ๋ฉ๋ชจ๋ฆฌ์ ๋ฐฐ์น๋์๋ค.
์ด๊ธฐํ ์ 1์ฐจ์ ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก int arr[2][3]={1,2,3,4,5,6};
์์ฐจ์ ์ผ๋ก ๋ค์ด๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ ์ด์ค ์๋ ์๊ณ , ๋
ผ๋ฆฌ์ ์ธ ๊ตฌ์กฐ๋ก๋ ๊ฐ๋ฅํ๋ค.
int arr[2][3]={
{1,2,3},
{4,5,6}
}
๋ฐฐ์ ๋๋ ๋ฐฐ์ด์ ์์ ๊ฐ๋ 1์ฐจ์ ๋ฐฐ์ด๊ณผ ๊ฐ์ ๋ก์ง์ด๋ค.
ํฌ์ ํ๋ ฌ ํํ
- ๋ชจ๋ ์์๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ
- -) ๊ณต๊ฐ์ด ๋ญ๋น๋๋ค.
- +) ํ๋ ฌ์ ์ฐ์ฐ๋ค์ ๊ฐ๋จํ๊ฒ ๊ตฌํํ ์ ์๋ค.
- 0์ด ์๋ ์์๋ง ์ ์ฅํ๋ ๋ฐฉ๋ฒ (ํ, ์ด, ๊ฐ ์ ์ ์ฅ)
- -) ํ๋ ฌ ์ฐ์ฐ๋ค์ ๊ตฌํ์ด ๋ณต์กํด์ง๋ค.
- +) ๊ณต๊ฐ์ด ์ ์ฝ๋๋ค.
์ฃผ์์ ํฌ์ธํฐ
๋ฐฐ์ด์ ์ด๋ฆ์ ํด๋น ๋ฐฐ์ด ์๋ฃ๊ตฌ์กฐ๊ฐ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ์ ์์์ฃผ์๋ฅผ ์๋ฏธํ๋ค. ์ด ์ฃผ์๋ฅผ ์ด์ฉํ์ฌ ์ฆ๊ฐ ๊ฐ์ ์ฐ์ฐ์๋ก ๋ฐฐ์ด์ ์ ํ ์์๋ฅผ ๋ฐ์์ฌ ์ ์๋ค. ์ฆ, ์ฆ๊ฐ ์ฐ์ฐ์๊ฐ ๋ฐฐ์ด์ ๊ธฐ์ด ์๋ฃํ์ ๋จ์๋ก ์์ฉํ๋ค. ์ด๋ ์์๋ค์ด ๋ฉ๋ชจ๋ฆฌ ์์ ์ฐ์ํ๊ฒ ํ ๋น๋๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฅํ๋ฉฐ, ์ฆ๊ฐ ์ฐ์ฐ์๋ ๋ฐ๋ณต๋ฌธ๊ณผ ํจ๊ป ์ ์ฉํ๊ฒ ์ฐ์ธ๋ค. ์๋๋ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ถ๋ ฅํ๋ ์ฝ๋์ด๋ค.
int arr[5] = { 1,2,3,4,5 };
for (int i = 0; i < sizeof(arr)/sizeof(int); i++) {
cout << *(arr)+i; // 12345
}
๋ฉ๋ชจ๋ฆฌ ์ ์ฃผ์๋ฅผ ๋ ํญ๋๊ฒ ํ์ฉํ๋ ค๋ฉด ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
(ํฌ์ธํฐ ์ ๋ฆฌ)
ํน์ง
์ฐ๊ฒฐ ๋ฆฌ์คํธ์๋ ๋ฌ๋ฆฌ offset์ ํตํด ์์์ ๊ทผํ ์ ์๋ค.
์ ์ฝ
์ง๊ธ๊น์ง ์ดํด๋ณธ array, ์ฆ ๊ณ ์ ๋ฐฐ์ด์ ์ปดํ์ผ์๊ฐ์ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๊ธฐ ๋๋ฌธ์ ์คํ์๊ฐ์ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๊ฒฐ์ ํ ์ ์๋ค. ๋ฐ๋ผ์ ๊ธฐ์กด์๋ _๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น_์ ์ฌ์ฉํด์ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์คํ์๊ฐ์ ๊ฒฐ์ ํ๋๋ฐ, ํ์ฌ c++์ _๋์ ๋ฐฐ์ด_์ด๋ผ๋ ๊ฐ๋ ๋ํ ์ง์ํ๋ค.
๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น
์ผ๋ฐ์ ์ผ๋ก ๋ณ์๋ ์ปดํ์ผ ๋จ๊ณ์์ ๋ณ์์ ํฌ๊ธฐ๊ฐ ์ ํด์ง๋ค. ์ด ํ, ์คํ์๊ฐ์ ๋ณ์์ ํฌ๊ธฐ๋ฅผ ์ ํ๊ธฐ ์ํด ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ด ๋ฑ์ฅํ๋ค. ๋ค์ ๋ฑ์ฅํ ๋์ ๋ฐฐ์ด์ ์คํ์๊ฐ์ ์ ์ ์ผ๋ก ๋ณ์์ ํฌ๊ธฐ๋ฅผ ์ ํด์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ '๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น'๊ณผ ๋ฌ๋ฆฌ ๋ณ์์ ํฌ๊ธฐ ์์ฒด๋ ๊ณ์ํด์ ๋ณํํ ์ ์๋ ๊ตฌ์กฐ๋ผ๋ ์ ์์ ๊ตฌ๋ถ๋๋ค. ๋ฉ๋ชจ๋ฆฌ ๋์ ํ ๋น ์ heap ์์ญ์ ๋ณ์๊ฐ ํ ๋น๋๋ค.
๋๋ถ๋ถ malloc ํจ์๋ฅผ ์ด์ฉํด์ heap ์์ญ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น๋ฐ์ ํ, free ๋ช ๋ น์ด๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํด์ค๋ค.
int* a = (int*)malloc(sizeof(int) * 5);
cout << _msize(a); // 20
free(a);
cout << _msize(a); // error
sizeof๋ก a์ ํฌ๊ธฐ๋ฅผ ์ธก์ ํ๋ ค ํ๋ฉด int* ํ์ธ ์ฃผ์์ ํฌ๊ธฐ๊ฐ ๋์ค๊ธฐ ๋๋ฌธ์, ์ค์ heap์์ ์ฌ์ฉํ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ์ธก์ ํ๋ ค๋ฉด _msize๋ฅผ ์ด์ฉํด์ผํ๋ค.
์์ธํ ์ค๋ช ์ ๋ฐ๋ก ํฌ์คํ ํ๊ฒ ๋ค.
(๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์ ๋ฆฌ)
(๋ฉ๋ชจ๋ฆฌ ์์ญ ์ ๋ฆฌ ํ์)
(๊ฐ๋น์ง ์ฝ๋ ์
/ ํ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ์ ๋ฆฌ ํ์)
๋์ ๋ฐฐ์ด (vector)
vector๋ ๊ธธ์ด๊ฐ ๋ณํ ์ ์๋ ๋์ ์ธ ๋ฐฐ์ด๋ก์จ ๋ณ๋์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํฌํจํ ํ ์ฌ์ฉํ ์ ์๋ค. ๋ฐฐ์ด๊ณผ ๊ฐ์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋๊ธฐ ๋๋ฌธ์, offset์ ์ด์ฉํ์ฌ ์์์ ๊ทผํ ์ ์๋ค. ๋ฐ๋ผ์ vector๋ ์์ฐจ์ ๋์ ์ปจํ ์ด๋์ด๋ค.
์คํ์๊ฐ ์ค ์์๋ฅผ ์ถ๊ฐํ์ฌ ์ฌ์ด์ฆ๊ฐ ๋์ด๋๋ฉด ์๋ก์ด ๋ฐฐ์ด์ ํ ๋นํ ํ ๋ชจ๋ ์์๋ฅผ ์ด๋์ํค๋ ๋ฐฉ๋ฒ์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ฌ์ฉํ์ง๋ง, ์ด๋ก ์ธํด ๋ฐ์ํ๋ ์ค๋ฒํค๋๋ฅผ ์ค์ด๊ธฐ ์ํด ํ ๋น ์ ์ฌ์ ๊ณต๊ฐ์ ๋๋ค.
๋ค๋ฅธ ๋์ /์์ฐจ ์ปจํ ์ด๋์ธ deque, list, forward-list์ ๋น๊ตํ๋ฉด, ์ปจํ ์ด๋ end์์์ ์ฝ์ / ์ญ์ ์ฐ์ฐ์ ํจ์จ์ ์ด์ง๋ง ๋ค๋ฅธ ์์น์์์ ์ฐ์ฐ์ ๋นํจ์จ์ ์ด๋ค.
<์์ฑ>
import <vector>;
๋ก c++ STL์ธ vector๋ฅผ ๋ถ๋ฌ์จ ํ, vector<int> vec;
๊ณผ ๊ฐ์ด vector<์๋ฃํ> ๋ฒกํฐ์ด๋ฆ
์ผ๋ก ๋ณ์๋ฅผ ์์ฑํ๋ค.
STL : Standard Template Library (ํ์ค ํ ํ๋ฆฟ ๋ผ์ด๋ธ๋ฌ๋ฆฌ)
<์ด๊ธฐํ>
vector์ ๊ธฐ๋ณธ๊ฐ์ ์ฑ์ฐ๋ ์ฌ๋ฌ ๋ฐฉ์์ ์๋์ ๊ธ์ ์ ๋ฆฌํด๋์๋ค.
(๊ธฐ๋ณธ๊ฐ ์ฑ์ฐ๊ธฐ ๋งํฌ)
์์ธํ ์ค๋ช ์ STL์ ๋ฐ๋ก ์ ๋ฆฌํด์ ์ฌ๋ฆฌ๊ฒ ๋ค.
(STL ์ ๋ฆฌ)
๋ฌธ์์ด
๋ฌธ์์ด์ char ์๋ฃํ์ ๋ฐฐ์ด์ด๋ค. ์ ํํ ๋งํ์๋ฉด bytes์ ๋ฐฐ์ด์ธ basic_string์ ํ ์๋ก charํ์ ์ฌ์ฉํ๋ string class๊ฐ ์๊ณ ์ด๊ฒ์ด ๋ฌธ์์ด์ด๋ค. UTF-8๊ณผ ๊ฐ์ multi-byte๋ ์ฌ๋ฌ ๊ธธ์ด์ char ์๋ฃํ์ ๋ค๋ฃจ๋๋ผ๋, string class์ ๋ฉค๋ฒ ํจ์๋ค์ byte๋จ์๋ก ๋์ํ๊ธฐ ๋๋ฌธ์ ์ธ์ฝ๋ฉ์๋ ์ ์ฝ์ด ์๋ค.
(์ธ์ฝ๋ฉ ์ข
๋ฅ ์ ๋ฆฌ)
C++์์๋ ์ฃผ๋ก import <string>;
์ผ๋ก string ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๋ถ๋ฌ์์ ์ฌ์ฉํ๋ค.
์ ์ธ
string ๋ณ์์ด๋ฆ;
๊ณผ ๊ฐ์ด ์ ์ธํ๋ค.
์ด๊ธฐํ
์ด๊ธฐํ๋ ์ ์ธ๊ณผ ๋์์ constructor์๊ฒ ์ด๊ธฐํํ ๋ฌธ์์ด์ ๋๊ฒจ์ค ์๋ ์๊ณ , ๋ฐ๋ก ์ด๊ธฐํํ ์๋ ์๋ค. constructor์๋ ๋๊ดํธ(""
)๋ก ๋ฌถ์ธ ๋ฌธ์์ด ๋ฟ๋ง ์๋๋ผ ๋ค๋ฅธ string ๊ฐ์ฒด๋ ์ ๋ฌ๋ ์ ์๋ค.
ex_ string s = "hi"; string s("hi"); string s1(s);
constructor์ (์ซ์, ๋ฌธ์)์ ๋๊ธฐ๋ฉด ํด๋น ๋ฌธ์์ด์ ์ซ์๋งํผ ๋ฐ๋ณตํด์ ์ ์ฅํ๋ฉฐ, (๋ฌธ์์ด, ์ซ์1, ์ซ์2)๋ฅผ ๋๊ธฐ๋ฉด ํด๋น ๋ฌธ์์ด์ offset์ด ์ซ์1์ธ ๊ณณ๋ถํฐ ์ซ์2 ๋งํผ ์ ์ฅํ๋ค. ์ ์(ๅ่ )์ ์ํฉ์์ ๋ฌธ์์๋ ์ซ์๊ฐ ๋ค์ด๊ฐ๋ ๋์ง๋ง, ์ด๋ ์์คํค์ฝ๋์ ์ํด ๋ณํ๋์ด ์ ์ฅ๋๋ค.
ex_ string s1(10,'x'); // xxxxxxxxxx
string s1(10,42); // **********
ํจ์
- size : ๋ฌธ์์ด์ ํฌ๊ธฐ๋ฅผ byte ๋จ์๋ก return
- length : size ํจ์์ ๊ฐ์
- [] : ๊ฐ ์์์ ์ ๊ทผ
- at : [] ์ฐ์ฐ์์ ๊ฐ์
- back / front : ๋ง์ง๋ง, ์ฒ์ ๋ฌธ์์ ์ ๊ทผ
- append : ๊ธฐ์กด ๋ฌธ์์ด์ ๋ํ๊ธฐ
- += : append ํจ์์ ๊ฐ์
- push_back /pop_back : ๋ฌธ์ ํ๋๋ฅผ ๊ธฐ์กด ๋ฌธ์์ด์ ๋ํ๊ธฐ
- assign : ๋๊ฒจ์ค ๋งค๊ฐ๋ณ์๋ฅผ stringํ ํ์ฌ ๋ณ์์ ๋ฃ๊ธฐ
string str; str.assign("heeeun is cool",6); // heeeun
string str; str.assign(10,*); // **********
- insert : ๋๊ฒจ๋ฐ์ ์์น์ ๋๊ฒจ๋ฐ์ ๋ฌธ์์ด ์ฝ์
- erase : ๋๊ฒจ๋ฐ์ ์์น๋ถํฐ ๋๊ฒจ๋ฐ์ ๋ฌธ์๊ฐฏ์๋งํผ ์ญ์
- find : ๋๊ฒจ๋ฐ์ ๋ฌธ์์ด์ ์์ํ๋ ์์น ๋ฐํ, ์๋ค๋ฉด npos ๋ฐํ
- compare : ๋๊ฒจ๋ฐ์ ๋ฌธ์์ด๊ณผ ๊ธฐ์กด์ ๋ฌธ์์ด ๋น๊ต
- 0: ๊ฐ์
- substr : ๋๊ฒจ๋ฐ์ ์์น์์ ๋๊ฒจ๋ฐ์ ๋ฌธ์๊ฐฏ์๋งํผ ์๋ผ์ ๋ฐํ
Comment