์์ฑ์ : ["Lovelyboy^_^"]
๋ฒกํฐ๋ฅผ ์ฌ์ฉํด๋ณด๊ธฐ ์ํ ๊ธฐ๋ณธ ์ ํ (์์ผ๋ก ํธ์์ ๋ฐ๋ง๋ก ํฉ๋๋ค.) ¶
~cpp #include <iostream> #include <vector> using namespace std; int main() { return 0; }
- ๋ช ๋ฒ ์จ๋ณธ๊ฒฐ๊ณผ vector๋ฅผ ๊ฐ์ฅ ์์ฃผ ์ฐ๊ฒ ๋๋ค. vector๋ง ๋ฐฐ์ ๋์ผ๋ฉด list๋ deque๊ฐ์๊ฒ์ ๋๊ฐ์ด ์ธ์ ์๋ค. vector๋ฅผ ์ฐ๊ธฐ ์ํ vector ํค๋๋ฅผ ํฌํจ์์ผ์ค์ผํ๋ค. STL์ ์ธ๋ผ๋ฉด #include <iostream.h> ์ด๋ ๊ฒ ์ฐ๋ฉด ๊ท์ฐฎ๋ค. ๋์ค์ std::cout, std:vector ์ด๋ฐ ์ฝ์ง์ ํด์ค์ผ ํ๋ค. ์ด๋ ๊ฒ ํ๊ธฐ ์ซ์ผ๋ฉด ๊ฑ ์ฐ๋๋๋ก using namespace std ์ด๊ฑฐ ์จ์ฃผ์.
intํ ๋ฐฐ์ด์ intํ ๋ฒกํฐ์ ๋ณต์ฌํด ๋ณด์. ¶
~cpp #include <iostream> #include <vector> using namespace std; typedef vector<int>::iterator VIIT; // Objectํ์ด๋ผ๋ฉด typedef vector<Object>::iterator VOIT; int main() { int ar[10] = {45,12,76,43,75,32,85,32,19,98}; // Objectํ์ด๋ผ๋ฉด Object ar[10]={...}; vector<int> v(&ar[0], &ar[10]); // Objectํ์ด๋ผ๋ฉด vector<Object> v(...); // ar๋ฐฐ์ด์ 0๋ฒ ์์๋ถํฐ 9๋ฒ์์๊น์ง๋ฅผ // v๋ฒกํฐ์๋ค๊ฐ ๋ณต์ฌ [0,10) ์ฒ์์ ํ๊ตฌ๊ฐ // ๋ง์ง๋ง์ ๊ฐ๊ตฌ๊ฐ์ด๋ผ๋๊ฑฐ ๋ช ์ฌ! for(VIIT it = v.begin() ; it != v.end(); ++it) // ์ ๋๋ก ๋ณต์ฌ๋๋ ๊ฒฐ๊ณผ ๋ณด๊ธฐ cout << *it << endl; return 0; }
- typedef์ผ๋ก ์์ํ๋ ๋ถ๋ถ๋ถํฐ ๋ณด์. ์ผ๋จ ๋ฐ๋ณต์๋ผ๋ ๊ฐ๋
์ ์์์ผ ๋๋๋ฐ, ์ฌ์ค์ ๋๋ ์ ๋ชจ๋ฅธ๋ค.
; ์ฒ์ ๋ฐฐ์ธ๋ ๊ทธ๋ฅ ์ผ์ข ์ ํฌ์ธํฐ๋ผ๋ ๊ฐ๋ ์ผ๋ก ๋ณด๋ฉด ๋๋ค. vector<int>::iterator ํ๋ฉด intํ vector์ ์ ์ฅ๋์ด ์๋ ๊ฐ์ ์ํํ๊ธฐ ์ํ ๋ฐ๋ณต์์ด๋ค. ๋น์ทํ๊ฒ vector<Object>>::iterator ํ๋ฉด Objectํ vector์ ์ ์ฅ๋์ด ์๋ ๊ฐ์ ์ํํ๊ธฐ ์ํ ๋ฐ๋ณต์๊ฒ ์ง ๋ญ; ๊ฐ๋จํ๊ฒ ์ค์ฌ์ธ๋ผ๊ณ typedefํด์ฃผ๋ ๊ฒ์ด๋ค. ํ๊ธฐ ์ซ์ผ๋ฉด ์ํด์ค๋ ๋๋ค.--;
- ๋ค์์ vector<int> v~~ ์ด๋ถ๋ถ์ ๋ณด์. vector<T> ์๋ ์์ฑ์๊ฐ ์ฌ๋ฟ ์๋ค. ๊ทธ ์ค์ ํ๋๋ก, ๋ฐฐ์ด์ ๋ณต์ฌํ๋ ์์ฑ์๋ฅผ ์จ๋ณด์. ๊ทธ๋ฅ ์ฐ๋๋ฒ๋ง ๋ณด์. ๋จ์ํ ๋ฐฐ์ด ๋ณต์ฌํ๋ ๊ฑฐ๋ค. C++ ๊ณต๋ถํ๋ค๋ฉด ์ฑ์๋น 10์ฅ์ธ๊ฐ 11์ฅ์ ๋ณต์ฌ ์์ฑ์๋ผ๊ณ ๋์ฌ๊ฒ์ด๋ค. ๊ทธ๊ฑฐ๋ค.
; ๊ทธ๋ฅ 2๋ฒ ์์์์ 5๋ฒ์์๊น์ง ๋ณต์ฌํ๊ณ ์ถ๋ค. ํ๋ฉด vector<int> v(&ar2, &ar6) ์ด๋ ๊ฒ ํ๋ฉด ๋๊ฒ ์ง?(์ด์งธ ์ข ๊ฑฐ๋งํด ๋ณด์ธ๋ค.๋ง์ง๋ง์ ๊ฐ๊ตฌ๊ฐ์ด๋ผ๋๊ฑธ ๋ช ์ฌํ๊ธฐ ๋ฐ๋๋ค.
- for ๋ถ๋ถ์ ๋ณด๋ฉด ์์์ typedef ํด์ค VIIT ํ์ผ๋ก ์ํํ๊ณ ์๋๊ฒ์ ๋ณผ์ ์๋ค. vector<T>์ ๋ฉค๋ฒ์๋ ์ด๋ผ ๋ง์ ๋ฉค๋ฒํจ์๊ฐ ์๋ค. ๊ทธ์ค์ begin() ์ ๋งจ ์ฒ์ ์์น๋ฅผ ๊ฐ๋ฅดํค๋ ๋ฐ๋ณต์๋ฅผ ๋ฆฌํดํด์ค๋ค. ๋น์ฐํ end()๋ ๋งจ ๋ ์์น๋ฅผ ๊ฐ๋ฅดํค๋ ๋ฐ๋ณต์๋ฅผ ๋ฆฌํดํด์ฃผ๋ ๊ฑฐ๋ผ๊ณ ์๊ฐํ๊ฒ ์ง๋ง ์๋๋ค.--; ์ ํํ๊ฒ๋ '๋งจ ๋์์น๋ฅผ ๊ฐ๋ฅดํค๋ ๋ถ๋ถ์์ ํ ์นธ ๋๊ฐ ๋ฐ๋ณต์๋ฅผ ๋ฆฌํด'ํด์ฃผ๋ ๊ฑฐ๋ค. ์ ๊ทธ๋ ๊ฒ ๋ง๋ค์๋์ง๋ ๋ํํ
๋ฌป์ง ๋ง๋ผ. ์๊น ๋ฐ๋ณต์๋ ํฌ์ธํฐ๋ผ๊ณ ์๊ฐํ๋ผ ํ๋ค. ์ญ์ ๊ทธ ํฌ์ธํฐ๊ฐ ๊ฐ๋ฅดํค๋ ๊ฐ์ ๋ณด๋ ค๋ฉด ๋น์ฐํ ์์ * ์ ๋ถ์ฌ์ผ๊ฒ ์ง.
๋ฒกํฐ๋ก ๋์ ๋ฐฐ์ด ์ฐ๊ธฐ ¶
- ์๋ง ์ด๋ณด์๋ ๋๊ตฌ๋ ํ๋ ์ค์๊ฐ ์์ ๊ฒ์ด๋ค. ๋ณธ์ธ๋ ๊ทธ๋ฌ๋ค.--;
- ์์ ๋ก ์ซ์๋ฅผ ๋ช๊ฐ ์
๋ ฅ๋ฐ๋ ๊ฐฏ์๋ฅผ ์
๋ ฅ๋ฐ์ ๋งํผ, ๊ทธ๋งํผ ๋ฃจํ๋ฅผ ๋๋ ค์ ์ซ์๋ฅผ ์
๋ ฅ๋ฐ๋ ๊ฑธ ๋ณด์.
~cpp #include <iostream> using namespace std; int main() { int num; cin >> num; int ar[num]; for(int i = 0 ; i < num ; ++i) { cout << i+1 << "๋ฒใ คใ ใ ใ ค" << endl; cin >> ar[i]; } return 0; }
- ์ ์ด๋๊ฐ ํ๋ ธ์๊น? ๊ณต๋ถ ์ข ํ์ผ๋ฉด ๋๊ตฌ๋ ์์ ์๋ ์ฝ์ง์ด์ง๋ง, c++ ๋ฐฐ์ด์ง ๋ช์ฃผ๋ฐ์ ์๋์์๋ ๋๋ก์๋ ์ ๊ฒ ์ ํ๋ ธ๋์ง ์์๊ฐ ์์๋ค.
- ์์ธ์ ๊ทธ๊ฑฐ๋ค. ์ ์ ๋ฐฐ์ด์ ์ปดํ์ผ ์์ ํฌ๊ธฐ๋ฅผ ์ก๋๋ค. ์
๋ ฅ๋ฐ๋ ๋ถ๋ถ์ ์ปดํ์ผ ๋๋๊ณ ์คํํ ๋ ํฌ๊ธฐ๋ฅผ ์
๋ ฅ๋ฐ๋๋ค. ์ปดํ์ผ๋ฌ๋ ๋น์ฐํ ํฌ๊ธฐ๋ฅผ ์์ ์์ผ๋ ์๋ฌ๊ฐ ๋๊ฒ๋๋ค. ๊ณ ์ณ ๋ณด์.
~cpp #include <iostream> using namespace std; int main() { int num; cin >> num; int* ar = new int[num]; for(int i = 0 ; i < num ; ++i) { cout << i+1 << "๋ฒใ คใ ใ ใ ค : "; cin >> ar[i]; } delete [] ar; return 0; }
- ์ฐ๋ฆฌ๊ฐ ์ฌํ๊น์ง ๋ฐฐ์ด ๊ฑฐ๋ง ์จ๋ณด๋ฉด ์ด๋ ๊ฒ ๊ณ ์น ์ ์๋ค. ๊ทธ ์ ๋ช
-_-ํ ๋์ ๋ฐฐ์ด์ด๋ค.--; ์.. delete [] ์ ๊ฑฐ ๋ณด๊ธฐ ์ซ์ง ์์๊ฐ? c์ c++์ ๊ณ ์ง์ ์ธ ๋ฌธ์ ์ ์ด ๋ฐ๋ก ์ ๊ฑฐ๋ค. ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ํ๋ก๊ทธ๋๋จธ๊ฐ ํด์ค์ผ ํ๋ค๋๊ฑฐ.. ์๋ฐ ๊ฐ์๊ฑด ์ง๊ฐ ์์์ delete ํด์ฃผ์ง๋ง.. c๋ c++์์ delete ์ํด์ฃผ๋ฉด.. X๋๋ ๊ผด์ ๋ณผ์ ์๋ค. (๋ณธ์ธ์ด ํ๋ฒ ๊ฒฝํํด ๋ดค๋ค.) ๊ทธ๋์ ์ ๋์์ธ๋ ํด๋์ค๋ ํด๋์ค ๋ด์์ ์์์ ์์ ์ค์ผ ํ๋ค. ๋ฐ๋ก vector๋ฅผ ์ฐ๋ฉด ์ ์ง์ ์ํด์ค๋ ๋๋ค. ๋ ๊ณ ์ณ๋ณด์.
~cpp #include <iostream> #include <vector> using namespace std; int main() { int num; cin >> num; vector<int> ar(num); for(int i = 0 ; i < ar.size() ; ++i) { cout << i+1 << "๋ฒใ คใ ใ ใ ค : "; cin >> ar[i]; } return 0; }
- vector<int>... ๋ถ๋ถ์ ๋ณด๋ฉด ๋ ๋ค๋ฅธ ์์ฑ์๊ฐ ๋ณด์ธ๋ค. ์ธ์๋ก ์ซ์ ํ๋๋ฅผ ๋ฐ๋๋ค. ๊ทธ ๋งํผ ๋์ ํ ๋น ํด์ค๋ค๋ ๋ป์ด๋ค. delete? ๊ทธ๋ด๊ฑฐ ์ํด์ค๋ ๋๋ค. ํ๋ก๊ทธ๋จ ๋๋๋ฉด์ intํ ๋ฒกํฐ ar์ด ์๋ฉธ๋๋ฉด์ ์์์ ์์ ์ค๋ค.
- ๋ ํ๋ ์ดํด๋ณผ๊ฒ ์๋ค. ์๊น ์์ ์์๋ ๋ฐ๋ณต์๋ก ๋ฒกํฐ ๋ด๋ถ๋ฅผ ์ํํ์๋ค. ํ์ง๋ง ๋ฒกํฐ๋ ์์์ ๊ทผ์ ํ์ฉํ๋ค. ๋ฐฐ์ด์ฒ๋ผ ar4 ์ด๋ฐ์์ผ๋ก ์ธ์ ์๋จ ๋ง์ด๋ค. ํธํ๋๋ก ์จ์ฃผ์.
๋ฒกํฐ๋ก 2์ฐจ์ ๋์ ๋ฐฐ์ด ์ฐ๊ธฐ ¶
- ๋ฐ๋ธ์ค ์บ ํ๋ ์ ๋ช
ํด์ง 2์ฐจ์ ๋์ ๋ฐฐ์ด ์ฐ๊ธฐ๋ค.
- ํ์ค์นผ ์ผ๊ฐํ ์์ ํ ๋ ๋ฐ๋ธํผ์์์ ์ฐ๋๋ฒ ๋ฐฐ์์ ์ด์ฌํ ์ฐ๋ค๊ฐ ๋ฐ๋ธ์ค ์บ ํ๋ ์ฌ๋์ด๊ฐ ํผ๋จ๋ ธ๋ค. 1ํ๊ธฐ ๋ด๋ด ํธํด์ ์ข๋ค๊ณ ์จ๋๋๋ฐ.. ์ง๊ธ ๋ณด๋ฉด ๋ด๊ฐ ์ ๊ฑธ ์ ์ฐ๊ณ ์์์๊น ํ๋ ์๊ฐ์ด ๋ ๋ค.
- vector๋ก ๊ฐ๋จํ ํด๊ฒฐ์ด ๊ฐ๋ฅํ๋ค. See also RandomWalk2/Vector๋ก2์ฐจ์๋์ ๋ฐฐ์ด๋ง๋ค๊ธฐ
- resize() ๋ฉ์๋๋ ๋ฒกํฐ์ ํฌ๊ธฐ๋ฅผ ๋ค์ ์ก์์ฃผ๋ ์ญํ ์ ํ๋ค. ์ ์ฐ์
Pointer๋ฅผ ์ ์ฅํ๋ Container ¶
- container ์ ๊ฐ์ด ์ ์ฅ๋ ๋๋ ๋ณต์ฌ ๊ณผ์ ์ด ์ํ๋๋ค. ๊ทธ๋์ ๊ฐ์ด ๊ฐ๋จํ int, doubleํ ์ ๋ํ containter๋ ๊ทธ๋ ๊ฒ ๋ฌธ์ ๊ฐ ๋์ง ์๋๋ค.
- ๋ฉ์น๊ฐ ํฐ ์๋ฃํ์ container์ ์ ์ฅํ ๋ ๋ง๋ค ๋ณต์ฌ๊ฐ ์ํ๋๋ค๋ฉด, ๋ง์ ๋ญ๋น๊ฐ ๋ฐ์ํ๋ค.
- ์ฌ๊ธฐ์ ์ก๋ด ํ๋. ๊ฐ์ฒด๋ฅผ parameter๋ก ๋๊ธธ๋๋ ๋ณต์ฌ๊ฐ ์ํ๋์ง ์๋ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ์.
~cpp Func(const Obj& obj)
- ์ฌ๊ธฐ์ ์ก๋ด ํ๋. ๊ฐ์ฒด๋ฅผ parameter๋ก ๋๊ธธ๋๋ ๋ณต์ฌ๊ฐ ์ํ๋์ง ์๋ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ์.
- ๊ทธ๋์ pointer๋ง์ ์ด์ฉํด์ ์ ์ฅํ์. ํ์ง๋ง ์ธ๋ชจ ์๋ ๊ฐ์ฒด๋ ์ฐ๋ฆฌ๊ฐ ์ง์์ค์ผ ํ๋ค. ํฌ์ธํฐ๋ฅผ ๋ฃ์ด์ค๋์๋, ์ปจํ
์ด๋๊ฐ ์๋ฉธ๋ ๋๋ ํฌ์ธํฐ๋ค์ ์ง์์ง๊ฒ ์ง๋ง. ๊ทธ ํฌ์ธํฐ๋ค์ด ๊ฐ๋ฅดํค๋ ๊ฐ๋ค์ ์ง์์ง์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
- ๋ค์ ์์ ๋ pointer๋ก ์๋ฃ๋ฅผ ๋ฃ๊ณ , ์ง์ฐ๋ ์์ ์ด๋ค.
~cpp #include <iostream> #include <string> #include <vector> using namespace std; class Obj { private: int a; string c; public: Obj(int n, const string& str) : a(n), c(str) {} void showMember() { cout << a << " " << c << endl; } }; typedef vector<Obj*>::iterator VOIT; int main() { vector<Obj*> v; // ํฌ์ธํฐ๋ฅผ ์ ์ฅํ๋ vector // ๋ฒกํฐ์ Obj๊ฐ์ฒด๋ค์ ํฌ์ธํฐ๋ฅผ ๋ฃ๋๋ค. v.push_back(new Obj(1, "๊ธธ๋")); v.push_back(new Obj(3, "ํ์ค")); v.push_back(new Obj(5, "์ ๋ง")); // ์ํํ๋ฉด์ showMember ๋ฉ์๋ ํธ์ถํ๊ณ for(VOIT it = v.begin() ; it != v.end() ; ++it) (*it)->showMember(); // ์ํํ๋ฉด์ ๊ฐ๋ฆฌํค๋ ๊ฐ๋ค์ ์ง์ด๋ค. for(it = v.begin() ; it != v.end() ; ++it) delete *it; v.clear(); return 0; }
ํ๊ณ ์ถ์ ๋ง ¶
- ํ . ๋ณ๋ฃจ ์ด๋ ค์ด๊ฑด ์๊ฒ ์ง
- ์ด๊ฒ ์ ๊ฐ ์๊ณ ์๋ STL์ ๋ํ ๊ฒ๋๋ค. ๋๋จธ์ง๋ ๋ ์์ธํ ์๊ณ ์ถ์ผ์ ๋ถ์ ์ฑ
์ ๋ณด์๋ ์ง..
; MSDN์ ์ฐธ๊ณ ํ์ธ์. ๊ทผ๋ฐ ์ด์ ๋๋ง ์์๋.. ์ ๋งํ๊ฑด ๋ค ํฉ๋๋ค. C++๋ง๋ ๊ทธ ์ด๋ฆ ์ด๋ ค์ด ์ฌ๋ BJar... Str...(์ด ์ฌ๋์ด ์ฐ๊ณ ์ถ์ ๊ธฐ๋ฅ๋ง ์ฐ๋ฌ๊ฑฐ๋ ์--; ์๋ฐ๊ฐ ์ฐ๊ธฐ๋ ์ฌ์๋ ์ญ์ ๋ c++์ด ์ข๋ค.
- ๋
ธํ์ฌ์์ ๋งํ๋ ๊ฑด๋ฐ.. ํจ์๋ก ๊ฐ์ฒด๋ฅผ ๋๊ธธ๋๋ ๊ผญ ์ฐธ์กฐ! ์ฐธ์กฐ! ์
๋๋ค. ๊ฐ์ด ์ ๋ฐ๋๋ฉด ๊ผญ const ์จ์ฃผ์๊ตฌ์ฌ. ์ฐธ์กฐ ์ ์ฐ๊ณ ๊ฐ ์ฐ๋ฉด ์ด๋ป๊ฒ ๋๋์ง ์ดํํฐ๋ธ C++์ ์ ๋์ ์์ต๋๋ค.(์ฑ
์ ์ ์ ๋ ์๋) ๋ณต์ฌ ์์ฑ์๋ฅผ 10๋ฒ ๋๊ฒ ํธ์ถํ๋ค๋ ๊ฑธ๋ก ๊ธฐ์ตํจ.
- C++์์๋ ๊ตฌ์กฐ์ฒด์์๋ ์์ฑ์๊ฐ ๋๋๊ตฐ์.--;
- ๊ตฌ์กฐ์ฒด์์ ํจ์์ญ์ ๊ฐ๋ฅํ๊ณ , constructor, destructor์ญ์ ๊ฐ๋ฅํฉ๋๋ค. ๋ค๋ง class์ ์ฐจ์ด์ ์ ์์์ด ์๋๊ณ , ๋ด๋ถ ํ๋๋ค์ด public์ผ๋ก ๋์ด ์์ต๋๋ค. ์์์ด ์๋์ ํ์ํ๋ ๋ถ์ ๋ค์ ๊ดํด์๋ ํ๊ต C++๊ต์ ์์ ๋ถ๋ถ๊ณผ virtual ํจ์ ๊ด๋ จ ๋ถ๋ถ์ ๋์ ๋ฐ์ธ๋ฉ ๋ถ๋ถ์ ์ฐธ๊ณ ํ์๊ธฐ ๋ฐ๋๋๋ค.--์๋ฏผ
- ๊ตฌ์กฐ์ฒด์์ ํจ์์ญ์ ๊ฐ๋ฅํ๊ณ , constructor, destructor์ญ์ ๊ฐ๋ฅํฉ๋๋ค. ๋ค๋ง class์ ์ฐจ์ด์ ์ ์์์ด ์๋๊ณ , ๋ด๋ถ ํ๋๋ค์ด public์ผ๋ก ๋์ด ์์ต๋๋ค. ์์์ด ์๋์ ํ์ํ๋ ๋ถ์ ๋ค์ ๊ดํด์๋ ํ๊ต C++๊ต์ ์์ ๋ถ๋ถ๊ณผ virtual ํจ์ ๊ด๋ จ ๋ถ๋ถ์ ๋์ ๋ฐ์ธ๋ฉ ๋ถ๋ถ์ ์ฐธ๊ณ ํ์๊ธฐ ๋ฐ๋๋๋ค.--์๋ฏผ
- ๊ธ๊ตฌ.. ์๊ฒ๋ ๋ณ๊ฑฐ ์๋ ํ์ด๊ธด ํ๋ฐ.. i++๊ณผ ++i์ ์ฐจ์ด์ ์ ๋ค ์์์ฃ ? ๊ทผ๋ฐ ์นด์ดํธํ๊ฑฐ๋ ๋ฃจํ๋ฅผ ๋๋๋ ์ฐจ์ด๊ฐ ์๋ค๊ณ ๋ด๋ ์ข์ต๋๋ค. ++i๊ฐ i++๋ณด๋ค ์ฑ๋ฅ์ด ์ข๋ค๊ณ ํ๋ค์.(see also i++VS++i ์ด๊ฑด ๋ญ..~ ๋ง๋๋ก ํ์ธ์^^
- 02 ์ฌ๋ฌ๋ถ c++๊ณต๋ถ ์ด์ฌํ ํด์~
STL/vector