버퍼(buffer)와 표준입력 스트림(stream) 그리고 getch 와 getchar

버퍼(Buffer)

입력 버퍼는 사용자가 키보드나 마우스를 통해 입력한 데이터를 임시적으로 저장하는 메모리 공간입니다.

일반적으로 입력 버퍼는 FIFO(First-In-First-Out) 방식으로 동작합니다.

사용자가 키를 누르면 해당 키의 입력 데이터가 입력 버퍼의 맨 뒤에 추가됩니다.

그리고 프로그램에서 입력 함수를 호출할 때마다, 입력 버퍼의 가장 앞에 있는 데이터가 제거되며, 이 데이터를 함수가 반환합니다.

 

입력 버퍼는 보통 운영체제에서 관리되며, 이를 통해 여러 개의 프로그램이 동시에 입력을 처리할 수 있습니다. 입력 버퍼는 입력 함수를 호출하기 전까지는 입력 데이터를 저장하기 위한 임시적인 저장소일 뿐입니다. 따라서 입력 함수를 호출하면 입력 버퍼에서 데이터가 제거되므로, 같은 데이터를 두 번 이상 읽을 수 없습니다.

 

예를 들어, 사용자가 "Hello"라는 문자열을 입력하고, 프로그램에서 입력 함수를 두 번 호출하는 경우를 생각해보겠습니다

 

#include <iostream>
using namespace std;

int main() {
    char ch1, ch2, ch3, ch4, ch5;
    ch1 = getchar();
    ch2 = getchar();
    ch3 = getchar();
    ch4 = getchar();
    ch5 = getchar();

    cout << "입력한 문자: " << ch1 << ch2 << ch3 << ch4 << ch5 << endl;
    return 0;
}

위 예제 코드에서 사용자가 "Hello"를 입력하면, 입력 버퍼에는 "H", "e", "l", "l", "o", '\n'이 저장됩니다.
이후 getchar() 함수를 다섯 번 호출하면, 입력 버퍼에서 맨 앞에 있는 데이터가 제거되며, 이를 함수가 반환합니다.
따라서, 위 예제 코드에서 출력되는 문자열은 "Hello\n"이 됩니다.
즉, 입력 버퍼는 프로그램이 입력 데이터를 효율적으로 처리할 수 있도록 하는 운영체제의 기능으로,
입력 함수를 호출할 때마다 데이터를 반환하고, 버퍼에서 제거합니다.

 

 

입력 버퍼는 운영체제에서 제공하는 메모리 공간 중 하나로, 일반적으로 커널 내부의 메모리 영역에 위치합니다.

(따라서 프로그램에서는 입력 버퍼에 직접적으로 접근할 수 없습니다)

운영체제는 표준 입력 스트림에서 데이터를 읽어들이고, 이를 입력 버퍼에 저장합니다.

이후 입력 함수가 호출되면, 입력 버퍼에서 데이터를 읽어들이고, 함수가 반환됩니다.

 

입력 버퍼는 보통 운영체제에서 관리되며, 프로그램에서는 이를 직접적으로 조작할 수 없습니다.

대신, 프로그램은 입력 함수를 호출하여 입력 버퍼에서 데이터를 읽어들입니다.

입력 버퍼의 크기는 운영체제나 터미널의 설정에 따라 다르며, 이를 조절할 수 있는 경우도 있습니다.

일반적으로 입력 버퍼의 크기는 몇 바이트에서 몇 킬로바이트까지 가능합니다

입력 버퍼의 크기는 일반적으로 정적으로 결정됩니다.
즉, 프로그램이 실행될 때 버퍼의 크기가 결정되고, 이후에는 변경되지 않습니다.
이는 대부분의 운영체제에서 버퍼의 크기가 고정되어 있기 때문입니다.
버퍼의 크기는 운영체제나 터미널의 설정에 따라 다르며, 보통 수십바이트에서 수천바이트까지 가능합니다.
이 값은 보통 프로그램에서 변경할 수 없으며, 운영체제나 터미널 설정을 변경하여 버퍼의 크기를 조절할 수 있습니다.
또한, 동적으로 버퍼의 크기를 조절하는 방법도 있습니다.
이 경우에는 프로그램에서 직접적으로 버퍼를 관리하여 크기를 조절할 수 있으며, 이를 위해서는 동적 메모리 할당 함수인 malloc, realloc, free 등을 이용하여 메모리를 할당하고 해제해야 합니다.
그러나 이 방법은 일반적으로 복잡하고 오버헤드가 크므로, 버퍼 크기를 미리 결정하는 것이 일반적입니다

 

버퍼와 사용자 메모리

 

입력 함수가 호출되면, 입력 버퍼에 저장된 데이터를 가져와서 스택이나 힙 영역에 저장할 수 있습니다.

이 때, 입력 함수가 반환하는 값은 입력 버퍼에서 가져온 데이터가 저장된 위치를 나타내는 포인터입니다.

프로그래머는 이 포인터를 이용하여 가져온 데이터를 변수나 배열에 저장할 수 있습니다

 

예를 들어, C++에서 std::cin을 이용하여 입력을 받는 경우, 입력 버퍼에 저장된 데이터를 가져와서 std::string이나 char 배열 등의 변수에 저장할 수 있습니다. 이 때, std::cin 함수는 입력 버퍼에서 가져온 데이터가 저장된 위치를 나타내는 포인터를 반환하며, 이를 이용하여 변수에 데이터를 저장합니다

 

표준 입력 스트림(standard input stream)
표준 입력 스트림은 키보드나 파일 등의 입력 소스에서 데이터를 읽어오는 C++ 표준 라이브러리의 입력 스트림 객체입니다.
표준 입력 스트림은 std::cin 객체를 통해 사용할 수 있으며, >> 연산자를 이용하여 데이터를 읽어올 수 있습니다.
예를 들어, int형 변수에 값을 입력받는 코드는 다음과 같습니다.

int num;
std::cin >> num;

표준 입력 스트림은 프로그램에서 입력을 받는 가장 일반적인 방법입니다.
키보드로부터 데이터를 입력받는 경우에는 표준 입력 스트림이 사용되며,
파일로부터 데이터를 입력받는 경우에도 표준 입력 스트림을 이용하여 파일의 내용을 읽어올 수 있습니다.

 

std::cin

 

std::cin은 C++ 표준 라이브러리에서 제공하는 입력 스트림 객체 중 하나로, 표준 입력(standard input)으로부터 데이터를 읽어옵니다. std::cin은 iostream 헤더 파일에 정의되어 있으며,아래와 같이 동작합니다.

 

1. 키보드나 파일 등의 입력 소스에서 데이터를 읽어옵니다. 이때, 키보드로부터 데이터를 입력받는 경우에는 사용자가 Enter 키를 입력할 때까지 입력을 받습니다

2. 입력된 데이터를 입력 버퍼(input buffer)에 저장합니다

3. 프로그램에서 std::cin 객체를 이용하여 데이터를 읽어오는 경우, 입력 버퍼에서 데이터를 읽어옵니다

4. 읽어온 데이터를 변수에 저장합니다. 이때, >> 연산자를 이용하여 데이터를 읽어옵니다.

     >> 연산자는 입력 버퍼에서 공백(space), 탭(tab), 개행(newline) 등을 구분자로 사용하여 데이터를 분리합니다

 

 

std::cin은 입력 버퍼에 데이터가 있으면 즉시 데이터를 읽어옵니다.

따라서, std::cin을 이용하여 입력을 받을 때에는 입력 버퍼가 비어있는지 확인하는 것이 중요합니다.

입력 버퍼가 비어있지 않은 상태에서 std::cin을 이용하여 데이터를 읽어오면, 입력 버퍼에 남아있는 데이터를 읽어올 수 있습니다.

이를 방지하기 위해서는 std::cin을 이용하여 데이터를 읽어오기 전에 입력 버퍼를 비워주는 작업이 필요합니다

 

예를 들어, 다음과 같은 코드는 사용자로부터 정수를 입력받고, 입력된 값을 출력합니다.

 

#include <iostream>

int main() {
    int num;
    std::cin >> num;
    std::cout << "입력된 값: " << num << std::endl;
    return 0;
}

 

이 코드는 std::cin을 이용하여 사용자로부터 정수를 입력받은 후, 입력된 값을 출력합니다.

>> 연산자를 이용하여 데이터를 읽어올 때, 입력 버퍼에 데이터가 없는 경우에는 사용자의 입력을 기다리며,

입력 버퍼에 데이터가 있는 경우에는 바로 데이터를 읽어옵니다

 

getch

 

C++에서 콘솔 입력을 받을 때 버퍼를 이용하지 않고 바로 입력을 받는 방법으로는 "getch()" 함수를 사용하는 방법이 있습니다.

 

getch()" 함수는 conio.h 헤더 파일에 정의되어 있으며, 키보드 입력을 즉시 받아서 처리합니다. 이 함수는 키 입력을 받으면 바로 반환하므로 버퍼를 사용하지 않습니다

 

다음은 "getch()" 함수를 사용하여 콘솔에서 한 글자를 입력받는 예제 코드입니다.

 

#include <iostream>
#include <conio.h>

using namespace std;

int main() {
    char ch = getch();
    cout << "입력한 문자: " << ch << endl;
    return 0;
}

 

위 예제 코드에서 getch() 함수는 사용자로부터 한 글자를 입력받고, 그 결과를 변수 ch에 저장합니다.
그리고 저장된 값을 출력합니다. 이렇게 하면 입력 버퍼를 사용하지 않고 즉시 입력을 받을 수 있습니다.

 

getchar

 

"getchar()" 함수는 stdio.h 헤더 파일에 정의되어 있으며, 표준 입력 스트림에서 한 글자를 읽어서 처리합니다. 이 함수는 버퍼를 사용하지 않으므로 입력을 받을 때마다 바로 처리할 수 있습니다.

 

다음은 "getchar()" 함수를 사용하여 콘솔에서 한 글자를 입력받는 예제 코드입니다.

 

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    char ch = getchar();
    cout << "입력한 문자: " << ch << endl;
    return 0;
}

 

위 예제 코드에서 getchar() 함수는 표준 입력 스트림에서 한 글자를 읽어서 변수 ch에 저장합니다.
그리고 저장된 값을 출력합니다. 이렇게 하면 입력 버퍼를 사용하지 않고 즉시 입력을 받을 수 있습니다

 

C++에서 콘솔 입력을 받을 때 버퍼를 사용하지 않는 또 다른 방법으로는 "getchar_unlocked()" 함수를 사용하는 방법이 있습니다

"getchar_unlocked()" 함수는 getchar() 함수와 비슷하지만, 내부적으로 동기화를 수행하지 않아서 더 빠르게 입력을 받을 수 있습니다. 이 함수는 일반적으로 멀티스레드 환경에서 사용되지 않으며, 동기화가 필요하지 않은 단일 스레드 환경에서 사용됩니다

다음은 "getchar_unlocked()" 함수를 사용하여 콘솔에서 한 글자를 입력받는 예제 코드입니다.

 

#include <iostream>
#include <cstdio>

using namespace std;

inline char read_char() {
    char c = getchar_unlocked();
    while (c == ' ' || c == '\n' || c == '\r') {
        c = getchar_unlocked();
    }
    return c;
}

int main() {
    char ch = read_char();
    cout << "입력한 문자: " << ch << endl;
    return 0;
}

 

위 예제 코드에서 read_char() 함수는 getchar_unlocked() 함수를 사용하여 한 글자를 읽어서 처리합니다. 이 함수는 입력 버퍼를 사용하지 않으므로 더 빠르게 입력을 처리할 수 있습니다. 함수 내부에서는 입력 받은 값이 공백 문자(' '), 개행 문자('\n'), 혹은 캐리지 리턴('\r')인 경우에는 다시 입력을 받도록 처리합니다.

 

getch()와 getchar()  차이

 

getch()와 getchar() 함수는 모두 콘솔에서 입력을 받는 함수입니다. 그러나 두 함수에는 몇 가지 차이가 있습니다.

 

1. 헤더파일

 

getch() 함수는 conio.h 헤더 파일에 정의되어 있고, getchar() 함수는 stdio.h 헤더 파일에 정의되어 있습니다

 

2. 입력 대기 방식

 

getch() 함수는 사용자가 키를 누르는 즉시 바로 입력을 받아들입니다. 이에 반해 getchar() 함수는 사용자가 입력을 마치고 Enter 키를 누르면 입력을 받아들입니다

 

3. 입력 처리 방식

 

getch() 함수는 입력 받은 키 값을 즉시 반환합니다. 이에 반해 getchar() 함수는 표준 입력 스트림에서 한 글자를 읽어서 반환합니다

 

4. 입력 처리 대상

 

getch() 함수는 콘솔에서 키 입력만을 받아들입니다.

이에 반해 getchar() 함수는 콘솔에서 뿐만 아니라 파일 등에서도 입력을 받아들일 수 있습니다

따라서, getch() 함수는 사용자가 키 입력을 바로 반영하여 빠른 입력 처리가 필요한 경우에 사용되며, getchar() 함수는 문자열 입력을 받아야 하는 경우나, 파일에서 입력을 받아들여야 하는 경우에 사용됩니다

getchar() 함수는 표준 입력 스트림에서 한 글자씩 읽어들입니다. 때문에 두 글자 이상을 입력하고 Enter 키를 누르면 첫 번째 글자만 읽어들이고, 두 번째 글자는 입력 버퍼에 남게 됩니다. 그리고 Enter 키는 새로운 줄 문자('\n')으로 인식되어 입력 버퍼에 추가됩니다.

이후 getchar() 함수를 다시 호출하면 입력 버퍼에 있는 다음 글자를 읽어들이게 됩니다. 만약 입력 버퍼에 다음 글자가 없다면, getchar() 함수는 입력 대기 상태가 됩니다

따라서, getchar() 함수를 두 번 호출하면 두 글자 이상의 입력을 받을 수 있습니다. 다음은 이에 대한 예제 코드입니다

 

#include <iostream>
#include <cstdio>

using namespace std;

int main() {
    char ch1 = getchar();
    char ch2 = getchar();
    cout << "입력한 문자: " << ch1 << ch2 << endl;
    return 0;
}

위 예제 코드에서 첫 번째 getchar() 함수는 입력 버퍼에서 한 글자를 읽어들이고, 두 번째 getchar() 함수는 다음 글자를 읽어들입니다. 그리고 두 글자를 모두 출력합니다.