如何在没有警告的情况下使结构中的变量等于任何值？ （C）

Question

So I have a simple struct that looks like

struct var {
    char* name;
    int value;
}

and I don't know how to avoid warning: assignment makes integer from [non-int] without a cast [-Wint-conversion] when I try to make value a non-integer, which I'll be doing a lot. I know I shouldn't worry about a warning, but I really want to get rid of it, so what's the best way to fix this? Example of what I want to do:

int main() {
    struct var a[100];
    a[0].name = "a";
    a[0].value = "c";
    a[1].name = "b";
    a[1].value = 0;
}

Answer 1

Based on the naming conventions you're using, I'm assuming struct var is meant to store key-value pairs, where the value can be any type. Unfortunately, C is statically typed - if you declare value as an int , it can only store int values. If you assign a floating-point value to it, that value will be converted to an integer and you will lose the fractional portion. You can't use it to store a string or any other aggregate type.

You basically have two options. You can make value a union of different types:

enum var_type { INTEGER, FLOATING, STRING };
struct var
{
  char *name;
  enum var_type type;
  union {
    int i;
    double f;
    char *s;
  } value;
};

and then you can store different types to different members of the union:

struct var v[3];
v[0].name = "foo";
v[0].type = INTEGER;
v[0].value.i = 1;

v[1].name = "bar";
v[1].type = FLOATING;
v[1].value.f = 3.14;

v[2].name = "bletch";
v[2].type = STRING;
v[2].value.s = "this is a test";

This approach, while not involving dynamic memory and all the heartburn that comes with it, is a pain. You have to make sure you have a union member for every type you want to represent, and if that changes you have to hack the type and rebuild. You have to assign to the specific union member.

Another approach is to make value a simple void * , and then dynamically allocate and assign memory to it. While this introduces memory management headaches, it's more flexible and easier to abstract.

struct var {
  char *name;
  void *value;
};

struct var v[3];
v[0].name = "foo";
v[0].value = copy_int( 1 );

v[1].name = "bar";
v[1].value = copy_float( 3.14 );

v[2].name = "bletch";
v[2].value = copy_string( "this is a test" );

where each of copy_int , copy_float , and copy_string are functions that abstract away the malloc calls and assignments:

void *copy_int( int arg )
{
  int *mem = malloc( sizeof *mem );
  if ( mem )
    *mem = arg;
  return mem;
}

void *copy_float( double arg )
{
  double *mem = malloc( sizeof *mem );
  if ( mem )
    *mem = arg;
  return mem;
}

void *copy_string( const char *str )
{
  char *mem = malloc( sizeof *mem * (strlen( str ) + 1 ));
  if ( mem )
    strcpy( mem, str );
  return mem;
}

The beauty of this method is that you don't have to hack your struct var type every time you want to store a different type of value - you only have to implement a new copy_* function.

However...

You still need some way to determine what the type of value is when you want to use it later on. You can either the enum method above to explicitly tag it, or you can add a function pointer member and create functions to return information about the type, like so:

struct var {
  char *name;
  void *value;
  char *(*type)( void );
};

char *int_type( void ) { return "int"; }
char *double_type( void ) { return "double"; }
char *string_type( void ) { return "string"; }
...
struct var v[3];
v[0].name = "foo";
v[0].type = int_type;
v[0].value = copy_int( 1 );
...
if ( strcmp( v[0].type(), "int" ) )
{
  printf( "%s = %d\n", v[0].name, *((int *) v[0].value) );
}

Again, the beauty of this approach is you don't have to hack your struct or the enum when you want to add new value types - you only have to implement the functions to copy and indicate type.

Answer 2

What you want is to use a union inside of the struct with fields for each type you want to support:

struct var {
    char* name;
    char type;
    union {
        int i;
        char c;
        char *s;
        float f;
        double d;
    } value;
};

The type field can be used to determine which field of the union is active:

struct var a[100];
a[0].name = "a";
a[0].type = 's';
a[0].value.s = "c";
a[1].name = "b";
a[0].type = 'i';
a[1].value.i = 0;

Answer 3

Using a union is probably not what you want

As @dbush stated, a union will fix your immediate problem. However, this is like using a flamethrower to erase a whiteboard. It works, but it will cause more problems later on.

Why this is the code yelling at you

C has a type system. It helps you check if what you're assigning to the variable has the same type as what the variable is. It doesn't really make sense to say int = "hello" + 1 . Something similar is happening in your question. What does int value = "c" mean?

What should I do instead?

The real answer is one you won't like. You probably shouldn't assign a letter to a number. This is what the warning is telling you. We can't really answer what you should be doing as we would need to have more knowledge of your code.

Why is it a warning and not an error?

Using the ASCII format, each letter has an equivalent number. In more advanced programs, you might need to assign the number representing the letter into a variable with a numeric type. You usually don't want to do this (so it's a warning) but sometimes you really want to do that, and the compiler knows how to do it if you really want to (which is why it is not an error).