6
votes

Post-incrément dans une boucle de temps

Le code suivant m'a confondu un bit: xxx

Il s'agit d'une implémentation supprimée de la fonction Strcpy . À partir de ce code, nous voyons que le pointeur p et q sont incrémentés puis déérique et q est attribué à p jusqu'à ce que Le \ 0 Char a été atteint.

J'aimerais que quelqu'un explique la première itération de la boucle tandis.


                        
                        
                            
                                                                    c
                                                                    pointers
                                                                    post-increment
                                                            
                        
                                                    
                            
                            
                                6 commentaires
                                
                                                                            Vos définitions de Post / Pre Semblaient être en arrière. Post = après, avant avant. La post-augmentation montre ici que le premier caractère sera copié, puis le pointeur sera incrémenté.
                                        
                                                                            Pourquoi la balise C ++ (et le titre)? Ceci est une fonction de bibliothèque C.
                                        
                                                                            Ressemble à un code C ++ parfaitement valide pour moi, @Paul. Alors pourquoi  pas  la balise C ++?

                                        
                                                                            Dupliqué possible de  Comment l'attribution du pointeur dans Strcpy fonctionne-t-elle? 
                                        
                                                                            @ROB: Eh bien c'est parfaitement valide  Code de l'objectif-C  aussi - peut-être qu'il devrait être étiqueté comme  objectif-c  alors?

                                        
                                                                            @DAVITA: Pas tout à fait - cela dit toujours "C ++" dans le titre.



                                    
                    8 Réponses :
                    
                                            
                            
                                
                                    9
 votes
                                
                            
                            
                                
                                     Parce que le  ++  est après les variables, ils ne sont pas incrémentés jusqu'à ce que  après  l'expression est évaluée. C'est pourquoi c'est l'opérateur post-incrément; Le pré-augmentation est préfixé ( ++ p ).  * ++ p  écrirait sur la deuxième spot,  * p ++  écrit au premier.                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Le côté droit de l'expression (* Q ++) sera évalué avant * p ++, et les deux ne seront incrémentés qu'après que l'affectation a lieu. 
 Lisez la déclaration à gauche et rappelez-vous post-incraction (Q ++ Au lieu de ++ Q) arrive après que tout ce qui soit dans la ligne soit résolu.   xxx  
 incrément à la fois.  
 fais cela jusqu'à ce que qp prenant q's element = 0 qui est quand il atteint le terminateur nul.                                  

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                      p ++  est post-incrémentation du pointeur  p . Donc la valeur actuelle de  p  est utilisée par l'opérateur de déférence  *  avant  p  est incrémenté. 
 Votre raisonnement aurait été correct Si le  pendant  est écrit comme suit:   xxx  
 Dans ce cas, l'incrément se produirait avant la déséroférance.                                  


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Non, l'incrément se produit après l'affectation. 

 S'il était  * (++ p) , le pointeur  p  serait incrémenté et après cela assigné.                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                    
   Ceci est une implémentation dépouillée de la fonction Strcpy. À partir de ce code, nous voyons que le pointeur P et Q sont flous, que la perférencée et Q est affectée à P jusqu'à ce que le caractère \ 0 ait été atteint. 


 Cela arrive dans l'inverse. La valeur au  * p  est définie sur  * q , puis les deux pointeurs sont incrémentés. 

 Lorsque vous avez  int foo = bar ++  L'incrément se produit après la définition de FOO. Pour que cela se produise, vous feriez d'abord  int foo = ++ bar                                  


                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    @Marlon, pourquoi avez-vous édité mon message? Vous avez inversé le sens, ce qui est incorrect. * P est défini sur * Q, pas l'inverse, à moins d'avoir un pet cérébral complet et de manquer quelque chose.                                                
                                                
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     La valeur de  q ++  est q 

La valeur de  ++ q  est  q + 1                                  


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Le  pendant que  La condition de la boucle est effectué après l'incrément. Équivalent:  xxx                                  


                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    Pas tout à fait vrai, parce que votre temps (* p) regarde le caractère suivant, pas celui qui vient de copier.                                                
                                                
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     Les expressions  x ++  et  ++ x  ont à la fois un  résultat  (valeur) et un effet secondaire  . 
 Le  résultat  de l'expression  x ++  est la valeur actuelle de  x . L'effet secondaire   est que le contenu de  x  est incrémenté par 1.  
 le résultat   de l'expression  de l'expression  ++ x  est la valeur actuelle de  x  plus 1. L'effet latéral   est identique que ci-dessus.  
 Notez que le côté L'effet ne doit pas nécessairement être appliqué immédiatement après l'évaluation de l'expression; Il suffit d'être appliqué avant le point de séquence suivant. Par exemple, étant donné le code   xxx  
 il n'y a aucune garantie que le contenu de  x  sera modifié avant l'expression  y ++  est évalué, ou même avant le résultat de  ++ x + y ++  est attribué à  z  (ni le  =  ni  +  Les opérateurs introduisent un point de séquence). L'expression    ++ x  est évaluée à 2, mais il est possible que la variable  x  ne peut pas contenir la valeur 2 jusqu'à après  z < / code> a été attribué.  
 Il est important de vous rappeler que le comportement des expressions comme  x ++ + x ++  est  explicitement  non défini par la norme de langue; Il n'y a pas de moyen (bon) de prédire ce que le résultat de l'expression sera ou quelle valeur  x  contiendra après avoir été évaluée.  
 Les opérateurs postfix ont une priorité plus élevée que les opérateurs unaires, les expressions telles que  * p ++  sont analysées comme  * (p ++)  (c.-à-d. L'opérateur  *  à la suite de l'expression  p ++ ). Encore une fois, le résultat de l'expression  p ++  est la valeur actuelle de  p , donc  tandis que (* p ++ = * q ++);  ne saute pas Le premier élément.  
 Notez que l'opérande aux opérateurs AutooinCrementation / décrémentation doit être un  lvalue  (essentiellement une expression qui fait référence à un emplacement de mémoire de sorte que la mémoire puisse être lue. ou modifié). Le résultat de l'expression  x ++  ou  ++ x  est  pas  un lvalue, vous ne pouvez donc pas écrire des choses comme  ++ x ++  ou  (x ++) ++  ou  ++ (++ x) . Vous  pourrait  écrire quelque chose comme  ++ (* p ++)  ( p ++  n'est pas un lvalue, mais  * p ++  est ), bien que cela vous ferait probablement gifler par quiconque lisant votre code.                                  


                                                                    
                                    
                                    
                                        0 commentaires

Articles qui pourrait vous intéresser : Que puis-je utiliser pour la conversion d'entrée au lieu de scanf? Comment puis-je calculer a * b / c lorsque a et b sont tous deux plus petits que c, mais que a * b déborde? Comment vérifier si un pointeur void (void *) est l'un des deux types de données? L'écran LCD affiche des caractères aléatoires (MPLAB)