streambuf Layerstreambuf 계층 사용하기
The istream and ostream classes are meant to handle
conversion between objects in your program and their textual representation.
istream과 ostream 클래스는 프로그램의 객체들과
그것들의 문자 그대로의 표현 사이의 전환을 다룬다.
By contrast, the underlying streambuf class is for transferring
raw bytes between your program, and input sources or output sinks.
Different streambuf subclasses connect to different kinds of
sources and sinks.
대조적으로 기초를 이루는 streambuf 클래스는 프로그램과
입력 소스 또는 출력 싱크(sink) 간에 원시(raw) 바이트를
이동시킨다. 다른 streambuf 서브 클래스들과 다른 종류의 소스, 싱크를 연결한다.
The GNU implementation of streambuf is still evolving; we
describe only some of the highlights.
streambuf에 대한 GNU 구현은 아직 전개 중이다. 몇몇
중요한 부분만 설명한다.
streambufstreambuf의 영역
Streambuf buffer management is fairly sophisticated (this is a nice way to say "complicated"). The standard protocol has the following "areas":
Streambuf 버퍼 관리는 매우 정교하다("복잡한"이라는 표현이 나을 것이다). 표준 프로토콜에는 다음과 같은 "영역(area)"이 있다.
The GNU streambuf design extends this, but the details are
still evolving.
GNU streambuff 디자인은 이것을 확장한다. 그러나 세부 사항은
아직 전개 중이다.
The following methods are used to manipulate these areas.
These are all protected methods, which are intended to be
used by virtual function in classes derived from streambuf.
They are also all ANSI/ISO-standard, and the ugly names
are traditional.
(Note that if a pointer points to the 'end' of an area,
it means that it points to the character after the area.)
다음 메소드를 사용해 이 영역들을 조작한다. 이것들은 protected 메소드이고,
streambuf에서 파생된 클래스들에 속한 가상함수에
의해 사용된다. 그것들은 또한 ANSI/ISO 표준이고 전통적으로 추한
이름이다(포인터가 영역의 '끝'을
가리키면 그것은 영역 다음에 있는 문자를 가리킨다).
pptr() < epptr (), the pptr()
returns a pointer to the current put position.
(In that case, the next write will
overwrite *pptr(), and increment pptr().)
Otherwise, there is no put position available
(and the next character written will cause streambuf::overflow
to be called).
pptr() < epptr()이면, pptr()은 현재 put 위치(position)를 가리키는
포인터를 리턴한다(이 경우, 다음 쓰기는 *pptr()를 덮어쓸 것이다.
그리고 pptr()을 증가시킨다). 그렇지 않으면, 사용할 수
있는 put 위치가 없다(그리고
쓰여진 다음 문자가 streambuf::overflow를 호출할 것이다).
gptr() < egptr (), then gptr()
returns a pointer to the current get position.
(In that case the next read will read *gptr(),
and possibly increment gptr().)
Otherwise, there is no read position available
(and the next read will cause streambuf::underflow
to be called).
gptr() < egptr()이면, gptr()는 현재
get 위치를 가리키는
포인터를 리턴한다(이 경우 다음 읽기는 *gptr()을 읽고 가능하면 gptr()을
증가시킬 것이다). 그렇지 않으면, 이용할 수 있는 읽기 위치가 없다(그리고 다음
읽기는 streambuf::underflow를 호출할 것이다).
overflowoverflow
Suppose you have a function write_to_window that
writes characters to a window object. If you want to use the
ostream function to write to it, here is one (portable) way to do it.
This depends on the default buffering (if any).
window 객체에 문자를 쓰는 write_to_window
함수가 있다고 가정하자. 만약 ostream 함수를 사용해 그것에 쓰려고 하면,
여기에 알맞은 방법이 있다. 이것은 기본 buffering에 의존한다.
#include <iostream.h>
/* Returns number of characters successfully written to win. */
extern int write_to_window (window* win, char* text, int length);
class windowbuf : public streambuf {
window* win;
public:
windowbuf (window* w) { win = w; }
int sync ();
int overflow (int ch);
// Defining xsputn is an optional optimization.
// (streamsize was recently added to ANSI C++, not portable yet.)
streamsize xsputn (char* text, streamsize n);
};
int windowbuf::sync ()
{ streamsize n = pptr () - pbase ();
return (n && write_to_window (win, pbase (), n) != n) ? EOF : 0;
}
int windowbuf::overflow (int ch)
{ streamsize n = pptr () - pbase ();
if (n && sync ())
return EOF;
if (ch != EOF)
{
char cbuf[1];
cbuf[0] = ch;
if (write_to_window (win, cbuf, 1) != 1)
return EOF;
}
pbump (-n); // Reset pptr().
return 0;
}
streamsize windowbuf::xsputn (char* text, streamsize n)
{ return sync () == EOF ? 0 : write_to_window (win, text, n); }
int
main (int argc, char**argv)
{
window *win = ...;
windowbuf wbuf(win);
ostream wstr(&wbuf);
wstr << "Hello world!\n";
}
streambuf objectsstreambuf objects
The GNU streambuf class supports printf-like
formatting and scanning.
GNU streambuf 클래스는 printf 같은 포맷팅과
스캐닝을 지원한다.
fprintf(file, format, ...).
The format is a printf-style format control string, which is used
to format the (variable number of) arguments, printing the result on
the this streambuf. The result is the number of characters printed.
]
fprintf(file, format, ....)와
비슷한다. format은 printf 스타일의 포맷
제어 문자열이다. 이 문자열은 (여러 개의) 인자를 포맷하고 결과를
this streambuf에 출력한다. 결과는 출력된 문자의 수다.
vfprintf(file, format, args).
The format is a printf-style format control string, which is used
to format the argument list args, printing the result on
the this streambuf. The result is the number of characters printed.
vfprintf(file, format, args)와 비슷하다. format은
printf 스타일의 포맷 제어 문자열로 매개변수 리스트
args를 포맷하고 this
streambuf에 결과를 출력한다. 결과는 출력된 문자들의 수다.
fscanf(file, format, ...).
The format is a scanf-style format control string, which is used
to read the (variable number of) arguments from the this streambuf.
The result is the number of items assigned, or EOF in case of
input failure before any conversion.
fscanf(fileformat, ...)과
비슷하다. format은 scanf 스타일의 포맷
제어 문자열이다. 이 문자열은 (여러 개의) 인자를 this
streambuf에서 읽어들인다.
결과는 대입된 아이템의 개수이거나 변환 전 입력 실패 경우에 나오는 EOF다.
streambuf::scan, but takes a single va_list argument.
streambuf::scan과 비슷하다, 그러나 단일 va_list 인자를
받는다.
stdiostdio
A stdiobuf is a streambuf object that points to
a FILE object (as defined by stdio.h).
All streambuf operations on the stdiobuf are forwarded
to the FILE. Thus the stdiobuf object provides a
wrapper around a FILE, allowing use of streambuf
operations on a FILE. This can be useful when mixing
C code with C++ code.
stdiobuf는 FILE
객체(stdio.h에 정의된)를 가리키는 streambuf
객체다. stdiobuf의 모든 streambuf 오퍼레이션은 FILE에 전달된다. 그러므로
stdiobuf 객체는 FILE에 래퍼를 제공해
FILE에서 streambuf를 사용할 수 있게 한다.
이것은 C 코드를 C++ 코드와 섞을(mix) 때 유용하다.
The pre-defined streams cin, cout, and cerr are
normally implemented as stdiobuf objects that point to
respectively stdin, stdout, and stderr. This is
convenient, but it does cost some extra overhead.
미리 정의된(pre-defined) 스트림 cin, cout,
and cerr은 일반적으로 각각 stdin, stdout,
stderr를 가리키는 stdiobuf 객체로 구현된다. 이것은 매우 편리하지만, 약간의
오버헤드가 있다.
If you set things up to use the implementation of stdio provided
with this library, then cin, cout, and cerr will be
set up to use stdiobuf objects, since you get their benefits
for free. See section C Input and Output.
만약 이 라이브러리로 제공된 stdio를 구현하기 위해
설정하면, 당신의 제약없이 그것들의 이점을 얻기 때문에
cin, cout, cerr은
stdiobuf 객체들을
사용하여 설정할 것이다. C 입력과
출력 절을 참고하라.
The procbuf class is a GNU extension. It is derived from
streambuf. A procbuf can be closed (in which case
it does nothing), or open (in which case it allows communicating
through a pipe with some other program).
procbuf 클래스는 GNU 확장으로 streambuf에서 파생되었다.
procbuf는 (아무 것도 없는 경우) 닫혀질
수 있거나 (한 프로그램에서 다른 프로그램으로
파이프를 통해 통신을 허락할 경우) 열린다.
procbuf in a closed state.
procbuf를 closed 상태로 만든다.
쉘(`/bin/sh')을 command에 의해 지정된 프로그램을 실행한다.
If mode is `ios::in', standard output from the program is sent
to a pipe; you can read from the pipe by reading from the
procbuf. (This is similar to `popen(command, "r")'.)
만약 mode가 `ios::in'이면 프로그램의 표준
출력은 파이프로
보내진다. procbuf에서 읽음으로써 파이프로부터 읽을 수 있다(이것은
`popen(command, "r")'와 비슷하다).
If mode is `ios::out', output written to the
procbuf is written to a pipe; the program is set up to read its
standard input from (the other end of) the pipe. (This is similar to
`popen(command, "w")'.)
만약 mode가 `ios::out'이면 procbuf에 쓰여진 출력은
파이프에 쓰여진다. 프로그램은 파이프(의 다른 한 쪽)에서 표준 입력을 읽기 위해 설정된다( 이것은
`popen(command, "w")'와 비슷하다).
The procbuf must start out in the closed state.
Returns `*this' on success, and `NULL' on failure.
procbuf는 closed 상태로 시작되어야만 한다. 성공하면 `*this'를 리턴하고 실패하면
`NULL'을 리턴한다.
The GNU iostream library allows you to ask a streambuf to
remember the current position. This allows you to go back to this
position later, after reading further. You can back up arbitrary
amounts, even on unbuffered files or multiple buffers' worth, as long as
you tell the library in advance. This unbounded backup is very useful
for scanning and parsing applications. This example shows a typical
scenario:
GNU iostream 라이브러리는 streambuf가 현재 위치를
기억하게 한다.
이것은 좀더 읽은 후에 이 위치로 돌아가는
것을 허락한다. 미리 라이브러리에 알렸다면 버퍼리드 안 된 파일 또는 다중 버퍼
값이라도 원하는 만큼 백업할 수 있다. 이 제약없는 백업은 스캐닝과 파싱
응용 프로그램에 매우 유용하다. 이 예는 전형적인 개요를 보여준다.
// Read either "dog", "hound", or "hounddog".
// If "dog" is found, return 1.
// If "hound" is found, return 2.
// If "hounddog" is found, return 3.
// If none of these are found, return -1.
int my_scan(streambuf* sb)
{
streammarker fence(sb);
char buffer[20];
// Try reading "hounddog":
if (sb->sgetn(buffer, 8) == 8
&& strncmp(buffer, "hounddog", 8) == 0)
return 3;
// No, no "hounddog": Back up to 'fence'
sb->seekmark(fence); //
// ... and try reading "dog":
if (sb->sgetn(buffer, 3) == 3
&& strncmp(buffer, "dog", 3) == 0)
return 1;
// No, no "dog" either: Back up to 'fence'
sb->seekmark(fence); //
// ... and try reading "hound":
if (sb->sgetn(buffer, 5) == 5
&& strncmp(buffer, "hound", 5) == 0)
return 2;
// No, no "hound" either: Back up and signal failure.
sb->seekmark(fence); // Backup to 'fence'
return -1;
}
streammarker associated with sbuf
that remembers the current position of the get pointer.
streammarker를
만든다.
*this and mark2 (which must point into the same
streambuffer as this).
*this와 일치하는 get 위치와
mark2(this와 같은 streambuffer를
가리켜야 한다) 사이의 차이를 리턴한다.
An indirectbuf is one that forwards all of its I/O requests to another streambuf.
indirectbuf는 다른 streambuf에 I/O 요청 모두를 전달한다.
An indirectbuf can be used to implement Common Lisp
synonym-streams and two-way-streams:
indirectbuf는 Common Lisp 유사 스트림과 두방향
스트림으로 사용할 수 있다.
class synonymbuf : public indirectbuf {
Symbol *sym;
synonymbuf(Symbol *s) { sym = s; }
virtual streambuf *lookup_stream(int mode) {
return coerce_to_streambuf(lookup_value(sym)); }
};