À quoi servent-const pointeurs (par opposition à des pointeurs vers des objets const)?

Lorsque vous êtes en train de concevoir des programmes en C pour les systèmes embarqués, ou à des fins spéciales des programmes qui ont besoin de se référer à la même mémoire (multi-processeur d'applications de partage de mémoire), alors vous avez besoin constant de pointeurs.

Par exemple, j'ai un 32 bits processeur MIPs qui a un peu à écran LCD attaché à elle. Je dois écrire mon écran LCD de données vers un port spécifique de la mémoire, qui est ensuite envoyé au contrôleur de l'écran LCD.

Je pourrais #define nombre, mais j'ai aussi d'avoir à jeter comme un pointeur, et le compilateur C n'a pas beaucoup d'options quand je le fais.

De plus, j'ai peut-être besoin d'être volatile, qui peut aussi être lancé, mais il est plus facile et plus clair d'utiliser la syntaxe fournie - const pointeur vers une mémoire volatile de l'emplacement.

Pour les programmes de PC, voici un exemple: Si vous concevez DOS VGA jeux (il y a des tutoriels en ligne qui sont amusants pour apprendre les rudiments de bas niveau graphique), alors vous avez besoin pour écrire sur le VGA de la mémoire, qui peut être référencé comme un décalage à partir d'un pointeur const.

-Adam

un autre exemple:
si vous savez où il a été initialisé, vous pouvez éviter à l'avenir NULL contrôles.
Le compilateur garantit que le pointeur n'a jamais changé (NULL)...

À usage unique est dans les bas-niveau (pilote de périphérique ou intégrés) code où vous avez besoin de faire référence à une adresse spécifique qui est mappé à un périphérique d'entrée/sortie comme une broche matériel. Certaines langues, vous permettent de lier des variables à des adresses spécifiques (par exemple, Ada a use at). En C, la plus idiomatique façon de le faire est de déclarer un pointeur constant. Notez que ces usages doivent aussi avoir la volatile qualificatif.

D'autres fois c'est juste défensive de codage. Si vous avez un pointeur qui ne devrait pas changement, il est sage de le déclarer tel qu'il ne peut pas changement. Cela permettra au compilateur (et lint) afin de détecter les tentatives erronées de la modifier.

Même comme un "const int" ... si le compilateur sait qu'il ne va pas changer, il peut être l'optimisation des hypothèses fondées sur que.

struct MyClass
{
    char* const ptr;
    MyClass(char* str) :ptr(str) {}

    void SomeFunc(MyOtherClass moc)
    {
         for(int i=0; i < 100; ++i)
         { 
                 printf("%c", ptr[i]);
                 moc.SomeOtherFunc(this);
         }
    }
}

Maintenant, le compilateur pourrait faire un peu afin d'optimiser cette boucle --- à condition qu'il sait que SomeOtherFunc() ne change pas la valeur de ptr. Avec le const, le compilateur sait que, et peut faire des hypothèses. Sans elle, le compilateur a supposer que SomeOtherFunc va changer ptr.

Plusieurs bonnes raisons ont été invoquées comme des réponses à ces questions (memory-mapped appareils et juste un bon vieux défensive de codage), mais je serais prêt à parier que la plupart des cas où vous voyez ce qu'il est en fait une erreur et que l'intention était d'avoir au point être un pointeur-à-const.

Je n'ai certainement pas de données à sauvegarder cette intuition, mais je préfère encore faire le pari.

toujours penser à un pointeur de type int. cela signifie que

object* var;

peut effectivement être considéré comme

int var;

donc, un pointeur const signifie simplement que:

const object* var;

devient

const int var;

et donc u ne pouvez pas modifier l'adresse sur laquelle pointe le pointeur trop, et c'est tout. Pour empêcher la modification des données, u doit faire un pointeur vers un const objet.