Discussion :

[Fooshi]

Bonjour,
j'ai une petite question d'optimisation.
une de mes fonctions lis des message stockées dans un tableau statique (preferable dans mon cas pour eviter les allocations).
je passe toujours en parametre a plusieurs fonctions l'adresse comme ceci :

Code :

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

1
2
char msg [512];
sql_conn->notify = sql_notify_read(sql_conn, &msg[0]);

Dans le cas ou je veux lire &msg[4] est ce que msg + 4 est plus clean ?

Merci d'avance.

[sloshy]

Bonjour,

que tu utilises msg ou &msg ou &msg[0], l'adresse sera la même.
que tu utilises msg + 4 ou &msg[4] aussi.

Tant que tu reste dans un tableau à une dimension tu n'a aucun soucis de ce coté, c'est juste comme tu préfères le lire.
j'ai un faible pour msg + 4

cdt

[Pierre Maurette]

Bonjour,

que tu utilises msg ou &msg ou &msg[0], l'adresse sera la même.
que tu utilises msg + 4 ou &msg[4] aussi.

Tant que tu reste dans un tableau à une dimension tu n'a aucun soucis de ce coté, c'est juste comme tu préfères le lire.
j'ai un faible pour msg + 4
cdt

Je suis à peu près d'accord. Une nuance quand même. On va dire qu'on a soit msg + 4, qui s'accompagne de msg + 0, et disqualifie msg. Ou &msg[4] qui s'accompagne de &msg[0] et disqualifie &msg. Question de cohérence sémantique et de maintenabilité. C'est juste mon avis.

Pour le reste, l'équivalence est d'autant plus flagrante que msg + 4 ou &msg[4] seront traités de la même façon. Dans le code produit, ce seront la même valeur constante, produite à la compilation. En fait un adressage immédiat.

Sinon, je ne pige pas trop le problème de Fooshi. Pourquoi pas simplement un tableau de chaînes ?

Comme je ne fais plus de C depuis un moment, j'ai voulu m'y remettre un peu. J'ai fait quelques essais sans intérêt majeur. C'est surtout utile pour suivre dans un débugger, ou sortir le code assembleur:

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
#include <stdio.h>
#include <stdlib.h>
 
 
//const char const mots1[] = "zero\0un\0deux\0trois\0quatre\0";
//const char const * mots2[] = {"zero", "un", "deux", "trois", "quatre"};
 
static void affiche(const char* s){
	puts(s);
}
 
#define AFFICHE(s) puts((s))
 
 
int main(void) {
	static const char const lettres[] = "zero\0un\0deux\0trois\0quatre\0";
	static const char const * mots[] = {"zero", "un", "deux", "trois", "quatre"};
 
	affiche(lettres + 0);
	affiche(lettres + 13);
	affiche(&lettres[0]);
	affiche(&lettres[13]);
 
	affiche(mots[0]);
	affiche(mots[2]);
	affiche(*(mots + 0));
	affiche(*(mots + 2));
 
	AFFICHE(lettres + 0);
	AFFICHE(lettres + 13);
	AFFICHE(&lettres[0]);
	AFFICHE(&lettres[13]);
 
	AFFICHE(mots[0]);
	AFFICHE(mots[2]);
	AFFICHE(*(mots + 0));
	AFFICHE(*(mots + 2));
 
	return EXIT_SUCCESS;
}

[Fooshi]

Dans mon cas le message est un tableau de chaine de caracteres classiques et non un tableau de chaines, tableau a une dimension donc.

[Sve@r]

Bonjour,
j'ai une petite question d'optimisation.
une de mes fonctions lis des message stockées dans un tableau statique (preferable dans mon cas pour eviter les allocations).

Salut

Fais gaffe aux tableaux statiques, ça peut produire des effets de bord difficilement détectable
Exemple

Code C :

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
 
#include <stdio.h>
#include <string.h>
 
char *fct(char l)
{
        static char tab[512];
        int len;
 
        len=strlen(tab);
        tab[len]=l;
        tab[len+1]=0;
        return tab;
}
 
int main()
{
        int i;
        for (i=0; i < 5; i++)
        {
                printf("%s\n", fct(i + 'a'));
        }
}

Exécution

moi@debian:~$ ./essai
a
ab
abc
abcd
abcde

Là ça fonctionne super

Petite modif

Code C :

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
 
#include <stdio.h>
#include <string.h>
 
char *fct(char l)
{
        static char tab[512];
        int len;
 
        len=strlen(tab);
        tab[len]=l;
        tab[len+1]=0;
        return tab;
}
 
int main()
{
        int i;
        int j;
        for (i=0; i < 5; i++)
        {
                printf("%s\n", fct(i + 'a'));
                for (j=0; j < 5; j++)
                {
                        printf("%s\n", fct(j + 'A'));
                }
        }
}

Exécution

moi@debian:~$ ./essai
a
aA
aAB
aABC
aABCD
aABCDE
aABCDEb
aABCDEbA
aABCDEbAB
aABCDEbABC
aABCDEbABCD
aABCDEbABCDE
aABCDEbABCDEc
aABCDEbABCDEcA
aABCDEbABCDEcAB
aABCDEbABCDEcABC
aABCDEbABCDEcABCD
aABCDEbABCDEcABCDE
aABCDEbABCDEcABCDEd
aABCDEbABCDEcABCDEdA
aABCDEbABCDEcABCDEdAB
aABCDEbABCDEcABCDEdABC
aABCDEbABCDEcABCDEdABCD
aABCDEbABCDEcABCDEdABCDE
aABCDEbABCDEcABCDEdABCDEe
aABCDEbABCDEcABCDEdABCDEeA
aABCDEbABCDEcABCDEdABCDEeAB
aABCDEbABCDEcABCDEdABCDEeABC
aABCDEbABCDEcABCDEdABCDEeABCD
aABCDEbABCDEcABCDEdABCDEeABCDE
moi@debian:~$

Comme il n'y a qu'une seule zone statique, les fonctions des deux boucles imbriquées tapent dans la même (alors qu'on s'attendait très certainement à une certaine indépendance des appels)...

[Fooshi]

Bien sur mais dans le deuxieme exemple, tu utilise deux index ce qui est risqué, j'utilise toujours un seul index qui va parcourir la chaine du debut a la fin.

[Sve@r]

Bien sur mais dans le deuxieme exemple, tu utilise deux index ce qui est risqué

Hé oui. C'est le problème inhérent aux statiques. J'avais eu le même problème avec strstr que j'appelais dans 2 boucles imbriquées sur des chaines différentes. Comme cette fonction garde dans une statique une trace du dernier appel, la seconde boucle polluait la première (comme ici).

, j'utilise toujours un seul index qui va parcourir la chaine du debut a la fin.

Pas de soucis. Garde juste cet exemple à l'esprit pour te souvenir du danger (si jamais ton code évolue par exemple...)

[Invité]

Bonjour,
Oui, moi aussi j'utilisais un tableau statique pour ce genre ce chose. Maintenant je préfère ce type d'écriture

Code :

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

1
2
3
4
5
6
7
8
9
10
int Carte(char* Ligne, FILE *lec,  int nbcar);
 
int main()
{
// initialisation de ligne, soit malloc, soit static
  int NbCar=80; // anciennes cartes perforées
  char Ligne[81];
  FILE *lec=fopen(...);
  int nbLu=Carte(Ligne, lec, NbCar);
}

La raison principale est que je peux lire des lignes pas très longues, mais je veux pouvoir lire aussi des lignes très-très longues, tout avec la même fonction. Et naturellement, j'ai eu aussi des effets de bord , alors dans ces cas là on n'hésite pas.

[uknow]

Exemple

Code C :

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

1
2
3
4
5
 
static char tab[512];
int len;
 
len=strlen(tab);

Ne manquerait-il pas une initialisation de tab avant l'utilisation de strlen ?

[Invité]

@uknow,
En l'absence de déclaration explicite, une variable static est initialisée à o ou NULL.

[sloshy]

C'est le cas et donc len vaudra zero

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <string.h>
#include <stdio.h>
 
int             main(void)
{
  static char   tab[512];
  int           len;
 
  len = strlen(tab);
  printf("len = '%d'\n", len);
  return (0);
}

Code :

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

1
2
3
4
sloshy@clonix-laptop:/tmp/src$ gcc -W -Wall -ansi -pedantic main.c -o test
sloshy@clonix-laptop:/tmp/src$ ./test 
len = '0'
sloshy@clonix-laptop:/tmp/src$

[Invité]

@sloosky,
Où voulez-vous en venir avec votre code.
Le tableau static est dans une fonction.
A la création, sauf initialisation, il vaut NULL, donc len = 0 (naturellement)
Puis cette fonction est appelée et modifie le tableau (voir #5).
La question est tableaux static ou pas?