0
votes

Quelle est la différence entre * & arr et * & Arr [0] en C ++, si ARR est un tableau?

Supposons que j'ai un éventail d'entiers appelés arr . J'essaie de comprendre la distinction entre * & arr et * & arr [0] .

J'ai lu qu'en C ++, Ar est essentiellement un pointeur sur le premier élément de la matrice et & arr est un pointeur sur l'ensemble de la matrice. Ils retournent tous les deux la même adresse, je reçois cette partie. Ensuite, si j'entre * & arr [0] , alors le premier élément, c'est-à-dire à Arr [0] est renvoyé. Mais si j'insère * & arr , l'adresse de arr [0] est renvoyée. Ma question est de savoir pourquoi quand j'utilise * & arr , est l'adresse renvoyée, plutôt que le premier élément? La logique dicterait que depuis l'opérateur * renvoie la valeur, on s'attendrait à ce que * & arr pour renvoyer le premier élément au lieu d'une adresse.

merci.


                        
                        
                            
                                                                    arrays
                                                                    pointers
                                                                    c++
                                                                    dereference
                                                            
                        
                                                    
                            
                            
                                3 commentaires
                                
                                                                            Pourquoi vous attendez-vous au  * & arr  pour renvoyer le premier élément?  *  et  &  s'annulent sur l'autre, donc  * & arr [0]  est equlivalent à  arr [0] , et  * & arr  est équivalent à  Art .

                                        
                                                                            Peut-être devriez-vous démontrer ce dont vous parlez avec un  exemple de reproductible minimal  (donc nous avons une signification précise pour "si J'entre ", comme nous ne savons pas où vous entrez des choses)? Définissez  Ar , puis sortie  * & arr [0]  et  * & arr compte>. Pendant que vous êtes à cela, émettez également  arr [0] Arr [0]  et  Arr  et expliquez pourquoi vous attendez  * & arr [0]  pour correspondre  Arr [0]  mais ne vous attendez pas à  * & arr  pour correspondre  Ar .

                                        
                                                                            L'opérateur  *  donne une expression de lvalue, qui désigne un emplacement de mémoire. Il ne récupère pas la valeur stockée de cet emplacement (cette opération s'appelle l'aversion LValue-to-RValue)



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    2
 votes
                                
                            
                            
                                
                                     one est une expression  int , l'autre est une expression  int [n] , pour une taille  n . .


   J'ai lu qu'en C ++,  arr  est essentiellement un pointeur 


 Jetez ce livre. Il est dangereusement imprécis.  ARR  peut convertir en un pointeur à un moment de préavis, mais il est le plus clairement pas un pointeur. 


   Ils renvoient tous les deux la même adresse 


 mais pas le même type. 


   Ma question est, pourquoi quand j'utilise  * & arr  est l'adresse renvoyée, plutôt que le premier élément? 


 Parce que vous avez une indemnité de pointe-to-tableau. Si vous utilisez  * & arr  dans un contexte qui attend un pointeur, il se désintègre à un, comme toute autre expression de tableau.                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                    
   J'ai lu qu'en C ++,  arr  est essentiellement un pointeur sur le premier élément de la matrice 


 C'est faux. Si  ARR  est un tableau, il s'agit d'un tableau. Les tableaux ne sont pas des pointeurs ^{1 .}

   Pourquoi quand j'utilise * & ARR, est l'adresse renvoyée 


 étant donné que  & arr [0]  est un pointeur sur le premier élément, indirectant via le pointeur ( * & arr [0] ) vous donne une référence de lvalue au premier élément. 

 étant donné que  & arr  est un pointeur sur la matrice, indirectant via le pointeur ( * & arr ) vous donne une référence de LValue à la matrice. Juste comme  arr , ce réseau LValue décrit à un pointeur au premier élément lorsqu'il est converti en rvalue. 

 Sauf pour les cas où les opérateurs sont surchargés,  * &  s'annulent essentiellement. Ce sont des opérations inverse.  * & arr [0]  vous donne la même chose que  arr [0]  et  * & arr  vous donne la même chose que  ARR . 



 ^{1  sauf dans la déclaration de fonctions Partmètres, où un paramètre de matrice ne déclare pas du tout un tableau, mais plutôt un pointeur à l'élément de ce tableau.}


                                                                    
                                    
                                    
                                        3 commentaires
                                        
                                                                                            
                                                    • NIT: Déclaration d'une fonction et de ses  paramètres . Les arguments sont ce que les procédés passent en fonctions.                                                

                                                
                                                                                            
                                                    @Eljay Je n'ai jamais pu apprendre, ce qui est lequel :) particulièrement déroutant car ils sont également parfois appelés arguments / paramètres formels "et argument / paramètre" réel "dans quel contexte ils sont synonymes.                                                
                                                
                                                                                            
                                                    J'ai finalement utilisé que les arguments mnémoniques "sont comme des automobiles et des paramètres sont comme des taches de stationnement".                                                
                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                    
   J'ai lu qu'en C ++,  arr  est essentiellement un pointeur sur le premier élément de la matrice 


 Alors tout ce que vous lisez est faux. Il est vrai que les matrices se décomposeront dans un pointeur sur leur premier élément si vous les regardez mal, mais  Les tableaux ne sont pas des pointeurs . .



 Ça hors de la route: 


   * & arr  donne l'ensemble de la matrice.  & ARR  forme un pointeur sur le tableau et  *  DÉRÉFERFERENCES que le pointeur. Ainsi, le type de cette expression est identique à celui  arr . Encore une fois, cela se décomposera dans un pointeur sur le premier élément de la matrice si vous le regardez mal. Par exemple, si vous essayez d'imprimer cela avec  std :: COUT << * & ARR , le tableau décédera à un pointeur sur son premier élément et finissez probablement à appeler l'opérateur  << (STD :: Ostream &, void *)  Surcharge.  
   * & arr [0]  donne le premier élément de la matrice.  arr [0]  Index dans la matrice,  &  forme un pointeur sur le premier élément de la matrice, puis  *  Déroférences que le pointeur. Le type de cette expression est le même que  arr [0] .  
                                


                                                                    
                                    
                                    
                                        0 commentaires

Articles qui pourrait vous intéresser : Empilez plusieurs colonnes en une sans ignorer les cellules vides Recherche du nombre de doublons uniquement et uniquement à la fin d'un tableau numpy JS: filtre le tableau d'objets par valeur maximale par catégorie Faire pivoter les éléments d'un tableau