Discussion :

[darkwall_37]

Bonjour Bktero,

Ben, je suis obligé, enfin je crois.

La formation du prototype de mes fonction est de la sorte : #type_variable#_1D_Fonction et je ne peux pas écrire unsigned long_1D_Fonction.
Pour factoriser et palier ce souci qui n'en est peut être pas un ? je fais de la sorte.
Sachant que de toute façon, ceci n'a pas pour but de remplacer les types de manière définitive mais juste pour la macro.

Par conséquent, j'écrirai toujours int *p = i_1D_allocate ( 120 );.

[Sve@r]

Concernant la déclaration des fonctions dans le header définies par les macros/DEF dans le .c, est-ce que je dois les déclarer de la sorte dans le header ou il y a moyen de factoriser ?

Hélas non. La signature d'une fonction c'est le nombre et le type de ses paramètres. Donc si une fonction X reçoit un signed char et une autre Y reçoit un unsigned char, ce sont deux signatures différentes donc deux déclarations différentes.

Toutefois, puisque free n'a pas besoin de connaitre le type pointé pour fonctionner, je me demande pourquoi toi tu t'embêtes à les diiférencier...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void all_1D_deallocate(void *p)
{
    if (p) free(p);
}

De plus, pas besoin de tester la non-nullité de p avant de l'envoyer à free car free le fait aussi (enfin bon ça évite juste un appel inutile quoi). Donc si on laisse free() gérer la non-nullité, le if devient inutile.

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void all_1D_deallocate(void *p)
{
    free(p);
}

Et là, avoir une fonction qui ne fait qu'appeler free() laisse planer un doute sur la plus-value et l'utilité de la fonction en question...

[darkwall_37]

Merci pour tes précisions.
A vrai dire, cette fonction n'a pas vocation à 'apporter quelque chose d'intéressant, si ce n'est de rester dans la lignée du format pour la lisibilité.
Effectivement, remarque pertinente, je m'en vais changer de suite changer ça =)

[Pyramidev]

Concernant la déclaration des fonctions dans le header définies par les macros/DEF dans le .c, est-ce que je dois les déclarer de la sorte dans le header ou il y a moyen de factoriser ?

Réflexion faite, le moyen le plus simple de tout factoriser est de définir deux grosses macros : une qui déclare toutes les fonctions d'un coup pour un type donné, et une autre qui définit toutes les fonctions d'un coup pour un type donné.

Voici ce que ça donne avec deux fonctions :

ptr.h :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#ifndef PTR_H
#define PTR_H
 
#include <stddef.h>
#include <stdbool.h>
// Pas besoin d'inclure <stdio.h> et <stdlib.h> dans ptr.h.
 
typedef signed char sc;
typedef int short s;
typedef int i;
typedef long l;
typedef long long ll;
typedef char c;
typedef unsigned char uc;
typedef unsigned short us;
typedef unsigned ui;
typedef unsigned long ul;
typedef unsigned long long ull;
typedef float f;
typedef double d;
typedef long double ld;
 
#define DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(type) \
 \
void  type##_1D_deallocate( type *p ); \
type* type##_1D_allocate( size_t p_sz );
 
 
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(sc)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(s)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(i)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(l)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(ll)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(c)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(uc)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(us)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(ui)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(ul)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(ull)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(f)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(d)
DECLARATION_DES_FONCTIONS_DU_MODULE_PTR(ld)
 
#endif

ptr.c :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include "ptr.h"
 
#include <stdio.h>
#include <stdlib.h>
 
#define DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(type) \
 \
void type##_1D_deallocate( type *p ) \
{ \
    if ( p ) { free( p ); } \
} \
 \
type* type##_1D_allocate( size_t p_sz ) \
{ \
    type *p = NULL; \
    if ( ( p = (type*)malloc( p_sz*sizeof(type) ) ) ) \
    { \
        size_t i; \
        for ( i=0 ; i<p_sz ; i++ ) \
            p[i] = 0; \
    } \
    return p; \
}
 
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(sc)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(s)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(i)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(l)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(ll)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(c)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(uc)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(us)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(ui)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(ul)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(ull)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(f)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(d)
DEFINITION_DES_FONCTIONS_DU_MODULE_PTR(ld)

[Bktero]

Le plus simple ne serait-il pas plutôt de faire de la génération de code, pour obtenir un code propre sans se prendre la tête avec ces typedefs et macros qui semblent donner mal à la tête aux gens ici présents ?

Exemple simple (j'ai vérifié la validité du template et de la sortie, c'est juste pour l'idée) de code Python :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
template = '''#include <stdlib.h>
 
#type# * #initials#allocate(size_t length)
{
        #type# *ptr;
 
        // Malloc blabla
 
        return ptr;
}
 
// Autres fonctions
 
void #initials#deallocate(#type# * ptr)
{
        free(ptr);
}
'''
 
type = 'unsigned long long'
generated = template.replace('#type#', type)
 
initials = ''.join([word[0] for word in type.split()]) + '_'
generated = generated.replace('#initials#', initials)
 
print generated

Donne en sortie :

$ python generator.py 
#include <stdlib.h>

unsigned long long * ull_allocate(size_t length)
{
	unsigned long long *ptr;

	// Malloc blabla

	return ptr;
}

// Autres fonctions

void ull_deallocate(unsigned long long * ptr)
{
	free(ptr);
}

[darkwall_37]

C'est ce que j'ai fais pour mon ancienne librairie.
Un template avec en param les différents types et pif paf pouf 3000 lignes de codes.
Mais je trouve ça aussi sympa de faire comme le propose pyramidev.

La différence est que c'est j'ai une fonction à rajouter ou à modifier. Avec la macro c'est beau goss.
Avec la génération c'est plus relou déjà.

Je me tate du coup xD