[C] dubbi sulla inizializzazione di una struct

[virusso80]

ciao a tutti.
Ho cercato su internet, ho trovato, ma continua a non essermi chiaro come fare.

consideriamo il seguente codice:

typedef struct id_t
{
	short int id_manager;
	short int id_appl;	
} id_t;

typedef struct message_t
{
	id_t sender_id;
	id_t receiver_id;
	short int msg_type;
	short int len;
	char* data;	  //questo sarà una stringa di lunghezza che non è sempre uguale
	unsigned data_len;
} message_t;

ora io devo creare un nuovo message_t e lo devo ovviamente popolare.

non voglio usare la malloc.

Come faccio a inizializzare tutto? quale è la sizeOf?

ho fatto così...ma non mi convince molto:

message_t message;
		memset(&message, 0x00, sizeof(message_t));

		message.sender_id.id_appl = Run.id;
		message.sender_id.id_manager = 0;
		message.data_len = strlen(service);
		strnlen(message.data, service, message.data_len);
		message.receiver_id.id_appl = 1000;
		message.receiver_id.id_manager = 0;
		
		message.len = sizeof(message_t);

Grazie mille

[cionci]

Potresti ad esempio fare così:

message_t m = { { Run.id, 0 }, { 1000, 0 }, 0, sizeof(message_t), NULL, strlen(service) };

A cosa serve il campo short int len; ? La dimensione della struttura su una data architettura è costante. A meno che tu non voglia includere la dimensione della stringa, ma sappi che in ogni caso la lunghezza della stringa non sarà inclusa nel sizeof.

[darksax]

Originariamente inviato da virusso80

typedef struct id_t
{
	short int id_manager;
	short int id_appl;	
} id_t;

typedef struct message_t
{
	id_t sender_id;
	id_t receiver_id;
	short int msg_type;
	short int len;
	char* data;	  //questo sarà una stringa di lunghezza che non è sempre uguale
	unsigned data_len;
} message_t;

message_t message;
		memset(&message, 0x00, sizeof(message_t));

		message.sender_id.id_appl = Run.id;
		message.sender_id.id_manager = 0;
		message.data_len = strlen(service);
		strnlen(message.data, service, message.data_len);
		message.receiver_id.id_appl = 1000;
		message.receiver_id.id_manager = 0;
		
		message.len = sizeof(message_t);

1)
strnlen(message.data, service, message.data_len);
(Immagino che sia una strncpy ??)

Comunque message.data e' un puntatore, quindi prima lo devi allocare...

[virusso80]

Originariamente inviato da cionci

Potresti ad esempio fare così:

message_t m = { { Run.id, 0 }, { 1000, 0 }, 0, sizeof(message_t), NULL, strlen(service) };

A cosa serve il campo short int len; ? La dimensione della struttura su una data architettura è costante. A meno che tu non voglia includere la dimensione della stringa, ma sappi che in ogni caso la lunghezza della stringa non sarà inclusa nel sizeof.

si, mi serviva proprio per valutare la lunghezza complessiva!

Originariamente inviato da darksax

1)
strnlen(message.data, service, message.data_len);
(Immagino che sia una strncpy ??)

Comunque message.data e' un puntatore, quindi prima lo devi allocare...

si si era una strncpy, ovviamente!

una domanda che mi sorge quasi spontanea è: quanti "zeri" imposterà il memset in quella istruzione? è lì che non mi torna!

[cionci]

Originariamente inviato da virusso80

si, mi serviva proprio per valutare la lunghezza complessiva!

Non ha senso. Se tu andassi a scrivere quella struct su disco, ti ci andrebbe a scrivere il puntatore e non il contenuto della stringa
Quindi il modo coretto di lavorare è quello di mantenere in data_len la dimensione della di data, mentre il campo len è inutile perché ha una dimensione fissa.

Il modo corretto di operare è questo:

typedef struct message_t
{
id_t sender_id;
id_t receiver_id;
short int msg_type;
short int len;
unsigned data_len;
char* data;
} message_t;

Quando andrai a scrivere su disco dovrai scrivere sizof(m)-sizeof(m.data) byte.
m.data è un puntatore, quindi il sizeof ritorna 4 o 8 byte.
Subito dopo andrai a scrivere il contenuto puntato da data, la cui dimensione si trova in data_len.
Al momento della lettura dovrai leggere sizof(m)-sizeof(m.data) byte, poi dovrai allocare m.data_len + 1 byte per data e ci andrai a mettere m.data_len byte letti successivamente.

[virusso80]

Originariamente inviato da cionci

Quando andrai a scrivere su disco dovrai scrivere sizof(m)-sizeof(m.data) byte.
m.data è un puntatore, quindi il sizeof ritorna 4 o 8 byte.
Subito dopo andrai a scrivere il contenuto puntato da data, la cui dimensione si trova in data_len.
Al momento della lettura dovrai leggere sizof(m)-sizeof(m.data) byte, poi dovrai allocare m.data_len + 1 byte per data e ci andrai a mettere m.data_len byte letti successivamente.

ecco, mi sono perso