Bonjour,
je souhaiterais savoir s'il est possible d'échanger les adresses de deux variables type structure.
Exemple:
 
struct Essai
{
 int n;
 float *X;
}
 
1 int main(void)
2 {
3   Essai Essai1, Essai2, *EssaiTampon;
4    
5   //Allocation des tablo Essai1.X et Essai2.X
6  
7   //Echange des adresses:
8   EssaiTampon= &Essai1;
9   &Essai1= &Essai2;
10  &Essai2= EssaiTampon;
11
12 }
 
g++ me crie à la ligne 9... Donc ca marche pas (au moins comme ça).
 
D'avance merci.

Pourquoi échanger les addresses et pas les contenu ?

Parce qu'en réalité il y a plein de tableaux et autres int, float dans la structure.
Ceci dit, c'est ce que je faisais jusqu'à présent en ne changeant que les pointeurs des tableaux dans la structure. mais je me suis rendu compte qu'il fallait aussi  que je change les autres données. Bref.
 
C'est par curiosité pour savoir si c'est possible comme pour les tableaux.

il dit quoi le compilo ?

message d'erreur: non-lvalue in assignment.
La ligne juste au dessus (8) fonctionne (encore heureux, je l'ai vu dans un tutoriel)

"Echanger des adresses structures" -> pas possible .| D'ailleurs ça n'a aucun sens.
 
question suivante ?

Pourquoi est-ce que ça n'a pas de sens?

ben parce que par définition, si s1 et s2 sont des structures, s1 EST s2 équivaut à &s1 == &s2.

Je ne comprends pas mais bon, tant pis. Je changerais tout "à la main". Merci pour vos réponses.

comment ça tout changer à la main ? tu comprends quoi ? l'addresse d'un objet, c'est sa référence, son identité. Tu ne peux pas la changer.

Tout changer à la main:
Echanger les pointeurs des tableaux, échanger les valeurs des variables.
 
Bon je crois que j'ai compris.  
 
La seule chose que je peux faire, c'est créer deux variables de la même structure, 2 pointeurs pointant chacun vers une de ces structures et lorsque j'en ai besoin, échanger les valeurs des deux pointeurs.
 
struct essai {...};
 
main()
essai s1, s2, *pverss1, *pverss2, *ptampon;
 
pverss1= &s1;
pverss2= &s2
 
//et quand j'en ai besoin
 
ptampon= pverss1;
pverss1= pverss2;
pverss2= ptampon;

oui.
 
ou plus simplement
 
 
std::swap(pverss1, pverss2);
 
ou
std::swap(verss1, verss2); // le contenu

Par curiosité, ça sert à quoi d'intervertir les 2 adresses ?
Je sais pas si c'est faisable, mais éventuellement (sans tenir compte de la méthode de Taz) tu pourrais éviter de déclarer s1 et s2  de manière statique et les initialiser de manière dynamique (avec un new), et là ta méthode marcherais. Ca donnerais qq chose comme :
main()  
essai *pverss1, *pverss2, *ptampon;  
 
pverss1= new essai;  
pverss2= new essai;  
//puis
ptampon= pverss1;  
pverss1= pverss2;  
pverss2= ptampon;
//ne pas oublier de deleter tes objets à la fin du traitement
 
Sinon merci pour la méthode Taz, je connaissais pas

Merci mmoiz
je suis un ane, j'aurais du y penser.
 
Ca me sert parce que j'ai une boucle sur le temps
 
do
 X(t)= f(X(t-dt))
 t+= dt;
while t<tend
 
J'ai besoin de déplacer le contenu de X(t) vers X(t-dt) à chaque itération, X étant ma structure. Copier c'est long sachant que j'ai des millions d'intégration. Intervertir les pointeurs c'est rapide.
 
Je ne suis pas un as de la programmation, je vous l'accorde mais ca marche bien comme ça.
 
Encore merci à tous. J'ai une solution à mon problème et j'ai appris deux nouvelles choses.

intervertir ce n'est pas copié. d'ailleurs je vois pasce que tu veux intertir comme pointeur dans ta boucle. t'es pas un as, on a bien compris. fais simple et laisse les pointeurs pour quand t'y comprendras quelque chose.

Des malpensants pourraient te répondre que vu ta maîtrise de la grammaire française, tu devrais utiliser le style sms pour commencer et utiliser le français quand tu sauras le parler.
 
Et si tu ne le parles pas, comment l'apprendras-tu d'ailleurs?
 
Je te remercie pour tes conseils. Je continuerai néanmoins d'utiliser les pointeurs.

t'as raison, les pointeurs ça fait plus warrior ... vive la branlette intellectuelle du newbie qui optimise.

Sans commentaire.

Bof, les pointeurs c'est un outil comme un autre. C'est clair qu'il y a des risques mais ça permet aussi d'éviter des réallocations dans le cas de _Noir_. Ca fait gagner du temps et on évite d'écrire un constructeur de copie (quoique pas sur qu'il serve avec swap ?)
Maintenant, il y a peut être plus simple et plus rapide, mais avec les pointeurs ça ne me paraît pas ingérable, si il tient bien son code

juste par hasard, c'est quoi le type de X(t) ?