Pourquoi ne const variables doivent être initialisés tout de suite?

C'est une programmation générale de la question. Je suis en train d'apprendre le C++ et j'ai appris que tout const variables, c'est à dire: const int i, ou int *const ptr, soit initialisé.

C'est aussi la raison sous-jacente que les références à des adresses doit être initialisé tout de suite, car les adresses sont const.

Mais je ne peux pas trouver la raison pour laquelle cela doit être fait, pourquoi cette règle est imposée.

Quelqu'un peut-il expliquer cela, pour moi, s'il vous plaît?

OriginalL'auteur Lebowski156 | 2011-12-09

  1. 19

    Car il n'y a aucun moyen que vous pouvez l'initialiser, ou affecté à une valeur plus tard.

    const int size; //no initialization (error)

size = 100; //error - you cannot assign a const variable.

    Maintenant, si une variable qui n'est ni avoir aucun véritable valeur, et vous n'êtes pas autorisé à faire de la valeur plus tard parce que c'est un const variable, alors quel est l'intérêt d'une telle variable? Il est complètement inutile.

    Cependant, cela est vrai pour seulement intégré et la GOUSSE types:

    struct A{}; //POD type
struct B{ B(){} }; //Non POD type because it has user-defined constructor!

const int i; //error - built-in type
const A a;   //error - POD type
const B b;   //ok -    Non POD type

//likewise
const std::string s; //ok - std::string is a non-POD
const std::vector<std::string> v; //ok - std::vector is a non-POD

    En fait un NON-type de POD ne peut pas restent non initialisée, parce que le constructeur par défaut sera appelée, et l'objet de l'initialisation.

    Maintenant considérer cette structure,

    struct C
{
   const int i;
   C() {}
};

    C est certainement un non-type de POD, parce qu'il a définie par l'utilisateur constructeur. Notez également que dans le constructeur, il n'est pas initialiser i qui est int, a déclaré que const. En raison de cette non initialisée const je, la suite serait donner d'erreur:

    const C c; //error -

    On pourrait penser que l'erreur est à cause de const dans la déclaration ci-dessus de variable c. Mais c'est la myopie et n'est pas vrai. Même si vous supprimez const, elle donnera l'erreur:

    C c; //error - same error

    L'erreur est à cause de C::i qui est déclaré const mais n'a pas été initialisé.

    Démo : http://ideone.com/NJT8L

    Cette analyse montre également que les types intégrés ne pas de l'initialisation des automatiquement même si elles sont membres de la non-POD types. Cela est vrai de la non-POD types de classe.

    Et la syntaxe de par défaut initialisation pour les types intégrés (et la GOUSSE types):

    struct C
{
    const int i;
    C() : i() {} //note the syntax - it is called member-initialization list
};

    Maintenant, c'est permis : 

    C x; //ok
const C y; //ok

    Démo : http://ideone.com/84vD9

    Que pour ce qui fait une struct/classe POD, voir ce sujet:

    Ah merci! De bon sens!
    N'est pas const int taille; initialiser la taille à l'aide de l'int du constructeur par défaut (c'est à dire à 0)?
    Pas de.
    Btw, je suis en train de donner votre réponse le coche une fois ce temps me le permet. Dans l'écriture " int i;', i est initialisé à 0 avec le constructeur par défaut. Pourquoi ne pas utiliser le constructeur par défaut avec const? Peut-être cela devrait être une question distincte ...
    Wow super réponse, merci beaucoup.

    OriginalL'auteur Nawaz

  2. 4

    Parce que si vous pouvez attribuer à eux plus tard, qu'ils ne serait pas "const".

    Je pense que "plus tard" est un peu trompeur ici. Il semble que la propriété la plus importante d'un const variable est qu'elle ne peut être attribuée . Donc, si elle peut être attribuée après une mission a eu lieu, il ne serait pas const. Mais rien de cela exige que la mission doit être faite au moment de la déclaration. Donc, je pense que ce que l'OP se poser est, pourquoi ne l'affectation initiale se produire dans le cadre de la déclaration?
    Pour être pédant, un const variable peut jamais être affecté. Et pour répondre à votre point; vous êtes l'amalgame entre la déclaration et la définition.
    oui exactement, c'est ce que je demandais.
    Et il est intéressant de noter (dans l'esprit de ce qui est une programmation générale de la question), Java ne permet final variables à être affectée après la déclaration initiale. Mais une fois seulement.
    propriété la plus importante d'une variable const" définir "variable const"

    OriginalL'auteur Oliver Charlesworth

  3. 0

    Affectation à une variable const dans le programme n'est pas autorisée, car alors on peut changer sa valeur, ce qui est évidemment faux!!!!

    Par conséquent, vous devez les initialiser..

    espère que cela aide

    Pourquoi les votes contre ?

    OriginalL'auteur bhuwansahni

  4. 0

    Lorsqu'une variable est déclarée const cela signifie que la variable est en lecture seule et ne peut pas être changé .afin de rendre une variable en lecture seule, il doit être initialisé au moment où elle est déclarée.

    Pour une meilleure compréhension des variables ont un coup d'oeil à programme suivant

    Tous les processus se compose de 4 parties de l'espace d'adressage qui sont accessibles au processus lorsqu'il est en cours d'exécution

    Texte - Cette partie contient les m/c des instructions à exécuter. Sur de nombreux Systèmes d'Exploitation ce qui est mis en lecture seule, de sorte que le processus ne peut pas modifier ses instructions. Cela permet à plusieurs instances du programme d'action de la seule copie du texte.

    De données Cette partie contient le programme, les données de la partie. Il furthere divisé en

    1) Initialisé Lire Uniquement les Données qui contient les éléments de données sont initialisées par le programme, et ils sont en lecture seule lors de l'exécution du processus.

    2) Initialisé en Lecture et en Écriture de Données qui contient les éléments de données sont initialisées par le programme et être modifié en cours d'exécution des processus.

    3)Uninitalized de Données qui contient les éléments ne sont pas initialisés par le programme et sont fixés à 0 avant que le processus s'exécute. Ceux-ci peuvent également être modifiés et dénommé BSS(Bloc a Commencé Symbole). L'adv de ces éléments, le système n'a pas à allouer de l'espace dans le fichier de programme pour cette zone, b'coz il est initialisé à 0 par le système d'exploitation avant le début du processus à exécuter.

    Pile - Cette partie est utilisée pour les variables locales, stack frames

    Tas Cette partie contient la mémoire allouée dynamiquement

    int abc = 1;                            ---->   Initialized Read-Write Data
char *str;                              ---->   BSS
const int i = 10;                       ----->  Initialized Read-Only Data

main()
{
    int ii,a=1,b=2,c;                            ----->  Local Variables on 
Stack

    char *ptr;
    ptr = malloc(4);                     ------> Allocated Memory in Heap

     c= a+b;                             ------> Text

}

    Des données, de stocker des données de Texte, store code

    Il y a 3 (principal?) segments/sections du fichier produit par un éditeur de liens. texte - texte du programme (et, apparemment, const char tableaux. peut-être que d'autres 'const' tableaux, puisque celles-ci ne peut pas être changé de toute façon). Je ne suis pas sûr à 100% sur le tableau de la partie, peut-être que quelqu'un va me corriger.

    données initialisées avec des données globales. voir les exemples ci-dessous. bss - données globales non-initialisées. Voici quelques exemples

    int x = 1;    /* goes into data */
int y;        /* goes into bss  */
const int z = 1;/* goes into text */

    cela, nous avons vu aller dans "texte" qui, depuis, ne peut pas être changé de toute façon,mais peut être protégé

    OriginalL'auteur Imposter