Voila j'essaye toujour de m'ameliore en programation et je ne trouve pas ma reponse (meme sur internet)
est ce que l'on peut ecrire ce qui suit ( soustraction de pointeur de structure):
typedef struct Date Date;
struct Date
{
int j;
int m;
int a;
};
/*_____________________________________________fonction evenement____________________________*/
// verifi si un evenement a eu lieu il prend en parametre deux date ( celle a verifier, celle de reference).
boolean Evenement(Date*date_1,Date*date){
boolean reponse=false;
if( date_1->a-date->a==0 && date_1->m-date->m==0 &&date_1->j-date->j>=0){// c'est ici que je suis pas sur!!!
reponse=true;
};
if(date_1->a-date->a==0 && date_1->m-date->m>0){
reponse=true;
};
if(date_1->a-date->a>0){
reponse=true;
};
return reponse;
}
ça compile mais j'ai pas de quoi tester pour le moment , merci de votre aide!
Bonjour,
Bienvenue dans le monde merveilleux de l'ide arduino : quand tu commences à sortir des sentiers battus ya plus rien qui marche 
Met ton typedef et ta déclaration de structure dans un fichier .h dans le même dossier que ton programme.
Et inclut ce .h dans ton programme, tout (re)marcheras comme par magie.
Pourquoi ? (blabla technique) :
En fait l'ide arduino n'extrait pas les typedef qui se retrouve donc âpres les prototypes de fonctions "auto-généré", du coup tout plante à la compilation sans raison.
Au passage, c'est tellement plus simple :
typedef struct Date
{
int j;
int m;
int a;
} Date;
Merci skywodd!
Mais en fait sa compile trés bien ,c'est juste que je suis pas sur de l'ecriture avec le pointeur de structure , car pour le reste l'ide ne ma pas posé de souci, et j'ai bien fait un .h( je suis en train de me faire des petite bibliothéque pour me simplifier la vie)
voila par exemple le code a verifier 
le coup des" ->")
if(date_1->a-date->a>0){
reponse=true;
};
Heloderma-kris:
Mais en fait sa compile trés bien ,c'est juste que je suis pas sur de l'ecriture avec le pointeur de structure , car pour le reste l'ide ne ma pas posé de souci, et j'ai bien fait un .h( je suis en train de me faire des petite bibliothéque pour me simplifier la vie)
T'avais déjà fait le .h, t'est du genre chanceux on dirait
Heloderma-kris:
voila par exemple le code a verifier le coup des" ->")
if(date_1->a-date->a>0){
reponse=true;
};
Simple :
pointeur ->
variable .
Donc ici les flèches sont effectivement adaptées 
Par contre, j'avais pas vu (t'as eu de la chance !) :
if( date_1->a-date->a==0 && date_1->m-date->m==0 &&date_1->j-date->j>=0){// c'est ici que je suis pas sur!!!
reponse=true;
};
C'est quoi ce ; en fin d'accolades ? Il a rien à faire là (même si c'est pas une erreur syntaxiquement parlant)
Et attention les parenthèses ne servent pas qu'as faire jolie dans les tests.
boolean Evenement(Date* date_1, Date* date) {
if ((date_1->a - date->a) == 0 && (date_1->m - date->m) == 0 && (date_1->j - date->j) >= 0)
return true;
if ((date_1->a - date->a) == 0 && (date_1->m - date->m) > 0)
return true;
if ((date_1->a - date->a) > 0)
return true;
return false;
}
Merci c'est vrai que j'en colle partout des ";" et les parenthése a part clarifier le code la elle non pas de vrai role non?
petite question( peut etre béte :P) en passant est ce que les pointeurs prenent exactement la meme taille que leur type ou alors il on une place memoire bien caractéristique?
par exemple
void mafonction(int a,int b){
//le corps de ma fonction
};
void mafonction(int *a,int *b){
//le corps de ma fonction
};
est ce que la deuxieme genere moin de place en RAM ou pas?
PS : je veux bien la reponse pour le enumeration egalement!!
Heloderma-kris:
Merci c'est vrai que j'en colle partout des ";" et les parenthése a part clarifier le code la elle non pas de vrai role non?
Les parenthèses sont là pour clarifier le code mais surtout pour éviter toutes erreurs dans le if.
Tu le vois bien, avec des parenthèses et des espaces le code est tout de suite beaucoup plus simple à comprendre / modifier.
Ce n'est pas obligatoire mais autant prendre l'habitude dés le début
Heloderma-kris:
petite question( peut etre béte :P) en passant est ce que les pointeurs prenent exactement la meme taille que leur type ou alors il on une place memoire bien caractéristique?
Bien sûr que non et heureusement puisse que c'est le but de pointeurs : ne pas avoir à copier de contenu.
Un pointeur prend toujours 2 octets sur AVR (ou 3 sur les gros ATmega style mega2560).
Par conséquent faire une pointeur sur byte / char / int / long / ... (types primaires) n'as pas grand intérét si tu peut t'en passer (= tu n'as pas à retourner plusieurs résultats).
Par contre sur une structure ça peut être avantageux d'avoir un pointeur car tu ne copie pas son contenu lors de l'appel à la fonction.
Heloderma-kris:
PS : je veux bien la reponse pour le enumeration egalement!!
Une énumération est une série de constantes de type int.
voila une reponse claire!
Merci c'est exactement ce que je voulais !
et c'est difficile de trouvé ce type de reponse je trouve !
nouvelle question :
je galere comme pas possible pour faire un pointeur vers un tableau de structure , je sais pas si c'est moi qui est C.. :0 alors voila le prototpe:
void foncSaison( Saison *(saison[]),int nbSaison,Date*rtc,float *Tmax ,float *Tmin ,float*Tmoy);
/*c'est le *Saison qui me casse la tete*/
dans mon code je cherche a l'utiliser comme suit :
Saison tabsaison[4];
foncSaison(&tabsaison,4,&rtcD,&tmax,&tmin,&tmoy);
est ça c'est l' erreure
serpentduino.ino: In function 'void loop()':
serpentduino:39: error: cannot convert 'Saison*' to 'Saison**' for argument '1' to 'void foncSaison(Saison**, int, Date*, float*, float*, float*)'
merci d'avance
bon j'ai finalement reusi a compiler mais je compren pas pourkoi!
le code de la fonction et le suivant :
cette fonction me permet de calculer des temperature de consigne a partire de date de valeur et de longueur de la monté bref
/*_________________________________________ calcule de la temperature a apliqué par saison ______________________________________________*/
void foncSaison( Saison *saison,int nbSaison,Date*rtc,float *Tmax ,float *Tmin ,float*Tmoy){
//nbSaison = nombre de saison
int indexSaison=0;
int indexprecedent=0;
float deltaMAX=0;
float deltaMIN=0;
float deltaMOY=0;
int nbJour=0;
float nbSemaine=0;
for (byte i=0; i<nbSaison;i++){
if ( Evenement((&saison[i].date),rtc)==true){
indexSaison=i;
};//detecte a quel niveau d'evenement on ce situ
}
//indexprecedent=constrainCycle((indexSaison-1),0,3);// on calcule l'index précédent
deltaMAX=((saison[indexSaison].tempMax)-(saison[indexprecedent].tempMax))/(saison[indexSaison].nbS);//on calcul le delta de temperature par semaine
deltaMIN=((saison[indexSaison].tempMin)-(saison[indexprecedent].tempMin))/(saison[indexSaison].nbS);//on calcul le delta de temperature par semaine
deltaMOY=((saison[indexSaison].tempMoy)-(saison[indexprecedent].tempMoy))/(saison[indexSaison].nbS);//on calcul le delta de temperature par semaine
//si nous somme dans le mois en cour
if((rtc->a-saison[indexSaison].date.a)==0 && (rtc->m-saison[indexSaison].date.m)==0){
nbJour=(rtc->j-saison[indexSaison].date.j);
};
//si nous somme dans l'annee en cour mais pas dans le mois
if((rtc->a-saison[indexSaison].date.a)==0 && (rtc->m-saison[indexSaison].date.m)>0){
nbJour=0;
for (int mois=((saison[indexSaison].date.m)+1); mois<(rtc->m);mois++){
nbJour=nbJour+jParM[mois-1];
} //les jour des mois entier
nbJour=nbJour+(jParM[(saison[indexSaison].date.m)-1])-((saison[indexSaison].date.j));//on ajoute les jour restant du moi de levenement
nbJour=nbJour+(rtc->j); //on ajoute les jour ecouler du moi en cour
};
//si nous ne somme pas dans la meme annee
if((rtc->a)-(saison[indexSaison].date.a)>0){
for (byte mois=1; mois<rtc->a;mois++){
nbJour=nbJour+jParM[mois-1];
}///penser a anne bisex
for (byte mois=int(saison[indexSaison].date.m+1); mois<=12;mois++){
nbJour=nbJour+jParM[mois-1];
}///penser a anne bisex
nbJour=nbJour+ (jParM[(saison[indexSaison].date.m)-1])-(saison[indexSaison].date.j);//on ajoute les jour restant du moi de levenement
nbJour=nbJour+(rtc->j);//on ajoute les jour ecouler du moi en cour
};
nbSemaine=nbJour/7;
*Tmax= saison[indexprecedent].tempMax+ (nbSemaine*deltaMAX);
*Tmoy= saison[indexprecedent].tempMin+ (nbSemaine*deltaMIN);
*Tmin= saison[indexprecedent].tempMoy+(nbSemaine*deltaMOY);
if (nbSemaine>saison[indexSaison].nbS){
*Tmax=saison[indexSaison].tempMax;
*Tmoy=saison[indexSaison].tempMoy;
*Tmin=saison[indexSaison].tempMin;
};
return;
}
pour moi quand on declare un pointeur de structure
comme ceci:
Structure *P_structure;
on obtenai la valeur dune variable de la structure par
une_variable=P_structure->variable;
comme mon pointeur Date*rtc
qui lui semble fonctioné je pije plus là
ps ce code compile mais du coup je sui pas sur qu'i face bien ce que je veux!
Heloderma-kris:
je galere comme pas possible pour faire un pointeur vers un tableau de structure , je sais pas si c'est moi qui est C.. :0 alors voila le prototpe:
void foncSaison( Saison *(saison[]),int nbSaison,Date*rtc,float *Tmax ,float *Tmin ,float*Tmoy);
Un tableau est de fait un pointeur.
Saison *(saison[])
Ça aurait presque pu être un pointeur sur un tableau multi-dimensionnel mais la syntaxe n'est pas le même 
Heloderma-kris:
pour moi quand on declare un pointeur de structure
comme ceci:
Structure *P_structure;
on obtenai la valeur dune variable de la structure par
une_variable=P_structure->variable;
comme mon pointeur Date*rtc
qui lui semble fonctioné je pije plus là
Tu sembles oublier un truc ... un pointeur pointe sur quelque chose.
MaStruct_t *p;
p est un pointeur qui pointe ... sur rien, il faut l'initialiser avant de l'utiliser.
Mon coco va falloir reprendre les cours de C
Allez hop hop hop :
http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-c/a-l-assaut-des-pointeurs
http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-c/pointeur-de-structure
http://www-igm.univ-mlv.fr/~paumier/C/C5-types%20structures.pdf
j'arete pas de relire les site mais je comprend pas en plus selon les site il ecrive pas tous de la meme magniere !
est ce que je comprend bien ?
lorsque je pase une structure a un pointeur de structure pour obtenir la variable on utilise ->
ex:
structure A;
fonction(structur *ptr_A){
une_variable=*(ptr_A).varX;
/* meme chose que :*/
une_variable=ptr_A->varX;
};
mais dans le cas d'un tableau qui est passer a une fonction il est consideré comme une adresse c'est ça non ?
donc :
structure A[];
fonction(structur *ptr_A){
/* directe on utilise */
une_variable=A[i].varX;
skywodd : desoler si j'ai du mal a comprendre , pour les pointeur clasique de variable j'ai je pense bien compris et pour les pointeur de structure clasique ausssi mais c'est pour les pointeur de tableaux de structure que je block grave!
que faut'il donc ecrire:
pour la fonction :
foncSaison( Saison *(saison[]));
avec pour utiliser le pointeur dans la fonction:
*(saison[indexSaison]).tempMax)
qui pour moi est la meme que :
(saison[indexSaison])->tempMax)
ou
foncSaison( Saison *saison);
avec pour utiliser le pointeur dans la fonction:
saison[indexSaison]).tempMax
avec pour utiliser la fonction
foncSaison( tab_structure);
je n'arrive plus a savoir a quel moment c'est une adresse et a quel moment c'est la variable situer a l'adresse! 
char[] et char * sont tout deux des pointeurs.
Sauf que le premier réserve l'espace requis alors que le deuxième ne fait que pointer sur quelque choses sans réserver d'espace.
En gros :
foncSaison(Saison saison[]);
(attention bien que ce soit des [] ça ce comporte comme un pointeur simple dans le prototype d'une fonction)
ou plus simplement :
foncSaison(Saison* saison);
Puis :
Saison tab_structure[4];
// ...
foncSaison(tab_structure);
et dans la fonction :
saison[...] = ...;
Si tu veut un pointeur sur pointeur :
foncSaison(Saison** saison);
ou
foncSaison(Saison* saison[]);
Si tu veut un pointeur sur pointeur :
foncSaison(Saison** saison);
ou
foncSaison(Saison** saison);
heu est ce que c'est pas ça que tu voulais ecire:
foncSaison(Saison** saison);
ou
foncSaison(Saison* saison[]);
pour resume c'est bien parsque c'est un tableau de structure que la sytax est differente
dans les deux cas qui suivent on initialise le pointeur de structure ou de tableau de structure avec
fonction(structure *ptr_structure);
donc pour un tableau de structure on obtiendra la valeur par
valeur de la variable =ptr_structur.champ
alorque dans le cas ou on envoi pas un tableau mes une structure on aurat
valeur de la variable =*(ptr_structur).champ
ou bien encore:
valeur de la variable =ptr_structur->champ
Heloderma-kris:
heu est ce que c'est pas ça que tu voulais ecire:
foncSaison(Saison** saison);
ou
foncSaison(Saison* saison[]);
Oui c'est ça.
Heloderma-kris:
pour resume c'est bien parsque c'est un tableau de structure que la sytax est differente
Les structures contiennent plusieurs champs, d'ou le point et la flèche pour y accéder.
C'est juste une extension à la syntaxe des pointeurs de base.
Heloderma-kris:
donc pour un tableau de structure on obtiendra la valeur par
valeur de la variable =ptr_structur.champ
NON NON NON NOOOOON
Pour un tableau :
val = ptr_structure[x].champs;
ptr_structure : pointeur sur la première structure du tableau
ptr_strcuture[...] : accès à une des structures du tableau (alloué en mémoire)
ptr_structure[...].champs : accès à un des champs de la structure dans le tableau
Faut bien comprendre qu'un pointeur peut pointer sur 1 à N valeurs (quelque soit le type, int, char, struct, ...).
Si tu fait :
*pointeur = val;
ou :
pointeur[0] = val;
c'est la même chose.
Heloderma-kris:
alorque dans le cas ou on envoi pas un tableau mes une structure PAR POINTEUR on aurat
valeur de la variable =*(ptr_structur).champ
ou bien encore:
valeur de la variable =ptr_structur->champ
Oui
Heloderma-kris:
donc pour un tableau de structure on obtiendra la valeur par
valeur de la variable =ptr_structur.champ
NON NON NON NOOOOON
oups desoler c'eait ce que tu a s ecri que je voulais ecrire !
merci c'est bien plus claire maintenant
desoler mais sur internet j'arrivais pas a comprendre
meme dans le bouquin du site du zero c'est pas expliqué comme ça !