principes de programmation en c

PRINCIPES DE PROGRAMMATIONEN C

.

OBJECTIFS

.

REGLES DE CODAGE

OBJECTIFS POURQUOI DES REGLES LES REGLES POUR QUEL LANGAGE VUE GLOBALE REGLES DIVERSES

DES REGLES POURQUOI ?

LISIBLE– STRUCTURER

MAINTENABLE PORTABLE EVITER LES PROBLEMES

DES REGLES POUR QUELS LANGAGES

C, la référence PASCAL, le compromis avec le passé

– VAX, BSO, OREGON

ASSEMBLEUR, un combat dépassé ADA, pour les pros C++, la nouvelle référence

LES QUALITES VISEES

faible couplage externe forte cohésion interne bonne décomposabilité bonne composabilité bonne compréhensibilité non ambiguïté portabilité testabilité

FAIBLE COUPLAGE ET FORTE COHESION

BONNE DECOMPOSABILITE

BONNE COMPOSABILITE

NOTATION COD-CNN/X

CATEGORIE C– S REGLE DE STRUCTURATION

– P REGLE DE PRESENTATION

– D REGLE SUR LES DONNEES

– I REGLE SUR LES INSTRUCTIONS

– G REGLE GENERALE

– O REGLE DE PROGRAMMATION ORIENTEE OBJETS

OBLIGATION X– O REGLE OBLIGATOIRE

– T|R REGLE RECOMMANDEE

– F REGLE FACULTATIVE

CHOIX DES REGLES

DANS LES NORMES DE DEVELOPPEMENT OU LE PLAN DE DEVELOPPEMENT

EN COMPLETANT LA GRILLE ANNEXE EN FONCTION DES NIVEAUX, FUTURE

NOTATION [12 ]COD-CNN– 1,2,3 EN SOULIGNE : OBLIGATOIRE

– 1.,2,3 EN NORMAL : RECOMMANDEE

– 1,2,3 REMPLACE PAR UN ESPACE : FACULTATIF

CHOIX DES REGLES

(G01/O) Une dérogation à une règle de codage doit faire l'objet d'une justification. Une dérogation à une règle de codage doit être accompagnée de mesures complémentaires pour compenser la perte de qualité.

CONCEPTION PRELIMINAIRE

ARCHITECTURE LOGIQUE ARCHITECTURE DYNAMIQUE ARCHITECTURE PHYSIQUE

ARCHITECTURE PHYSIQUE

METHODE STRUCTUREE : DECOMPOSITION EN MODULES FONCTIONNELS

METHODE OBJET : DECOMPOSITION EN OBJETS

COMPOSANT = MODULES FONCTIONNELS OU OBJETS

ARCHITECTURE PHYSIQUE

Décomposition en composants Spécification des composants

LOGICIEL

ELEMENT

COMPOSANT

ELEMENT

COMPOSANT COMPOSANT COMPOSANT COMPOSANT COMPOSANT

ELEMENT

ELEMENT ELEMENT

L'ARTICLE

DONNEE = – CONSTANTE

– ou TYPE

– ou VARIABLE

ou TRAITEMENT– SOUS-PROGRAMME (FONCTION/PROCEDURE)

– ou TACHE

– ou MACRO

COMPOSANT = MODULE

GROUPE/ENSEMBLE D'ARTICLES A FORTE COHESION INTERNE A FAIBLE COUPLAGE

PROPRIETE D'UN ARTICLE

(S01/O) Tout article doit avoir une définition unique à laquelle tous les utilisateurs se réfèrent.– > DEFINITION DANS DES FICHIERS INCLUS

– > OU GERE PAR LE LANGAGE (EX ADA)

– > OU GERE PAR UN OUTIL (EX OSCAR)

(S02/F) La propriété d'un article est donnée à un composant et un seul.– > DEFINITION GLOBALE/EXPORTABLE DANS UN SEUL

COMPOSANT

– > REFERENCE EN EXTERNE/IMPORTE DANS LES COMPOSANTS UTILISATEURS

COMMENT REGROUPER LES ARTICLES

POUR AVOIR BEAUCOUP D'ARTICLES LOCAUX

POUR AVOIR PEU D'ARTICLES GLOBAUX/EXPORTABLES

S03 = SOLUTION IDEALE A S01+S02

(S03/F) Chaque composant est constitué d'une interface et d'un ou de plusieurs corps. Chaque élément comporte une interface. Ces interfaces contiennent les déclarations accessibles de l'extérieur.

INTERFACE CORPS

UTILISATEURS

UTILISATEURS

UTILISATEURS

SEPARATION INTERFACE/CORPS EN C/C++

M1.H

M1.C

M2.H

M2.C

#include M1.H #include M2.H

SI M2 UTILISE M1

M1.H

M1.C

M2.H

M2.C

#include M1.H #include M2.H#include M1.H

TYPE GLOBAL

M1.H

M1.C

M2.H

M2.C


typedef definition m1_type;

m1_type variable;

VARIABLE GLOBALE

M1.H

M1.C

M2.H

M2.C


extern m1_type m1_variable;

m1_variable = 4;

m1_type m1_variable;

FONCTION GLOBALE

M1.H

M1.C

M2.H

M2.C


[extern] void m1_fnc(void);

m1_fnc();

void m1_fnc(){}

IMPORTATION DANS L'INTERFACE

(S05/T)L'interface d'un composant ne doit faire référence à l'interface d'un autre composant que si les déclarations de l'autre composant lui sont nécessaires pour ses propres déclarations.

M1.H

M1.C

M2.H

M2.C


typedef definition m1_type;

m1_type variable;

typedef m1_type m2_type[10];

#include M1.H

COMMENT EVITER LES INCLUSIONS MULTIPLES

M1.H

M1.C

M2.H

M2.C


typedef definition m1_type;typedef m1_type m2_type[10];

#include M1.H

#ifndef M1#define M1

#endif

#ifndef M2

#endif

#define M2

COMMENT ACCELERER LA COMPILATION

M1.H

M1.C

M2.H

M2.C

#include M1.H #include M2.H

#include M1.H

typedef definition m1_type;typedef m1_type m2_type[10];

#include M1.H

#ifndef M1#define M1

#endif

#ifndef M2

#endif

#define M2#ifndef M1

#ifndef M1

#endif

#endif

SEPARATION INTERFACE/CORPS EN

PASCAL UTILISABLE EN OREGON, DIGITAL, BSO PROBLEME : SYNTAXES INCOMPATIBLES

DE DECLARATION D'INTERNES ET D'EXTERNE

SOLUTION : UTILISER DEUX VERSION D'INTERFACE– M1.DEF -> M1.REF

– GENERER LE SECOND A L'AIDE D'UN OUTIL TRANSDEFREF

SEPARATION INTERFACE/CORPS EN

PASCAL

M1.DEF

M1.C

M2.DEF

M2.C

include M1.DEF include M2.DEFinclude M1.REF

M1.REF M2.REF

trans_def_ref trans_def_ref

SEPARATION INTERFACE/CORPS EN ADA

IMPOSEE PAR LE LANGAGE

M1.ADS

M1.ADB

M2.ADS

M2.ADB

with M1

UTILISATION DE PLUSIEURS LANGAGES

(S04/T)En cas d'utilisation de plusieurs langages, un composant utilisé doit posséder une interface dans le langage du composant utilisateur.

M1.H

M1.C

M2.DEF

M2.PAS

#include M1.H include M2.DEFinclude M1.REF

M1.REF

UTILISATION D'ASSEMBLEUR

(S09/T)les sous-programmes assembleurs globaux doivent respecter les conventions de passage des paramètres du langage évolué utilisé.

M1.inc

M1.ASM

M2.H

M2.C

include M1.inc #include M2.h#include M1.h

M1.h

INTERFACE

DEFINITION DES ARTICLES EXPORTABLES/GLOBAUX DU COMPOSANT

ISSUS DE LA CONCEPTION PRELIMINAIRE PEUT ETRE ECRIT DES LA CONCEPTION

PRELIMINAIRE PEUT ETRE INCLUS EN ANNEXE DE LA

CONCEPTION PRELIMINAIRE (P01/O) le cartouche d'une interface est

imposé

INTERFACE : LES RUBRIQUES D'ENTETE

NOM DU COMPOSANT MEMORISATION DE LA DEFINITION CODE D'IDENTIFICATION REUTILISABILITE DESCRIPTION DEROGATION AUTEUR HISTORIQUE VISIBILITE/COMPOSANTS IMPORTES

INTERFACE : LES EXPORTATIONS

(S06/O) Seuls les articles (constante, variable, type, fonction) potentiellement utilisables par plusieurs composants peuvent être exportés.

DECLARATIONS DE CONSTANTES DECLARATIONS DE TYPES DECLARATION DE VARIABLES DECLARATION DE PROTOTYPE DE

FONCTIONS DECLARATION DE MACROS-FONCTIONS

LE(S) CORPS : LES RUBRIQUES

(P06/F) le format du cartouche d'un corps de composant est imposé

NOM DU COMPOSANT IMPORTATION DE L'INTERFACE HISTORIQUE COMPOSANTS IMPORTES

CORPS : LES DEFINITIONS

DONNEES EXPORTABLES CONSTANTES LOCALES TYPES LOCAUX VARIABLES ET CONSTANTES LOCALES FONCTIONS LOCALES

LES CONSTANTES

MACRO : #define les réserver pour les définitions de dimension (ex tableau)

(D01/T)Les constantes d'objets complexes doivent être définies comme des variables mais avec le préfixe const qui en interdit toute modification

ex : extern const float Pi; (D02/F)Pour les listes d'états possibles, la

définition d'un type énumération est préférable à celle des autres constantes.

ex : enum phase { repos, actif, en_panne };

LES MACROS ATTENTION DANGER

(P02/O)les noms de macros (constantes ou fonctions) doivent être écrites en majuscule, les autres identificateurs devant comporter au moins un caractère minuscule.

ELLES NE SONT PAS MASQUABLES PAR DES DECLARATIONS LOCALES

LES MACROS ATTENTION DANGER

(P05/O) Les arguments des macro-fonctions doivent être protégés par des parenthèses pour éviter des erreurs à l'expansion,

SAUF PROTECTION PAR DES PARENTHESES IL Y A RISQUE D'ERREUR A L'EXPANSION

(S07/T)L'utilisation de macros doit être justifiée par la criticité temps d'un composant.

LES TYPES GLOBAUX

LES ASSOCIER A UN COMPOSANT REGROUPER LES FONCTIONS AGISSANT

SUR CE TYPE DANS CE COMPOSANT

typedef struct complexe /* définition de l'objet mathématique

complexe */{ double réel; /* partie réelle */

double imaginaire; /* partie imaginaire */}complexe;

LES VARIABLES GLOBALES

LIMITER LES VARIABLES GLOBALES– LES REGROUPER DANS DES STRUCTURES

(P03/F)Le premier caractère d'une variable exportable sera en majuscule, tous les autres caractères devant être en minuscule. Une variable locale sera entièrement constituée de minuscules.

LES FONCTIONS

(P04/O) Une déclaration (prototype) est obligatoire pour un sous-programme, dans une interface :

- Elle doit être précédée par une description du sous-programme..

- Tous les arguments doivent être nommés et renseignés avec au moins une ligne par argument. (sauf la partie variable dans le cas d'un nombre variable d'arguments) et le type de l'argument (entrée, sortie, entrée/sortie, valeur de retour)

LES FONCTIONS

ex de prototype :/* addition de deux complexes */complexe complexe_add(

complexe source1, /* entrée : opérande source */complexe source2 /* entrée : 2é opérande source */

); /* retour : résultat de l'addition */

LES FONCTIONS

(I01/O) Dans un prototype de fonction- Le type 'void *' doit être réservé à la

manipulation de bloc binaire de bas niveau.- Le prototype d'une fonction sans

argument doit s'écrire : void fnc(void);

LES FONCTIONS

(P07/F) Le format du cartouche par sous-programme est imposé.

NOM DESCRIPTION FONCTIONS APPELEES DONNEES EXTERNES UTILISEES

LISIBILITE

A. PROGRAMMATION STRUCTUREE B. BOUCLES C. PARENTHESAGE D. REGLES DE NOMMAGE E. REGLES DE TYPAGE F. COMPLEXITE G. ASSEMBLEUR H. MOTS RESERVES I. RACCOURCIS D'ECRITURE

PROGRAMMATION STRUCTUREE

(P08/O)Le code et le pseudo-code doivent être structurés et commenté, ses structures doivent être mises en évidence par des indentations.


(P09/T) consignes de structuration du code et du pseudo-codestructuration

- l'instruction de fin de bloc doit être alignée sous l'instruction de début de bloc,

- le bloc d'instruction doit être décalé (indentation),

- chaque bloc doit comporter au minimum un commentaire,

- une ligne comporte au plus une instruction,

- les expressions longue doivent être évitées ou réparties sur plusieurs lignes.


/* commentaire sur l'instruction complète */if ( i == 2 ){ /* commentaire sur la branche */ action2();}else if ( j == 3 ){ /* commentaire sur l'autre branche */ action();}

UTILISATION DES INSTRUCTIONS DE RUPTURE

I03/T) Les instructions de rupture de séquence doivent correspondre ou synthétiser une structure de contrôle de la conception détaillée. L'instruction GOTO ne peut pas en faire partie, elle ne peut que synthétiser.autorisations :

pseudo-code instructions de ruptures autorisées.............................................................................................................................................................................................................................................

BOUCLE

(I04/O)Le traitement d'une boucle doit rester dans le corps de la boucle.

Une boucle complexe doit être exprimée sur plusieurs lignes

for( i=0,j=10; /* valeurs initiales */ (i<=10) && (état==OK); /* condition de maintien */ i++ , j-- ) /* passage à indice suivant*/{ tab1[i] = tab2[j]; printf("%d\n",i);}

BOUCLE

for(i=0; i<=10; i++) { debut_de_traitement; if(condition) { if( erreur() ) break; traitement; } fin_de_traitement; } suite;

int status = FALSE; /* initialisation ok ? */ for(i=0; (i<=10) && (status==FALSE;)/* bon test de maintien?*/ i++) { debut_de_traitement; if(condition) { if( erreur() ) status = TRUE; /* bonne affectation ? */ else traitement; } if( ! status ) /* bon test ? */ fin_de_traitement; } suite;

LISIBILITE / PRESENTATION

(P10/T)Les expressions doivent être parenthèsées

(P12/T) Tous les articles exportables doivent être préfixés par le code d'identification du composant propriétaire.

(P13/T) Le nom d'un fichier doit être préfixé par son code d'identification.

LISIBILITE / PRESENTATION

(P11/F) les opérateurs non standards suivants sont interdits : ++ -- += -= *= /= %= >>= <<= &= ^= |= affectation à l'intérieur d'une expression affectation conditionnelle ? :

ex : tab[i*2][j*3+k][l] += 4; au lieu tab[i*2][j*3+k][l] = tab[i*2][j*3+k][l] + 4;

LISIBILITE DES DONNEES

(D03/F)Il faut typer toutes les données (D07/T)l'utilisation du type standard 'entier'

est interdite (D04/F)Déclarer dans le fichier portab.ext les

redéfinitions de types standards, avec 'ext'= extension utilisé pour les fichiers inclus dans le langage .

(D05/O)Le signe du type 'char' dépend d'une option de compilation, le préfixe 'signed' ou 'unsigned' est donc obligatoire sur ce type.

LISIBILITE GENERALITE

(G02/O)il ne doit pas être tenu compte de l'implémentation du compilateur

(G03/F)Il faut fixer les limites admises pour la complexité d'un composant sur les mesures suivantes :

- niveau maximum d'imbrications (<=6)- nombre d'instructions par sous-

programme (<=100)- nombre de sous-programmes par

composant (<=7)- nombre d'instructions par ligne (<=1)

LISIBILITE / INSTRUCTIONS

(I08/T)L'usage d'instructions assembleurs dans le code C doit être justifiée et n'est autorisé que sous forme de macro-fonction définie dans le fichier "portab.h" pour des traitements qu'il serait impossible d'écrire en langage évolué..

ex #define MASQUER_CPU #asm("move #2700,SR")

LISIBILITE / INSTRUCTIONS

(I02/F)Les mots réservés nouveaux non supportés, comme const, volatile, noalias, doivent être déclarés comme macro dans le fichier portab.h.

ex #define volatile

SECURITE

A. AIGUILLAGE B. SORTIE DE FONCTION C. CONDITION D'EMPLOI DU GOTO D. EFFETS DE BORD E. PASSAGE D'ARGUMENTS F. OPTIONS DE COMPILATION G. L'OUTIL DE GENERATION H. MEMOIRE DYNAMIQUE I. RECURSIVITE J. REENTRANCE

AIGUILLAGE

(I05/T) une instruction d'aiguillage doit toujours comporter une branche 'autre/par défaut'

(I06/T)Toutes les branches d'un aiguillage (switch) doivent apparaître au même niveau et doivent comporter l'instruction 'break'.

switch(valeur_testee) { case cas_1 : traitement_1; break; . . . case cas_n : traitement_n; break; default : traitement_autres_cas; break; }

SORTIE DE FONCTION

(I09/T) Les sorties multiples sont interdites pour l'assembleur

USAGE DU GOTO

L'instruction GOTOsert exclusivement à coder une instruction du pseudo-code inexistante dans le langage utilisé

** SI alarme alors** TST ALARME BEQ OK**** afficher le message d'erreur** PEA MSGERR JSR ERREUR ADD #4,SP BRA SUITE**** sinon** traitement**OK: JSR TRAITEMENT**** finsi**SUITE:

EFFETS DE BORD

(I07/O)les instructions pouvant provoquer des ambiguïté suivant l'ordre d'évaluation sont interdites

ex : tab[i++] = tab[i++];

PASSAGE D'ARGUMENT

(D06/O)Lors d'un passage d'argument par adresse, le paramètre formel pointeur doit être qualifiés par le préfixe 'const' sauf s'il est nécessaire de le modifier dans la fonction. Un argument qui ne doit pas être modifié par la fonction doit également être préfixé.

void fnc( /* fonction quelconque */int * const pt_argument_retour)

{*pt_argument_retour = 0; /* raz argument */

pt_argument_retour = 0; /* erreur à la compilation*/ }

PASSAGE D'ARGUMENT

void fnc( /* fonction quelconque */const struct x * const pt_struct_entree)

{ ... i = pt_struct_entree->a; pt_struct_entree->a = 4;/* erreur à la compilation*/ }

OPTIONS DE COMPILATION

(G04/O)Les options de compilation et d'assemblage ne doivent pas être sélectionnées manuellement mais indiquées dans le fichier de génération

(G05/T)Les tests (unitaires, d'intégration, validation) doivent être réalisées avec les mêmes options de compilation que celles de la version livrée.

(G06/T)Les options permettant des contrôles à l'exécution (ex domaine d'activité des variables) doivent être activées.

WARNINGS

(G09/T) Seuls les messages d'avertissement (warnings) suivants sont tolérés lors de la génération :....................................................................................................................................................................................................................................

OUTIL DE GENERATION

(G07/O)Un outil de génération de l'application est obligatoire (make ou mms), ou par défaut un fichier de commande

fixer les options de compilation pour l'application,

indiquer les règles de dépendance et ne recompiler que les modules modifiés,

spécifier la version d'outil utilisé.

PROGRAMMATION AVANCEE

(G08/F)L'utilisation de la mémoire dynamique est délicate en temps réel. Les points suivants doivent être vérifiés :

- exclusion mutuelle d'accès en multitâches,

- pas d'algorithme de recompactage de la mémoire en temps réel

- temps d'allocation et de désallocation fixes et connus,

- traitement obligatoire des cas de saturation,

- test de la légalité de la désallocation.

PROGRAMMATION AVANCEE

(S08/T) L'utilisation de la récursivité doit s'accompagner des précautions suivantes :

- nombre d'activations borné,- connaissance des besoins en

mémoire locale.

ANNEXES

APPLICATION AUX AUTRES LANGAGES– C non ANSI

– FORTRAN

– POUR LE PASCAL ET L'ASSEMBLEUR VOIR LES AUTRES MANUELS

– PROCHAINEMENT POUR ADA ET C++

NORMALISATION– A. NORMES CIVILES

– B. NORMES MILITAIRES

LISTE DES REGLES MATRICE REGLES/PROPRIETES RULES FOR C LANGUAGE OUTILS D'AIDE

principes de programmation en c

Documents