Confirmation différence déclaration/définition de variable

Bonjour tout le monde ! Avant de me faire tirer dessus je tiens à préciser que j’ai fait plusieurs recherches et que ma question n’est pas de savoir la différence entre définition et déclaration de variable, je pense que j’ai compris le truc mais si jamais vous sentez que non dites le moi

Mes recherches :

• https://fr.wikipedia.org/wiki/D%C3%A9claration_(informatique)

• https://www.developpez.net/forums/d1674892/c-cpp/c/debuter/difference-entre-definition-declaration-variable-structure/

• Les langage C Norme ANSI 2ème édition (le K&R quoi)

Bon mon soucis c’est lorsque je "déclare" une variable dans une fonction. Ici je ne parle pas d’une variable externe car là le truc est clair : je la définie hors de toutes fonctions et je la déclare (si nécessaire avec le mot clef extern si la définition se trouve dans un autre fichier que la déclaration et que j’ai pas inclus de fichier header, blablabla) dans la fonction qui veut l’utiliser.

Donc en gros dans les tout premiers programmes qu’on fait quand on débute. On nous dit qu’il faut déclarer nos variables avant de pouvoir les utiliser mais, si j’ai bien compris, la ligne :

1

int nombre;

définie et déclare notre variable, non ? Pourquoi ne dit-on pas qu’on définie et déclare une variable ? Je suis d’accord pour dire que si on déclare c’est que forcément c’est défini avant mais ça me parait pas explicite… Du coup ma question est : Est-ce que je mélange tout ou pas… Ça m’a l’air important et je ne voudrai pas continuer avec des bases erronées !

Je vous remercie de votre temps et en attendant une réponse éclairée si possible éclairante, je vous souhaite une bonne journée/soirée/nuit !

Merci pour ta réponse !

En effet j’ai bien mélangé les pinceaux là…

Autant pour les fonctions je comprenais bien le fait de déclarer le prototype et après définir le corps de la fonction mais là :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int status; // J'ai enlevé le extern pour voir 

int
main(void)
{
    printf("%d\n", status);
    return status;
}


int status = 20;

J’ai compilé ce machin et ça semble renvoyer la bonne valeur, comment diable a t-il su que la première ligne était une déclaration et pas une définition

M’enfin je m’écarte de ma question et ce n’est plus adapté au sujet, je vais sagement finir mon bouquin, le relire pour éviter de dire de grosses bêtises, et je reviendrais vous embêter si jamais des questions subsistent

Quoi qu’il en soit, encore merci !

Re ! Du coup je suis parti fouiller un peu partout et j’ai compris quelques trucs en plus :

• Bon le extern a l’air plus important que n’avait l’air de le dire le K&R la première fois qu’il aborde le sujet, personnellement j’ai pas eu l’impression lors de la première lecture que ça permettait de faire la différence entre déclaration et définition. M’enfin quand on cherche on finit par s’en apercevoir.

• Ah me voilà bien embêté … Tu me dis que

1

int a; /* Déclaration */ 

mais pourtant j’ai lu et j’ai testé :

1
2
3
4
5
6
7
8

int status;

int
main(void)
{
    printf("%d\n", status);
    return status;
}

Ce bout de code fonctionne et status est d’office initialisé à 0 (donc d’abord défini, non ?). Donc j’en étais venu à penser que sans extern impossible de faire une déclaration de variable globale correctement parce pour moi le fait que le compilateur déduise que la première définition est en faite une simple déclaration parce que la dernière ligne est une définition je trouve pas ça propre/joli ^^. (je fais référence au code de mon message précédent)

Bon plus je cherche et plus je me perds, j’y arriverai pas décidément

Hey fallait tout dire d’un coup !

Désolé ça va faire plusieurs heures que je cherche des informations sur ce truc, je peux plus comprendre des trucs implicites En plus tu dis : Cependant, il y a une (petite) subtilité … Ah ! El famoso détail qui tue

En tout cas un énorme Merci à toi ! Maintenant tout est bien clair, du moins assez pour aborder la suite un peu sereinement, de nouveaux problèmes vont sûrement se pointer (Héhé pas mal non ? :lol:) mais c’est le jeu. Franchement je pense que ce cours est loin d’être inutile mais après je comprends qu’il doit y avoir du travail pour le rééditer

Je te souhaite une bonne soirée, je pense que je peux clore le sujet !

Avec plaisir.

À vrai dire, il est déjà en markdown, donc cela ne me prendra pas longtemps pour le proposer à la validation, il faut juste que je retouche une ou deux choses. Quoi qu’il en soit, je suis heureux de voir qu’il semble tout de même utile.

Il me semble qu’on en avait déjà parlé, mais je pense aussi que ça serait cool que tu le republies quelque part. C’est un point franchement pas clair dans la plupart des cours de C.

Enfin la problématique de la distinction entre déclaration (il existe une variable appelée truc) et définition (voilà la variable truc) n’est vraiment utile que pour des variables globales partagées entre plusieurs unités de compilation (rt c’est pas en général le code qu’on veut écrire). Car pour les variables locales (idéalement 100% des variables qu’on manipule), la distinction n’existe pas.

Je ne partage pas ton point de vue quant au fait que les variables globales (comprendre : définies en dehors de tout bloc et partagées ou non entre plusieurs unités de compilation) devraient être proscrites, mais sinon, oui, cette distinction est avant tout intéressante pour les variables et/ou fonctions partagées par plusieurs unités de compilation. Bien que, foncièrement, c’est aussi intéressant à savoir pour les variables et/ou fonction propre à une unité de compilation.

Puisque c’est demander si gentiment, c’est fait, je viens de le soumettre à la validation.

Je partage ici l’avis de David ici. Il n’y a pas vraiment de distinction qui compte ici hormis le cas des variables globales où l’on a besoin de dire: "il existe une variable de ce type et accessible de partout, mais elle sera définie dans une autre unité de traduction".

Le simple fait que l’on ne puisse pas écrire

1
2

int i;
int i;

est une preuve suffisante pour dire qu’il s’agit bien de définitions. Elle déclarent aussi, mais ce sont en plus des définitions. J’aime bien cette Q/A: https://stackoverflow.com/a/1410632/15934 Bref, ce sont bel et bien des définitions, le potentiel n’a aucun sens.

La norme C (dans le draft n1570 que j’ai) emploie "declaration" partout, mais c’est le §6.7/5 qui est intéressant

On est bien dans le premier cas.

Je vais réagir à un autre point:

Effectivement, dans ces langages, il n’est pas possible d’utiliser un élément sans qu’il ne soit connu. Il convient de les déclarer. Dans le cas des variables locales, toute déclaration sera une définition : l’espace adéquat dans la pile est réservé: la variable est réservée et prête à être utilisée.

Maintenant, le truc est qu’il est important d’initialiser la variable pour pouvoir s’en servir. Je pense qu’une des confusions classiques vient de là. Sans parler que certaines règles qualité demandent de tout déclarer en début de programme car le C89 ne permet pas autre chose – ce qui n’est pas ce qu’il y a de mieux à faire quand on a le choix.

Pourtant, le code que tu décris peut bien être compilé et est parfaitement légal depuis le C89.

1
2
3
4
5
6
7
8
9

int i;
int i;


int
main(void)
{
        return i;
}

Il y a deux définitions potentielles qui sont précédées d’une « vraie » définition implicite initialisant i à zéro.

Les définitions d’objet de classe de stockage automatique se font en début de bloc, pas en début de programme. Je sais que tu le sais (hu hu), mais les mots sont importants ici.

Pourtant, le code que tu décris peut bien être compilé et est parfaitement légal depuis le C89.

Au temps. Je ne savais pas que le C était différent du C++ ici – car ce code n’est pas légal en C++. (Ceci dit, nous sommes encore dans un cas de variable globale… ^^’ /me qui essaie de se rattraper aux branches)

Tout à fait. Tu as raison de me reprendre. En écrivant "programme" je pensais en fait à sous-programme, et donc oui, à "début de bloc".

Ben tu vois, je ne savais pas qu’il est illégal en C++.

En C++, cela produit un "error: redefinition of …". Et a ma connaissance, il n’y a pas de notion de "definition potentielle". (Vous confirmez, les autres devs C++ ?)

Publication expresse ! 😍

🍪

🍙 ありがと🍘

Yep.

Dans la mesure où le potentiel est contextuel et lié à l’endroit où la déclaration est réalisée comme dans l’exemple de @Taurre, i.e. hors fonction. Je dirais que oui, en C++.

Sauf qu’à bien chercher, il y le cas des variables membres, ou autres attributs de structures. J’ai bien envie de dire qu’il ne s’agit que d’une déclaration: C’est que que dit d’ailleurs g++. gcc parle lui de "duplicate member".

Dans tous les cas, je n’aime pas dire potentiel sans expliciter les contextes exacts où il s’agit d’une déclaration et ceux où il s’agit d’une définition.