Récupère le contenu du tampon de la console dans C

Question

Je me demande simplement s'il existe un moyen (en C) d'obtenir le contenu du tampon de la console, de préférence sous la forme d'une sorte de tableau char. Il va être écrit dans un fichier, donc si je rate quelque chose de stupide qui fera exactement cela, alors signalez-le. Cela peut être spécifique à Windows. J'utilise MinGW (gcc 3.4.5).

Merci d'avance.

Answer 1

Je pense que vous devez jeter un oeil à des fonctions de la console win32 par exemple GetStdHandle(), ReadConsoleOutput(), WriteConsoleOutput etc.

Answer 2

Si c'est l'écran dans une fenêtre de commande, alors potentiellement pas, ou pas de manière facile. Vous pouvez pirater les événements Windows pour sélectionner-tout, copier et lire le presse-papiers.

Answer 3

Dans Win32, ReadConsoleOutput:

Reads caractères et des données attribut de couleur à partir d'un bloc rectangulaire des cellules de caractères dans un tampon d'écran de console, et la fonction écrit les données dans un bloc rectangulaire à un emplacement spécifié dans le tampon de destination.

Answer 4

Télécharger mingw-readline

Et regardez GNU Readline

rl_line_buffer 

Answer 5

est ici un moyen de lire la mémoire tampon de la console. GetNumCharsInConsoleBuffer est d'obtenir le nombre total de caractères écrits dans le tampon de l'écran de la console, j'utilise GetConsoleScreenBufferInfo à l'intérieur. Après, je crée un tableau dynamiquement alloué de taille égale à la valeur précédemment retournée par GetNumCharsInConsoleBuffer + 1 (pour la fin zéro). Et enfin, ReadConsoleBuffer remplira le tampon tout juste créé avec le contenu de la mémoire tampon de l'écran de la console. Après, si vous voulez écrire le contenu de votre tampon dans un fichier, vous devrez probablement faire un peu de mise en forme. Avec ReadConsoleOutputCharacter vous obtenez une région (rectangle) du tampon de l'écran de la console. Les lignes que vous avez écrites dans le tampon de l'écran de la console seront remplies d'espaces pour correspondre à la région du tampon. ce sera la même chose avec le win32 ReadConsoleOutput/WriteConsoleOutput, vous obtiendrez une région (rectangle) de votre écran.

#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; 
} 

Sortie:

Writting 
in 
the 
buffer 
Buffer contents: 
Writting 
in 
the 
buffer 

Appuyez sur une touche pour continuer... 

EDIT:

Je viens d'écrire une fonction qui peut être utilisé pour écrire le contenu de la mémoire tampon de l'écran pour un fichier. Cette fonction supprime les espaces matelassés du tampon de la console d'écran. ReadConsoleBuffer prend un pointeur null char comme premier argument (buffer) qui sera alloué lors de son exécution. Donc, n'oubliez pas de le supprimer par vous-même. ReadConsoleBuffer écrira la taille du tampon dans le deuxième argument (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; 
} 

sortie dans 'out.txt':

Writting 
in 
the 
buffer