Le C

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 » :

int	valeur_numerique ;

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

Remplissage des variables et première utilisation :

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''''' :

#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 : \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 où elle est définie :

/* 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…