Why are pointers expected in structures? - c

Question

I was just testing structures using C. The code is:
#include <stdio.h>
struct {
int age;
char name[]; //just an array
char gender; //just a character (M for male and F for female)
}person;
int main()
{
person.age=10;
person.name="John";
person.gender="M";
printf("Person's age: %d", person.age);
printf("Person's name: %s", person.name);
printf("Person's gender: %c", person.gender);
return 0;
}
However, what the compiler returns is:
warning: initialization of 'char' from 'char *' makes integer from
pointer without a cast [-Wint-conversion]|
I have no idea what this means or why it appears.

Answer 1

This code has multiple issues.
First:
person.name="John";
You cannot assign a char* to a char array. The two types are not compatible.
You must either change your struct to:
char* name; //just an char pointer
Or use strcpy() to copy the name to this array.
strcpy(person.name, "John");
Also, you need to specify the size of this array in your struct. Depending on your compiler, funny things can happen with an undefined array size like this.
Second:
person.gender="M";
You also cannot assign a char* to a char.
Either change gender to be of type char*, or change your assignment to use a char.
person.gender = 'M';

Answer 2

Why are pointers expected in structures?
Pointers are not expected, nor are they dis-allowed.
"warning: initialization of 'char' from 'char *' makes integer from pointer without a cast [-Wint-conversion]|"
person.gender="M"; errantly attempts to take a pointer (the address of the stirng literal "M") and assign it to a char (.gender). Pointers do not fit in a char.
OP's code is invalid. OP is relying on a code extension.
A member like char name[]; must be the last member in a struct. There it is a flexible array member.
struct {
int age;
// char name[]; // move to the end
char gender;
char name[];
}person;
There are no pointers in OP's struct. With repair, member .name[] is an array.
Example usage
#include <stdio.h>
#include <stdlib.h>
// Define a type
typedef struct {
int age;
char gender;
char name[]; // last member
} person;
// Allocate and populate data
person* person_initialize(int age, const char *name, char gender) {
size_t len = strlen(name);
// Size needed is for the `person` and the name as a _string_.
person *p = malloc(sizeof *p + len + 1);
// If successful ....
if (p) {
p->age = age;
p->gender = gender;
strcpy(p->name, name);
}
return p;
}
int main(void) {
person *p = person_initialize(10, "John", 'M'); // Note 'M', not "M".
if (p) {
printf("Person's age: %d", p->age);
printf("Person's name: %s", p->name);
printf("Person's gender: %c", p->gender);
free(p);
}
return 0;
}

Answer 3

"Why are pointers expected in structures?"
They are not. They are also not unexpected.
This construction is however:
struct {
int age;
char name[]; //just an array <- A BOMB
char gender; //just a character (M for male and F for female)
} person;
You here have an instance (person) of an anonymous struct with a flexible array. Old-school structs with this setup had their last member declared as type identifier[1];.
[1] was historically used because a zero element array has never been valid in standard C (although accepted as a language extension by some compilers).
The C99 standard made char name[] legal by allowing indexing such an array if it's made the last element in a struct. The name[] member in your struct is not.
The purpose of the flexible array was to let writing to such an array be legal to let the programmer (or a called function) pre-allocate memory and have functions return an unknown amount of elements by writing their result in that memory.
If your struct is accepted by a compiler, a funcion using it will overwrite gender when writing more than zero chars to name as an answer.
This would be a definition (and typedef) with the potential of being used properly:
typedef struct person_ {
int age;
char gender;
struct person_ *next; // points somewhere after the '\0' in name[] or NULL
char name[]; // Pre C99 "char name[1];" was often seen
} person; // a typedef, not an instance here