Supprimer le plus d'allocation dynamique

Version imprimable

Re-Bonjour,
Mon code comporte plusieurs allocations dynamiques que l'on me conseille de supprimer (ce sont tous des allocations sur des pointeurs de structures). mais je ne vois pas comment les supprimer, je suis pourtant bien obligé d'allouer les memoires d'un pointeur de structure pour pouvoir ecrire dans sa memoire par la suite !
Je vous donne ici quelques exemples de fonctions ou il faudrais que je supprime mes allocations dynamiques :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 struct sql_result * sql_make_empty_sql_result() { struct sql_result * result = (struct sql_result *) malloc(sizeof(struct sql_result)); if (check_not(result == NULL, "Can't alloc result")) { return NULL; } result->nrows = 0; result->ncolumns = 0; result->row_array_size = 0; result->binary = 0; result->att_desc = NULL; result->rows = NULL; return result; }
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 struct sql_notify * sql_notify_read ( struct sql_connection * sql_conn, const char * msg ) { struct sql_notify * notify; char name[256]; int sread = 0; uint32_t id = sql_get_int(sizeof(uint32_t), msg); sread += sizeof(uint32_t); strcpy(name, msg + sread); /* The last character is not include in the name, it's an extra empty string because not inplementd yet in the protocol */ name[strlen(name)-1] = '\0'; sread += strlen(name); notify = (struct sql_notify *) malloc(sizeof(struct sql_notify) + sread); if (check_not(notify == NULL, "Can't alloc sql_notify")) { return notify; } notify->id = id; notify->name = (char *) notify + sizeof(struct sql_notify); strcpy(notify->name, name); return notify; }
il y a d'autres fonctions mais je ne les mes pas toutes car elles sont trop longues. Si quelqu'un pouvais me dire si il y avais une autre facon de faire pour optimiser mon code de cette facon ca serais cool !
Merci d'avance.

27/08/2010, 13h48
fregolo52

Bonjour,

Je ne vois qu'une solution : passer le résultat en paramètre.
Remplacer :
struct sql_result *sql_make_empty_sql_result();

par :
int sql_make_empty_sql_result(struct sql_result *res);
27/08/2010, 14h25
Fooshi

Avant l'appel à
int sql_make_empty_sql_result(struct sql_result *res);

tu devras allouer le piointeur non ?
27/08/2010, 15h14
haraelendil
Bah si le but est d'éliminer les alloc dynamiques, tu alloue ta structure en auto, et tu passe le pointeur:
Code:

1 2 struct sql_result result; int res = sql_make_empty_sql_result(&result);

Pourquoi pas ... en tout cas je ny aurais jamais pensé ! merci

Autre probleme malgré tout, voici ma structure :

Code:

1
2
3
4
5
6
7
8
9
struct sql_result
{
	int 						nrows;				// Number of rows returned by the query.	
	int 				  		ncolumns;			// Number of columns returned by row description.
	struct sql_att_desc		  * att_desc;			// A pointer to a row description.
	struct sql_att_value	 ** rows;				// Each sql_result is an array of sql_att_value.
	int 				 		row_array_size;		// Allocated size of rows array.
	int 				 		binary;				// Binary row values if binary == 1, otherwise Text.
};

J'initialise ma structure comme ceci :

Code:

1
2
3
4
5
6
7
static int	
sql_get_row_description( struct sql_connection * sql_conn, const char * msg )
{
	struct sql_result result;
        sql_make_empty_sql_result(&result);    // Initilisation de la structure
        ...
}

Mais comment initialiser les pointeurs sur les autres structures att_desc et rows ?

28/08/2010, 01h01
olibara

Pour ma part, si c'est encore une demande de ton maitre de stage, je trouve qu'il véhicule des idées bizares et des contraintes qui n'apportent rien ni en performances ni en lisibilité. Ne pas utiliser d'allocations dynamique, ne pas faire de memcpy.. ?? il préfère peut-ete le Basic :roll:

N.B. Le memmove est preferable au memcpy car il gere l'overlap.

Citation:
Envoyé par Fooshi
Pourquoi pas ... en tout cas je ny aurais jamais pensé ! merci

Autre probleme malgré tout, voici ma structure :
Code:

1 2 3 4 5 6 7 8 9 struct sql_result { int nrows; // Number of rows returned by the query. int ncolumns; // Number of columns returned by row description. struct sql_att_desc * att_desc; // A pointer to a row description. struct sql_att_value ** rows; // Each sql_result is an array of sql_att_value. int row_array_size; // Allocated size of rows array. int binary; // Binary row values if binary == 1, otherwise Text. };
J'initialise ma structure comme ceci :
Code:

1 2 3 4 5 6 7 static int sql_get_row_description( struct sql_connection * sql_conn, const char * msg ) { struct sql_result result; sql_make_empty_sql_result(&result); // Initilisation de la structure ... }
Mais comment initialiser les pointeurs sur les autres structures att_desc et rows ?
Ben soit tu les initialises toi-même

Code:

result.att_desc=<pointeur_valide ou NULL>

Soit tu le passes à une fonction qui s'en chargera

Code:

toto(&result.att_desc)

Avec toto définie ainsi
Code:

1 2 3 4 <type> toto(struct sql_att_desc** ptr) { ... }