Sous-programmes - Page 2

Quand je fait varier x et y (avec les touches directionnelles), z reste identique.

Tu as déclaré z comme variable locale dans calcz, donc il ne sortira pas de la fonction. Il faut déclarer une variable globale, ou bien passer par une valeur de retour.

Je la déclare où cette variable globale ?

dans z.c en dehors de calcz(), et tu rajoutes une déclaration "extern int z;" dans z.h... (et il faut aussi pas oublier de supprimer la déclaration dans _main)

Je ne peut pas mettre un autre "extern int z;" dans le Main ? Car je me sert autre part de z et il me dit qu'elle est pas déclarée.

Les déclarations extern on les met juste dans le .h, normalement (et comme il est inclus partout tu devrais pas avoir d'erreur)

Ah j'avais mis la déclaration externe dans le .c ... Par contre j'ai maintenant un autre problème : chaque fois que je vais chercher z dans le main TIGCC me dit "unresolved reference to'z'"


EDIT : pas que dans le main enfait, partout.

extern int z permet juste d'utiliser la variable, mais ne la définit pas : pour ça il faut mettre dans un des .c une déclaration du style "int z = 1;"

Juste dans 1 ?

Quand je met dans le main ou dans l'autre il me met les mêmes erreur et quand je met dans les deux, il veux bien compiler mais j'ai le même problème que tantôt (z ne change pas quand je change x et/ou y).


EDIT : petite présision : quand je le met dans un, il m'annule les erreur de celui-là mais pas de l'autre.

il faut pas le mettre à l'intérieur d'une fonction ^^ (sinon c'est une variable locale, pas globale)

Ok mais si je ne me le met pas il met 5/6 "Unresolved reference to 'z'"

poste ton code ^^

C'est fait !

Il faut utiliser une valeur de retour

Main.c

#include <tigcclib.h>
#include "Z.h"

void _main(void)
{
...
char b=0;
int x=0,y=0,z=1;
...
while(b==0)
{
...
z=calcz(x,y);
...
}
...
}

Z.c (entier)

#include "Z.h" 
 
int calcz(int x,int y) 
{
	int z;
	
	if((x==0) && (y==0))
	z=1;
	if((x==17) && (y==0))
	z=2;
	if((y==1) && (x<2))
	z=x+3;
	if((y==1) && (x>9))
	z=x-7;
	if((y==2) && (x<2))
	z=x+11;
	if((y==2) && (x>9))
	z=x+1;
	if(y==3)
	z=x+19;
	if(y==4)
	z=x+37;
	if((y==5) && (x<3))
	z=x+55;
	if((y==5) && (x>2))
	z=x+69;
	if((y==6) && (x<3))
	z=x+87;
	if((y==6) && (x>2))
	z=x+101;
	if(y==8)
	z=x+55;
	if(y==9)
	z=x+87;
	
	return z;
}

Z.h (entier aussi)

int calcz(int x,int y);

Je donne quand-même la solution correcte avec une variable globale:

Main.c

#include <tigcclib.h>
#include "Z.h"

void _main(void)
{
...
char b=0;
int x=0,y=0;
...
while(b==0)
{
...
calcz(x,y);
...
}
...
}

Z.c (entier)

#include "Z.h" 

int z;
 
int calcz(int x,int y) 
{
	if((x==0) && (y==0))
	z=1;
	if((x==17) && (y==0))
	z=2;
	if((y==1) && (x<2))
	z=x+3;
	if((y==1) && (x>9))
	z=x-7;
	if((y==2) && (x<2))
	z=x+11;
	if((y==2) && (x>9))
	z=x+1;
	if(y==3)
	z=x+19;
	if(y==4)
	z=x+37;
	if((y==5) && (x<3))
	z=x+55;
	if((y==5) && (x>2))
	z=x+69;
	if((y==6) && (x<3))
	z=x+87;
	if((y==6) && (x>2))
	z=x+101;
	if(y==8)
	z=x+55;
	if(y==9)
	z=x+87;
	
	return z;
}

Z.h (entier aussi)

void calcz(int x,int y);
extern int z;

mais la solution avec la valeur de retour est beaucoup plus propre!

Merci à vous tous, ça marche.

Les deux, toutes choses égales par ailleurs on cherche à minimiser les dépendances donc préférer les variables locales aux variables globales, les constantes aux variables modifiables. C'est le coeur de la programmation fonctionnelle, et ça permet de minimiser les risques de bugs (variable pas initialisée), de potentiellement mieux optimiser (on sait exactement quand on a besoin de quelle valeur dans quelle variable, plutôt que de devoir la mettre "au cas où" si les dépendances sont mal connues), et sur les architectures plus modernes que les TI de paralléliser le code (si on sait que deux calculs sont indépendants on peut les exécuter en parallèle).

Non les compilateurs C n'en sont pas encore vraiment là (ça pourrait facilement rendre le programme beaucoup plus lent dans certains cas), mais ils peuvent utiliser les multiples unités de calcul au sein d'un même coeur, ou encore les instructions SIMD...

(pour traduire : les processeurs "modernes" sont capables, dans certaines conditions, d'exécuter plus d'une instruction par cycle d'horloge... si les inter-dépendances des instructions le permettent)

Bah, c'est pas si compliqué hein

Bah t'as fait de l'assembleur, tu dois bien pouvoir comprendre ce que sont deux instructions indépendantes l'une de l'autre non ? Bah pouf, en même temps

Dans les processeurs superscalaires modernes, ce sont des dizaines/centaines de milliers de transistors qui s'occupent de calculer les dépendances entre instructions, et d'exécuter en parallèle s'il n'y a pas d'interdépendance.

A moins qu'il s'agisse de commencer à faire traiter une instruction par une unité du proc avant que celle d'avant ait fini d'être traitée ?

Ca, c'est le pipeline, que les processeurs superscalaires font également, mais je ne pense pas que ce soit à ça que Ximoon faisait référence.


Combine le pipeline et l'exécution superscalaire (éventuellement out of order) et tu comprends pourquoi c'est autant le bazar d'écrire de l'assembleur optimisé sur un x86 moderne

Optimiser en taille reste plutôt facile, c'est la vitesse qui est très difficile à prévoir, et qui dépend énormément du CPU exact (donc du code super-rapide sur un Pentium 4 peut ramer à fond sur un Core 2 Duo).

Et c'est surtout pour ça qu'un compilateur C sera souvent meilleur qu'un codeur pour générer du code sur ce genre de processeur

(je n'avais pas fini de lire ton post, donc Lionel)
Lionel> effectivement, je ne parlais pas du pipeline en particulier, mais ça intervient aussi