conditionnelles* , plus de place dans le titre

Salut,

Je suis sur un programme d'environ 150 lignes, donc assez court et la plupart de mes variables sont utilisées uniquement sous certaines conditions donc je les ai déclarées quand la condition est vérifiée .

Conséquence : pour repérer les variables, ben il faut les chercher, vu la taille de mon programme c'est rapide mais du coup, je me pose la question :

Pour les gros programmes, est ce qu'il vaut mieux déclarer toutes les variables en début de programme dans un soucis de clarté même si la grande majorité n'aura servi à rien, et aura grignoté de la mémoire inutilement pendant l’exécution du programme, ou alors déclarer les variables quand la condition pour qu'elles soient utilisée est vérifiée mais rendre le programme plus "bordélique" avec des déclarations un peu partout, mais une optimisation de la mémoire utilisée .

Je suis partisan de ne déclarer des variables qu'au moment précis où elles sont utilisées. Devoir réserver les débuts d'une fonction à des déclarations seules c'est une pratique qu'on impose aux débutants structurer leur réflexion.

Pourquoi attendre? Parce que si les structures sont conditionnelles ça limite naturellement leur portée et donc les chances qu'on s'en serve au mauvais endroit ou au mauvais moment.
Ensuite le problème que tu rencontres est caractéristique d'un code qui pourrait sans doute être refactoré en plusieurs fonctions.
C'est un symptôme, si tu commences à avoir besoin de trop de variables qui ne servent que dans des conditions très particulières, ça veut dire que ta fonction fait peut être trop de choses différentes.

elite_2009, ca ne depend pas du compilo ce truc la ?

Heu, non, C devrait etre desalloue a la sortie du block.

Si j'avais du temps, je regarderasi ce que fais icc...

Wow, icc 12 fait un truc super bizarre. Compiler en -O3. la fonction f est dans un autre objet est compiler en -O0 et le linkage est fait en -O0 pour eviter les cross objects optimization. La fonction f affiche l'adresse du pointeur sur stdout.

1. include <iostream>

void f(int*);

int main(int argc, char* argv[]) {
int A = 42;
f(&A);

if (argc>1) {
int B = 43;
f(&B);
}

if (argc>2)
{
int C = 12;
f(&C);
}

int D = 13;
f(&D);

return 0;
}

$ ./a.out 3 2
0x6052d4
0x7fffc23bc280
0x7fffc23bc284
0x7fffc23bc288

avec icc12 et gcc 4.4.4 sur centos 6.

[esaule@master test]$ icc -O3 gistfile.cpp
[esaule@master test]$ ./a.out
Abc()
&aa:0x7fff8ec8c808
~Abc()
Abc()
&bb: 0x7fff8ec8c80b
~Abc()
----- end a() -----

Abc()
&bb: 0x7fff8ec8c80c
~Abc()
----- end a() -----

Abc()
&aa:0x7fff8ec8c809
~Abc()
Abc()
&bb: 0x7fff8ec8c80d
~Abc()
----- end a() -----

Abc()
&bb: 0x7fff8ec8c80e
~Abc()
----- end a() -----

Abc()
&aa:0x7fff8ec8c80a
~Abc()
Abc()
&bb: 0x7fff8ec8c80f
~Abc()
----- end a() -----

[esaule@master test]$ icc -O0 gistfile.cpp
[esaule@master test]$ ./a.out
Abc()
&aa:0x7fffae853184
~Abc()
Abc()
&bb: 0x7fffae853185
~Abc()
----- end a() -----

Abc()
&bb: 0x7fffae853185
~Abc()
----- end a() -----

Abc()
&aa:0x7fffae853184
~Abc()
Abc()
&bb: 0x7fffae853185
~Abc()
----- end a() -----

Abc()
&bb: 0x7fffae853185
~Abc()
----- end a() -----

Abc()
&aa:0x7fffae853184
~Abc()
Abc()
&bb: 0x7fffae853185
~Abc()
----- end a() -----

[esaule@master test]$ g++ -O0 gistfile.cpp
[esaule@master test]$ ./a.out
Abc()
&aa:0x7fff859a433e
~Abc()
Abc()
&bb: 0x7fff859a433f
~Abc()
----- end a() -----

Abc()
&bb: 0x7fff859a433f
~Abc()
----- end a() -----

Abc()
&aa:0x7fff859a433e
~Abc()
Abc()
&bb: 0x7fff859a433f
~Abc()
----- end a() -----

Abc()
&bb: 0x7fff859a433f
~Abc()
----- end a() -----

Abc()
&aa:0x7fff859a433e
~Abc()
Abc()
&bb: 0x7fff859a433f
~Abc()
----- end a() -----

[esaule@master test]$ g++ -O3 gistfile.cpp
[esaule@master test]$ ./a.out
Abc()
&aa:0x7fffdf3ec01f
~Abc()
Abc()
&bb: 0x7fffdf3ec01e
~Abc()
----- end a() -----

Abc()
&bb: 0x7fffdf3ec01e
~Abc()
----- end a() -----

Abc()
&aa:0x7fffdf3ec01f
~Abc()
Abc()
&bb: 0x7fffdf3ec01e
~Abc()
----- end a() -----

Abc()
&bb: 0x7fffdf3ec01e
~Abc()
----- end a() -----

Abc()
&aa:0x7fffdf3ec01f
~Abc()
Abc()
&bb: 0x7fffdf3ec01e
~Abc()
----- end a() -----

Les deux compilateurs font qqch different en -O0 et -O3 (inversion des placement).

Comme la classe est vide, j'imagine que le compilo met juste un char dedans pour resoudre les addresses differement.

Peut etre que icc inline l'appel en -O3?

C'est bon arrêtez ! j'ai compris la leçon je poserai plus de question, plus jamais

" void abc (int A) {
int B;

A=B;
}

A est a stackframe+0
B est a stackframe+4 "

Ce serait pas plutôt A à +8 (derrière la copie du pointeur d'instruction faite lors de l'appel de la fonction) et B à -4?

L'hypothese de mon chef est: pour aider a detecter les bugs de variable non initialise. Par exemple valgrind ca rendrait valgrind fou.

myhideout Voir le profil de myhideout
Posté le 1er mai 2013 à 23:15:54 Avertir un administrateur
C'est bon arrêtez ! j'ai compris la leçon je poserai plus de question, plus jamais

J'ai à peu près eu la même réaction que toi en lisant le topic !
On demande si on peut faire des variables conditionnelles, on se retrouve avec des tests de moult compilateur et l'analyse du code assembleur !

Dbzgokussj2 : ça peut ête violent de mélanger les gens de différents niveaux comme ça