Pré incrémentation et de post-incrémentation

Je vais avoir du mal à comprendre comment Post Incrémentation (++), Pré-Incrémentation (--) et de l'addition/soustraction de travailler ensemble dans un exemple.

x++ signifie ajouter 1 à la variable.

x-- signifie soustraire 1 de la variable.

Mais je suis confus avec cet exemple:

int x = 2, y = 3, z = 1;`

y++ + z-- + x++;

Je suppose que cela signifie 3(+1) + 1(-1) + 2(+1) ce Qui signifie que le résultat doit être de 7.

Mais quand je compile, je reçois 6. Je ne comprends pas.

int main() {
  int x=2, y=3, z=1;
  int result;

  result = y++ + z-- + x++;    //this returns 6

  cout << result << endl;
  return 0;
}

Recherche de préfixe et le suffixe d'incrémentation/décrémentation les opérateurs.

OriginalL'auteur Hoon | 2012-09-23

c++operators post-increment pre-increment

6
```
 result = y++ + z-- + x++;
           3     1      2  = 6
```
si vous effectuez ce nouveau
```
 result1 = y++ + z-- + x++;
          4     0      3  = 7
```
raison

operator++ renvoie la valeur d'origine, avant l'incrémentation de la variable.

et

++operator renvoie la valeur incrémentée

-- est la même que ci-dessus juste son décrémenter

OriginalL'auteur NullPoiиteя

Parce que le suffixe operator++ renvoie la valeur d'origine, avant l'incrémentation de la variable. Le préfixe operator++ incrémente la varialbe et renvoie une référence à elle. Le comportement peut être facilement illustré par un exemple:

#include <iostream>

int main()
{
  int n = 1;
  std::cout << n++ << "\n"; //prints 1
  std::cout << n << "\n";   //prints 2

  int m = 10;
  std::cout << "\n";
  std::cout << ++m << "\n"; //prints 11 
  std::cout << m << "\n";   //prints 11
}

OriginalL'auteur juanchopanza

5

lorsque vous écrivez x++ il utilise la valeur actuelle de x et puis l'augmente par un.

vous voulez écrire ++x au lieu si vous voulez augmenter en premier.

OriginalL'auteur none
3

Pre-increment operator(++p) première augmentation de la valeur et de l'affecter et post increment operator(p++) d'abord attribuer la valeur et puis effectuez l'opération d'incrémentation.Ici, toutes les variables sont post incrément je.e initialement affecter sa valeur (sur le tampon) puis augmenter (pour y et x par 1) et de la diminution de z par 1. j'.e
d'abord attribuer 3 + 1 + 2 dans le tampon(ajout est effectué sur la valeur tampon) et ensuite effectuer incrémente/décrémente x= 3,y=4 et z=0

pour plus d'informations, vous pouvez lire la réponse sur le Quelle est la réponse correcte pour cout << c++ << c;? et Pourquoi ces constructions (à l'aide d' ++) comportement indéfini? questions

Le code de l'OP est bien défini et peut être expliqué. Les liens ne pas répondre à la question.
Merci pour votre suggestion...j'avais ajouté de description ...

OriginalL'auteur Lionel
2

La position de ++ question.

Si ++ précède la variable, par exemple ++counter, la valeur retournée est la
valeur dans la lutte contre après il a été incrémenté. Si ++ suit l'
variable, par exemple counter++, la valeur retournée est la valeur du compteur
avant il a été incrémenté.

(source)

OriginalL'auteur Fabio Mora
1

Post-incrémentation/postdecrement incrémenter/décrémenter la variable, mais évalue les variables "précédent" de la valeur.

Donc l'expression result = y++ + z-- + x++ agira quelque chose comme:
```
result = y + z + x;  //result == 6

//perform the 'post' operations
y += 1;
z -= 1;
x += 1;
```
Cependant, gardez à l'esprit que ce n'est pas nécessairement strictement la façon dont le compilateur d'effectuer l'évaluation. Pour cette expression, les résultats sont bien définis et vous vous retrouverez comme dans l'exemple. Lors de l'utilisation de plusieurs incrémenter/décrémenter les opérations dans la même expression, il est facile d'intégrer un comportement indéfini où vous ne serez pas en mesure de s'attendre à quelque chose en particulier à partir de l'expression. Voir Pourquoi ces constructions (à l'aide d' ++) comportement indéfini? pour plus de détails.

OriginalL'auteur Michael Burr
1

La raison en est simple.
L'association principe est utilisé ici, qui calcule les valeurs en fonction de la priorité des opérateurs.

AUSSI X++ ou X-- les moyens... ALORS un CHANGEMENT...
Il va d'abord utiliser la valeur et de l'incrémenter ou de décrémenter il.
Si vous voulez obtenir un résultat de 7...
essayez ceci.. il pourrait fonctionner...
```
result = ++y + z-- + x++;
```
Il va d'abord utiliser la valeur et puis* incrément

OriginalL'auteur Siddharth-Verma
0

i++/i-- post-incrémentation et de décrémentation de la variable...

donc, dans notre expression, il prendra la valeur initiale pour la résolution de problèmes ensuite inc/dec par 1.
```
int x = 2, y = 3, z = 1;
y++ + z-- + x++;
2   + 3   + 1    = 6
```
OriginalL'auteur Sai Ram

Vous pourrait aussi se rendre compte du comportement différent avec une boucle while:

#include <iostream>
void main{
int count = 0;
    while (count < 5 )
    {
    std::cout << "counter is: " << count << std::endl
    //replace this line with one of the lines below at a time
    }
}

considérant les expressions suivantes pour les incréments de count

++count  //the variable 'count' will grow from 0 to 4
count++  //ditto, weird as it seems; 'count' grows nonetheless
count = ++count  //the old 'count' becomes 'count + 1'
count = count++  //endless loop: back to square zero time and time again

De la même manière, vous pouvez obtenir plus de perspicacité avec une boucle while, avec le préfixe

count = 0;
do
{
    std::cout << ++count << "\n";
} while (count < 5);  //prints out 1 to 5

contre suffixé

count = 0;
do
{
    std::cout << count++ << "\n";
} while (count < 5);  //prints out 0 to 4

OriginalL'auteur XavierStuvw

-2

Dim i As Integer = 10
    Dim b As Integer
    Dim c As Integer
    Dim d As Integer
    b = ++i
    c = i + 1
    d = b + c
    Response.Write("<br/>")
    Response.Write("The Value of ++i :-" & b)
    Response.Write("<br/>")
    Response.Write("The Value of i++ :-" & c)
    Response.Write("<br/>")
    Response.Write("Answer is " & d)

De sortie:

The Value of ++i :-10
The Value of i++ :-11
Answer is 21

Ce qui signifie que
++var renvoie la valeur d'origine et
var++ renvoie la valeur incrémentée.

Quelle langue est-ce? Il n'est certainement pas ressembler à n'importe quel C++ que j'ai vu...

OriginalL'auteur vaibhav sonje

Vous devez vous connecter pour publier un commentaire.