如何将存储作为用户输入的数据类型的字符串传递到sizeof()运算符中,并获得数据类型的大小?

首先 sizeof

数据类型 不再(需要)存在。编译器根据数据类型分配内存(map),从而终止数据类型的存在。事实并非如此 居住 int 或 short .

sizeof公司 该变量/类型上的运算符。

最后但并非最不重要 , 生成类型的结果 size_t ,您必须使用 %zu

不,那是不可能的。编译后的程序中没有更多的类型信息(当然,可能有调试信息,但我怀疑您是否愿意使用)。

// ...
scanf("%s",&s); 

size_t size;
if (strcmp(s, "int") == 0) {
  size = sizeof(int);
}
else if (strcmp(s, "short") == 0) {
  size = sizeof(short);
}
// ... all other types you wanna support
else {
  printf("Did not recognize type %s\n", s);
  return 1;
}

printf("The size of %s data type in c language is: %d ",s,size); 

通过这种方式,您可以在编译时检索所有类型信息,将其显式存储在程序中,从而可以访问它。

不是的 sizeof 运算符直接处理类型和变量。无法使用变量引用类型,并且 sizeof公司 对变量引用的类型进行操作。

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

typedef struct {
    const char *const name;
    const size_t      size;
} type_spec;

const type_spec  known_types[] = {
    { "char",           sizeof (char) },          /* Always 1 */
    { "signed char",    sizeof (signed char) },   /* Always 1 */
    { "unsigned char",  sizeof (unsigned char) }, /* Always 1 */
    { "short",          sizeof (short) },
    { "signed short",   sizeof (signed short) },
    { "unsigned short", sizeof (unsigned short) },
    { "int",            sizeof (int) },
    { "signed int",     sizeof (signed int) },
    { "unsigned int",   sizeof (unsigned int) },
    { "long",           sizeof (long) },
    { "signed long",    sizeof (signed long) },
    { "unsigned long",  sizeof (unsigned long) },
    { "size_t",         sizeof (size_t) },
    { "off_t",          sizeof (off_t) },
    { "time_t",         sizeof (time_t) },
    { "float",          sizeof (float) },
    { "double",         sizeof (double) },
    /* End of array terminator */
    {  NULL,            0 }
};

size_t size_of(const char *name)
{
    size_t i;
    for (i = 0; known_types[i].name != NULL; i++)
        if (!strcmp(name, known_types[i].name))
            return known_types[i].size;
    /* Unknown type name, return 0 */
    return 0;
}

void list_all_types(FILE *out)
{
    size_t  i;
    for (i = 0; known_types[i].name != NULL; i++)
        fprintf(out, "sizeof (%s) == %zu\n",
                     known_types[i].name, 
                     known_types[i].size);
}

注意,因为类型名可以包含空格,所以我不会使用 scanf() 阅读它们。我只需要让用户在命令行上指定类型,而不是:

int main(int argc, char *argv[])
{
    size_t size;
    int    arg;

    if (argc < 2) {
        list_all_types(stdout);
        return EXIT_SUCCESS;
    }

    if (!strcmp(argv[1], "-l") || !strcmp(argv[1], "--list")) {
        list_all_types(stdout);
        return EXIT_SUCCESS;
    }

    if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
        printf("\n");
        printf("Usage: %s -h | --help\n", argv[0]);
        printf("       %s [ -l | --list ]\n", argv[0]);
        printf("       %s type [ type ... ]\n", argv[0]);
        printf("\n");
        printf("This program reports the sizes of most basic\n");
        printf("types supported in C.\n");
        printf("\n");
        return EXIT_SUCCESS;
    }

    for (arg = 1; arg < argc; arg++) {
        size = size_of(argv[arg]);
        if (!size) {
            fflush(stdout);
            fprintf(stderr, "%s: unsupported type.\n", argv[arg]);
            return EXIT_FAILURE;
        }
        printf("sizeof (%s) == %zu\n", argv[arg], size);
    }

    return EXIT_SUCCESS;
}

known_types 数组不是穷举的,但您可以简单地将任何类型添加到数组中,每种类型一行。 .

char mytype[100] = "unsigned long long int";
int mysize;

// start the compiler
FILE *f = popen("gcc -x c -o test -", "w");

// generate the program to compile
fprintf(f, "int main(){return sizeof(%s);}", mytype);

// wait for the compiler to finish
mysize = pclose(f);

// run the compiled program and get its exit code
mysize = WEXITSTATUS(system("./test"));

// cleanup - delete the executable
remove("test");

printf("Size of %s is %d\n", mytype, mysize);

这太麻烦了,太多地方可能会出错(系统上没有安装gcc;当前目录不可写;等等)。