Hola! Estoy intentando implementar una función en C que me arme una trama (cadena de caracteres) que luego será mandada a través de un canal de comunicación.

Para esto, primero tengo que crear la trama, la cual está compuesta de sus respectivos encabezados, campos de información, indicadores de fin de trama y finalmente el checksum.

Mi problema es que la longitud de la trama (cantidad de caracteres que poseerá) nunca será fija. Esto es, dependiendo de la trama que deseo enviar, varía la longitud de la misma, ya que ni la cantidad de campos es fija, ni la cantidad de caracteres lo es.

Para esto, se me ocurrió que podía hacer una función cuya declaración sea la siguiente:

En donde **campos vendría a ser un vector de <cant_campos> cadenas de caracteres, en donde cada una de estas es de longitud distinta. Cada uno de estas cadenas representará un campo disitinto.

La idea es que la función concatene cada uno de estos campos dentro de una misma cadenas de caracteres y luego esta cadena de caracteres (trama) sea devuelta por la función.

Mi pregunta es: ¿Es necesario pedir memoria dinámica cada vez que concateno un campo dentro de la cadena de caracteres (trama) que será devuelta?

Muchas gracias por su ayuda

Muchas gracias por tu respuesta Didacso.

Había pensado en hacer algo de ese tipo pero sucede que la función que me envía las tramas al canal de comunicación recibe únicamente variables del tipo char*. Por esta razón estaba necesitando una función que me devuelva la trama como cadena de caracteres.

Sucede que para ese puntero doble que recibirá la función (char **campos), ya habré pedido memoria dinámica.

Entonces el procedimiento dentro de mi función consistirá en volver a pedir memoria dinámica y liberar la que ya habia pedido cuando creé el puntero doble?

Saludos

Hola, estaba aburrido y decidí escribir una implementación de lo comentado, espero te sirva.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct {
	char * headers;
	char * info;
	char * checksum;
}Trama;
 
 
char * dataFromTrama(Trama * trama);
char checksum(char* s);
 
 
int main(int argc, char **argv)
{
	char* header = "the header";
	char* info = "the info";
 
 
	Trama * trama = (Trama *) malloc(sizeof(Trama));
	(*trama).headers = (char *) malloc(sizeof(header));
	(*trama).info = (char *) malloc(sizeof(info));
 
	strcpy((*trama).headers, header);
	strcpy((*trama).info, info);
 
	char * result = dataFromTrama(trama);
 
	printf ("%s\n" , result );
 
	return 0;
 
}
 
 
char * dataFromTrama(Trama * trama){
 
	char* tmpData;
 
	int sizeTotal = sizeof((*trama).headers) + sizeof((*trama).info) + sizeof(char);
 
	tmpData = (char *) malloc(sizeTotal);
 
	memset(tmpData, '\0', sizeTotal);
 
	strcpy(tmpData, (*trama).headers);
 
	strcat(tmpData , (*trama).info);
 
	char checksumdata = checksum(tmpData);
 
	printf ("Checksum %d \n" , checksumdata );
 
	tmpData = strcat(tmpData , &checksumdata);
 
	return tmpData;
}	
 
 
 char checksum(char* s){
	signed char sum = -1;
	while (*s != 0)	{
		sum += *s;
		s++;
	}
	return sum;
}