¿Cómo trabajar con campos de cadena en una estructura C?

Tengo problemas para crear una base de datos basada en una lista de enlaces únicos en C, no por el concepto de lista enlazada sino por los campos de cadena en la estructura en sí.

Esta es una tarea en C y, que yo sepa (soy un novato), C no reconoce ‘cadena’ como un tipo de datos.

Así es como se ve mi código de estructura:

typedef struct 
{
  int number;
  string name;
  string address;
  string birthdate;
  char gender;
} patient;

typedef struct llist
{
  patient num;
  struct llist *next;
} list;

Estaba pensando en hacer una estructura para las propias cadenas para poder usarlas en la estructura, así:

typedef struct string 
{ 
  char *text;
} *string;

Lo haré entonces malloc() cada uno de ellos cuando se requiere realizar nuevos datos del tipo string (array of char).

typedef struct string
{
  char *text;
} *string;

int main()
{
    int length = 50;
    string s = (string) malloc(sizeof string);
    s->text = (char *) malloc(len * sizeof char);
    strcpy(s->text, patient.name->text);
}

¿Puede alguien ayudarme a resolver esto?
Gracias.

En cadenas y asignación de memoria:

Una cadena en C es solo una secuencia de chars, para que puedas usar char * o un char matriz donde quiera usar un tipo de datos de cadena:

typedef struct     {
  int number;
  char *name;
  char *address;
  char *birthdate;
  char gender;
} patient;

Luego, debe asignar memoria para la estructura en sí y para cada una de las cadenas:

patient *createPatient(int number, char *name, 
  char *addr, char *bd, char sex) {

  // Allocate memory for the pointers themselves and other elements
  // in the struct.
  patient *p = malloc(sizeof(struct patient));

  p->number = number; // Scalars (int, char, etc) can simply be copied

  // Must allocate memory for contents of pointers.  Here, strdup()
  // creates a new copy of name.  Another option:
  // p->name = malloc(strlen(name)+1);
  // strcpy(p->name, name);
  p->name = strdup(name);
  p->address = strdup(addr);
  p->birthdate = strdup(bd);
  p->gender = sex;
  return p;
}

Si solo necesitas unos pocos patients, puede evitar la administración de memoria a expensas de asignar más memoria de la que realmente necesita:

typedef struct     {
  int number;
  char name[50];       // Declaring an array will allocate the specified
  char address[200];   // amount of memory when the struct is created,
  char birthdate[50];  // but pre-determines the max length and may
  char gender;         // allocate more than you need.
} patient;

En listas enlazadas:

En general, el propósito de una lista enlazada es demostrar un acceso rápido a una colección ordenada de elementos. Si tu llist contiene un elemento llamado num (que presumiblemente contiene el número de paciente), necesita una estructura de datos adicional para contener el número real patients mismos, y tendrá que buscar el número de paciente cada vez.

En cambio, si declaras

typedef struct llist
{
  patient *p;
  struct llist *next;
} list;

entonces cada elemento contiene un puntero directo a un patient estructura, y puede acceder a los datos de esta manera:

patient *getPatient(list *patients, int num) {
  list *l = patients;
  while (l != NULL) {
    if (l->p->num == num) {
      return l->p;
    }
    l = l->next;
  }
  return NULL;
}

Creo que esta solución usa menos código y es fácil de entender incluso para los novatos.

Para el campo de cadena en la estructura, puede usar el puntero y reasignar la cadena a ese puntero será directo y más simple.

Definir definición de estructura:

typedef struct {
  int number;
  char *name;
  char *address;
  char *birthdate;
  char gender;
} Patient;

Inicialice la variable con el tipo de esa estructura:

Patient patient;
patient.number = 12345;
patient.address = "123/123 some road Rd.";
patient.birthdate = "2020/12/12";
patient.gender="M";

Es así de simple. Espero que esta respuesta ayude a muchos desarrolladores.

Mientras que Richard’s es lo que quieres si quieres ir con un typedef, sugeriría que probablemente no sea una idea particularmente buena en este caso, ya que pierdes de vista que es un puntero, sin ganar nada.

Si lo estuviera tratando como una cadena contada, o algo con funcionalidad adicional, eso podría ser diferente, pero realmente recomendaría que en este caso, simplemente se familiarice con la implementación de la cadena C ‘estándar’ que es un ‘char *’. ..

Podrías usar una aún más simple typedef:

typedef char *string;

Entonces, su malloc se vería como un malloc habitual:

string s = malloc(maxStringLength);

Esto no funciona:

string s = (string)malloc(sizeof string); 

string se refiere a un puntero, necesita el tamaño de la estructura en sí:

string s = malloc(sizeof (*string)); 

Tenga en cuenta la falta de reparto también (conversión de void* (malloctipo de retorno) se realiza implícitamente).

También, en tu maintienes un certificado global patient, pero eso no está inicializado. Probar:

 patient.number = 3;     
 patient.name = "John";     
 patient.address = "Baker street";     
 patient.birthdate = "4/15/2012";     
 patient.gender="M";     

antes de acceder a cualquiera de sus miembros

También, strcpy es intrínsecamente inseguro ya que no tiene verificación de límites (se copiará hasta el primer '\0' se encuentra, escribiendo más allá de la memoria asignada si la fuente es demasiado larga). Usar strncpy en cambio, donde al menos puede especificar la cantidad máxima de caracteres copiados; lea la documentación para asegurarse de pasar el valor correcto, es fácil cometer un error de uno.