[C++] 파일 & 문자열 스트림

References

• C++ Standard Library 2nd

Contents

• File Access (파일 스트림)
• Stream Classes for String (문자열 스트림)

---

[C++] 스트림(stream) 클래스 (1)

[C++] 스트림(stream) 클래스 (2)

 

File Access

파일에 액세스할 때 스트림을 사용할 수 있습니다. 이번에는 파일 액세스에 대한 기능들에 대해서 살펴보도록 하겠습니다.

 

File Stream Classes

C++ 표준 라이브러리에서는 아래의 표준 특수화(standard specializations)가 정의되어 있습니다.

1. ifstream과 wifstream 으로 특수화된 basic_ifstream<> 클래스 템플릿은 파일 읽기 액세스를 제공합니다 (input file stream).
2. ofstream과 wofstream 으로 특수화된 basic_ofstream<> 클래스 템플릿은 파일 쓰기 액세스를 제공합니다 (output file stream).
3. fstream과 wfstream 으로 특수화된 basic_fstream<> 클래스 템플릿은 파일에 대한 읽기와 쓰기는 동시에 할 때 사용할 수 있습니다.
4. filebuf와 wfilebuf 로 특수화된 basic_filebuf<> 클래스 템플릿은 다른 파일 스트림 클래스에서 문자를 실제로 읽거나 쓰려고 할 때 사용합니다.

이 클래스들은 아래 그림과 같이 stream base 클래스들과 연관되어 있습니다.

그리고 <fstream> 헤더에 다음과 같이 선언되어 있습니다.

namespace std {
  template <typename charT,
            typename traits>
  class basic_ifstream;
  
  typedef basic_ifstream<char>    ifstream;
  typedef basic_ifstream<wchar_t> wifstream;
  
  template <typename charT,
            typename traits>
  class basic_ofstream;
  
  typedef basic_ofstream<char>    ofstream;
  typedef basic_ofstream<wchar_t> wofstream;
  
  template <typename charT,
            typename traits>
  class basic_fstream;
  
  typedef basic_fstream<char>    fstream;
  typedef basic_fstream<wchar_t> wfstream;
  
  template <typename charT,
            typename traits>
  class basic_filebuf;
  
  typedef basic_filebuf<char>    filebuf;
  typedef basic_filebuf<wchar_t> wfilebuf;
}

C에서 제공하는 방식과 비교할 때 파일 액세스를 위한 파일 스트림 클래스가 제공하는 가장 큰 장점은 파일을 알아서 관리한다는 것 입니다. 파일들은 클래스를 생성할 때 자동으로 open되고, 클래스가 소멸될 때 자동으로 close됩니다. 물론 적절한 생성자, 소멸자가 정의되어 있는 경우에만 해당됩니다.

 

읽기와 쓰기 모두를 위한 스트림에서는 읽기와 쓰기 사이를 임의로 전환할 수 없습니다. 파일을 읽거나 쓰기 시작한다면, 먼저 seek 연산부터 수행해야 합니다. 대체로 현재 위치로 이동하지만 읽기에서 쓰기, 또는 쓰기에서 읽기로 전환하기 위해서는 seek 연산을 수행해야만 합니다. 만약 파일의 끝에 도달할 때까지 읽은 경우에는 이 법칙이 적용되지 않으며, 즉시 쓰기 작업을 수행할 수 있습니다. 그 이외의 경우 이러한 규칙을 어길 때의 동작은 undefined 입니다.

 

파일 스트림 객체를 string이나 C-string을 인자로 받아 생성했다면 자동으로 쓰기를 위해 파일을 열거나 파일을 읽습니다. 성공 여부는 스트림의 상태를 확인하여 알 수 있습니다.

아래 예제 코드는 charset.out 파일을 열고, 모든 문자 집합(32에서 255까지 값에 대응되는 문자)를 write 하고 그 내용을 출력합니다.

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdlib>
using namespace std;

void writeCharsetToFile(const string& filename)
{
  // open output file
  ofstream file(filename);
  // file opened ?
  if (!file) {
    // no, abort program
    cerr << "can't open output file \"" << filename << "\"" << endl;
    exit(EXIT_FAILURE);
  }
  // write character set
  for (int i = 32; i < 256; i++) {
    file << "value: " << setw(3) << i << " "
         << "char: " << static_cast<char>(i) << endl;
  }
  // close file automatically
}

void outputFile(const string& filename)
{
  // open input file
  ifstream file(filename);
  // file opened ?
  if (!file) {
    // no, abort program
    cerr << "can't open input file \"" << filename << "\"" << endl;
    exit(EXIT_FAILURE);
  }
  // copy file contents to cout
  char c;
  while (file.get(c)) {
    cout.put(c);
  }
  // close file automatically
}

int main()
{
  writeCharsetToFile("charset.out");
  outputFile("charset.out");
}

위의 코드에서는 파일 내용을 문자 단위로 복사하고 있습니다. 이 대신 한 명령어로 전체 내용을 출력할 수 있는데, 파일의 스트림 버퍼에 대한 포인터를 << 연산자의 인자로 전달해어 출력하면 됩니다.

cout << file.rdbuf();

 

Rvalue and Move Semantics for File Streams

C++11부터 파일 스트림에서 rvalue와 move semantics를 제공합니다. 사실 ostream은 스트림의 rvalue 참조자를 받는 output 연산자를, istream은 rvalue reference를 받는 input 반복자를 제공합니다. 이를 사용하여 임시로 생성한 스트림 객체를 사용할 수도 있고 원하는 대로 동작도 수행할 수 있습니다. 예를 들어, 아래와 같이 임시로 생성한 파일 스트림에도 write 할 수 있습니다.

#include <iostream>
#include <fstream>
#include <string>
using namespace std;


int main()
{
  // write string to a temporarily created file stream (since C++11)
  string s("hello");
  ofstream("fstream2.tmp") << s << endl;
  
  // write C-string to a temporarily created file stream
  // - NOTE: wrote a pointer value before C++11
  ofstream("fstream2.tmp", ios::app) << "world" << endl;
}

C++11 이전에는 위 코드의 두 번째 명령문이 컴파일은 되지만 예상과는 다른 동작을 수행합니다 (ostream& ostream::operator<<(cosnt void* ptr) 이 호출되기 때문).

 

파일 스트림은 이제 move와 swap semantics를 제공하며, 이동 생성자, 이동 할당 연산자와 swap()이 제공됩니다. 따라서, 파일 스트림을 함수의 인자로 전달하거나 함수로부터 파일 스트림을 반환받을 수 있습니다. 예를 들어, 파일을 생성한 scope보다 상위 scope에서 사용되어야 한다면 다음과 같이 파일 스트림을 반환할 수 있습니다.

std::ofstream openFile(const std::string& filename)
{
  std::ofstream file(filename);
  ...
  return file;
}

std::ofstream file;
file = openFile("xyz.tmp"); // use returned file stream (Since C++11)
file << "hello, world" << std::endl;

C++ 이전에는 파일 객체를 heap에 할당하여 사용하고, 사용이 끝나면 명시적으로 delete 해주어야 했습니다.

 

File Flags

ios_base 클래스에는 파일의 처리하는 모드를 정밀하게 컨트롤하기 위해서 여러 가지 플래그가 정의되어 있습니다. 이 플래그들은 fmtflags와 유사한 비트마스크 타입인 openmode 타입을 갖습니다.

binary 플래그는 end-of-line이나 end-of-file과 같은 특수 문자나 문자열의 변환을 억제하도록 합니다. 윈도우의 경우 텍스트 파일에서 행의 끝은 두 개의 문자(CR과 LF)로 표현됩니다. 일반적인 텍스트 모드(binary가 set 되지 않은)에서는 읽거나 쓸 때 특수한 처리를 하지 않아도 되도록 이 두 개의 문자를 개행(newline) 문자로 바꾸거나 반대로 바꿉니다. binary mode에서는 이러한 변환이 일어나지 않습니다.

일부 구현에서는 nocreate와 noreplace와 같은 플래그를 추가로 제공합니다만, 표준은 아닙니다.

 

플래그들은 '|' 연산자를 사용하여 결합할 수 있습니다. 예를 들어, 아래 코드는 파일의 끝에 텍스트를 덧붙이는 모드로 파일을 open 합니다.

std::ofstream file("xyz.out", std::ios::out | std::ios::app);

아래 표는 C의 fopen()에 사용되던 문자열에 대응되는 플래그 조합을 보여줍니다.

표에서 언급하지 않는 조합 (ex, trunc|app 등)은 허용되지 않습니다.

 

파일이 읽기 위해서 열렸는지 쓰기 위해서 열렸는지는 해당하는 스트림 객체의 클래스와는 독립적입니다. 만약 클래스를 생성할 때 두 번째 인자가 사용되지 않으면 default open mode를 사용합니다. 즉, 오직 ifstream 클래스 또는 ofstream 클래스에 의해 사용되는 파일은 읽기와 쓰기 모두에 대해 사용된다는 것을 의미합니다. open mode는 해당하는 스트림 버퍼 클래스로 전달됩니다. 하지만, 객체에서 가능한 연산은 스트림의 클래스에 따라 결정됩니다.

파일 스트림이 소유한 파일은 명시적으로 열거나 닫을 수 있습니다. 이를 위해서 아래의 세 가지 멤버 함수가 정의되어 있으며, 초기화없이 파일 스트림을 사용할 때 유용합니다.

아래 예제 코드를 참조 바랍니다.

#include <iostream>
#include <fstream>
using namespace std;

// for all filenames passed as command-line arguments
// open, print contents, and close file
int main(int argc, char** argv)
{
  ifstream file;

  // for all command-line arguments
  for (int i = 0; i < argc, i++) {
    // open file
    file.open(argv[i]);
    // write file contents to cout
    char c;
    while (file.get(c)) {
      cout.put(c);
    }
    // clear eofbit and failbit set due to EOF
    file.clear();
    // close file
    file.close();
  }
}

위 코드에서 스트림 객체는 여러 파일에서 사용할 수 있기 때문에 clear() 함수를 호출하여 EOF에서 설정된 상태 플래그를 지워주어야 하며, 함수 open()은 이전 상태 플래그를 지우지 않습니다. 따라서 만약 스트림이 열고 처리를 한 뒤, 닫을 때 good 상태가 아니라면 clear()를 호출하여 good 상태로 복구시켜두어야 합니다.

 

Random Access

아래의 함수들은 C++ 스트림에서 위치를 지정하기 위해 사용되는 멤버 함수입니다.

이 함수들은 읽기와 쓰기 위치를 구별합니다 (g는 get을 의미하고, p는 put을 의미합니다). read-position 함수는 basic_istream<>에 정의되어 있고, write-position 함수는 basic_ostream<>에 정의되어 있습니다. 그러나 모든 스트림 클래스가 positioning을 지원하는 것은 아닌데, 예를 들어, cin, cout, cerr와 같은 스트림에서는 positioning이 정의되지 않습니다. 대체로 istream과 ostream 타입의 객체의 레퍼런스가 전달되기 때문에 파일의 positioning은 베이스 클래스에서 정의됩니다.

 

seekg()와 seekp()는 절대 위치나 상대 위치를 사용하여 호출할 수 있습니다. 절대 위치를 처리하고 싶다면 tellg()와 tellp()를 사용해야 하는데, 이 함수들은 pos_type 타입 값으로 절대 위치를 반환합니다. 이 값은 정수값이 아니며 단순히 인덱스로 문자의 위치를 표현한 것입니다. 이는 논리적 위치와 실제 위치는 다를 수 있기 때문입니다. 예를 들어, 윈도우의 텍스트 파일은 개행 문자가 논리적으로는 하나의 문자이지만 두 개의 문자로 표현됩니다. 만약 문자를 다중바이트 표현을 사용하면 상황은 더 나빠집니다.

 

pos_type의 정확한 정의는 조금 복잡합니다. C++ 표준 라이브러리는 file position을 위해 전역 클래스 템플릿 fpos<>를 정의합니다. 이 클래스는 char에서 streampos 타입을 정의하는데 사용되고, wchar_t를 위해 wstreampos 타입을 정의하는데 사용됩니다. 이들의 데이터 타입은 대응되는 character traits의 pos_type으로 정의되고, 이 traits의 pos_type 멤버는 대응되는 스트림 클래스의 pos_type을 정의하는데 사용됩니다.

따라서, streampos도 스트림 위치를 위한 타입으로 사용할 수 있습니다. 하지만 정수 타입이 아니기 때문에 long이나 unsigned long은 사용할 수 없습니다.

// save current file position
std::ios::pos_type pos = file.tellg();
...
// seek to file position saved in pos
file.seekg(pos);

위의 코드에서 line 2 코드는 아래와 같이 사용할 수도 있습니다.

std::streampos pos;

 

상대적인 값을 나타내기 위해서 다음의 세 가지 위치가 정의되어 있고, 이들에 대한 상대값으로 오프셋을 전달합니다.

위 상수들은 ios_base 클래스에 정의되어 있으며 타입은 seekdir 입니다.

 

오프셋의 데이터 타입은 streamoff의 간접 정의인 off_type 입니다. pos_type과 유사하게 streamoff는 traits의 off_type과 스트림 클래스를 정의하는데 사용됩니다. 하지만 streamoff는 부호가 있는 정수 타입이기 때문에 정수값을 오프셋으로 사용할 수 있습니다. 아래 예제 코드를 참조바랍니다.

// seek to the beginning of the file
file.seekg(0, std::ios::beg);
...
// seek 20 characters forward
file.seekg(20, std::ios::cur);
...
// seek 10 characters before the end
file.seekg(-10, std::ios::end);

파일 내에서 위치를 다룰 때에는 조심해야 하는데, 파일의 시작 이전이나 파일의 끝 이후를 가리킬 때의 동작은 undefined 입니다.

 

아래 예제 코드는 seekg()를 어떻게 사용하는지 보여줍니다.

#include <iostream>
#include <fstream>
using namespace std;

void printFileTwice(const char* filename)
{
  // open file
  ifstream file(filename);
  // print contents the first time
  cout << file.rdbuf();
  // seek to the beginning
  file.seekg(0);
  // print contents the second time
  cout << file.rdbuf();
}

int main(int argc, char** argv)
{
  // print all files passed as a command-line argument twice
  for (int i = 0; i < argc, i++) {
    printFileTwice(argv[i]);
  }
}

여기서는 file의 내용을 출력하기 위해 file.rdbuf()를 사용했습니다. 이는 스트림의 상태를 조작하지 못하는 스트림 버퍼를 사용한다는 의미입니다. 만약 file의 내용을 getline()과 같은 스트림 인터페이스 함수로 출력한다면, EOF를 만났을 때 파일의 상태가 변경되므로 clear()가 필요합니다.

 

read/write-position은 다양한 함수를 통해 조작할 수 있는데, 표준 스트림의 경우, 같은 스트림 버퍼에 대해서는 같은 read/write position을 유지합니다.

 

Using File Descriptors

일부 구현에서는 이미 열려있는 I/O 채널에 스트림을 연결할 수 있는 기능을 제공합니다. 이를 위해서는 파일 스트림을 file descriptor로 초기화해야 합니다.

 

file descriptor는 열려있는 I/O 채널을 식별하기 위한 정수값입니다. 유닉스와 같은 시스템에서 file descriptor는 OS의 I/O 함수에 대한 low-level 인터페이스를 사용합니다. 미리 정의되어 있는 file descriptor는 다음과 같습니다.

• 0 : standard input channel
• 1 : standard output channel
• 2 : standard error channel

이 채널들은 파일, 콘솔, 다른 프로세스 또는 다른 I/O facility에 연결되어 있을 수 있습니다.

 

하지만 C++ 표준 라이브러리에서는 file descriptor를 통해 I/O 채널에 스트림을 연결하는 기능을 제공하지 않습니다. 다만 실제로 사용할 수 있는 가능성은 존재합니다. 문제는 OS에 의존적이다는 것인데 POSIX와 같은 운영체제 인터페이스에서는 표준이 부족하기 때문입니다. 어쨌든 file descriptor를 사용하여 스트림을 초기화할 수 있는데, 이를 사용할 수 있는 방식에 대해서는 스트림 버퍼에 대해서 살펴볼 때 알아보도록 하겠습니다.

 

 

Stream Classes for Strings

문자열을 읽거나 문자열을 쓸 때도 스트림 클래스의 메커니즘을 사용할 수 있습니다. 문자열 스트림은 버퍼를 제공하지만 I/O 채널은 아닙니다. 이 퍼버와 문자열은 특수함 함수를 사용하여 조작할 수 있는데, 실제 I/O와는 관계없이 I/O를 처리하고 싶을 때 주로 사용됩니다. 예를 들면, 출력할 텍스트를 문자열에 포맷을 맞추어 저장한 뒤, 이후에 출력 채널로 전달할 수 있습니다. 또한, 입력을 한 행 씩 읽은 후 문자열 스트림을 사용해 각 행을 처리할 수도 있습니다.

 

C++98 표준화 이전에는 문자열 스트림 클래스는 문자열을 표현하기 위해서 char* 타입을 사용했는데, 이제는 string 타입(또는, 일반적으로 basic_string<>)을 사용합니다.

 

String Stream Classes

문자열 스트림에 대해 아래의 스트림 클래스들이 정의되어 있습니다.

• read를 위한 istringstream과 wistringstream으로 특수화된 basic_istringstream<> 클래스 템플릿 (input string stream)
• write를 위한 ostringstream과 wostringstream으로 특수화된 basic_ostringstream<> 클래스 템플릿 (output string stream)
• read/write 모두를 위한 stringstream과 wstringstream으로 특수화된 basic_stringstream<> 클래스 템플릿
• 다른 문자열 스트림 클래스가 문자를 읽고 쓰기 위해 사용하는 stringbuf와 wstringbuf로 특수화된 basic_stringbuf<> 클래스 템플릿

위 클래스들과 스트림의 베이스 클래스와의 관계는 파일 스트림 클래스와 유사합니다.

 

문자열 스트림 클래스의 인터페이스에서 주요 멤버 함수는 str()인데, 문자열 스트림 클래스를 조작하기 위해 사용됩니다.

아래 예제 코드는 문자열 스트림을 어떻게 사용할 수 있는지 보여줍니다.

#include <iostream>
#include <sstream>
#include <bitset>
using namespace std;

int main(int argc, char** argv)
{
  ostringstream os;

  // decimal and hexadecimal value
  os << "dec: " << 15 << hex << " hex: " << 15 << endl;
  cout << os.str() << endl;

  // append floating value and bitset
  bitset<15> b(5789);
  os << "float: " << 4.67 << " bitset: " << b << endl;

  // overwirte with octal value
  os.seekp(0);
  os << "oct: " << oct << 15;
  cout << os.str() << endl;
}

위 코드에서는 먼저 os에 10진수와 16진수의 값을 쓰고, 부동소수점 값과 이진수 값이 추가됩니다. 그리고 write-position을 스트림의 처음으로 이동시키기 위해 seekp()를 사용합니다. 따라서, 이동한 뒤에 << 연산자를 사용하면 문자열 시작 부분에 write를 하고, 기존의 문자열을 덮어쓰게 되고, 덮어써지지 않은 문자들은 그대로 남게 됩니다.

만약 스트림의 현재 내용을 삭제하고 싶다면, 함수 str()을 사용하여 버퍼에 빈 내용을 할당할 수 있습니다.

strm.str("");

 

입력 문자열 스트림은 현재 문자열에서 포맷을 맞추어 읽을 때 주로 사용됩니다. 예를 들어, 이 방식을 사용하면 행 별로 데이터를 읽어 쉽게 각 행을 개별적으로 분석할 수 있습니다. 아래 예제 코드는 문자열 s에서 읽은 3을 정수 x에 할당하고, 나머지 0.7은 f에 할당합니다.

int x;
float f;
std::string s = "3.7";

std::istringstream is(s);
is >> x >> f;

 

문자열 스트림은 존재하는 문자열로 파일 open mode에서 사용되는 플래그와 함께 생성할 수 있습니다. ios::ate 플래그를 사용하면 기존의 문자열의 끝에 이어서 문자를 덧붙일 수 있습니다.

std::string s("value: ");
...
std::ostringstream os(s, std::ios::out | std::ios::ate);
os << 77 << " " << std::hex << 77 << std::endl;
std::cout << os.str(); // "value: 77 4d"
std::cout << s;        // "value: "

위의 결과를 보면 알 수 있듯이 str()에서 반환된 문자열은 문자열 s의 복사본인데, 끝에 77의 10진수 값과 16진수 값이 추가되었습니다. 기존 문자열 s 자체는 수정되지 않았습니다.

 

Move Semantics for String Stream

C++11부터 문자열 스트림은 rvalue와 move semantics를 제공합니다. ostream은 스트림의 rvalue 레퍼런스를 받는 출력 연산자를, istream은 rvalue 레퍼런스를 받는 반복자를 제공합니다. 따라서, 임시로 생성한 스트림 객체를 사용할 수 있을 뿐만 아니라 원하는대로 동작시킬 수 있습니다.

예를 들어, 아래와 같이 임시로 생성한 문자열 스트림에 write 할 수 있습니다.

#include <iostream>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
using namespace std;

tuple<string,string,string> parseName(string name)
{
  string s1, s2, s3;
  istringstream(name) >> s1 >> s2 >> s3;
  if (s3.empty()) {
    return tuple<string,string,string>(move(s1),"",move(s2));
  }
  else {
    return tuple<string,string,string>(move(s1),move(s2),move(s3));
  }
}

int main(int argc, char** argv)
{
  auto t1 = parseName("Nocolai M. Josuttis");
  cout << "firstname: " << get<0>(t1) << endl;
  cout << "middle: " << get<1>(t1) << endl;
  cout << "lastname: " << get<2>(t1) << endl;

  auto t2 = parseName("Nico Josuttis");
  cout << "firstname: " << get<0>(t2) << endl;
  cout << "middle: " << get<1>(t2) << endl;
  cout << "lastname: " << get<2>(t2) << endl;
}

 

char* Stream Classes

C++11 이전에는 문자열 스트림에 char* 타입을 사용했습니다. 따라서, 하위 호환성을 위해 char* 스트림 클래스가 제공됩니다. 이 스트림 클래스의 인터페이스는 에러가 발생하기 매우 쉽고, 올바르게 사용되는 경우가 거의 없고 요즘은 사용을 거의 하지 않는 것으로 보이기 때문에 여기서 따로 다루지는 않겠습니다.

 

참고: https://en.cppreference.com/w/cpp/header/strstream

Standard library header <strstream> (deprecated in C++98) - cppreference.com