Ottenere la larghezza del terminale in C?

Ho cercato un modo per ottenere la larghezza del terminale dal mio programma C. Quello che continuo a pensare è qualcosa sulla falsariga di:

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

Ma ogni volta che provo, ottengo

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.)

È questo il modo migliore per farlo o esiste un modo migliore? In caso contrario, come posso farlo funzionare?

EDIT: il codice fisso è

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

Hai considerato l'utilizzo di getenv () ? Ti permette di ottenere le variabili d'ambiente del sistema che contengono le colonne e le linee dei terminali.

In alternativa, usando il tuo metodo, se vuoi vedere cosa vede il kernel come la dimensione del terminale (meglio nel caso in cui il terminale sia ridimensionato), dovresti usare TIOCGWINSZ, al contrario di TIOCGSIZE, in questo modo:

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

e il codice completo:

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

Questo esempio è un po 'lungo, ma credo che sia il modo più portatile per rilevare le dimensioni del terminale. Questo gestisce anche gli eventi di ridimensionamento.

Come suggeriscono tim e rlbond, sto usando ncurses. Garantisce un grande miglioramento nella compatibilità del terminale rispetto alla lettura diretta delle variabili d'ambiente.

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

Deve essere compilato con -ltermcap. Ci sono molte altre informazioni utili che puoi ottenere usando termcap. Controlla il manuale del termcap usando info termcapper maggiori dettagli.

Se hai ncurses installato e lo stai usando, puoi usare getmaxyx()per trovare le dimensioni del terminale.

Supponendo che tu sia su Linux, penso che tu voglia usare invece la libreria ncurses . Sono abbastanza sicuro che la roba ttysize che hai non sia in stdlib.

Quindi non suggerendo una risposta qui, ma:

linux-pc:~/scratch$ echo $LINES

49

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

linux-pc:~/scratch$

Ok, e noto che se ridimensiono il terminale GNOME, le variabili LINES e COLUMNS lo seguono.

Sembra che il terminale GNOME stia creando queste variabili di ambiente da solo?

Per aggiungere una risposta più completa, quello che ho trovato che funziona per me è utilizzare la soluzione di @ John_T con alcuni bit aggiunti da Rosetta Code , insieme ad alcuni problemi di risoluzione delle dipendenze. Potrebbe essere un po 'inefficiente, ma con la programmazione intelligente puoi farlo funzionare e non aprire il file del terminale tutto il tempo.

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

Se ti assicuri di non chiamare tutto ma forse ogni tanto dovresti andare bene, dovrebbe anche aggiornarsi quando l'utente ridimensiona la finestra del terminale (perché stai aprendo il file e leggendolo ogni volta).

Se non stai usando, TIOCGWINSZvedi la prima risposta su questo modulo https://www.linuxquestions.org/questions/programming-9/get-width-height-of-a-terminal-window-in-c-810739/ .

Oh, e non dimenticate di free()la result.

Ecco le chiamate di funzione per la variabile ambientale già suggerita:

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