Discussion :

[Seabirds]

Salut à toutes et à tous,

Cela fait plusieurs fois que je suis confronté au cas où je souhaite utiliser conjointement une variable et son incrément :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
int previous = 0;
int next = previous;
++next;
some_function(previous, next);

Il y a un moyen de copier+incrémenter en une seule étape ? Je n'arrive pas à trouver la réponse sur internet.
Cordialement,

[EDIT]
Oups, mon exemple est nul, l'idée était plutôt d'utiliser un type template, et je voulais que quoiqu'il arrive previous ne soit pas modifié :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
T previous;
T next = previous;
++next;
some_function(previous, next);

[Matt_Houston]

Attention, haute technologie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int next = previous + 1;

[Daïmanu]

Bonjour.

En passant par la pré incrémentation ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int previous = 0;
some_function(previous, ++previous); //previous est incrémenté de 1, puis fourni en paramètre à la fonction

PS: Merci Matt pour la correction.

[Matt_Houston]

Mais l'ordre d'évaluation des paramètres d'appel de fonction n'étant pas défini, some_function(previous, ++previous) peut tout aussi bien valoir some_function(0, 1) que some_function(1, 1).

[dalfab]

Je ne vois pas bien l'intérêt, à moins que l'objet ne soit de taille importante.
On peut pour éviter les copies faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<class T> struct PrevNext {
	T  prev;   // copie de la valeur précédente
	T& next;   // référence sur la nouvelle valeur mise à jour
	PrevNext(T& x) : prev(x), next(++x) {} // ici l'ordre d'interprétation est garanti
};
void some_function( PrevNext<int> z ) {
   ... cout << z.prev;
   ... cout << z.next;
}
int main() {
   int x = 0;
   some_function( x );  // => "0 1" et x vaut 1
   some_function( x );  // => "1 2" et x vaut 2
}

[Seabirds]

Au temps pour moi, l'exemple était présenté avec un int, mais le but était d'effectuer le traitement avec un type template supportant l'opérateur d'incrémentation. L'intérêt était jute de m'assurer qu'il n'existait pas une syntaxe classique qui remplisse ce job (copier l'objet -> incrémenter la copie -> l'assigner). Apparemment non, ce qui répond à ma question.

La structure de Dalfab est ce qui ressemble le plus à ce que je cherchais, mais vu la lourdeur le jeu n'en vaut peut être effectivement pas la chandelle.

Merci à tous !

[ternel]

il y a bien une possibilité, d'un point de vue syntaxique, si on ce n'est pas une déclaration.
x = y étant une expression retournant, pour les types normalement constitués, une référence sur l'assigné, il suffit donc d'incrémenter cette référence:
L'instruction "magique" est ++(x = y);. Cela dit, c'est assez particulier.

[Médinoc]

Y a-t-il un point de séquencement dans cette expression? Sinon, il s'agira d'un comportement indéterminé, car x sera modifiée deux fois...

[Bousk]

Y a-t-il un point de séquencement dans cette expression? Sinon, il s'agira d'un comportement indéterminé, car x sera modifiée deux fois...

?
x=y assigne la valeur de y à x, puis retourne x
ensuite on incrémente le tout, soit x

[ternel]

Il y a un défaut de séquencement potentiel entre les sous expressions x et y, mais x=y est évaluée avant ++, ce dernier s'applique non pas à l'expression x, mais à la valeur de la parenthèse, qui s'avère être une référence sur x.