๐ก ๋ณธ ๋ฌธ์๋ '[C++] ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ: fstream ๊ฐ์ฒด๋ฅผ ํตํ ํ์ผ ์ ์ถ๋ ฅ'์ ๋ํด ์ ๋ฆฌํด๋์ ๊ธ์ ๋๋ค.
C++์ ๋ํ์ ์ธ ํ์ผ ์ ์ถ๋ ฅ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธ fstream์ ๋ํด ์ ๋ฆฌํ์์ผ๋ ์ฐธ๊ณ ํ์๊ธฐ ๋ฐ๋๋๋ค.
1. fstream ๊ฐ์ฒด๋ฅผ ํตํ ํ์ผ ์ ์ถ๋ ฅ
1.1. fstream ํ์ผ ์ ์ถ๋ ฅ ๊ธฐ๋ณธ
C++์ ifstream์ด๋ ofstream์ ์ฌ์ฉํ๋ ค๋ฉด <fstream> ํค๋๋ฅผ ์ถ๊ฐํด์ผ ํฉ๋๋ค.
#include <fstream>
ofstream์ ํ์ผ์ ๊ธฐ๋กํ ๋ ์ฌ์ฉํ๊ณ ifstream์ ํ์ผ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ฌ ๋ ์ฌ์ฉํฉ๋๋ค.
์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ด ๋ชจ๋ ๊ฐ๋ฅํ fstream ํด๋์ค ์ญ์ ์กด์ฌํฉ๋๋ค.
ํด๋์ค์ open() ๋ฉ์๋๋ฅผ ํตํด ํ์ผ์ ์ด๊ฑฐ๋ ์์ฑํ ์ ์์ต๋๋ค.
std::ofstream ofs;
ofs.open("ํ์ผ ๊ฒฝ๋ก");
std::ifstream ifs;
ifs.open("ํ์ผ ๊ฒฝ๋ก");
์์ฑ์์ ํ์ผ ๊ฒฝ๋ก๋ฅผ ์ ๋ ฅํด์ ๋ฐ๋ก ํ์ผ์ ์์ฑํ๊ฑฐ๋ ์ฌ๋ ๊ฒ๋ ๊ฐ๋ฅํฉ๋๋ค.
std::ofstream ofs("ํ์ผ ๊ฒฝ๋ก");
std::ifstream ifs("ํ์ผ ๊ฒฝ๋ก");
๋ค์๊ณผ ๊ฐ์ด ํ์ผ์ ์์ฑํ๊ฑฐ๋ ์ฌ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
#include <fstream>
#include <iostream>
#include <string>
int main()
{
std::ofstream ofs("D:\\test.txt", std::ios::out | std::ios::app);
if (ofs.fail())
{
std::cerr << "Error!" << std::endl;
}
std::ifstream ifs;
ifs.open("D:\\test.txt", std::ios::in);
if (!ifs)
{
std::cerr << "Error!" << std::endl;
}
ifs.close();
return 0;
}
ofstream ๊ฐ์ฒด(ofs)๋ ์์ฑ์๋ฅผ ํตํด ํ์ผ์ ์์ฑํ๊ณ ifstream ๊ฐ์ฒด(ifs)๋ open() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ต๋๋ค. ์ฌ๊ธฐ์ open()์ผ๋ก ํ์ผ์ ์ด ๊ฒฝ์ฐ ๋ฐ์ดํฐ ์ฌ์ฉ ํ close()๋ฅผ ํธ์ถํด์ฃผ์ด์ผ ํ๋ฉฐ, close()๋ฅผ ํธ์ถํ๋ฉด fstream ๊ฐ์ฒด๋ RAII ํจํด์ด ์ ์ฉ๋์ด ์๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด๊ฐ ์๋ฉธ๋ ๋ ์๋์ผ๋ก ๋ซํ๋๋ค.
1.2. fstream ๊ฐ์ฒด๋ฅผ ํตํ ํ์ผ ์ ์ถ๋ ฅ ๋ชจ๋
ํ์ผ์ ์ด ๋ ๋ชจ๋๋ฅผ ์ค์ ํ ์ ์๋๋ฐ ์ง์ํ๋ ๋ชจ๋๋ค์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
in | ํ์ผ์ ์ฝ๊ธฐ ๋ชจ๋๋ก ์ด๊ธฐ (ifstream์์ ๊ธฐ๋ณธ๊ฐ) |
out | ํ์ผ์ ์ฐ๊ธฐ ๋ชจ๋๋ก ์ด๊ธฐ (ofstream์์ ๊ธฐ๋ณธ๊ฐ) |
binary | ํ ์คํธ ๋ชจ๋ ๋์ ๋ฐ์ด๋๋ฆฌ ๋ชจ๋๋ก ์ด๊ธฐ |
ate | ์ถ๋ ฅ ์์น๊ฐ ํ์ผ์ ๋์์ ์์ |
app | ๋ชจ๋ ์ถ๋ ฅ์ด ํ์ผ์ ๋์ ์ถ๊ฐ ๋จ |
trunc | ํ์ผ์ ๋ด์ฉ์ ๋ชจ๋ ์ญ์ ํ๊ณ ์ด๊ธฐ |
- ์ํ๋ ํ์ผ ์ฒ๋ฆฌ๋ฅผ ์ํด OR ์ฐ์ฐ์(|)๋ก ๊ฒฐํฉํด์ ํ์ผ์ ์ด ๋ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค.
- ํ์ผ์ด ์ ์์ ์ผ๋ก ์ด๋ ธ๋์ง ํ์ธํ๋ ค๋ฉด fail()์ด๋ bad() ํจ์ ๋ฑ์ ํธ์ถํ๋ฉด ๋ฉ๋๋ค.
- C++11 ์ดํ๋ถํฐ๋ fstream์ด bool ํ์ ๋ณํ ๋ฉ์๋๋ฅผ ์ง์ํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด ์์ฒด๋ฅผ ์กฐ๊ฑด๋ฌธ์ ๋ฃ์ด๋ ๋ฉ๋๋ค.
1.2.1. ํ ์คํธ ๋ชจ๋(๊ธฐ๋ณธ)
๋ผ์ธ ๋์ ์ฒ๋ฆฌํ๊ธฐ ์ํด ์ด์์ฒด์ ๋ง๋ค ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
๊ตฌ๋ถ | ๋ผ์ธ ์ฒ๋ฆฌ ๋ฐฉ์ |
C | HELLO\n |
Windows | HELLO\r\n |
Unix, Linux | HELLO\n |
Mac | HELLO\r |
1.2.2. ๋ฐ์ด๋๋ฆฌ ๋ชจ๋
- binary๋ก ์ฝ๊ณ ์ธ ๋, string์ binary๋ก ๋ฐ๊พธ์ด ์ ์ฅํด์ผํ๊ธฐ์ binary๋ก encodeํ์ฌ ์ ์ฅํฉ๋๋ค.
- file์ binary๋ก ์ฝ์ด์ ์ถ๋ ฅํด๋ณด๋ฉด, ํ ์คํธ๊ฐ ์๋๋ผ ์ด์ํ ์ซ์๋ค๋ก ์ฃฝ ๋์ด๋์ด ์๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
- binary data๋ฅผ utf-8๋ก ๋์ฝ๋ฉํ์ฌ ์ถ๋ ฅํด๋ณด๋ฉด ์ ๋๋ก ๋์ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
- ์ถ๊ฐ๋ก, ์ฐ๋ฆฌ๊ฐ ํํ ์ฐ๋ ํ ์คํธ๋ค์ ๊ฒฝ์ฐ๋ binary์ผ ์๋ ์๊ณ , text์ผ ์๋ ์ ์ชฝ ๋ชจ๋ ์ ์ฅ ํ๋ ๊ฒ์ด ๊ฐ๋ฅํ์ง๋ง image๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ฌด์กฐ๊ฑด binary์ ๋๋ค.
2. fstream ๊ธฐ๋ณธ ์์
2.1. ๋ฐ์ด๋๋ฆฌ ๋ชจ๋ ์์
๋ฐ์ด๋๋ฆฌ ๋ชจ๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๊ฒฝ์ฐ, ํ์ผ์ ๋ถ๋ฌ์ฌ ๋ std::ios::binary ์ต์ ์ ์ฃผ์ด ์ฝ์ด๋ค์ด์ผ ํฉ๋๋ค. ์์์ ์ธ๊ธํ๋ฏ์ด ํน์ ์ต์ ๊ณผ ๊ฐ์ด ์ฌ์ฉํ๊ธฐ ์ํด์๋ OR ์ฐ์ฐ์(|)๋ก ๊ฒฐํฉํด์ ํ์ผ์ ์ด ๋ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค.
ofstream
int n1 = 500;
int n2 = 1000;
double f = 3.14;
int arr[5] = {1, 2, 4, 8, 16};
string str = "ABCDE";
std::ofstream output("data.bin", std::ios::out | std::ios::binary);
output.write((char*)&n1, sizeof(int));
output.write((char*)arr, sizeof(arr));
output << n2 << f << str;
output.close();
ifstream
int n1, n2;
double f;
int arr[5];
string str;
std::ifstream input("data.bin", std::ios::in | std::ios::binary);
input.read((char*)&n1, sizeof(int));
input.read((char*)arr, sizeof(arr));
input >> n2 >> f >> str;
2.2. ํ์ผ ํ ์ค์ฉ ์ฝ๊ธฐ (ifstream)
getline ๋ฉ์๋๋ฅผ ํ์ฉํ๋ฉด ํ์ผ์ ํ ์ค์ฉ ์ฝ์ด์ ํน์ ๋ณ์์ ๋ฃ์ ์ ์์ต๋๋ค.
// std::string ์ ์ ์๋ getline ์ฌ์ฉ
#include <fstream>
#include <iostream>
#include <string>
int main() {
// ํ์ผ ์ฝ๊ธฐ ์ค๋น
std::ifstream in("test.txt");
if (!in.is_open()) {
std::cout << "ํ์ผ์ ์ฐพ์ ์ ์์ต๋๋ค!" << std::endl;
return 0;
}
std::string s;
while (in) {
getline(in, s);
std::cout << s << std::endl;
}
return 0;
}
2.3. ํ์ผ ์ ์ฒด๋ฅผ ํ ๋ฒ์ ์ฝ๊ธฐ (ifstream)
ํน์ ๋ฌธ์์ด์ ํ์ผ๋ก ๋จ๊ถ์ ๊ฒฝ์ฐ, ๋ฌธ์์ด ๋ด๋ถ์ ๊ฐํ๋ฌธ์๊ฐ ์๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค. ์ด๋ฌํ ๊ฒฝ์ฐ ํ๋์ ๋ฌธ์์ด๋ก ๋ณ์์ ์ ์ฅํ๊ธฐ ์ํด์๋ ๋ค์๊ณผ ๊ฐ์ด ํ์ผ ์ ์ฒด๋ฅผ ์ฝ์ด์ผ ํฉ๋๋ค.
#include <fstream>
#include <iostream>
#include <string>
int main() {
// ํ์ผ ์ฝ๊ธฐ ์ค๋น
std::ifstream in("test.txt");
std::string s;
if (in.is_open()) {
// ์์น ์ง์ ์๋ฅผ ํ์ผ ๋์ผ๋ก ์ฎ๊ธด๋ค.
in.seekg(0, std::ios::end);
// ๊ทธ๋ฆฌ๊ณ ๊ทธ ์์น๋ฅผ ์ฝ๋๋ค. (ํ์ผ์ ํฌ๊ธฐ)
int size = in.tellg();
// ๊ทธ ํฌ๊ธฐ์ ๋ฌธ์์ด์ ํ ๋นํ๋ค.
s.resize(size);
// ์์น ์ง์ ์๋ฅผ ๋ค์ ํ์ผ ๋งจ ์์ผ๋ก ์ฎ๊ธด๋ค.
in.seekg(0, std::ios::beg);
// ํ์ผ ์ ์ฒด ๋ด์ฉ์ ์ฝ์ด์ ๋ฌธ์์ด์ ์ ์ฅํ๋ค.
in.read(&s[0], size);
std::cout << s << std::endl;
}
else {
std::cout << "ํ์ผ์ ์ฐพ์ ์ ์์ต๋๋ค!" << std::endl;
}
return 0;
}
์ฐธ๊ณ
- [Cpp Reperence] ofstream: https://en.cppreference.com/w/cpp/io/basic_ofstream
- [Cpp Reperence] ifstream: https://en.cppreference.com/w/cpp/io/basic_ifstream
- C++ fstream ๊ฐ์ฒด๋ฅผ ํตํ ํ์ผ ์ ์ถ๋ ฅ: https://psychoria.tistory.com/774
- ํ์ผ ์ข ๋ฅ - ํ ์คํธ ํ์ผ, ์ด์ง ํ์ผ: https://codedragon.tistory.com/5103
- binary data: https://frhyme.github.io/python/binary_data/