๊ณ ์ ์ ์ธ c๊ฐ์์์๋ ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ๋ฅผ ๊ฐ์ด ์ค๋ช ํ๋ค. ๋ฐฐ์ด์ ์ด๋ฆ์ด ๊ณง ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์ฃผ์๋ฅผ ์๋ฏธํ๋ ํฌ์ธํฐ๋ก๋ ์ฐ์ผ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐฐ์ด ์ฑํฐ์์๋ ์ธ์ด์์ ๊ธฐ๋ณธ์ผ๋ก ์ ๊ณตํ๋ ๋ฐฐ์ด์ ์ฌ์ฉ ๋ฐฉ๋ฒ๊ณผ Standard library๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํ๋ค. ํฌ์ธํฐ๋ ๋ค์ ์ฑํฐ์์ ์๊ฐํ๊ฒ ๋ค.
โ ๋ฐฐ์ด
C/C++์์ ๋ฐฐ์ด ์ ์ธ๊ณผ ์ฐ์์ ๋ค์๊ณผ ๊ฐ๋ค.
#include <iostream>
void changeVal(double* d)
{
d[4] = 6.0;
}
void changeColor(Car* cars)
{
cars[1].color = "blue";
}
int main()
{
double d[5] = {1.0, 2.0, 3.0, 4.0, 5.0};
Car cars[3];
int arr[] = {7,8,9};
changeVal(d);
changeColor(cars);
std::cout << d[4] << " " << cars[1].color << " " << *(arr + 1);
}
// ์คํ ๊ฒฐ๊ณผ: 6.0 blue 8
5๊ฐ์ง๋ฆฌ double ๋ฐฐ์ด๊ณผ ์ฌ์ฉ์ ํด๋์ค Car 3๊ฐ์ง๋ฆฌ ๋ฐฐ์ด์ ๋ง๋ค์๋ค. ๋ฐฐ์ด์ ๊ธธ์ด๋ ๊ณ ์ ๋์ด ์๊ณ , ๊ธธ์ด๋ฅผ ๋ณ๊ฒฝํด์ผ ํ ๊ฒฝ์ฐ ๋ค์ ๋ง๋ค์ด์ผ ํ๋ค. ๋ํ ๋ฐฐ์ด ๊ฐ์๋ฅผ ๋์ด๊ฐ๋ index์ ์ ๊ทผํ๋ ค๊ณ ํ ๊ฒฝ์ฐ out of bound ๋๋ฌธ์ ํ๋ก๊ทธ๋จ์ด ์ฃฝ์ ์๋ ์๋ค. ๋ฐฐ์ด ์ ์ธ ์ ๋๊ดํธ์ ๋ฐฐ์ด๊ธธ์ด๋ฅผ ๋ช ์์ ์ผ๋ก ์ ์ง ์๋๋ผ๋ ์ด๊ธฐํ ๊ตฌ๋ฌธ์ผ๋ก 3๊ฐ๋ฅผ ์ธ์งํ๊ณ ๋ฐฐ์ด ๊ธธ์ด๋ฅผ 3๊ฐ๋ก ์ก๊ฒ ๋๋ค. ๋ง์ฝ arr ์ ์ธ๋ถ์์ ์ด๊ธฐํ๋ฅผ ๋บ๋ค๋ฉด ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ ๊ฒ์ด๋ค.
์ฝ๋ ์์์ ๋ฐฐ์ด์ ๋ณ์ d๋ผ๋ ์ด๋ฆ์ผ๋ก ์ ๊ทผํ ๊ฒฝ์ฐ, ๋ฉ๋ชจ๋ฆฌ์์ 5๊ฐ์ ์ฐ๊ฒฐ๋ double์ 40byte ์ค ์ฒซ ๋ฒ์งธ ์ฃผ์๋ฅผ ๋ํ๋ธ๋ค. ๋๋ฌธ์ changeVal์ ๋ฐฐ์ด์ด๋ฆ์ผ๋ก๋ง ํ๋ผ๋ฏธํฐ๋ก ๋ฃ์ด๋ ์ค์ ๊ฐ์ด ๋ฐ๋๋ค. changeVal์ ๋งค๊ฐ๋ณ์๋ ํฌ์ธํฐ๋ณ์๋ก์จ ์ค์ ๋ฃ๋ ์ธ์๊ฐ์ ์ฃผ์๊ฐ ๋ค์ด๊ฐ์ผ ํ๋ค. ๋ฐฐ์ด์ ์ด๋ฆ ์์ฒด๊ฐ ์์์ฃผ์๋ฅผ ์๋ฏธํ๋ ๊ฒ์ ์ ์ ์๋ค. *(arr+1)๋ ๋ง์ฐฌ๊ฐ์ง๋ก arr์ ๋ฐฐ์ด์ ์์์ฃผ์์ด๋ฉฐ +n์ ํ๋ฉด n๋ฒ์งธ ๊ฐ์ด ์๋ ๊ณณ์ ์ฃผ์๋ฅผ ๋ํ๋ธ๋ค. ๋๋ ๊ฐ์ ์ถ๋ ฅํ๊ณ ์ถ๊ธฐ ๋๋ฌธ์ ํฌ์ธํฐ์ ๊ฐ์ ์ ๊ทผํ๋ *์ฐ์ฐ์๋ฅผ ๋ถ์๋ค. ํฌ์ธํฐ์ ๋ํ ์ฌ์ด ์ค๋ช ์ ๋ณด๊ณ ์ถ์ผ๋ฉด ์ฌ๊ธฐ๋ฅผ ์ฐธ๊ณ ํ์.
ํด๋์ค ๋ํ ๋ฉค๋ฒ๋ณ์์ size๋งํผ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ๊ฐ๋ค. ๋ง์ฝ ๋ด๊ฐ ๋ง๋ ํด๋์ค์ ๋ฉค๋ฒ๋ณ์๊ฐ int 1๊ฐ, double 1๊ฐ์ธ ๊ฒฝ์ฐ, 12byte๋ฅผ ์ฐจ์งํ๋ฉฐ 3๊ฐ์ ๋ฐฐ์ด๋ก ๋ง๋ค์์ ๋ 36byte๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ๊ฐ๊ฒ ๋๋ค.
int arr[3][5]์ ๊ฐ์ด 2์ค ๋ฐฐ์ด ๋๋ ๊ทธ ์ด์ n์ค ๋ฐฐ์ด๋ ์ฌ์ฉ๊ฐ๋ฅํ๋ค. ํ์ง๋ง ๊ฐ๋ฐํ๋ ์ฌ๋ ์ ์ฅ์์ ์ง๊ด์ ์ด์ง ์์ผ๋ฉฐ ๋น๋๊ฐ ๋ฎ์์ ์์ธํ ๋ค๋ฃจ์ง ์๊ฒ ๋ค.
โ std::array์ std::vector
๋ชจ๋ C++์์๋ C์์ ์ฐ๋ ์ผ๋ฐ ๋ฐฐ์ด์ ์ฐ๋ ๊ฒ ๋ณด๋ค๋ Standard library๋ฅผ ์ถ์ฒํ๋ค. std::array์ std::vector์ ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ ๊ณ ์ ๊ธธ์ด ๋ฐฐ์ด๊ณผ ๊ฐ๋ณ๊ธธ์ด ๋ฐฐ์ด์ ์๋ค. ๋ด๋ถ์ ์ผ๋ก๋ ๋ ๋ค ๊ธฐ๋ณธ ๋ฐฐ์ด์ ์ฌ์ฉํ์ง๋ง ์ฌ์ฉ์ ์ธํฐํ์ด์ค ๋จ์์๋ std::array๋ ์ ์ธ ์ ๊ธธ์ด๋ฅผ ์ง์ ํด ์ฃผ๊ณ , std::vector๋ ๊ธธ์ด๋ฅผ ์ง์ ํ์ง ์๋ค. ๋ค์ ์์๋ฅผ ๋ณด์.
#include <array>
#include <vector>
#include <iostream>
class Point
{
public:
Point(double _x, double _y) : x(_x), y(_y)
double getX() const { return x; }
double getY() const { return y; }
private:
double x;
double y;
};
int main()
{
std::array<int, 5> arr = { 1, 2, 3, 4, 5};
std::vector<Point> vec;
arr[2] = 11;
Point p1(5.1, -3.8);
vec.push_back(p1);
vec.push_back(Point(-1.1, 2.2));
std::cout << "arr size: " << arr.size() << ", arr[2] : " << arr[2] << endl;
std::cout << "vec size: " << vec.size() << ", vec[1] : " << vec[1].getX() << "," << vec[1].getY() << endl;
}
// ์คํ๊ฒฐ๊ณผ: arr size: 5, arr[2] : 11
// vec size: 2, vec[1] : 5.1,-3.8
array๋ ์ ์ธ์ ๊ณ ์ ๊ธธ์ด์ ์ฌ์ด์ฆ๋ฅผ ๋ ๋ฒ์งธ ํ ํ๋ฆฟ ์ธ์์ ๋ฃ์ด์ฃผ์ด์ผ ํ๋ค. ์ฒซ ๋ฒ์งธ ์ธ์๋ array, vector์ ๋ค์ด๊ฐ ํ์ ์ ๋ฃ์ผ๋ฉด ๋๋ค.
std::array์ std::vector๋ ํด๋์ค๋ก ๊ตฌํ๋ ๊ฒ์ด๋ฏ๋ก ์ธํฐํ์ด์ค ํจ์๋ฅผ ์ฌ์ฉํด์ ์ ์ดํ ์ ์๋ค. ๊ฝค๋ ํธ๋ฆฌํ ๊ธฐ๋ฅ์ด ๋ง๊ธฐ๋ ํ๊ณ ๊ฒ์ฆ๋ ์ปจํ ์ด๋๊ธฐ ๋๋ฌธ์ ํ์ํ ๋ ์ฐธ๊ณ ํด์ ์ฌ์ฉํ์. cppreference์ ๊ณต์ ๋ฌธ์๋ ์๋์ ๊ฐ๋ค.
https://en.cppreference.com/w/cpp/container/array
std::array - cppreference.com
template< class T, std::size_t N > struct array; (since C++11) std::array is a container that encapsulates fixed size arrays. This container is an aggregate type with the same semantics as a struct holding a C-style array T[N] as its only non-s
en.cppreference.com
https://en.cppreference.com/w/cpp/container/vector
std::vector - cppreference.com
template< class T, class Allocator = std::allocator > class vector; (1) (2) (since C++17) 1) std::vector is a sequence container that encapsulates dynamic size arrays. The elements are stored contiguously, which means that elements can be acces
en.cppreference.com
๋๋ ๋ฐฐ์ด์ ์จ์ผํ๋ ๊ฒฝ์ฐ๋ 100% array์ vector๋ง ์ฌ์ฉํ๋ค. C์์ ์ ๊ณตํ๋ ๊ธฐ๋ณธ ๋ฐฐ์ด์ ๊ฒฝ์ฐ ์์ธ์ฒ๋ฆฌ๋ ๊น๋ํ์ง ์๊ณ , ์ง๊ด์ ์ด์ง ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ฒ๋ค๊ฐ standard library๋ฅผ ์ฌ์ฉํ๋ ๋ฐ ์์ด ์ด์ ์ด ํจ์ฌ ๋ง๊ธฐ ๋๋ฌธ์ ์์ธ ์ด์ ๊ฐ ์๋ค.
'ํ๋ก๊ทธ๋๋ฐ ์ธ์ด > C++ ๊ธฐ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[C++] 11. ํจ์(feat. ์ ์ญํจ์, ๋ฉค๋ฒํจ์, ์ ์ ํจ์, ๋๋คํจ์) (0) | 2023.04.28 |
---|---|
[C/C++] 10. ํฌ์ธํฐ(feat. ์ค๋งํธ ํฌ์ธํฐ) (0) | 2023.04.26 |
[C/C++] 8. ๋ฐ๋ณต๋ฌธ(์ฌํ)(feat. iterator, predicate, lambda) (0) | 2023.04.22 |
[C/C++] 7. ๊ฐ๋ฐํ๊ฒฝ ๊ตฌ์ฑ(windows/linux) (1) | 2023.04.11 |
Makefile ๊ธฐ์ด (0) | 2023.04.11 |
๋๊ธ