Quelques notions de bases en C que je voudrais vérifier

Résolu/Fermé
Utilisateur anonyme - 26 juil. 2013 à 23:22
 Utilisateur anonyme - 27 juil. 2013 à 19:10
Bonjour!

M'étant récemment remis au C, j'ai décidé d'étudier le code d'une bibliothèque afin de renouer avec les notions que j'avais de ce langage.

J'ai cependant des questions à poser et des précisions à demander à plus expert que moi. J'espère que vous saurez m'aider.


Question 1 :
La bibliothèque que j'étudie s'intitule "TableauNoir.c", elle s'appuie sur SDL et met à disposition des fonctions graphiques simplifiées.
J'ai dans l'en-tête "#include"libTableauNoir.h" " Je ne comprends pas ce que cela veut dire, la bibliothèque s'inclue elle-même???


Question 2 :
J'ai après les "include" deux "#ifndef/#define/#endif", l'un avec "_Win32_" et l'autre avec "_Win32".
Concrètement, la différence entre les deux, c'est quoi à pars le tiret de différence?

Je sais que les #ifndef/#define/#endif servent à éviter des inclusions à répétitions lorsque deux bibliothèque s'appellent l'une l'autre, est-ce une précaution parce que la bibliothèque s'incluerait elle-même dans le cas présent?


Question 3 :
Après l'en-tête viennent des définitions de "constantes symboliques" et de "variables statiques".
N'ayant jamais fait de focus sur ces notions en cours je m'interroge sur les différences entre les deux.

Dites-moi si je me trompe mais si je comprends bien, les constantes symboliques sont des valeurs fixes, qui ne peuvent être modifiées qu'en touchant au code source, elles fixent certaines valeurs, des réglages en somme, auxquels tu ne touches plus par la suite.
Les variables statiques en revanche peuvent être modifiées lors de l'exécution du programme, et là ce sont carrément des valeurs que tu peux régler comme de vrais settings et qui sont seulement prédéfinies par la source.

Ces constantes et variables sont-elles accessibles par un autre fichier incluant leur bibliothèque?


Question 4 :
J'ai également les définitions de types structurés, qui ont tous la syntaxe suivante :

typedef struct { type_champ1 champ1, type_champ 2 champ2...} nom_type_structuré;

Je connaissais sans le "typedef", à quoi sert-il? J'ai lu quelquepart qu'il était déjà utilisé pour définir un type à partir d'un autre déjà existant, mais ceux qui sont ainsi définis ne pouvaient être confondus avec d'autres types puisqu'ils étaients les seuls à avoir "cette tête là".

Existe-t'il de cette manière encore d'autres syntaxes pour la définition de types structurés? (ormis l'inversion du nom du type et des {...}).


Question 5:
Concernant le problème plus général de la disposition des différents éléments dans un .C .
J'ai appris à faire comme ceci:


#includes

Définitions de constantes symboliques, types, énums et variables statiques.

Déclarations de fonctions.

Main()

Définitions de fonctions.



Est-ce bien la bonne disposition? D'autres sont-elles acceptables ou bien s'en fout-on carrément?






Voilà à peu près mes plus grosse interrogations :)

Merci d'avance pour vos avis!
A voir également:

1 réponse

fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 835
27 juil. 2013 à 11:49
Bonjour,

Q1 : Attention à ne pas confondre bibliothèque et fichier header.
La bibliothèque, c'est un programme embarquant un certain nombre de fonctions pouvant être appelées depuis n'importe quelle autre programme.
Le header contient juste les prototypes des fonctions de la bibliothèque.
Les deux sont donc essentielles.

Q2 : Normalement, c'est plutôt _WIN32 qui est utilisé. Confirmes-tu que tout n'est pas écrit en majuscule ? Là, faut voir du côté des variables définies par ton compilateur.

Je sais que les #ifndef/#define/#endif servent à éviter des inclusions à répétitions lorsque deux bibliothèque s'appellent l'une l'autre, est-ce une précaution parce que la bibliothèque s'incluerait elle-même dans le cas présent?
Ce n'est pas pour éviter l'inclusion multiple de bibliothèque mais de header.

Q3 : Du code, ça serait plus simple pour t'aider...

Q4 : Le typedef, c'est pour définir un synonyme. Dans le cas présent, tu dis que struct {...} est l'équivalent de nom_...

Sinon, non il n'existe pas différentes manières d'utiliser les structures.

Q5 :
#includes

Définitions de constantes symboliques, types, énums et variables statiques.


Pour les variables statiques, cela dépend. Tu peux également en trouver dans les fonctions. Mais le comportement sera différent (static dans les fonctions crée une variable dans le segment data ou .bss, la variable ne sera donc pas détruite après la fin de la fonction comme ce serait le cas pour une variable automatique).

La variable statique placée en dehors d'une fonction est juste une variable globale dont tu restreins la portée au fichier.

Tu peux rajouter également les variables globales, les structures, etc.

Les déclarations de fonction ? Oui c'est ici, mais c'est plus propre dans un .h.

Ce n'est pas Main(), mais int main(void) ou int main(int argc, char *argv[]) (voire int main(int argc, char **argv))

Cdlt,
1
Utilisateur anonyme
27 juil. 2013 à 15:35
Bonjour, tout d'abord merci d'avoir répondu.

Q1: donc le .h sert à contenir les déclarations de fonctions?
Mais lorsque je fais un "#include<libTableauNoir.h>", comment libTableauNoir.h "sait" que les définitions des fonctions sont contenues dans le fichier TableauNoir.c"?

J'ai voulu également essayer de trouver l'écriture de string.h en C mais j'ai lu que ça n'avait pas forcément été écrit en C.
Donc les .h existent pour d'autres langages? Tous?
Cela veut-il dire que je peux coder des fonctions dans un langage A, mettre les déclarations dans un .h et l'inclure dans un code écrit dans un langage B?

Q2: Oui, c'était en majuscules.

Q3: Voici le code:

/**************************/
/* constantes symboliques */
/**************************/

/* taille de la fenêtre mémoire */

#define MEM_WIDTH  1920          // Taille max de l'affichage en x
#define MEM_HEIGHT 1080          // Taille max de l'affichage en y

/* taille initiale de la fenêtre affichée */
#define WIN_WIDTH_INITIAL 800
#define WIN_HEIGHT_INITIAL 600


/**************************/
/* variables statiques    */
/**************************/



// la fenêtre en mémoire fait 1920x1280 pixels (écran Full HD)
// l'origine du repère orthonormé dans la fenêtre mémoire est :
static const tPoint s_orig = {MEM_WIDTH/2, MEM_HEIGHT/2};

// taille de la fenêtre
static tPoint s_taille_win = {WIN_WIDTH_INITIAL, WIN_HEIGHT_INITIAL};


static int s_redimensionnable = 1   ;  /* la fenêtre peut-elle être redimensionnée ? */
static int s_temporise = 0          ;  /* Mode Bufferisation enclenché? (1:non 0:oui) */

static tRVB s_couleur_fond = { 0, 0, 0 };
static tRVB s_couleur_pinceau = { 0xFF, 0xFF, 0xFF } ;
static tRVB s_couleur_stylo = { 0xFF, 0, 0 } ;
static int  s_taille_stylo = 1;            // Diametre du point




static SDL_Surface * s_sdl_win      = NULL;          // Surface visible
static SDL_Surface * s_sdl_mem      = NULL;          // Surface de l'écran virtuel
/*static SDL_Surface * s_sdl_pinceau = NULL;        // Couleur du fond
static SDL_Surface * s_sdl_pixel   = NULL;          // Couleur du pixel (taille: 1*1)*/
static tStylo        s_sdl_stylo    = {NULL, NULL, 0};    // Image d'un point


static EtatSourisClavier lEtat;
static unsigned char s_opacite      = 0xFF  ;       // opacité des tracés
static int s_fermetureDemandee      = 0     ;       // 1 si l'utilisateur essaie de fermer la fenêtre
static int s_attenteBoutonGauche    = 0     ;       // en attente de clic
static int s_attenteBoutonDroit     = 0     ;       // en attente de clic
static int s_attenteBoutonMilieu    = 0     ;       // en attente de clic
static int s_attenteNms             = 0     ;       // en attente chronométrée


Q5: entendu pour les déclarations de fonctions et la disposition, pour main() je désignais bien ça, j'ai juste "simplifié" pour la rédaction.

Si les variables statiques sont des variables dont "la portée est restreinte au fichier", (mais à valeurs dans tout le fichier?), au contraire, la portée des constantes symboliques n'est pas restreinte au dit fichier, mais dans les fichier faisant une inclusion de la librairie également?

Que puis-je mettre d'autre dans un header?

Cordialement.
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 835
27 juil. 2013 à 18:30
Q1: donc le .h sert à contenir les déclarations de fonctions?
Yep, il peut contenir aussi des variables globales (structure, ...).

Mais lorsque je fais un "#include<libTableauNoir.h>", comment libTableauNoir.h "sait" que les définitions des fonctions sont contenues dans le fichier TableauNoir.c"?
Bah, il le sait pas. Et il n'a pas besoin de le savoir. Le principal est qu'à la compilation (et plus précisément lors de l'édition des liens) que la fonction existe parmi les *.c du programme (peu importe que ça doit dans tartempion.c ou TableauNoir.c).

J'ai voulu également essayer de trouver l'écriture de string.h en C mais j'ai lu que ça n'avait pas forcément été écrit en C.
Donc les .h existent pour d'autres langages? Tous?

string.h est une partie des définitions de la bibliothèque libC.

Donc les .h existent pour d'autres langages? Tous?
Disons plutôt que, ta bibliothèque tu la codes dans le langage que tu veux. Ensuite, si tu as le .h associé (pour les appels en C), tu peux effectivement utiliser la bibliothèque.

Q3/
Ce qu'il faut retenir c'est que les variables statiques utilisées dans ce code sont des variables globales dont la portée est restreinte au fichier. Donc tu pourras appeler ces variables de n'importe quelle fonction du fichier.

Q5/
Si les variables statiques sont des variables dont "la portée est restreinte au fichier",
Attention à bien préciser : placées en dehors de fonctions (sinon, ça change la définition) :-p.

au contraire, la portée des constantes symboliques n'est pas restreinte au dit fichier, mais dans les fichier faisant une inclusion de la librairie également?
Bah si, c'est restreint aussi au fichier. C'est pour cela qu'il faut inclure les .h dans tous les fichiers nécessitant la déclaration des prototypes de fonctions.
Et, je le redis (mais ça a son importance) : on n'inclue pas une bibliothèque mais un header. (Le .h n'est pas la bibliothèque).
0
Utilisateur anonyme
27 juil. 2013 à 18:36
Juste pour la Q5 : Il faut tout de même que le .h contienne les constantes symboliques pour qu'elles soient efficaces en dehors du .c? ou c'est comme pour les définitions de fonctions dans la Q1?

Sinon à part ça j'ai tout compris, merci à toi =)
0
fiddy Messages postés 11069 Date d'inscription samedi 5 mai 2007 Statut Contributeur Dernière intervention 23 avril 2022 1 835
27 juil. 2013 à 18:56
Il faut tout de même que le .h contienne les constantes symboliques pour qu'elles soient efficaces en dehors du .c? ou c'est comme pour les définitions de fonctions dans la Q1?
Comme la Q1. Dis-toi bien que #include est une bête instruction préprocesseur qui va lui dire de remplacer tout le contenu du fichier dans le .c appelant le .h.
0
Utilisateur anonyme
27 juil. 2013 à 19:10
merci! =)
0