É possível descobrir os tamanhos dos tipos de dados (int, float, double, ...) em um sistema Linux, sem escrever um programa em C?
Os resultados para C são os mesmos que para C ++ e outras linguagens de programação no mesmo sistema Linux?
Se você conhece a definição do tipo de dados desejado, você pode usar getconf para encontrar esses valores na maioria dos sistemas Unix.
$ getconf CHAR_BIT
8
A lista de variáveis é definida na página man man limits.h , bem como aqui, man sysconf , além de estar no disco. Você pode usar locate limits.h para encontrá-lo, geralmente está aqui: /usr/include/linux/limits.h .
Mais ou menos.
Com o gcc, pelo menos, isso funciona:
$ cpp -dD /dev/null | grep __SIZEOF_LONG__
Enfim, por que você não quer escrever um programa em C para fazer isso? Você poderia enviar um pequeno programa em C para o seu compilador a partir do shell algo assim:
binary=$(mktemp)
cat <<\EOF | cc -o $binary -x c -
#include <stdio.h>
int main() {
printf("int=%lu bytes\n", sizeof(int));
printf("long=%lu bytes\n", sizeof(long));
}
EOF
$binary
rm $binary
O -x c informa ao compilador que o idioma é C e o - significa leitura da entrada padrão.
No meu sistema, as impressões acima:
int=4 bytes
long=8 bytes
Testado no gcc e no clang.
Sim. Você pode verificar /usr/include/<arch>/limits.h
Por exemplo, no meu NetBSD amd64, /usr/include/amd64/limits.h mostraria:
#define CHAR_BIT 8 /* number of bits in a char */
#define SCHAR_MAX 0x7f /* max value for a signed char */
#define SCHAR_MIN (-0x7f-1) /* min value for a signed char */
#define UCHAR_MAX 0xff /* max value for an unsigned char */
#define CHAR_MAX 0x7f /* max value for a char */
#define CHAR_MIN (-0x7f-1) /* min value for a char */
#define USHRT_MAX 0xffff /* max value for an unsigned short */
#define SHRT_MAX 0x7fff /* max value for a short */
#define SHRT_MIN (-0x7fff-1) /* min value for a short */
#define UINT_MAX 0xffffffffU /* max value for an unsigned int */
#define INT_MAX 0x7fffffff /* max value for an int */
#define INT_MIN (-0x7fffffff-1) /* min value for an int */
#define ULONG_MAX 0xffffffffffffffffUL /* max value for an unsigned long */
#define LONG_MAX 0x7fffffffffffffffL /* max value for a long */
#define LONG_MIN (-0x7fffffffffffffffL-1) /* min value for a long */
Se você tem o perl instalado, você pode obter isso de perl -V:
intsize=4, longsize=8, ptrsize=8, doublesize=8, byteorder=12345678
d_longlong=define, longlongsize=8, d_longdbl=define, longdblsize=16
ivtype='long', ivsize=8, nvtype='double', nvsize=8, Off_t='off_t', lseeksize=8
alignbytes=8, prototype=define
Não ... é possível executar binários com idéias diferentes dos tamanhos dos tipos básicos, particularmente em arquiteturas de 64 bits. Kernels Linux recentes em x86_64 podem executar binários nativos de 32 bits, e existe a ABI x32 com tipos de 32 bits.
Os tamanhos dos tipos de dados são parcialmente o que o compilador usa. Mas é claramente vantajoso (1) usar tipos que a máquina suporta com eficiência e (2) usar tipos consistentemente das bibliotecas de baixo nível através de aplicativos do usuário. Ter que lidar com várias variantes é uma bagunça.
Os tamanhos dos tipos de dados são uma propriedade de um compilador (ou ABI), não do sistema. Você pode ter vários compiladores usando tamanhos diferentes para tipos de dados no mesmo sistema.
Tente isso para analisar e gerar as linhas que contêm as strings que fazem referência aos tipos de dados:
{ shopt -s globstar; for i in /usr/include/**/*.h; do grep -HE '\b(([UL])|(UL)|())LONG|\bFLOAT|\bDOUBLE|\bINT' $i; done; }
Isso captura, é claro, as definições em /usr/include/limits.h , então você obterá isso mais mais, às vezes com valores, mas principalmente referenciando o que está definido em limits.h , que você pode ver com convenientemente com getconf -a e ulimit -a de comandos.
Tags c