C : Comportement du mot clé `const`.

Question

On m'a dit que si je code en ANSI C, je dois déclarer dans l'ordre que les variables seront utilisées, affirmer que les pointeurs ne sont pas nuls et que les indices sont dans les limites, et initialiser juste avant l'utilisation de la variable.

Si je déclare un const Puis-je l'initialiser après un bloc d'assertions et de code ?

En Java, les initialisations finales doivent avoir lieu au moment de la déclaration, mais les implémentations ANSI C sont-elles cohérentes avec le fait que je puisse initialiser un fichier de type const une fois, mais pas nécessairement au moment de la déclaration ?

Answer 1

Le compilateur Java possède une petite quantité de logique de flux pour vous permettre d'initialiser final après leur déclaration. Ceci est légal en Java :

final int something;

if ( today == Friday )
    something = 7;
else
    something = 42;

Java détectera si une branche laisse la valeur finale indéfinie. Il n'analysera pas les conditions, donc ce n'est pas du Java légal, même si c'est logiquement similaire :

final int something;

if ( today == Friday )
    something = 7;

if ( today != Friday )
    something = 42;

Dans la norme ANSI C89, const variables ( autres que extern ) doivent être initialisés dans la déclaration dans laquelle ils sont déclarés.

const int something = ( today == Friday ) ? 7 : 42;

En extern sur une déclaration indique au compilateur que la variable est initialisée dans une unité de compilation différente (ou ailleurs dans cette unité de compilation).

En ANSI C99, vous pouvez mélanger les déclarations et le code, ainsi vous pouvez déclarer et initialiser un fichier const après un bloc d'assertions et de code. La portabilité du C ANSI de 1999 reste un problème.

Une solution de contournement pour C89 consiste à noter que les règles relatives aux déclarations précédant le code s'appliquent à la portée du bloc plutôt qu'à celle de la fonction, ce qui vous permet de procéder ainsi :

#include<stdio.h>

int main ( void )
{
    printf ( "wibble\n" );

    {
        const int x = 10;

        printf ( "x = %d\n", x );
    }

    return 0;
}

Answer 2

const sont en lecture seule et doivent être initialisées là où elles sont définies.

Ce code produit error: assignment of read-only variable 'foo' (CCG 4) :

const int foo;
foo = 4;

Il en va de même pour les pointeurs const (à noter ici : const int * n'est pas un pointeur de const, mais un pointeur de const) :

int * const foo;
foo = 4;

Answer 3

Sachez que même en C89 Si l'on veut que la définition se rapproche du point de première utilisation, on peut souvent introduire un bloc nu, juste pour la portée supplémentaire. Avant :

int a, b, c;

a = 12;
// Do some stuff with a

b = 17;
// Do some stuff with a and b

c = 23;
// Do some stuff with a, b, and c

Après :

int a = 12;
// Do some stuff with a
{
    int b = 17
    // Do some stuff with a and b
    {
        int c = 23;
        // Do some stuff with a, b and c
    }
}

Avec C99 Bien entendu, vous pouvez définir des variables ailleurs qu'au début d'un bloc :

int a = 12;
// Do some stuff with a

int b = 17
// Do some stuff with a and b

int c = 23;
// Do some stuff with a, b and c

Answer 4

Vous ne pouvez pas initialiser la déclaration const after dans le corps de la fonction, mais vous pouvez ouvrir un bloc après vos assertions :

void func()
{
    int y;

    // Do assertions
    assert(something);
    {
        int const x = 5;
        // Function body
     }
}

Answer 5

En dehors de la portée du bloc et des méthodes de déclaration C99 que d'autres ont montrées, la réponse est non ; vous ne pouvez pas différer l'initialisation d'une variable const. De toute façon, const n'est pas très utile pour les variables locales. Les principales fois où j'utilise le mot-clé const en C sont :

• Les pointeurs dans les arguments de fonction (ou les pointeurs de variables locales basés sur les arguments) où la fonction honore un contrat pour ne pas modifier les données pointées. Le mot-clé const permet de s'assurer que l'implémentation de la fonction respecte l'obligation de ne pas modifier (il faut faire un effort particulier pour se débarrasser de const) et permet à cette obligation de se propager à travers plusieurs appels de fonction.
• Pour déclarer les tables de constantes de compilation (tables de recherche, objets permanents prédéfinis, etc.) qui doivent être stockées dans une section en lecture seule du binaire afin de ne pas utiliser de ressources physiques supplémentaires lors de l'exécution.

Je déclare parfois des variables locales constantes si je pense que cela aidera le lecteur à comprendre une fonction, mais c'est assez rare.