Définition et déclaration

Bonsoir,

une question me trotte dans la tête, et en cherchant, je n'arrives pas à en trouver la solution. Quelle est la différence entre défintion et déclaration?
J'ai lu qu'une déclaration pouvait être une définition ou pas, mais je ne sais pas pourquoi. Est-ce que quelqu'un peut m'éclairer?

Merci.

La déclaration ca peut être court.
Par exemple :

Code:

---

1 2 3 4

class A; int f(int a, char c); int i; // ...

---

Mais en C++, on peut soit donner déclaration puis implémentation (class A; puis class A { // ... }; plus loin), soit déclarer tout d'un coup (directement class A { // ... }; ).

Donc une déclaration peut définir aussi ce dont il s'agit.

Pendant la rédaction de ce message, j'ai trouvé ceci.

Tu fais mieux la différence ?

Merci pour ta réponse. Je penses avoir saisie le "concept".

En visitant le site que tu as fournis dans ta réponse, j'ai pus observé ce ci:

Code:

---

1 2 3

Exemples de définitions (+déclarations): int i;

---

Or il semble pour toi, que c'est une simple déclaration sans définition, et pour moi également d'ailleur... Est-ce une faute de l'auteur ou un manque de compréhension de ma part?

Hé bien pour un int, tout est dit dans cette ligne :

Code:

---

int i;

---

Alors que pour une classe par exemple :

Code:

---

class A;

---

On ne dit rien à propos de son futur contenu. Il en faut plus.
Pour "int i;" on instancie un int, tout ce qu'on pourrait faire de plus sur une ligne similaire serait de lui donner une valeur.

Donc c'est bien une définition :)

Ok merci beaucoup tout est devenu clair! ^^

Salut,

Si l'on devait (tres fortement) schématiser, on pourrait dire que la déclaration permet de dire que quelque chose (une variable, une fonction, ou une classe) existe, alors que la définition permet de fournir des valeurs concretes et cohérentes à quelque chose (variable, fonction ou classe).

Une définition peut tres bien etre une déclaration, du fait que le code

Code:

---

1 2 3 4 5 6 7 8

class MaClass { public: MaClass(); ~MaClass(); /*...*/ };

---

dit, non seulement, que la classe MaClass existe, mais lui donne aussi une série d'informations qui lui sont propres (toutes les méthodes et tous les membres de la classe) alors qu'une déclaration aura plutot pour but de dire que "quelque chose existe, mais, ne t'en fais pas, tu trouveras plus tard sa définition"...

En effet, le compilateur ne peux travailler que sur ce qu'il connait:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#ifndef MON_FICHIER_H #define MON_FICHIER_H class MaClass { public: MaClass(); ~MaClass(); MonAutreClass& LaFonction(); }; class MonAutreClass { /*...*/ }; /*...*/

---

posera problème du fait que, quand le compilateur devra gérer LaFonction, il n'a pas encore rencontré le type MonAutreClass, et qu'il ne sait donc pas qu'il existe :P

Par contre, le simple fait de fournir une déclaration pour MonAutreClass avant que l'on en aie besoin pour MaClass permettra au compilateur de savoir que MonAutreClass existe, et qu'il peut attendre de trouver sa définition ;)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#ifndef MON_FICHIER_H #define MON_FICHIER_H class MonAutreClass; /* déclaration (anticipée) de MonAutreClass */ class MaClass /* déclaration de MaClass ET définition dans la foulée */ { public: MaClass(); ~MaClass(); MonAutreClass& LaFonction(); }; class MonAutreClass /* Définition (le compilateur sait déjà qu'elle existe) de   * MonAutreClass   */ { /*...*/ }; /*...*/

---

pour les variables, on fera plutot la distinction entre définition et assignation:

Code:

---

1 2	int MaVariable; /* définit une variable de type int nommée MaVariable */

---

• va Déclarer MaVariable (dire qu'elle existe) et
• va fournir les informations nécessaires à son utilisation (adresse mémoire mémoire, taille en mémoire, nom...)

alors que

Code:

---

MaVariable=3;

---

va assigner la valeur 3 à la variable connue sous le nom de MaVariable
Enfin, pour les fonctions, on fera plus volontier la distinction entre déclaration (dire qu'elles existent) et implémentation (fournir les instructions qu'elle doit effectuer):

Code:

---

1 2 3 4 5 6 7

void MaFonction();/* déclare MaFonction */   void MaFonctin()/* Definis (fournit les informations relatives) ou implémente   * la fonction */ { /*...*/ }

---

En gros une définition est forcément une déclaration, mais l'inverse n'est pas toujours vrai.

Merci beaucoup koala01.