Discussion :

[LE_BU]

Bonjour,
Pour économiser de la mémoire programme sur mon microcontrôleur je voudrais appeler une fonction parmi plusieurs qui sont identiques (pas d'argument)

pour faire simple, au lieu d'appeler:

mafonction3();

je voudrais faire

mafonctionx() ou x prendrait la valeur 3

Merci

[Corluk]

Je ne sais pas si j'ai bien compris, mais le préprocesseur pourrait t'aider :

Code :

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

#define mafonction(x) mafonction ## x()

Appelle ainsi :

Code :

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

mafonction(3)

[LE_BU]

Corluk

Merci pour ta réponse
Ce que tu me proposes va remplacer lors de la compilation alors que je souhaite plutôt une partie variable que va appeler la bonne fonction
c'est a dire que le x entre crochet serait une partie variable

mafonction[x](); avec [x] pouvant prendre une valeur comprise entre 1 et 20 par exemple

si avant de demander l’exécution de la ligne ci-dessus et que x vaut 6 j'aurais

je vais executer
mafonction6();

puis quelques cycles plus tard avant de demander l’exécution de la ligne et que x vaut 2

je vais appeler
mafonction2();

Voilà j'espère avoir été plus clair

[Bousk]

Une fois compilée les fonctions n'ont plus de nom mais juste une adresse.
Ta raison d'économiser de la mémoire est au moins fausse parce que tu n'économiseras rien.
Au lieu d'écrire call3(); call2(); tu veux avoir une variable x qui prenne les valeurs 2,3, ... et devine quelle fonction appeler.
Donc pour économiser de la mémoire tu ajoutes une variable ?
Le moyen le plus simple d'appeler une fonction c'est de l'appeler directement. Si tu rajoutes une indirection, tu vas toujours perdre du temps à résoudre l'indirection avant de faire l'appel réel.

[foetus]

Voilà j'espère avoir été plus clair

Non pas du tout quel est le but de la manœuvre ?

Si tu prends la solution @Corluk, ou tu passes le nombre en paramètre de ta fonction, tu vas avoir 1 gros switch.
Mais si chaque embranchement a beaucoup de code (> plus de 20 lignes) ou il y a beaucoup d'embranchements (apparemment 20), la taille de ta fonction va exploser.
Ou alors, tu fais 1 embranchement == 1 appel d'une fonction.

Mais quelle que soit la façon de coder, tu vas avoir 1 grosse fonction ou alors 20+1 petites fonctions.
Que veux-tu faire au juste ? Est-ce que tu veux que tes fonctions ne soient pas toutes présentes en mémoire - c'est à dire par exemple, charger la fonction/ l'embranchement 5 et 7, mais pas les autres ?
Ce n'est pas très clair ?

[dalfab]

Bonjour,

Générer un nom de fonction ça n'a de sens qu'au moment de la compilation, car à l'exécution les noms n'existent plus (heureusement et c'est pour ça qu'on n'utilise pas de langage de script sur microcontrôleur). Donc seul le préprocesseur peut faire cela comme la solution de Corluk.
Ce que tu peux faire c'est utiliser un tableau de pointeurs de fonctions. Et les noms n'y joueront aucun rôle.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void fonction1(void);
void deuxiemeFonction(void);
void fonction3(void);
 
static const void (*MesFonctions[3])(void) = { // tableau de pointeurs sur void fct(void)
    fonction1,
    deuxiemeFonction,
    fonction3
};
 
void appelerFonction( int x) {
    (*MesFonctions[x])();  // appeler la x-ième fonction
}

[LE_BU]

Une fois compilée les fonctions n'ont plus de nom mais juste une adresse.
Ta raison d'économiser de la mémoire est au moins fausse parce que tu n'économiseras rien.
Au lieu d'écrire call3(); call2(); tu veux avoir une variable x qui prenne les valeurs 2,3, ... et devine quelle fonction appeler.
Donc pour économiser de la mémoire tu ajoutes une variable ?
Le moyen le plus simple d'appeler une fonction c'est de l'appeler directement. Si tu rajoutes une indirection, tu vas toujours perdre du temps à résoudre l'indirection avant de faire l'appel réel.

Je suis d'accord que les fonctions ont une adresse une fois compilé mais je pense que de faire une programme :

Code :

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

1
2
3
4
5
6
if (appellefonction==2) mafonction2();
if (appellefonction==3) mafonction3();
    |
    |
if (appellefonction==N-1) mafonctionN-1();
if (appellefonction==N) mafonctionN();

sera beaucoup plus gourmand en mémoire que

Code :

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

mafonction[appellefonction]();

Surtout si N est grand

[LE_BU]

Bonjour,

Générer un nom de fonction ça n'a de sens qu'au moment de la compilation, car à l'exécution les noms n'existent plus (heureusement et c'est pour ça qu'on n'utilise pas de langage de script sur microcontrôleur). Donc seul le préprocesseur peut faire cela comme la solution de Corluk.
Ce que tu peux faire c'est utiliser un tableau de pointeurs de fonctions. Et les noms n'y joueront aucun rôle.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void fonction1(void);
void deuxiemeFonction(void);
void fonction3(void);
 
static const void (*MesFonctions[3])(void) = { // tableau de pointeurs sur void fct(void)
    fonction1,
    deuxiemeFonction,
    fonction3
};
 
void appelerFonction( int x) {
    (*MesFonctions[x])();  // appeler la x-ième fonction
}

Bonjour, ta solution me semble la plus approprié ... mais je pensais qu'il existait quelque chose de plus simple que j'ignorais

[foetus]

Je suis d'accord que les fonctions ont une adresse une fois compilé mais je pense que de faire une programme [...] sera beaucoup plus gourmand en mémoire que [...] Surtout si N est grand

Ben non parce que le switch utilise des tables de branchements ("jump tables" en anglais ) et donc c'est gros modo équivalent à un tableau de pointeurs.

Après , il faudra sûrement mettre l'optimisation à fond lors de la compilation.

[Bousk]

Plus N est grand, plus tu gaspilles de mémoire.
Prenons N = 1000. Maintenant en plus de 1000 fonctions, tu te retrouves avec un tableau de 1000 pointeurs, donc 2-8ko de mémoire utilisées pour écrire call(3); au lieu de call3(); quand tu veux appeler la troisième fonction.
Je vois pas où tu vois un gain là-dedans
Les tableaux de fonction ont une utilité, mais optimiser la mémoire en fait pas partie.

[L'EMPEREUR LION]

Je ne comprends pas bien le tableau de pointeur sur fonction

[Sve@r]

Bonjour

Je ne comprends pas bien le tableau de pointeur sur fonction

Une fonction c'est un code exécutable identifié par un nom. Mais au niveau machine, ce nom c'est simplement une adresse.
Donc (exemple) si tu écris void toto(int n) {printf("toto %d\n", n)}, tu crées une fonction dont le nom "toto" correspond à l'adresse d'un code. Tu as alors le droit de créer un pointeur qui récupère cette adresse.
Ce code étant void et recevant un int, ce pointeur sera alors défini ainsi: void (*pt)(int) signifiant "pt va contenir une adresse" et "*pt" correspond à un code de fonction de type void et recevant un int. Ensuite, tu lui affectes l'adresse de la fonction toto de façon naturelle comme pour toute autre valeur pt=toto (mais pas de parenthèse à "toto" car tu ne veux pas l'exécuter, juste la nommer).
De là, tu peux exécuter le code de toto soit de la façon classique toto(123) soit par le pointeur qui contient lui-aussi l'adresse de ce code => (*pt)(456) mais les parenthèses sont obligatoires à cause des priorités.

Une fois que tu comprends ce concept qu'une fonction n'est avant tout qu'une adresse que tu peux stocker dans un pointeur, c'est pas compliqué à étendre à un tableau de pointeurs pouvant stocker diverses adresses de diverses fonctions.