枚举C中的基本数据类型，以便可以方便地访问大小

Question

使用for循环可以获得C中所有基本数据类型的大小吗？例如，我们能做这样的事情吗？

#include <datatypes.h> /* or something else which defines get_data_types() */
#include <stdio.h>

int main() {
    for (int x = 0; x < len(get_data_types()); x++) {
        printf("Size of %s is %d", get_data_types()[x], sizeof(get_data_types()[x]));
    }
 }

我可以通过替换for循环并为int、long等编写单独的语句来枚举所有的数据类型。但是，我想知道是否有一个for循环也可以这样做？

基本上，我试图避免以下几点：

#include <stdio.h>

int main() {
    printf("Size of int is %d", sizeof(int);
    printf("Size of unsigned int is %d", sizeof(unsigned int);
    printf("Size of long is %d", sizeof(long);
    /* etc. */
    return 0;
}

数据类型- char，unsigned char，signed char，int，unsigned int，short，unsigned short，long，unsigned long，float，double，long double

Clarification：我不一定想要一个混合类型的数组，但需要能够枚举这些类型，这样就可以方便地访问大小。

Answer 1

不这是不可能的。无法自动列出C中的所有类型，必须手动对每种类型执行此操作。

但是，如果您经常使用这些信息，您可以随时预先准备一个列表。有一些方法可以做到。这是一个：

#include <stdio.h>
#include <string.h>

typedef struct {
    char name[20];
    int size;
} type;

int main()
{
    type types[3] = { {"int", sizeof (int) },
                      {"char", sizeof (char) },
                      {"double", sizeof (double) } };

    for (int x = 0; x<sizeof(types)/sizeof(types[0]); x++)
        printf("Size of %s is %d\n", types[x].name, types[x].size);
}

(下面是保罗·奥吉尔维的答案的启发，简化了代码。)

在对这个答案的注释中，您问:我们是否可以创建一个数组，如: types_array ={int“、"char”、"double“、"long"}，并在迭代时得到相应的大小？我的意思是，使用一些函数f，我们是否可以将typesj.size赋值为sizeof(f(types_arrayj))

总之，没有。这是因为C是一种强类型的编译语言。在Python和PHP这样的语言中，你可以做各种花哨的事情，但在C语言中不行。不是没有诡计。示例中的函数f必须具有指定的返回类型，这是sizeof将作为参数的类型。

解决这个问题的一种方法是编写一个自定义大小：

int mysizeof(char * s) {
    if(strcmp(s, "char") == 0)
        return sizeof(char);
    if(strcmp(s, "int") == 0)
        return sizeof(int);
}

如果此列表很长，则可以使用一个宏：

#define MYSIZEOF(x) if(strcmp(s, #x) == 0) return sizeof(x)

int mysizeof(char * s) {
    MYSIZEOF(int);
    MYSIZEOF(char);
    MYSIZEOF(double);
}

Answer 2

您的方法是不可能的，必须以这样或那样的方式显式地枚举各种类型，但是您可以创建一个结构数组，使用一个方便的宏将其简化，并编写一个循环来输出所有标准类型大小。

请注意，您忘记了一些有用的标准类型：

• long long，unsigned long long，size_t，ptrdiff_t，intmax_t，uintmax_t，wchar_t.
• 指针类型：void *，char *，int *.
• 函数指针类型：void(*)(void)

以下是一个实现：

#include <inttypes.h>
#include <stddef.h>
#include <stdio.h>

#define TYPEDESC(t)  { #t, sizeof(t) }

static struct type_desc {
    const char *name;
    int size;
} const types[] = {
    TYPEDESC(char), TYPEDESC(unsigned char), TYPEDESC(signed char),
    TYPEDESC(wchar_t),
    TYPEDESC(short), TYPEDESC(unsigned short),
    TYPEDESC(int), TYPEDESC(unsigned int),
    TYPEDESC(long), TYPEDESC(unsigned long),
    TYPEDESC(long long), TYPEDESC(unsigned long long),
    TYPEDESC(float), TYPEDESC(double), TYPEDESC(long double),
    TYPEDESC(size_t), TYPEDESC(ptrdiff_t),
    TYPEDESC(intmax_t), TYPEDESC(uintmax_t),
    TYPEDESC(void *), TYPEDESC(char *), TYPEDESC(int *),
    TYPEDESC(void (*)(void)),
};

int main() {
    size_t i;
    for (i = 0; i < sizeof(types) / sizeof(types[0]); i++)
        printf("sizeof( %s ) = %d\n", types[i].name, types[i].size);
    return 0;
}

我的64位OS/X系统的输出如下：

sizeof( char ) = 1
sizeof( unsigned char ) = 1
sizeof( signed char ) = 1
sizeof( wchar_t ) = 4
sizeof( short ) = 2
sizeof( unsigned short ) = 2
sizeof( int ) = 4
sizeof( unsigned int ) = 4
sizeof( long ) = 8
sizeof( unsigned long ) = 8
sizeof( long long ) = 8
sizeof( unsigned long long ) = 8
sizeof( float ) = 4
sizeof( double ) = 8
sizeof( long double ) = 16
sizeof( size_t ) = 8
sizeof( ptrdiff_t ) = 8
sizeof( intmax_t ) = 8
sizeof( uintmax_t ) = 8
sizeof( void * ) = 8
sizeof( char * ) = 8
sizeof( int * ) = 8
sizeof( void (*)(void) ) = 8

令人惊讶的是，wchar_t是32位的，long double是16字节的。这并不意味着long double值使用所有128位作为浮点表示形式。在Windows系统上，输出将是非常不同的。

Answer 3

Klutt的答案可以简化为：

struct {
    char *name;
    int size;
} types[] = {
    {"int", sizeof(int)},
    {"char", sizeof(char)},
    {"long", sizeof(long)}
    //.. etcetera
};

int main(void) {
    int i;
    for (i=0; i<sizeof(types)/sizeof(types[0]); i++)
        printf("sizeof %s = %d\n",types[i].name, types[i].size);
    return 0;
}