Structured Bindings์ ๋ชจ๋ ๊ฒ
Structured Bindings๋ C++17์์ ๋์ ๋ ๊ธฐ๋ฅ์ผ๋ก, ๋ณตํฉ ๋ฐ์ดํฐ ๊ตฌ์กฐ(์: std::tuple, std::pair, ๋ฐฐ์ด, ๊ตฌ์กฐ์ฒด ๋ฑ)์์ ์ฌ๋ฌ ๊ฐ์ ๋์์ ์ถ์ถํ๊ณ , ๊ฐ๊ฐ์ ๋ณ๋์ ๋ณ์์ ๋ฐ์ธ๋ฉํ ์ ์๋ ํธ๋ฆฌํ ๋ฐฉ๋ฒ์ ์ ๊ณตํฉ๋๋ค. ์ด๋ ํนํ ํํ์ด๋ ์ฌ์ฉ์ ์ ์ ๊ตฌ์กฐ์ฒด์์ ์ ์ฉํ๋ฉฐ, ์ฝ๋์ ๊ฐ๋ ์ฑ๊ณผ ํธ์์ฑ์ ํฌ๊ฒ ํฅ์์ํต๋๋ค.
1. ๊ธฐ๋ณธ ๊ฐ๋
Structured Bindings๋ฅผ ์ฌ์ฉํ๋ฉด, ๋ณตํฉ ๋ฐ์ดํฐ ๊ตฌ์กฐ์์ ๊ฐ ์์๋ฅผ ์ฝ๊ฒ ๋ถํดํ์ฌ ๊ฐ๊ฐ์ ๋ณ์์ ๋ด์ ์ ์์ต๋๋ค. ์ด๋ auto ํค์๋์ ์ ์ฌํ ๋ฌธ๋ฒ์ ์ฌ์ฉํ์ฌ ๊ตฌํ๋ฉ๋๋ค.
- ๊ธฐ๋ณธ ์ฌ์ฉ๋ฒ:
auto [var1, var2, var3] = someTuple;
์ฌ๊ธฐ์ someTuple์ ๋ณตํฉ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ด๊ณ , [var1, var2, var3]๋ ๊ฐ๊ฐ์ ์์์ ๋ฐ์ธ๋ฉ๋ ๋ณ์๋ฅผ ๋ํ๋
๋๋ค.
2. ์ฌ์ฉ ๋ฐฉ๋ฒ
Structured Bindings๋ ๋ค์ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์์๋ก std::tuple, std::pair, ๋ฐฐ์ด, ๊ตฌ์กฐ์ฒด ๋ฑ์ด ์์ต๋๋ค.
์์ 1: std::tuple๊ณผ std::pair์์์ ์ฌ์ฉ
#include <iostream>
#include <tuple>
#include <utility> // for std::pair
int main() {
std::tuple<int, double, std::string> data = {1, 2.5, "Hello"};
// Structured Bindings๋ฅผ ์ฌ์ฉํ์ฌ ํํ์ ์์๋ฅผ ๊ฐ๊ฐ ๋ณ์์ ๋ฐ์ธ๋ฉ
auto [id, value, text] = data;
std::cout << "id: " << id << ", value: " << value << ", text: " << text << std::endl;
// std::pair์์์ ์ฌ์ฉ
std::pair<int, std::string> p = {42, "Answer"};
auto [number, answer] = p;
std::cout << "number: " << number << ", answer: " << answer << std::endl;
return 0;
}
์ถ๋ ฅ:
id: 1, value: 2.5, text: Hello
number: 42, answer: Answer
์ค๋ช :
- std::tuple์ด๋ std::pair์ ์์๋ฅผ ๊ฐ๊ฐ id, value, text์ ๊ฐ์ ๊ฐ๋ณ ๋ณ์์ ๋ฐ์ธ๋ฉํ์ฌ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ์ด๋ฅผ ํตํด ํํ์ด๋ ํ์ด์์ ํน์ ๊ฐ์ ์ถ์ถํ๋ ๊ณผ์ ์ ๊ฐ์ํํ ์ ์์ต๋๋ค.
์์ 2: ๋ฐฐ์ด์์์ ์ฌ์ฉ
#include <iostream>
int main() {
int myArray[3] = {10, 20, 30};
// ๋ฐฐ์ด์ ์์๋ฅผ ๊ฐ๊ฐ์ ๋ณ์์ ๋ฐ์ธ๋ฉ
auto [a, b, c] = myArray;
std::cout << "a: " << a << ", b: " << b << ", c: " << c << std::endl;
return 0;
}
์ถ๋ ฅ:
a: 10, b: 20, c: 30
์ค๋ช :
- ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ๊ฐ๋ณ ๋ณ์์ ๋ฐ์ธ๋ฉํ์ฌ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ ํน์ ์ธ๋ฑ์ค๋ก ์ ๊ทผํ๋ ๋์ , ๋ช
์์ ์ธ ์ด๋ฆ์ ํตํด ๊ฐ์ ์ฌ์ฉํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค.
์์ 3: ์ฌ์ฉ์ ์ ์ ๊ตฌ์กฐ์ฒด์์์ ์ฌ์ฉ
#include <iostream>
#include <string>
struct Person {
std::string name;
int age;
double height;
};
int main() {
Person person = {"John Doe", 30, 5.9};
// ๊ตฌ์กฐ์ฒด์ ๋ฉค๋ฒ๋ฅผ ๊ฐ๊ฐ์ ๋ณ์์ ๋ฐ์ธ๋ฉ
auto [name, age, height] = person;
std::cout << "Name: " << name << ", Age: " << age << ", Height: " << height << std::endl;
return 0;
}
์ถ๋ ฅ:
Name: John Doe, Age: 30, Height: 5.9
์ค๋ช :
- ์ฌ์ฉ์ ์ ์ ๊ตฌ์กฐ์ฒด์ ๋ฉค๋ฒ๋ค์ ๊ฐ๊ฐ์ ๋ณ์์ ๋ฐ์ธ๋ฉํ์ฌ ๋ ๋ช
ํํ๊ณ ๊ฐ๊ฒฐํ๊ฒ ์ ๊ทผํ ์ ์์ต๋๋ค.
3. ์ฃผ์ ์ฌํญ ๋ฐ ์ ํ ์ฌํญ
- ๋ฐฐ์ด ํฌ๊ธฐ: ๋ฐฐ์ด์ ์ฌ์ฉํ ๋, ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ์ ํํ ๋ง์์ผ ํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ํฌ๊ธฐ๊ฐ 3์ธ ๋ฐฐ์ด์์ 3๊ฐ์ ๋ณ์์ ๋ฐ์ธ๋ฉํ ์ ์์ง๋ง, ๋ ์ ๊ฑฐ๋ ๋ง์ ๋ณ์๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
- ๋ณ์ ํ์ : ๋ฐ์ธ๋ฉ๋ ๋ณ์๋ค์ ์๋ ์์๋ค์ ํ์ ์ ์ ์งํฉ๋๋ค. ๋ค๋ง, auto ํค์๋๋ฅผ ์ฌ์ฉํ๋ฉด ํ์ ์ถ๋ก ์ด ์๋์ผ๋ก ์ด๋ฃจ์ด์ง๋๋ค.
- ์บก์ฒ๋ ๋ฉค๋ฒ: ์ฌ์ฉ์ ์ ์ ๊ตฌ์กฐ์ฒด์์ ์์ ๋ฉค๋ฒ ๋ณ์๋ฅผ ์บก์ฒํ ๊ฒฝ์ฐ, ๋ฐ์ธ๋ฉ๋ ๋ณ์๋ ์์๋ก ์ทจ๊ธ๋ฉ๋๋ค.
- ์ค์ฝํ: Structured Bindings์์ ์ ์ธ๋ ๋ณ์๋ค์ ํด๋นํ๋ ์ฝ๋ ๋ธ๋ก ๋ด์์๋ง ์ ํจํฉ๋๋ค. ์ด๋ก ์ธํด ๋ณ์์ ์ค์ฝํ๊ฐ ๋ช
ํํ ์ ํ๋์ด ๋ถํ์ํ ๋ณ์ ์ฌ์ฉ์ ๋ฐฉ์งํ ์ ์์ต๋๋ค.
4. ์ฅ์ ๋ฐ ํ์ฉ
์ฅ์ :
- ์ฝ๋ ๊ฐ๊ฒฐํ: ๋ณตํฉ ๋ฐ์ดํฐ ๊ตฌ์กฐ์์ ํน์ ์์๋ฅผ ์ถ์ถํ๋ ๊ณผ์ ์ด ๋งค์ฐ ๊ฐ๋จํด์ง๋๋ค.
- ๊ฐ๋ ์ฑ ํฅ์: ๋ณ์์ ๋ช ์์ ์ธ ์ด๋ฆ์ ๋ถ์ฌํ์ฌ ์ฝ๋ ๊ฐ๋ ์ฑ์ ๋์ผ ์ ์์ต๋๋ค.
- ์ ์ฐ์ฑ: ๋ค์ํ ๋ณตํฉ ๋ฐ์ดํฐ ๊ตฌ์กฐ์์ ์ผ๊ด๋ ๋ฐฉ์์ผ๋ก ์์๋ฅผ ๋ถํดํ ์ ์์ด, ์ฝ๋ ์ฌ์ฌ์ฉ์ฑ์ด ๋์์ง๋๋ค.
ํ์ฉ:
- ๋ณต์กํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์ฒ๋ฆฌ: ๋ฐ์ดํฐ๋ฒ ์ด์ค ์กฐํ ๊ฒฐ๊ณผ๋ JSON ํ์ฑ ๋ฑ์์ ๋ณต์กํ ๊ตฌ์กฐ๋ฅผ ๋ค๋ฃฐ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ๋ฒ์ ๊ธฐ๋ฐ ๋ฃจํ์ ๊ฒฐํฉ: Structured Bindings๋ ๋ฒ์ ๊ธฐ๋ฐ for ๋ฃจํ์ ๊ฒฐํฉํ์ฌ, ๋ ๊ฐ๊ฒฐํ๊ณ ๋ช ํํ ๋ฐ๋ณต๋ฌธ์ ์์ฑํ๋ ๋ฐ ๋์์ ์ค๋๋ค.
#include <vector>
#include <tuple>
#include <iostream>
int main() {
std::vector<std::tuple<int, std::string>> vec = {
{1, "one"}, {2, "two"}, {3, "three"}
};
for (const auto& [num, word] : vec) {
std::cout << "Number: " << num << ", Word: " << word << std::endl;
}
return 0;
}
์ถ๋ ฅ:
Number: 1, Word: one
Number: 2, Word: two
Number: 3, Word: three
์ด ์์ ์์ ๋ณด๋ฏ, Structured Bindings์ ๋ฒ์ ๊ธฐ๋ฐ for ๋ฃจํ๋ฅผ ๊ฒฐํฉํ๋ฉด ๋ณต์กํ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฒ ๋ฐ๋ณต ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.