Terminalbreite in C abrufen?

Ich habe nach einer Möglichkeit gesucht, die Terminalbreite aus meinem C-Programm herauszubekommen. 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 es versuche, bekomme ich es

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, dies zu tun, oder gibt es einen besseren Weg? Wenn nicht, wie kann ich das zum Laufen bringen?

EDIT: Festcode 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 darüber nachgedacht, zu verwenden getenv() ? Es ermöglicht Ihnen, die Umgebungsvariablen des Systems zu erhalten, die die Spalten und Zeilen der Terminals enthalten.

Wenn Sie alternativ mit Ihrer Methode sehen möchten, was der Kernel als Terminalgröße sieht (besser, wenn die Größe des Terminals geändert wird), müssen Sie TIOCGWINSZ verwenden, im Gegensatz zu Ihrer TIOCGSIZE, 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 langatmig, aber ich glaube, es ist die portabelste Art, die Terminalabmessungen zu erkennen. Dies behandelt auch Größenänderungsereignisse.

Wie tim und rlbond andeuten, verwende 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 mit kompiliert werden -ltermcap . Es gibt viele andere nützliche Informationen, die Sie mit termcap erhalten können. Überprüfen Sie das Termcap-Handbuch mit info termcap für mehr Details.

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

Um eine vollständigere Antwort hinzuzufügen, habe ich herausgefunden, dass es für mich funktioniert, die Lösung von @ John_T mit einigen hinzugefügten Bits zu verwenden Rosetta-Code, zusammen mit einigen Fehlerbehebungen, um Abhängigkeiten herauszufinden. Es mag ein bisschen ineffizient sein, aber mit intelligenter Programmierung können Sie es zum Laufen bringen und müssen nicht ständig Ihre Terminaldatei ö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, es sollte sogar aktualisiert werden, wenn der Benutzer die Größe des Terminalfensters ändert (weil Sie die Datei öffnen und lesen jeder Zeit).

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

Ach ja, und nicht vergessen free() das result.

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

Also hier keine Antwort vorschlagen, aber:

linux-pc:~/scratch$ echo $LINES

49

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

linux-pc:~/scratch$

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

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