Moi j´ai testé l´#include massif, et il avait pas l´air de vouloir s´arrêter le compilo

main.cpp :

1. include " fonction.cpp"

fonction.cpp :

1. include " main.cpp"

( si vous avez du temps à perdre )

Comment faire pour qu´un structure soit exactement la meme entre 2 fonctions ?

Car dans mon programme, la structure personnage devient, par exemple, dans le cas d´un chevalier, 8 en force. Donc dans la fonction debut(), je modifie la structure qui a a la base 0 en force, je lui met 8. Quand je passe dans la fonction combat, perso.force ne vaut plus que 0...

La, j´ai vraiment besoin d´aide pour comprendre ça...

Il faut utiliser un passage par pointeur ou par référence !
Ou bien faire un retour modifié :

void Charger(personnage Perso)
{ Perso.HP = 1;
return; }
Charger(monperso);

Dans ce cas, ta fonction ne modifie pas monperso, mais une copie initialisée aux valeurs de monperso. Dès que la fonction est terminée, la copie est perdue, et monperso n´est pas modifié : MAUVAISE FACON DE PROCEDER

personnage Charger(personnage Perso)
{ Perso.HP = 1;
return Perso; }
monperso = Charger(monperso);

Dans cette façon, Charger fais une copie de monperso qu´il appelle Perso, il modifie cette copie, et il renvoie la copie modifiée, qu´on assigne à monperso : Ca marche, mais c´est pas génial, on se trimballe 2 copies de structure à chaque appel !

Maintenant, les 2 moyens BONS :

void Charger(personnage *Perso)
{ Perso->HP = 1; / / Ou bien ( *Perso).HP = 1;
return; }
Charger(monperso);

Dans ce cas, Perso n´est pas une copie de monperso, mais un pointeur qui pointe vers ( le vrai) monperso ! Ainsi, en modifiant ce que pointe Perso, on modifie bien monperso lui-même !
C´est il me semble la meilleur façon de procéder en C.
Cependant, pour éviter d´utiliser la syntaxe des pointeurs, le C++ rajoute la notion de référence :

void Charger(personnage &)
{ Perso.HP = 1;
return; }
Charger(monperso);

Ici, Perso est une référence vers monperso, on peut donc utiliser le " ." plutôt que le " *" ou le " ->" pour modifier les membres de la structure référencée.
( Sur ce coup j´espère ne pas dire de connerie )

Bon, c´est pas trop clair tout ça, mais je m´y pencherai demain, la pour l´instant je fais le tuto sur la SDL, et c´est pas simple...

JYY: il y a une option de compilation pour changer la taille de la pile.
Par default le compilateur de visual fait une pile de 1Mo mais tu peux le changer.

Sinon N_Cortex l´exemple suivant devrait t´eclairer

void toto(int t)
{
t=3;
}
void tata ( int* t)
{

• t=3;

}

int main()
{
int a=0;
toto(a);
std::cout<<"a"<<std::endl;//affiche 0
tata ( &);
std::cout<<"a"<<std::endl;//affiche 3
return 0;
}

Ah ok ! !! Donc ce que tu me demandes de faire, ce sont des copies par référence ?
Je verrais ça demain, ce soir, je joue a worms world party :p

Soit par pointeur, soit par référence ( ce que t´asm ontré godrik, c´est par pointeur)

Sinon pour me corriger, en haut c´était :

void Charger(personnage *Perso)
{ Perso->HP = 1; / / Ou bien ( *Perso).HP = 1;
return; }
Charger(&); / / Ici j´ai rajouté le & !

Il ne faut pas confondre les 2 fonctions de l´opérateur & !

&
Signifie " adresse de variable", et est valide en C et en C++

T &
Signifie que variable est une référence vers une variable de type T, et est seulement valide en C++

Adresse de variable et les pointeurs, c´est vachement flou pour moi, mais je vais retourner sur le tuto et essayer de comprendre.

J´ai beau chercher, je comprends pas comment je dois utiliser ça... Je dois créer une deuxième structure qui sera la copie de personnage perso ? Si je stock l´adresse de ma structure, je comprend pas comment la réutilisée...

J´arrive a stocker l´adresse de la structure, mais si je fais dans la fonction combat perso = *adresse, il me dit qu´il y a une erreur...

oups, pardon pas perso = *adresse, mais perso = &...

tu t´égares !
pour passer uen structure, tu la passe pas référence

void fonction(struct plouf& p)
{
p.data; --> le meme qu´en bas !

}

int main()
{
struct plouf p;
fonction(p);

}

void fonction(struct plouf& p)
{
p.data; --> le meme qu´en bas !

}
Ca, c´est la référence a ma structure ?

int main()
{
struct plouf p;
fonction(p);

}

La, c´est la création de ma structure, puis la création de sa référence ?
Donc, si je fais cout < < p.data il devrait m´afficher ce que vaut p.data, ou alors data vaut la référence de ma stucture ? ?!!

Ohlala, je sens que je m´égare là...

oui, ça t´affichera la meme chose qu´en bas
quand tu passes par référence, tu passes la structure originale ! mais si tu la modifie, ça modifie l´originale aussi !

Donc, ce qu´il faudrait que je fasse c´est :

struct personnage
{
struct inventaire objet[15];
struct sorts sort[10];
string nom;
string nom_travail;
int exp;
int exp_max;
int lvl;
int travail;
int pv;
int pv_max;
int mana;
int mana_max;
int force;
int agilite;
int magie;
};

void debut()
{
struct personnage perso
[la y a un bout de code ininterréssant]

copie(perso);
combat("Brigand", 10, 3, 2, 2);
}

void copie(struct personnage& perso)
{
perso.data;
}

void combat(string name,int life,int f,int a,int nb)
{
degats = rand()%perso.force; --> la ça va marcher ou il faut que je rajoute struct personnage perso ?

non non tu n´as rien compris !

Tu n´as pas à faire de copies, et ta fonction copie n´a d´ailleurs aucun sens !

Si tu veux que ta fonction combat modifie ta structure perso, tu lui passes en référence :

void combat(string name,int life,int f,int a,int nb, struct personnage &)
{
/ / Ici si tu veux lui enlever 10 HP
perso.pv -= 10;
}

et tu appelles la fonction comme avant en rajoutant ton perso :

combat("Brigand", 10, 3, 2, 2, perso);

Je te conseille quand même de lire un cours sur les notions de pointeurs et de référence, ça ne te ferait que du bien

AAAAAAAAAAAAAAAAAAAAAAaaaaaaaaaaaaaaah ! !! ok!!

J´ai déja relu le cours 3 fois, mais j´ai toujours pas compris appremment...

Enfin bon, maintenant j´ai beaucoup mieux compris.

Mais juste une question... ca c´est du pointeur ou du passage de parametre ?

En fait je pense que tu n´as pas bien compris la portée des variables :

int a = 0;

int addition()
{
int b = 1;
return a+b;
}

int main()
{
int c = addition();
return 0;
}

Dans ce cas, la variable a est connue d´addition et de main, la variable b est locale à la fonction addition, la variable c est locale à la fonction main.
De même si au lieu de variables tu utilises des structures !
Et aussi :

void Blesser()
{
struct personnage Perso;
Perso.pv -= 10;
}
int main()
{
struct personnage Perso;
Blesser();
return
}

Ici, nous avons 2 structures de même nom, mais elles ne sont pas les mêmes ( dans la mémoire, chacune est à un endroit). Elles ont chacune une portée différente, et ce n´est pas le fait qu´elles aient le même nom qui les rend unique !

ca c´est du pointeur ou du passage de parametre ?

->

Question un peu fausse

C´est du passage par paramètre, car on passe un paramètre à la fonction

Je pense que ta question était plutôt : " Est-ce un passage de paramètre par pointeur ou par valeur ? "

Ni l´un, ni l´autre, ce n´est ni un passage par valeur ( qui effectue une copie locale), ni un passage par pointeur.
C´est un passage par REFERENCE !

Tu peux dans ta tête le rapprocher du passage par pointeur, la seule différence avec le passage par pointeur sera syntaxique ( . au lieu de ->, rien à la place d´un *), sinon ça se passera pareil