¿Obteniendo ancho de terminal en C?

He estado buscando una forma de obtener el ancho de la terminal desde mi programa C. Lo que se me ocurre es algo parecido a:

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

Pero cada vez que lo intento consigo

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

¿Es esta la mejor manera de hacer esto o hay una mejor manera? Si no, ¿cómo puedo hacer que esto funcione?

EDITAR: el código fijo es

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

¿Ha considerado usar getenv () ? Le permite obtener las variables de entorno del sistema que contienen las columnas y líneas de los terminales.

Alternativamente, usando su método, si desea ver lo que el kernel ve como el tamaño de la terminal (mejor en caso de que se cambie el tamaño de la terminal), necesitaría usar TIOCGWINSZ, en lugar de su TIOCGSIZE, así:

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

y el código 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
}

Este ejemplo es un poco extenso, pero creo que es la forma más portátil de detectar las dimensiones del terminal. Esto también maneja eventos de cambio de tamaño.

Como sugieren tim y rlbond, estoy usando ncurses. Garantiza una gran mejora en la compatibilidad del terminal en comparación con la lectura directa de variables de entorno.

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

Necesita ser compilado -ltermcap. Hay mucha otra información útil que puede obtener usando termcap. Consulte el manual de termcap utilizando info termcappara obtener más detalles.

Si tiene ncurses instalado y lo está usando, puede usar getmaxyx()para encontrar las dimensiones del terminal.

Suponiendo que está en Linux, creo que desea usar la biblioteca ncurses en su lugar. Estoy bastante seguro de que las cosas ttysize que tienes no están en stdlib.

Así que no sugiero una respuesta aquí, pero:

linux-pc:~/scratch$ echo $LINES

49

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

linux-pc:~/scratch$

Ok, y noto que si cambio el tamaño del terminal GNOME, las variables LINES y COLUMNS siguen a eso.

¿Parece que el terminal GNOME está creando estas variables de entorno por sí mismo?

Para agregar una respuesta más completa, lo que encontré que me funciona es usar la solución de @ John_T con algunos bits agregados de Rosetta Code , junto con algunos problemas de resolución de dependencias. Puede ser un poco ineficiente, pero con la programación inteligente puede hacer que funcione y no tener que abrir el archivo de su terminal todo el tiempo.

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

Si se asegura de no llamarlo todo, pero tal vez de vez en cuando debería estar bien, incluso debería actualizarse cuando el usuario cambie el tamaño de la ventana del terminal (porque está abriendo el archivo y leyéndolo todo el tiempo).

Si no está utilizando, TIOCGWINSZvea la primera respuesta en este formulario https://www.linuxquestions.org/questions/programming-9/get-width-height-of-a-terminal-window-in-c-810739/ .

Ah, y no te olvides free()del result.

Aquí están las llamadas de función para la variable ambiental ya sugerida:

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