Terminalbreite in C ermitteln?

Ich habe nach einer Möglichkeit gesucht, die Terminalbreite aus meinem C-Programm heraus zu ermitteln. Was mir immer wieder einfällt, ist etwas in der Art von:

#include <sys/ioctl.h>
#include <stdio.h>

int main (void)
{
    struct ttysize ts;
    ioctl(0, TIOCGSIZE, &ts);

    printf ("lines %d\n", ts.ts_lines);
    printf ("columns %d\n", ts.ts_cols);
}

Aber jedes Mal, wenn ich das versuche, bekomme ich

austin@:~$ gcc test.c -o test
test.c: In function ‘main’:
test.c:6: error: storage size of ‘ts’ isn’t known
test.c:7: error: ‘TIOCGSIZE’ undeclared (first use in this function)
test.c:7: error: (Each undeclared identifier is reported only once
test.c:7: error: for each function it appears in.)

Ist dies der beste Weg, oder gibt es einen besseren Weg? Wenn nicht, wie kann ich das zum Laufen bringen?

EDIT: fester Code ist

#include <sys/ioctl.h>
#include <stdio.h>

int main (void)
{
    struct winsize w;
    ioctl(0, TIOCGWINSZ, &w);

    printf ("lines %d\n", w.ws_row);
    printf ("columns %d\n", w.ws_col);
    return 0;
}

Haben Sie überlegt, getenv () zu verwenden ? Hiermit können Sie die Umgebungsvariablen des Systems abrufen, die die Spalten und Zeilen der Terminals enthalten.

Wenn Sie alternativ Ihre Methode verwenden möchten, um zu sehen, was der Kernel als Terminalgröße sieht (besser, wenn die Größe des Terminals geändert wird), müssen Sie TIOCGWINSZ im Gegensatz zu Ihrer TIOCGSIZE verwenden, wie folgt:

struct winsize w;
ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);

und der vollständige Code:

#include <sys/ioctl.h>
#include <stdio.h>
#include <unistd.h>

int main (int argc, char **argv)
{
    struct winsize w;
    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);

    printf ("lines %d\n", w.ws_row);
    printf ("columns %d\n", w.ws_col);
    return 0;  // make sure your main returns int
}

Dieses Beispiel ist etwas langwierig, aber ich glaube, es ist die tragbarste Methode zum Erkennen der Terminalabmessungen. Dies behandelt auch Größenänderungsereignisse.

Wie tim und rlbond vorschlagen, benutze ich ncurses. Es garantiert eine große Verbesserung der Terminalkompatibilität im Vergleich zum direkten Lesen von Umgebungsvariablen.

#include <ncurses.h>
#include <string.h>
#include <signal.h>

// SIGWINCH is called when the window is resized.
void handle_winch(int sig){
  signal(SIGWINCH, SIG_IGN);

  // Reinitialize the window to update data structures.
  endwin();
  initscr();
  refresh();
  clear();

  char tmp[128];
  sprintf(tmp, "%dx%d", COLS, LINES);

  // Approximate the center
  int x = COLS / 2 - strlen(tmp) / 2;
  int y = LINES / 2 - 1;

  mvaddstr(y, x, tmp);
  refresh();

  signal(SIGWINCH, handle_winch);
}

int main(int argc, char *argv[]){
  initscr();
  // COLS/LINES are now set

  signal(SIGWINCH, handle_winch);

  while(getch() != 27){
    /* Nada */
  }

  endwin();

  return(0);
}

#include <stdio.h>
#include <stdlib.h>
#include <termcap.h>
#include <error.h>

static char termbuf[2048];

int main(void)
{
    char *termtype = getenv("TERM");

    if (tgetent(termbuf, termtype) < 0) {
        error(EXIT_FAILURE, 0, "Could not access the termcap data base.\n");
    }

    int lines = tgetnum("li");
    int columns = tgetnum("co");
    printf("lines = %d; columns = %d.\n", lines, columns);
    return 0;
}

Muss kompiliert werden mit -ltermcap. Es gibt viele andere nützliche Informationen, die Sie mit termcap erhalten können. info termcapWeitere Informationen finden Sie im termcap-Handbuch unter .

Wenn Sie ncurses installiert haben und verwenden, können getmaxyx()Sie die Abmessungen des Terminals ermitteln.

Angenommen, Sie arbeiten unter Linux, möchten Sie stattdessen die ncurses- Bibliothek verwenden. Ich bin mir ziemlich sicher, dass das ttysize-Zeug, das Sie haben, nicht in stdlib ist.

Schlagen Sie hier also keine Antwort vor, sondern:

linux-pc:~/scratch$ echo $LINES

49

linux-pc:~/scratch$ printenv | grep LINES

linux-pc:~/scratch$

Ok, und ich stelle fest, dass die Variablen LINES und COLUMNS dem folgen, wenn ich die Größe des GNOME-Terminals verändere.

Irgendwie scheint das GNOME-Terminal diese Umgebungsvariablen selbst zu erstellen?

Um eine vollständigere Antwort hinzuzufügen, habe ich festgestellt, dass die Lösung von @ John_T mit einigen aus Rosetta Code hinzugefügten Bits zusammen mit einigen Fehlern bei der Ermittlung von Abhängigkeiten funktioniert . Es mag ein bisschen ineffizient sein, aber mit intelligenter Programmierung können Sie es zum Laufen bringen und Ihre Terminaldatei nicht ständig öffnen.

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h> // ioctl, TIOCGWINSZ
#include <err.h>       // err
#include <fcntl.h>     // open
#include <unistd.h>    // close
#include <termios.h>   // don't remember, but it's needed

size_t* get_screen_size()
{
  size_t* result = malloc(sizeof(size_t) * 2);
  if(!result) err(1, "Memory Error");

  struct winsize ws;
  int fd;

  fd = open("/dev/tty", 0_RDWR);
  if(fd < 0 || ioctl(fd, TIOCGWINSZ, &ws) < 0) err(8, "/dev/tty");

  result[0] = ws.ws_row;
  result[1] = ws.ws_col;

  close(fd);

  return result;
}

Wenn Sie sicherstellen, dass Sie nicht alles aufrufen, aber vielleicht hin und wieder, sollte es Ihnen gut gehen, sollte es sogar aktualisiert werden, wenn der Benutzer die Größe des Terminalfensters ändert (weil Sie die Datei jedes Mal öffnen und lesen ).

Wenn Sie nicht verwenden, TIOCGWINSZlesen Sie die erste Antwort auf diesem Formular https://www.linuxquestions.org/questions/programming-9/get-width-height-of-a-terminal-window-in-c-810739/ .

Oh, und vergiss free()das nicht result.

Hier sind die Funktionsaufrufe für die bereits vorgeschlagene Umgebungsvariable:

int lines = atoi(getenv("LINES"));
int columns = atoi(getenv("COLUMNS"));