9
votes

Typedef et conteneurs des pointeurs de const

La ligne de code suivante compile uniquement bien et se comporte:

list<int * const> int_pointers;  // (3)

c++ containers stl typedef

0 commentaires

6 Réponses :

8
votes

Vous avez lu des déclarations de type de style C à gauche. Donc, "const int *" est un pointeur pour constants intens ("const int" et "int const" signifie la même chose). Ceux sont parfaitement assignables. Mais (2) et (3) sont des pointeurs constants à int, et donc non assignables.

0 commentaires

5
votes

const intptr et const int * n'est pas la même chose.

1) const int * est "pointeur sur const int ".

2) const intptr se développe à int * const (penser (int *) const ) qui est " const pointeur sur int ".

En bref, le Typedef agit comme un ensemble de parenthèses. Vous ne pouvez pas modifier le Const de ce que pointeur dacteurs Typef D Pointe à.



                                                                    
                                    
                                    
                                        0 commentaires


                        
                                            
                            
                                
                                    3
 votes
                                
                            
                            
                                
                                      const int *  est identique à l'écriture  int const * , ce qui signifie une valeur constante pointée par un pointeur non constant. 

 Avec le typeDEF, vous définissez le pointeur lui-même aussi constant, comme dans votre 3e déclaration.                                 


                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            

                        

                        
                                            
                            
                                
                                    10
 votes
                                
                            
                            
                                
                                     Réponse courte: 

 est une liste de pointeurs à constants intens. 
 est une liste de pointeurs constants vers INTS. 
 est le même que 2. 
  const (et volatile) doit naturellement apparaître après le type qu'ils admissibles.
Lorsque vous l'avez déjà écrit, le compilateur le réécrit automatiquement en interne:   xxx  
 devient   xxx  
 qui est un pointeur sur un constant int. Les listes de ceux-ci compileront une amende puisque le pointeur lui-même est toujours assignable.                                  

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    6
 votes
                                
                            
                            
                                
                                     Vous demandez "Pourquoi l'interprétation du compilateur (2) est-elle la même que (3)?". Eh bien, parce que dans la langue C ++ (ainsi que dans C), ils sont  EM> sémantiquement les mêmes. Lorsque vous définissez un typename comme  xxx  pré> 
 puis plus tard, le type  const intptr  code> sera debout pour  int * cons  code>, pas pour  const int *  code>. C'est à quel point les noms Thypef fonctionnent en C ++.  P> 
 Les noms TypeDEF en C ++ ne sont pas des macros. Bien qu'ils ne définissent pas de nouveaux types (juste des alias pour les existants), les alias résultants sont néanmoins «atomiques», «monolithique» dans un sens que tous les qualificatifs appliqués à l'alias s'appliqueront comme  haut niveau  em > qualificatifs. Lorsque vous travaillez avec un nom de typeDEF, il n'y a aucun moyen de "faufiler dans" un qualificatif de const, de sorte qu'il "descend" à une partie de niveau inférieur du type ( int  code> dans votre cas ).  p> 
 Si vous insistez sur l'utilisation des noms TapeDEF, vous n'avez pas d'autre choix immédiat, mais pour fournir deux noms TypeDEF différents, tels que  P> 
typedef int *IntPtr;
typedef const int *ConstIntPtr;

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Je suis sûr que vous savez que  const intPTR  code> et  intptr const  code> est le même type.
Ce qui signifie  list   code> et  list   code> est le même type.
Ce qui signifie que vous essayez de compiler ceci: 
typedef int * IntPtr;
         list<IntPtr const> int_pointers;  // (2bis)

                                

                                                                    
                                    
                                    
                                        0 commentaires