Veja o conteúdo da memória tampão em consola C

Question

Basta saber se existe alguma maneira (em C) para obter o conteúdo do tampão de consola, de preferência, como um tipo de matriz de char. Vai ser gravados em um arquivo, por isso, se estou perdendo algo estúpido que vai fazer exatamente isso, em seguida, aponte-o para fora. Pode ser específicos para Windows. Eu estou usando MinGW (GCC 3.4.5).

Agradecemos antecipadamente.

Answer 1

Eu acho que você precisa dar uma olhada em win32 funções do console, por exemplo, GetStdHandle () , ReadConsoleOutput () , WriteConsoleOutput etc. .

Answer 2

Em Win32, ReadConsoleOutput :

Lê dados de caracteres e atributo de cor de um bloco retangular de células de caracteres em um buffer de tela do console, ea função grava os dados em um bloco retangular em um local especificado no buffer de destino.

Answer 3

mingw-readline

E olhar GNU Readline

rl_line_buffer

Answer 4

Se é a tela em uma janela de comando, em seguida, potencialmente não, ou nenhuma maneira fácil. Você poderia cortar em eventos do Windows para selecionar-tudo, copiar, e ler a área de transferência.

Answer 5

Aqui está uma maneira de ler o buffer de console. GetNumCharsInConsoleBuffer é fazer com que os personagens totais escritos no buffer de tela do console, eu uso GetConsoleScreenBufferInfo dentro. Depois, eu criar uma matriz alocada dinamicamente de tamanho igual ao valor previamente retornado por GetNumCharsInConsoleBuffer + 1 (para zero terminando). E, finalmente, ReadConsoleBuffer vai encher o buffer apenas criado com o conteúdo do buffer de tela do console. Depois, se você quer escrever o conteúdo de seu buffer para um arquivo, você provavelmente vai precisar fazer alguma formatação. Com ReadConsoleOutputCharacter você obter uma região (retângulo) do buffer de tela do console. As linhas que você escreveu para o buffer de tela do console será preenchido com espaços para atender a região do buffer. que vai ser o mesmo com o ReadConsoleOutput/WriteConsoleOutput win32, você vai ter uma região (retângulo) de sua tela.

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

DWORD GetNumCharsInConsoleBuffer()
{
    CONSOLE_SCREEN_BUFFER_INFO buffer_info = {0};
    if( GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &buffer_info) != FALSE)
        return (DWORD) ( (buffer_info.dwSize.X * ( buffer_info.dwCursorPosition.Y + 1)) - (buffer_info.dwSize.X - ( buffer_info.dwCursorPosition.X)) );
    else
        return 0;
}

DWORD ReadConsoleBuffer(char* buffer, DWORD bufsize)
{
    DWORD num_character_read = 0;
    COORD first_char_to_read = {0};
    if( ReadConsoleOutputCharacterA(GetStdHandle(STD_OUTPUT_HANDLE), buffer, bufsize, first_char_to_read, &num_character_read) != FALSE)
        buffer[bufsize-1] = '\0';
    else
        buffer[0] = '\0';

    return num_character_read;
}

int main(int argc, char** argv)
{
    fprintf(stdout, "Writting\nin\nthe\nbuffer\n");
    DWORD bufsize = GetNumCharsInConsoleBuffer();

    if(bufsize > 0)
    {
        bufsize++; // Add 1 for zero-ending char

        char* buffer = malloc(bufsize);
        memset(buffer, 0, bufsize);

        ReadConsoleBuffer(buffer, bufsize);  

        puts("\nBuffer contents:");
        puts(buffer);

        free(buffer);
    }

    system("pause"); 
    return 0;
}

Output:

Writting
in
the
buffer
Buffer contents:
Writting
in
the
buffer

Appuyez sur une touche pour continuer...

EDIT:

Eu escrevi uma função que pode ser usado para escrever o conteúdo do buffer de tela para o arquivo. Esta função remove os espaços acolchoadas do buffer consola tela. ReadConsoleBuffer leva um ponteiro caractere nulo como primeiro argumento (buffer) que será alocado durante a sua execução. Então não se esqueça de apagá-lo por si mesmo. ReadConsoleBuffer vai escrever o tamanho do buffer no segundo argumento (bufsize).

#include <stdio.h>
#include <stdlib.h>
#include <crtdbg.h>
#include <Windows.h>

const char* ReadConsoleBuffer(char** buffer, size_t* bufsize)
{
    CONSOLE_SCREEN_BUFFER_INFO buffer_info = {0};
    if( GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &buffer_info) != FALSE )
    {
        size_t data_size = (size_t) ( (buffer_info.dwSize.X * ( buffer_info.dwCursorPosition.Y + 1)) - 
                                      (buffer_info.dwSize.X - ( buffer_info.dwCursorPosition.X + 1)) );

        if(data_size > 1)
        {
            char* data = malloc(data_size); //= new char[data_size];
            _ASSERTE(data != 0);

            DWORD num_char_read;
            COORD first_char_read = {0};
            if( ReadConsoleOutputCharacterA(GetStdHandle(STD_OUTPUT_HANDLE), data, data_size, first_char_read, &num_char_read) != FALSE )
            {
                data[data_size-1] = '\0';

                const char* const pbeg = &data[0];
                const char* const pend = &data[data_size-1];
                char* pcur, *pmem;

                const int line_size = buffer_info.dwSize.X;
                int line_count = buffer_info.dwCursorPosition.Y;

                if(buffer_info.dwCursorPosition.X > 0) // No new line char at the end of the last line, so no padded spaces. 
                {                    
                    if((line_count + 1) > 1)
                    {
                        pmem = &data[data_size - buffer_info.dwCursorPosition.X - 1];
                        pcur = (pmem - 1);
                    }
                    else // 1 line and no new line char(no padded spaces). Will no enters the loop.
                        pcur = &data[0];
                }
                else 
                {
                    pcur = &data[data_size-2];
                    pmem = 0;
                }

                if(pcur != pbeg)
                {
                    while(1)
                    {
                        line_count--;

                        while(*pcur == ' ') { pcur--; }
                        *(pcur + 1) = '\n'; // Padded spaces replaced by new line char.

                        if(!pmem) // first round. Add zero-ending char.
                            *(pcur + 2) = '\0'; 
                        else
                            memmove(pcur + 2, pmem, (pend - pmem) + 1);

                        if(line_count == 0)
                            break;

                        pmem = &data[line_count * line_size];
                        pcur = (pmem - 1);
                    }
                }

                *bufsize = strlen(data) + 1;

                *buffer = malloc(*bufsize); //= new char[*bufsize];
                _ASSERTE(*buffer != 0);

                memcpy(*buffer, data, *bufsize);
                free(data); //delete[] data;

                pcur= *buffer;
                return pcur;
            }

            if(data)
                free(data); // delete[] data;
        }
    }

    *buffer = 0;
    return 0;
}


int main(int argc, char** argv)
{
    printf("Writting\nin\nthe\nbuffer");

    char* buffer;
    size_t size;  
    ReadConsoleBuffer(&buffer, &size);

    if(buffer)
    {
        freopen("out.txt", "w", stdout); 
        fprintf(stdout, buffer);
        free(buffer);
        fclose(stdout);
    }  

    return 0;
}

Saída em 'out.txt':

Writting
in
the
buffer