Différences entre les versions de « Le C »

De Site à Mans
Aller à la navigation Aller à la recherche
m (réorganisation du code C avec SyntaxHighlightAce)
Ligne 17 : Ligne 17 :
En C les valeurs qui peuvent être modifiées, dans la mémoire, sont représentées par des « variables » crées par des prototypes en tout genre…
En C les valeurs qui peuvent être modifiées, dans la mémoire, sont représentées par des « variables » crées par des prototypes en tout genre…


Pour créer une variable dont le contenu peut-être changeant on fait appel, avant tout, à « la déclaration de variable » :
Pour créer une variable dont le contenu peut-être changeant on fait appel, avant tout, à « la déclaration de variable » représenté ici en rouge<span> </span>:


<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
Ligne 27 : Ligne 27 :
char **reference ;
char **reference ;


Remplissage des variables et première utilisation :
Remplissage des variables et première utilisation<span> </span>:


valeur_numerique = 65535 ;
valeur_numerique = 65535 ;
Ligne 42 : Ligne 42 :
Toutes ses instructions se placent dans un fichier ayant pour extension '''''.cpp''''' dans lequel peut y ajouter nos "définitions de fonctions".
Toutes ses instructions se placent dans un fichier ayant pour extension '''''.cpp''''' dans lequel peut y ajouter nos "définitions de fonctions".


Théorie : Définition de fonction simple :
Théorie<span> </span>: Définition de fonction simple<span> </span>:


Syntaxe :
Syntaxe<span> </span>:
<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
prototype Nom1(void)  
 
prototype Nom1(void)
 
{
{
Instructions, fonctions ou méthodes c'est du kiff...
 
Instructions, fonctions ou méthodes c'est du kiff...
}
}
</syntaxhighlight>
</syntaxhighlight>




Vrai fonction à placer :
Vrai fonction à placer<span> </span>:


''(à écrire dans un fichier nommé '''casdecole.cpp''')''
''(à écrire dans un fichier nommé '''casdecole.cpp''')''
Ligne 84 : Ligne 87 :
Quelque soit l’utilisation que vous prévoyez de votre '''.h''' il faut prendre garde à ce qu’il ne soit pas relu par le compilateur afin d'éviter une erreur de compilation ou une mise en garde (warning) disant que certaines choses sont redéfinies ; ''ça fait mauvais genre et ça compile pas!''
Quelque soit l’utilisation que vous prévoyez de votre '''.h''' il faut prendre garde à ce qu’il ne soit pas relu par le compilateur afin d'éviter une erreur de compilation ou une mise en garde (warning) disant que certaines choses sont redéfinies ; ''ça fait mauvais genre et ça compile pas!''


Pour éviter ce piège il faut placer les instructions à l'intérieur d'un #ifndef et #endif comme suit :
Pour éviter ce piège il faut placer les instructions à l'intérieur d'un #ifndef et #endif comme suit<span> </span>:


Fichier '''''casdecole.h'''''
Fichier '''''casdecole.h'''''
Ligne 105 : Ligne 108 :
Pensez à placer vos structures dans le '''''.h''''', ici placer la vrai structure dans '''''casdecole.h'''''.
Pensez à placer vos structures dans le '''''.h''''', ici placer la vrai structure dans '''''casdecole.h'''''.


Syntaxe :
Syntaxe<span> </span>:


<syntaxhighlight lang="cpp">struct NOM
<syntaxhighlight lang="cpp">struct NOM
Ligne 113 : Ligne 116 :
</syntaxhighlight>
</syntaxhighlight>


Pour de vrai :
Pour de vrai<span> </span>:


''(à placer dans la partie /* Structures... */)''
''(à placer dans la partie /* Structures... */)''
Ligne 133 : Ligne 136 :
Voici le prototype à placer dans '''''casdecole.h''''' suivi de sa définition à écrire dans '''''casdecole.cpp.'''''
Voici le prototype à placer dans '''''casdecole.h''''' suivi de sa définition à écrire dans '''''casdecole.cpp.'''''


Dans le '''''.h''''' : en dessous de /* Prototypes  ... */
Dans le '''''.h'''''<span> </span>: en dessous de /* Prototypes  ... */


<syntaxhighlight lang="cpp">
<syntaxhighlight lang="cpp">
void opt_main(mes_options *opt);
void opt_main(mes_options *opt);


Ajouter ce qui est en gras dans le '''''casdecole.cpp''''' :
Ajouter ce qui est en gras dans le '''''casdecole.cpp'''''<span> </span>:


#include <iostream> /* pour le C dans un .c c koi pour printf ? */
#include <iostream> /* pour le C dans un .c c koi pour printf ? */
Ligne 147 : Ligne 150 :
int count = 1;
int count = 1;


printf(“les arguments disponibles sont : \n”);
printf(“les arguments disponibles sont<span> </span>: \n”);


for( ; count < opt->argc ; count++)
for( ; count < opt->argc ; count++)
Ligne 179 : Ligne 182 :
Ce qui est appelé "structure complexe" est une structure simple avec soit sa propre structure en définition et/ou soit une déclaration d'un prototype de fonction. C’est-à-dire, non plus y stocker différents types de variable on y ajoute aussi des fonctions pour y être appelées par la structure elle-même.
Ce qui est appelé "structure complexe" est une structure simple avec soit sa propre structure en définition et/ou soit une déclaration d'un prototype de fonction. C’est-à-dire, non plus y stocker différents types de variable on y ajoute aussi des fonctions pour y être appelées par la structure elle-même.


Voici un exemple concret qui va se greffer au reste du projet :
Voici un exemple concret qui va se greffer au reste du projet<span> </span>:


''(à ajouter dans notre .h)''
''(à ajouter dans notre .h)''
Ligne 253 : Ligne 256 :
'''static''' int var_protect = 198;
'''static''' int var_protect = 198;


'''extern''' déclare qu'une fonction est déclarée ailleurs que dans le fichier où elle est définie :
'''extern''' déclare qu'une fonction est déclarée ailleurs que dans le fichier où elle est définie<span> </span>:


/* fonction déclarée ailleurs que dans ce fichier */
/* fonction déclarée ailleurs que dans ce fichier */

Version du 23 mai 2022 à 18:08

Avant-propos

Ce qui est proposé dans ce document est d’utiliser une structure (sa référence) comme argument de fonction et ainsi mettre en place un concept (que peut de gens se servent) proche de l’objet chère aux langage évolué comme le c++


Les données

Dans la grande majorité des cas, toutes informations transmises à un programme est stocké dans la mémoire de façon dynamique.

En C les valeurs qui peuvent être modifiées, dans la mémoire, sont représentées par des « variables » crées par des prototypes en tout genre…

Pour créer une variable dont le contenu peut-être changeant on fait appel, avant tout, à « la déclaration de variable » représenté ici en rouge :

int	valeur_numerique ;

char	caractere ;
char	tableau_dim [1024] ;
char	*pointeur ;
char	**reference ;

Remplissage des variables et première utilisation<span> </span>:

valeur_numerique	= 65535 ;
caractere			= 'c' ;
tableau_dim			= "une phrase qui en vaut une autre" ;
pointeur			= tableau_dim ;
reference			= &pointeur  ;


Fonctions et appel de fonction

Une fonction est un regroupement d’instructions pouvant être des conditions ou des changement d’état de la mémoire ( via les variables ou pointeurs).

Toutes ses instructions se placent dans un fichier ayant pour extension .cpp dans lequel peut y ajouter nos "définitions de fonctions".

Théorie : Définition de fonction simple :

Syntaxe :

prototype	Nom1(void)

{

Instructions, fonctions ou méthodes c'est du kiff...
}


Vrai fonction à placer :

(à écrire dans un fichier nommé casdecole.cpp)

#include <iostream> /* pour le C dans un .c c koi pour printf ? */
int	main'''(int argc, char *argv[], char **env)''' /*     **env équivalent à *env[] */
{
	printf("Nombre d’argument disponible lors de l'appel du programme '%s' est égal à '%d'\n", argv[0] , argc);

	/* La suite */

	return(argc);
}

La fonction main() est la seule obligatoire pour qu'un programme soit exécuté par le système. Sinon le résultat produit fournirait une librairie , voire ci-dessous.

Seul un code, avec main, pourrait s'en servir comme librairie (voyez là un dictionnaire d'instructions)...

Utilisation de librairies de fonctions

Une librairie est un magasin de fonctions organiser intelligemment pour faire gagner du temps au développement et permet au compilateur de perdre moins de temps lors d’une recompilation.

Pour être précis et rapide lorsque vous effectué des modifications dans un fichier de votre projet le compilateur va seulement recompiler le fichier modifié et non tout l’ensemble. Bien tendu il faut avoir organisé vos fonctions comme détaillé plus bas !

De façon générale il faut placer dans un fichier ayant pour extension '.h' (point H) tous les prototypes de fonction ainsi que les structures ; ceci permet au code d'être plus rapidement transformer dans les utilisations futures, mais pas seulement…

Une astuce fort utile dans un .h

Quelque soit l’utilisation que vous prévoyez de votre .h il faut prendre garde à ce qu’il ne soit pas relu par le compilateur afin d'éviter une erreur de compilation ou une mise en garde (warning) disant que certaines choses sont redéfinies ; ça fait mauvais genre et ça compile pas!

Pour éviter ce piège il faut placer les instructions à l'intérieur d'un #ifndef et #endif comme suit :

Fichier casdecole.h

#ifndef CAS_D_ECOLE /* Si CAS_D_ECOLE n’est pas définie (ou utilisé) j’interprète les instructions suivante, SINON celle qui suivent le #endif qui me concerne… */

#define CAS_D_ECOLE

/* Définition (ou alias/mini-macros ...) */
/* Inclusion de libraires ... */
/* Structures */
/* Prototypes  ... */

#endif /* concerne le ifndef  de CAS_D_ECOLE */

Structure simple

Une structure est un ensemble d'instructions servant principalement à diminuer le nombre d'argument à fournir à une fonction ou éviter les variables globales ; un fléau lorsqu'on veut modifier ou débugger son code…

Pensez à placer vos structures dans le .h, ici placer la vrai structure dans casdecole.h.

Syntaxe :

struct NOM
{
	... Instructions ...
};

Pour de vrai :

(à placer dans la partie /* Structures... */)

struct mes_options
{
	int			argc;
	char		**argv;
	char		**env;
};

typedef mes options mon_projet_struct;

Fonctions et structures

Maintenant qu'il existe une structure il est possible de travailler sans utiliser de variable globale ou une multitude d'argument dans la fonction.

Voici le prototype à placer dans casdecole.h suivi de sa définition à écrire dans casdecole.cpp.

Dans le .h : en dessous de /* Prototypes ... */

void		opt_main(mes_options *opt);

Ajouter ce qui est en gras dans le '''''casdecole.cpp'''''<span> </span>:

#include <iostream> /* pour le C dans un .c c koi pour printf ? */
#include "casdecole.h"

void		opt_main(mes_option *opt)
{
	int		count	= 1;

	printf(les arguments disponibles sont<span> </span>: \n);

	for( ; count < opt->argc ; count++)
	{
		printf(" %4d: %s\n", count, opt.argv[count]);
	}
}

int	main(int argc, char *argv[], char **env)	/* **env équivalent à *env[] */

{
	mes_options	opt;	/* Création d'une instance de "mes_options"  */

/* représentée par  "opt" */

	opt.argv	= argv ;
	opt.argc	= argc;
	opt.env		= env;

printf("Nombre d’argument disponible lors de l'appel du programme '%s' est égal à '%d'\n", argc, argv[0]);

	/* La suite */
	opt_main(&opt);

	return(argc);

}

Structures complexes

Ce qui est appelé "structure complexe" est une structure simple avec soit sa propre structure en définition et/ou soit une déclaration d'un prototype de fonction. C’est-à-dire, non plus y stocker différents types de variable on y ajoute aussi des fonctions pour y être appelées par la structure elle-même.

Voici un exemple concret qui va se greffer au reste du projet :

(à ajouter dans notre .h)

typedef struct
{
	char		*fonction;
	int		droits ;

	/* déclaration de fonction (prototype) */

	void		(*function)(struct *mon_menu, char *, char *);

	'''mon_menu'''	*next ;
	'''mon_menu'''	*prev ;
} command_tbl;

typedef	'''mon_menu'''	ma_structure_menu

Définir sa propre structure avant même qu'elle soit définie entièrement est quelque chose de plutôt abstrait pour un nom habitué. Cette possibilité est importante pour un programme devant gérer des listes de données (liste chaînée)…

/* Une autre façon de déclarer une structure dite ‘complexe’ */

struct
{
	char   *nom;                  /* name of command      */
	void   (*function)(char *, char*, char*);      /* pointer to function */
	int    userlvl;
} on_msg_commands[] =

/*     Commande         function   userlvl   forcedcc */

{
	{ "HELP",       show_help,      0,      FALSE  },
	{ "DC", do_dc,  0,      FALSE },

	/*
	.
	:
	*/
	{ NULL,         null(void(*)()), 0,   FALSE }
};

''(à placer dans le .c)''

struct mon_menu
{
	"httpd",	100,		do_httpd,
	"echo",		0,			do_echo,
}

ma_structure_menu
{
} on_cmds[];

void		do_menu(mon_menu opt)
{
	/* fonction gérant les droits d'accès et exécution des argv */
}

static et extern

static rend une variable ou fonction accessible uniquement dans le fichier où c'est déclaré.

fichier.c

/* variable non accessible ailleur que dans ce fichier */

'''static''' int var_protect	= 198;

'''extern''' déclare qu'une fonction est déclarée ailleurs que dans le fichier  elle est définie<span> </span>:

/* fonction déclarée ailleurs que dans ce fichier */

'''extern''' void la_fonction(void);

Le compilateur fait ainsi l'économie de recherche dans le fichier de déclaration. Seul le linkeur fait cette recherche pour remplacer la référence par la définition.

Le bon "const"

const règle l'accès à une données en lecture seule. Cette donné peut-être un emplacement mémoire, un pointeur ou une référence…

const char *p1 = "mon discours";

char	'''const'''	*p2	= "mon discours 2";
char	*p3	'''const'''	= "mon discours 3";

Ces formes n'ont pas les même signification pour le compilateur…