Remarques de développement avec C++ Builder 5

Partie I - par Gilles Louise

void __fastcall TForm1::Button1Click(TObject *Sender)
{

}

Application->MessageBox("Bouton cliqué!", "Ok", MB_OK);

void __fastcall TForm1::Button1Click(TObject *Sender)
{
Application->MessageBox("Bouton cliqué!", "Ok", MB_OK);
}

__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit01.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
/* Toutes les variables et constantes générales ici */
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
/* profitez de ce constructeur pour initialiser votre application*/
}
//---------------------------------------------------------------------------

TButton *B;

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
B=new TButton(this);
B->Parent=this;
B->Caption="TEST";
B->Height=20;
B->Width=60;
B->Left=15;
B->Top=15;
B->OnClick=Button1ClickX;
}

void __fastcall TForm1::Button1Click(TObject *Sender)
{

}

void __fastcall TForm1::Button1ClickX(TObject *Sender)
{

}

void __fastcall Button1Click(TObject *Sender);

void __fastcall Button1ClickX(TObject *Sender);

void __fastcall TForm1::Button1ClickX(TObject *Sender)
{
Application->MessageBox("Bouton cliqué!", "ok",MB_OK);
}

void __fastcall TForm1::FormDestroy(TObject *Sender)
{

}

delete B;

//-----------------------------------------------------------------------
#ifndef Unit07H
#define Unit07H
//-----------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//------------------------------------------------------------------------
class TForm1 : public TForm
{
__published: // Composants gérés par l'EDI
void __fastcall FormDestroy(TObject *Sender);
private: // Déclarations utilisateur
public: // Déclarations utilisateur
__fastcall TForm1(TComponent* Owner);
void __fastcall Button1ClickX(TObject *Sender);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

Votre curseur se trouvant sur une ligne quelconque du source, cliquer Exécuter du menu général de C++ Builder et choisissez l'option "jusqu'au curseur" du menu déroulant. Le programme arrêtera son exécution à ce moment là mais il faut préciser que le curseur doit se trouver sur une ligne du source où il y a effectivement une instruction, par exemple juste avant cette instruction mais ça marche aussi si le curseur se trouve au milieu de cette instruction, l'arrêt se fera précisément à cette instruction avant son exécution. Mais si le curseur se trouve sur une ligne blanche ou sur une ligne où il n'y a qu'une accolade, l'arrêt ne se fait pas. La doc ne précise pas ce point ce qui fait qu'on peut croire à un dysfonctionnement. Le mieux est de regarder sur la gouttière à gauche de la fenêtre, il y a un petit point bleu qui s'allume, cela signifie que cette ligne est un point d'arrêt possible, il faut donc toujours positionner le curseur sur un ligne doté d'un tel point bleu. Le mieux est d'utiliser le raccourci F4. Vous positionnez le curseur avant ou sur une instruction dans votre code, vous faites F4 pour exécuter le programme jusqu'à cette position. Dès que l'instruction est rencontrée, le logiciel vous affiche la fenêtre de code et l'instruction d'arrêt est surlignée. Là vous pouvez interroger certaines variables via Exécuter|Inspecter ou encore Exécuter|Évaluer/modifier (Ctrl F7). C'est évidemment très pratique pour interroger des variables parce que vous n'avez qu'à donner leur nom sans vous occuper du type (alors qu'un MessageBox ou un ShowMessage dans le programme à titre d'affichage de debug n'affiche qu'une variable du type Char* pour le premier et AnsiString pour le second).

Notez au passage que pour visualiser des tableaux entiers, il vaut mieux passer par "Exécuter|Inspecter" qui donne plusieurs visualisations différentes pour chaque élément du tableau (mode caractère, équivalent décimal, équivalent hexadécimal) alors que "Exécuter|Évaluer/modifier" est plus adéquat pour des variables à visualiser et éventuellement à modifier avant de reprendre l'exécution du programme. En utilisant "Exécuter|Inspecter", vous donnez d'abord le nom du tableau. Vous ne voyez certes que les premiers éléments mais vous pouvez agrandir cette zone de visibilité. Appuyez sur le bouton droit de la souris et choisissez "Étendue" (ou faites Ctrl R, ce qui revient au même), là vous pouvez indiquez le nombre d'éléments à voir.

Une autre méthode peut-être même plus rapide consiste à pointer quelques instants le curseur dans le source sur le nom d'une variable, le progiciel vous indiquera le contenu de la variable dans une toute petite fenêtre. Vous avez aussi la possibilité de passer par ce qu'on appelle des "points de suivi", voir alinéa 68 en troisième partie.

Même principe pour les points d'arrêt, le curseur doit se trouver sur une ligne où il y a effectivement une instruction sinon l'arrêt ne se fait pas. Vous positionnez le curseur sur l'instruction où se fera le point d'arrêt, vous faites F5, la ligne où se trouve l'instruction est alors surlignée. On supprime ce point d'arrêt en faisant F5 de nouveau sur cette même ligne. Vous pouvez aussi cliquer sur la bande grise à gauche appelée gouttière qui sert de marge à la fenêtre du source C juste en face d'une ligne de code, un point d'arrêt sera de la même façon mémorisé à cet endroit, en cliquant de nouveau à ce niveau, sur le point rouge de repère, le point d'arrêt est supprimé. Ces points d'arrêt sont très pratiques, ils vous permettent de contrôler le contenu de certaines variables, ils se suppriment facilement (on pointe la ligne avec le curseur et on fait F5 ou l'on clique sur le point rouge) et votre code n'a pas été altéré par un ordre quelconque d'affichage des variables. Notez que pour continuer l'exécution du programme à partir du point d'arrêt il faut faire Exécuter|Exécuter (ce qui ne va pas de soi, on aurait pu envisager un ordre dans le menu Exécuter du type "continuer l'exécution", la doc ne parle pas de cette possibilité). Notez que Exécuter|Exécuter revient à cliquer sur la petite flèche verte en haut vers la gauche du menu ou encore à appuyer sur la touche F9.

3. Point d'arrêt pendant l'exécution

Quand vous exécutez le programme pour le tester en cliquant sur la petite flèche verte ou via F9, vous remarquerez dans la ou les fenêtres dédiées au source que de petits points bleus s'affichent sur la colonne grisée de gauche en face de chaque instruction. En cliquant sur un de ces petits points, vous créez un point d'arrêt à l'instruction correspondante et vous pouvez ainsi créer facilement d'autres points d'arrêt en cliquant d'autres petits points bleus. On les supprime en recliquant dessus. C'est très pratique car cela se fait pendant l'exécution même du programme, ces points bleus disparaissent avec leurs points d'arrêt associés quand le programme a terminé son exécution (auquel cas on revient à C++ Builder pour continuer le développement) ou si vous réinitialisez de vous même le programme (Exécuter|Réinitialiser le programme) pendant l'exécution ou au moment d'un arrêt. Ce sont donc des points d'arrêt temporaires ou volatiles qui n'existent que le temps d'un test.

Si vous avez créé un raccourci de C++ Builder sur le bureau et que vous y accédiez en cliquant dessus, le logiciel vous affiche par défaut un projet vierge. Si vous voulez ouvrir un projet en cours, le mieux est de passer par Fichier|Réouvrir qui vous propose une liste de projets que vous avez ouverts dans vos précédentes utilisations de C++ Builder. Les projets étant proposés dans l'ordre, le premier qui apparaît est celui sur lequel on a travaillé la dernière fois, on l'ouvre aussi en appuyant sur la touche 0 (zéro). C'est assez pratique quand on travaille longtemps sur un même projet, on l'ouvre ainsi de façon automatique sans se poser de question. Sinon, autre possibilité, vous allez avec l'explorateur Windows dans le répertoire où se trouve votre projet (on le reconnaît par le fait qu'il est doté de la même icône que C++ Builder, il s'agit du .bpr unique pour un projet donné) et vous cliquez dessus, C++ Builder est alors chargé avec ce projet. Sinon passez par "Fichier|Ouvrir un projet" mais dans ce cas C++Builder part toujours du répertoire C:\Program Files\Borland\CBuilder5\Projects\ par défaut.

Dans un code classique en C++, on a tout intérêt à utiliser des chaînes de caractères du type AnsiString, vous avez ainsi accès à des syntaxes beaucoup plus simples qu'en C. Par exemple on utilise simplement le signe = et on met une chaîne entre quotes pour initialiser une variable, par exemple Var_AnsiStr="Bonjour" au lieu de strcpy(VarChar, "Bonjour") du C classique. Idem pour les concaténations qui se font simplement avec le signe + pour des AnsiString au lieu d'un strcat en C. Cela dit, si vous êtes amené à utiliser des fonctions de C pur, comme C ne connaît pas du tout les chaînes de type AnsiString, vous devez alors convertir un AnsiString en Char*. Imaginez par exemple qu'un OpenDialog vous donne le nom d'un fichier à ouvrir et que ce nom soit dans une variable AnsiString, vous ne pourrez pas ouvrir ce fichier par un fopen du langage C car la chaîne d'un fopen est du type Char*, donc il faut convertir l'AnsiString en Char*. Si donc NomFic est déclaré en AnsiString, il faudra écrire NomFic.c_str() pour ouvrir le fichier via un fopen. Vous appliquez ainsi la méthode c_str à la variable AnsiString la convertissant de cette manière en Char*. Il faudra donc écrire

fopen(NomFic.c_str(), etc.………);

pour que ça marche. Pour plus d'information sur cette question, mettez votre curseur juste avant la chaîne "c_str" et appuyez sur F1, l'aide associée à cette question apparaît. (il en va d'ailleurs de même pour tout autre mot clé). Idem si vous voulez connaître les statistiques concernant ce fichier (accessibilité, longueur etc.) on écrira une instruction du genre

stat(NonFic.c_str(), &statbuf) ;

à partir de laquelle vous avez accès à toutes les caractéristiques du fichier Voir "stat" dans le fichier d'aide et les exemples pour plus d'information. Idem pour les fonctions C de traitement de chaîne de caractères, strcpy, strcat etc. N'oubliez pas les parenthèses ouvrante et fermante quand vous ajouter c_str() sinon vous avez l'erreur E2034 en compilation. Ne pas oublier que VarAS.c_str() où VarAS est un AnsiString est considéré comme une constante, vous ne pouvez donc l'utiliser qu'en lecture mais vous ne pouvez pas y mettre une valeur. Ainsi par exemple un fputs du C pur avec VarAS.c_str() sera correct car vous écrivez une chaîne de caractères mais un fgets sera fautif car vous ne pouvez pas écrire dans VarAS.c_str() qui encore une fois est une constante. Il faudra donc pour lire un fichier via fgets utiliser un char* puis convertir en AnsiString par une affectation classique, VarAS = VarC avec par exemple char VarC[256].

Pour connaître la signification d'un paramètre dans l'inspecteur d'objet, il suffit de cliquer sur ce paramètre et de faire F1, l'aide concernant ce paramètre apparaît dans une fenêtre. Idem pour se remémorer la signification d'une instruction C ou C++ dans le source, on positionne le curseur juste avant le mot clé et on fait F1. Idem pour comprendre une option du menu, vous déployez le menu déroulant, vous mettez en reverse video l'option et vous faites F1, l'aide en ligne de cette fonction apparaîtra.

Pour avoir une explication de l'erreur de compilation, appelez l'aide de C++ Builder en cliquant sur le petit livre du menu en haut de l'écran ou via Aide|C++ Builder puis entrez dans la zone de saisie Ennnn où nnnn est le numéro d'erreur annoncée par le compilateur (la compilation est automatique avant une demande d'exécution ou par la construction de l'exécutable via Projet|Construire_projet où "projet" est le nom de votre propre projet qui apparaît maintenant dans le menu déroulant) ou encore Projet|Make. La réponse du compilateur se trouve dans une petite fenêtre au bas de l'écran juste en dessous du code source. En entrant Ennnn (où nnnn est le numéro de l'erreur e.g. E2034 pour l'erreur 2034), l'aide vous donnera des explications sur cette erreur particulière. Ou encore (et c'est peut-être mieux), vous double-cliquez sur la ligne signalant l'erreur au bas de l'écran pour la sélectionner (elle se met donc en reverse video) et vous faites comme d'habitude F1, une fenêtre apparaît pour vous donner des explications sur cette erreur. Notez que si le compilateur vous indique une ligne d'erreur où vous ne trouvez de toute évidence rien d'anormal, c'est la ligne précédente qui est souvent en cause notamment parce que votre instruction ne se termine pas comme ils se doit par un point-virgule. Pour aller à une ligne précise (par exemple celle annoncée par le compilateur pour vérifier votre code), faites Alt G et entrez le numéro de la ligne. Normalement, le progiciel surligne la première ligne de code trouvée en erreur mais si vous voulez y retourner par la suite, il suffit de double-cliquer dessus, c'est assez pratique.

Dans le menu déroulant Projet, vous avez deux options importantes, l'une est Construire et l'autre Make, elles sont presque identiques. Construire recompile tout et crée l'exécutable. Make (Ctrl F9) ne recompile que ce qui a été modifié depuis la dernière fois et construit l'exécutable. Cette seconde option est donc préférable, vous ne recompilez que les fichiers modifiés, ce qui est plus rapide que de tout recompiler à chaque fois. Notez qu'il n'y a pas de touche raccourci pour Construire alors qu'il y en a une pour Make (Construire ne s'utilise qu'à titre de vérification, cette option vous permet d'être sûr que tout le projet se compile normalement notamment quand vous avez modifié des options de compilation ou des directives). Quant à l'option Compiler l'unité, elle ne compile comme son nom l'indique que la fenêtre active, elle vous permet de vérifier qu'il n'y a pas d'erreur de syntaxe dans votre programme.

9. Appel d'une fonction à l'intérieur du code d'un événement

Quand vous programmez le code correspondant à un événement, par exemple

void __fastcall TForm1::Ouvrir1Click(TObject *Sender) ;

code qui s'exécute quand vous sélectionnez la fonction "ouvrir" d'un menu déroulant, vous avez accès directement aux objets de l'objet principal, en l'occurrence ici TForm1. Si cette fiche contient par exemple un mémo que vous voulez rendre visible à ce moment là, vous écrirez par exemple simplement

memo1->show();

dans le code de cet événement, le programme comprendra qu'il s'agit de la fiche mémo1 de Form1. Mais si cet événement fait appel à une fonction que vous écrivez, vous ne pourrez plus écrire

memo1->show();

le compilateur dira qu'il ne connaît pas mémo1. Il faut alors dans ce cas préciser qu'il s'agit de la fiche memo1 de Form1, il faut donc écrire à l'intérieur de la fonction appelée

Form1-> memo1->show();

Et ça marchera.

Si, suite à une erreur de programmation votre exécutable ne vous rend pas la main durant son exécution, vous avez néanmoins toujours accès au menu de C++ Builder qui reste actif malgré ce problème, il suffit donc de faire Exécuter|Réinitialiser le programme ou encore Ctrl F2 qui fait la même chose. Vous avez ainsi repris la main sur votre développement.

11. Extraction à l'intérieur d'un AnsiString d'un ou plusieurs caractères

Si vous voulez extraire un seul caractère d'un AnsiString, il suffit d'écrire sa position entre crochets sachant que le premier caractère à le numéro 1. Par exemple CarUnique = Chaine[3] fera que la variable CarUnique contiendra le 3^ème caractère de Chaine, CarUnique et Chaine étant tous deux des AnsiString. Mais si vous voulez extraire une suite de caractères, il faut utiliser la méthode SubString(P,L) où P est la position de départ et L la longueur à partir de cette position. Par exemple SousChaine=Chaine.Substring(3,2) extraira 2 caractères à partir du troisième caractère de la chaîne de caractères. Notons que SousChaine=Chaine[3]+Chaine[4] qui serait censé faire la même chose ne marche pas, le compilateur ne signale pas d'erreur mais le résultat est faux.

Quand vous saisissez le point dans une syntaxe du type Chaine.SubString (le point annonce la méthode), il suffit d'attendre une seconde ou deux, le progiciel vous propose d'office toutes les méthodes possibles dans le contexte. Si cela ne marche pas, appuyez sur le bouton droit de la souris dans une fenêtre de code C et choisissez tout en bas du menu déroulant l'option propriétés, là choisissez l'onglet "audit de code" et cochez la case "achèvement du code", c'est ce flag qui indique qu'on propose au développeur la liste des méthodes disponibles dans le contexte, cliquez sur aide et vous connaîtrez le détail de ces propriétés.

Cette fonction permet de convertir un integer en hexadécimal (base 16) sur un nombre de digits donné. On écrit par exemple VarAS = IntToHex(i,2) signifie que la chaîne AnsiString VarAS contiendra après exécution l'équivalent décimal du nombre entier i sur deux digits, i pouvant aussi être du type char (un char peut toujours être considéré comme un entier). Mais il faut préciser que i est considéré comme étant codifié en complément à 2 (ce qu'oublie de préciser la doc) et donc peut être négatif (bit le plus significatif au 1 logique). Si donc ce nombre entier est négatif, IntToHex l'écrit d'office sur huit chiffres hexadécimaux (i.e. quatre octets). Cela peut provoquer des erreurs. Imaginez un buffer de caractères par exemple char buffer[100] déclarant ainsi une chaîne de 100 caractères c'est-à-dire de 100 octets. Vous voulez afficher en hexadécimal chacune de ces cases mémoire. Chacune à un contenu allant en décimal de -128 à +127 c'est-à-dire en hexadécimal allant de 0x00 à 0XFF. Les valeurs positives peuvent être extraites normalement sur deux chiffres hexadécimaux. Mais, toutes les valeurs négatives c'est-à-dire celles dont le bit le plus significatif est au 1 logique seront transcrites sur 4 octets. Donc le mieux sera de tout extraire sur 4 octets et ensuite d'utiliser un SubString pour extraire de ce résultat les deux derniers caractères c'est-à-dire 2 caractères à partir de la 7^ème position. On écrira donc pour traiter la ième case du buffer HexaDec = IntToHex(Buffer[i],8).SubString (7,2) où HexaDec est un AnsiString qui contiendra après exécution les deux digits hexadécimaux. Vous voyez qu'on applique directement la méthode SubString qui extraie 2 caractères à partir de la 7^ème position de l'AnsiString donné par IntToHex sur 8 chiffres. La logique eût voulu qu'on puisse écrire dans ce cas HexaDec = IntToHex(Buffer[i],2) mais malheureusement ça sera faux pour toutes les valeurs négatives qui donneront non pas deux chiffres comme demandé mais huit. (Bug?).

Attention à ne pas dépasser la longueur de vos buffers. Si vous écrivez au-delà du buffer, vous risquez d'écraser certaines données qui se trouvent par hasard juste après ce buffer mais l'exécution du programme peut très bien continuer encore un peu si ces variables ne sont pas vitales à ce moment-là de l'exécution. Cela dit, tôt ou tard le programme va planter et c'est un des cas où vous avez droit au message "l'application va s'arrêter car elle a exécuté une opération non conforme". Notez que même dans ce cas, C++ Builder garde toujours la main si vous testez sous cet environnement, vous appuyez sur OK et vous retournez à votre source que vous pouvez maintenant vérifier. Si votre programme fonctionnait au moment du dernier test, mettez un point d'arrêt juste avant les lignes rajoutées ou modifiées et faites du pas à pas (une fois arrêté, faites Maj F7 pour exécuter jusqu'à la ligne suivante et continuez ainsi le debug).

À gauche des fenêtres source, vous avez un explorateur de classes que vous pouvez déployer en cliquant sur le petit +. Cela vous donne la structure de votre programme, en cliquant sur une fonction, le curseur se positionne au début de celle-ci dans le source. C'est donc très pratique pour s'y retrouver. Si vous supprimez cet explorateur en cliquant le petit x sur le bord haut de la fenêtre, ce qui vous donne une fenêtre plus grande au moment d'écrire le source, vous pouvez toujours le récupérer via Voir|Explorateur de classes. Pour que les fonctions soient accessibles à partir de cette liste, il faut déclarer leur prototype en début de listing, ce qui d'ailleurs est obligatoire si l'appel est antérieur dans le listing à la fonction elle-même (sinon le compilateur ne connaît pas le prototype de la fonction). Soit par exemple la fonction Essai qui revoie un AnsiString et qui a pour argument un integer et un AnsiString, vous déclarerez au début son prototype à savoir dans ce cas AnsiString Essai(int, AnsiString); le compilateur connaît alors le type du résultat et le type des arguments. La fonction étant dûment déclarée, elle sera accessible à partir de l'explorateur de classes (elle s'écrit d'ailleurs dans l'explorateur en même temps que vous l'écrivez dans le source). Sinon, si vous ne déclarez pas ainsi la fonction (ce qui est possible à condition que vous écriviez la fonction dans le listing avant que vous l'utilisiez par un appel), elle apparaîtra dans l'explorateur de classes mais en cliquant dessus, il ne se passera rien. À vous donc de savoir si vous voulez pouvoir accéder rapidement au code d'une fonction ou non. Pour plus d'informations sur les classes, voyez mon Étude autour des classes du C++.

Si votre programme doit procéder à des initialisations, créez-les au moment de la construction de la fiche principale dont la fonction (automatiquement créée par le logiciel) est facilement reconnaissable par sa syntaxe

__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner);

Cette fonction apparaît d'ailleurs dans l'explorateur de classes. Cliquez dessus et le progiciel positionnera le curseur au début du code de cette fonction qui n'est simplement que déclarée mais qui ne contient rien pour l'instant.

Vous voulez savoir où une variable ou constante a été déclarée, pointez le curseur sur son nom et appuyez sur Ctrl (la touche contrôle). La variable devient une sorte de lien hypertexte, en cliquant sur elle, le curseur pointe exactement la ligne du source où elle a été déclarée. En faisant Ctrl Z (contrôle Z), vous revenez où vous en étiez dans le source. Pratique non?

Si, après avoir cliqué dans le source un point d'arrêt pour débuguer une partie de programme juste après avoir lancé un test par F9 qui exécute l'application en cours de développement, vous avez perdu la fenêtre de l'application en train de s'exécuter (la fenêtre où se trouve le source étant maintenant active puisque vous l'avez sollicitée pour y positionner un point d'arrêt), vous la retrouver facilement en appuyant sur Alt Tab (touche Alt puis Tab). Là, Windows vous propose d'exécuter une autre fenêtre dont il vous indique le nom. Si ce n'est pas celle-là, appuyez de nouveau sur la touche tabulation (Alt étant toujours appuyée) jusqu'à ce que vous tombiez sur le nom de votre application. Cela vous évite d'avoir à modifier l'emplacement des fenêtres qui cache le bas de l'écran où toutes les programmes en cours sont affichés dans de petits rectangles. Si toutefois ces petits rectangles sont visibles, vous cliquez alors directement votre application qui est venue s'ajouter au nombre des programmes en cours.

Pour une fiche donnée, le progiciel vous fournit un premier fichier point cpp (C++). Si ce fichier devient trop grand, le mieux est de diviser en deux ce grand fichier d'origine et donc de créer un autre fichier cpp qui contiendra des routines que vous ne toucherez plus ou pratiquement plus, fichier qu'il faut compiler à part. La marche à suivre est la suivante.

1. faire Fichier|Nouveau et choisissez comme objet un fichier cpp parmi les choix possibles.
2. par défaut, ce nouveau fichier s'appelle file1.cpp, le mieux est de faire maintenant Fichier|Enregistrer sous et de lui donner le nom que vous voulez. Comme vous allez essayer de regrouper des routines ayant une signification globale pertinente, donnez lui un nom en conséquence. Vous venez donc d'enregistrer un nouveau fichier vide cpp.
3. Observez que dans le cpp portant le nom du projet, C++ a automatiquement rajouter le directive USEUNIT avec le nom de ce nouveau cpp source. D'ailleurs si vous faites maintenant Voir|Gestionnaire de projets, vous voyez que ce nouveau fichier fait maintenant partie du projet.
4. Recopier toute l'en-tête du fichier cpp d'origine (il s'agit du fichier crée par C++ Builder au moment de la création de la fiche associée). Il faut recopier la première section contenant tous les fichiers d'include (ou alors si vous voulez peaufiner, ne sélectionnez que les includes dont vous avez besoin dans ce nouveau fichier). De toute façon, il y aura des erreurs à la compilations s'il en manque.
5. Couper toutes les routines concernées par ce transfert et collez-les dans ce nouveau fichier. Normalement, leur prototype a été déclaré au début du fichier d'origine, donc si ce fichier d'origine fait appel à ces routines qui sont maintenant dans l'autre fichier, il n'y aura pas de problème de compilation.
6. Faites maintenant Projet|compiler l'unité. Si vous appelez des routines situées dans l'autre fichier, le compilateur vous le signalera, il suffira alors de déclarer le prototype de ces fonctions. Par exemple vous appelez la routine "essai" de l'autre fichier (celui d'origine à scinder en deux) qui renvoie un entier et qui a deux arguments, un integer long et un pointeur de caractères, vous déclarerez ce prototype ainsi int essai(long int, char*);
7. Ayant compilé cette unité à part sans erreur de compilation, le progiciel vous a créé le fichier point obj correspondant dont a besoin le lieur au moment de la construction de l'exécutable.
8. Faites maintenant Projet|construire (c'est-à-dire créez l'exécutable complet du projet), vous voyez que ça marche parfaitement. Vous avez tout à y gagner car d'une part cela vous évite d'avoir à manipuler des fichiers trop grands et d'autre part, la compilation est plus rapide puisque le nouveau fichier est déjà compilé.
9. Remarque. Les fonctions situées dans ce nouveau fichier ne seront accessibles par l'explorateur de classes qu'après sa première compilation. Cela signifie que si vous cliquez sur une des fonctions visibles dans l'explorateur de classes et appartenant à ce nouveau source C++ pour y positionner le curseur, cela ne fonctionnera qu'après une compilation de ce fichier (si le fichier n'est pas compilé, il ne se passe rien). Notez également que quand vous chargez un développement, C++ Builder ne charge que le fichier source de base i.e. celui qu'il a lui-même créé au moment de la création du projet. Mais si vous cliquez dans l'explorateur de classe sur une fonction qui est dans un autre fichier (celui que vous avez créé pour diviser le source en deux), C++ Builder chargera alors automatiquement ce fichier. C'est évidemment très pratique, vous n'avez pas besoin de savoir dans quel fichier source se trouve une fonction (si votre projet est complexe, il peut bien sûr y en avoir plusieurs et ça deviendrait vite compliqué), vous l'appelez via l'explorateur de classes qui se charge d'ouvrir le bon source mais encore une fois, cela ne fonctionne qu'après une première compilation de ce nouveau source. Il faut signaler que dans certains cas, l'explorateur de classes ne trouve pas la fonction bien qu'il soit dûment déclarée, il semble qu'il y ait un bug à ce niveau.
10. Autre remarque. Pour tester certaines syntaxes C que vous maîtrisez mal, vous pouvez toujours vous créer une sorte de brouillon.cpp isolé que vous pouvez compiler à part juste pour vérifier une syntaxe. De toute façon, il est bon d'avoir un répertoire de travail qui contient une copie temporaire de votre développement pour des tests spécifiques sans risque de toucher votre original. Une fois votre algorithme éprouvé, vous allez dans votre répertoire officiel que vous mettez à jour de ces nouveautés par un copier-coller judicieux.

Après avoir chargé votre projet (si vous travaillez toujours sur le même, utilisez Fichier|Réouvrir et une fois le menu déroulant actif, appuyez sur la touche 0), vous pouvez visualiser tous les sources liés à ce projet en faisant Voir|Gestionnaire de projet. C'est très pratique notamment quand vous avez différentes variantes pour savoir où vous en êtes. En effet, quand vous utilisez la fonction Enregistrer sous, c'est ce nouveau fichier qui devient actif, l'ancien ne fait plus partie du projet mais le fichier existe toujours. Si vous voulez revenir à l'ancienne version, il faut alors utiliser les fonctions Projet|retirer du projet (là vous supprimez le source dont vous ne voulez plus) puis Projet|ajouter au projet (là vous remettez en service l'ancien source). Si vous ne savez plus où vous en êtes suite à plusieurs de ces changements, utilisez la fonction Voir|Gestionnaire de projet qui vous indiquera clairement les fichiers impliqués à ce moment-là.

Pour aller vite, la meilleure façon est d'aller très lentement, de penser profondément les choses, de les structurer, de les maîtriser. Cioran disait "toute forme de hâte trahit quelque dérangement mental". Festina lente, hâte-toi lentement disaient les anciens. L'extrême lenteur est une sorte de vitesse absolue, vous vous en rendrez compte en en tentant l'expérience dans ce monde de suante précipitation. Ayez aussi cet adage en tête : suus cuique diei sufficit labor (à chaque jour suffit sa peine) c'est-à-dire n'essayez pas de tout faire en une seule fois. L'important est simplement d'avancer dans votre projet, non pas avancer vite mais simplement avancer. À ce sujet, il est très bon d'utiliser la fonction "ajouter un élément A faire" via Maj Ctrl T (vous appuyez simultanément sur Majuscule, Contrôle et la lettre T) ou encore, en cliquant sur le bouton droit de la souris, un menu déroulant apparaît où cette fonction est disponible. La principe est simple. Vous positionnez votre curseur à un endroit du listing où vous avez quelque chose à faire et à ne pas oublier. Vous appelez cette fonction et vous écrivez un petit mémo en style télégraphique rappelant brièvement ce qu'il y a à faire. Le texte ainsi saisi est écrit en commentaire dans votre source mais de plus son endroit dans le source est mémorisé par le progiciel. Ensuite, revenant à votre projet le lendemain, vous cliquez Voir|Liste à faire, toutes les occurrences de ce genre apparaissent, il suffit de cliquer sur l'une d'entre elles pour y accéder, C++ Builder charge le source cpp si ce n'est déjà fait et vous présente l'endroit du source où il y a ce commentaire et où il faut rajouter quelque chose. Vous pouvez aussi assigner un priorité, une catégorie (c'est une chaîne de caractères qui contient un code à vous) etc. Donc avant de fermer votre projet après une journée de travail, notez par un texte du type "A faire" l'idée que vous aviez, c'est très utile. Pour supprimer un élément de cette liste, vous avez le choix entre le supprimer dans le listing ou de visionner cette liste, de sélectionner l'occurrence à supprimer et d'appuyer sur la touche Suppr du clavier.

Je fais une légère déviation vers le C pur car les syntaxes de malloc sont assez difficiles et l'aide en ligne ne donne qu'un tout petit exemple.

Quand vous devez déclarer un tableau dont vous ignorez la longueur (la longueur va dépendre d'une donnée que vous ignorez au moment du développement soit par exemple une saisie de l'utilisateur au clavier soit suite au chargement d'un fichier etc.), il est préférable d'utiliser la fonction C malloc (memory allocation). Mais il faut se souvenir que malloc non seulement réserve l'emplacement mémoire demandé et d'autre part initialise un pointeur (c'est toujours un pointeur donc vous devez avoir le signe *) qui pointe le premier élément de cette structure. Par exemple vous ouvrez le fichier N (N étant un AnsiString qui contient le chemin d'accès et le nom du fichier, MES également qui contiendra un message d'erreur le cas échéant, Fichier est du type FILE*)

Notez que le fichier a été ouvert ici en mode r+b, cela signifie d'une part en lecture écriture (r pour read et + pour possibilité d'ajout) et d'autre part en binaire, cela signifie qu'on considère que c'est une suite d'octets. Voyez la documentation pour plus d'information sur la manière d'ouvrir les fichiers (vous mettez votre curseur devant fopen et vous faites F1, c'est l'aide en ligne).

Ensuite vous interrogez les stats pour connaître la longueur de ce fichier N, par exemple :

Cette syntaxe suppose d'une part que vous ayez déclaré au début du source l'include sys\stat.h ainsi : #include <sys\stat.h> et d'autre part que vous ayez déclaré statbuf (nom de variable arbitraire que je choisis) qui résulte de la structure officielle des statistiques de fichiers, on le déclare ainsi : struct stat statbuf;

Dans ces conditions stat (N.c_str(), &statbuf) signifie que vous demandez de mettre à jour dans la structure statbuf les renseignements concernant le fichier N. Ces statistiques étant maintenant en mémoire, on peut les lire notamment la longueur du fichier (mais bien d'autres choses, voyez l'aide en ligne). On a donc écrit LongFic = statbuf.st_size, LongFic est donc maintenant égal à la longueur du fichier en nombre d'octets que l'on a ouvert. Si maintenant on veut lire ce fichier en mémoire, il faut réserver une place de LongFic octets que l'on ne peut pas connaître à l'avance. Donc on utilise malloc qui va allouer LongFic octets. Il est bon de tester LongFic qui ne doit pas être nul sinon cela signifie que le fichier est vide :

Remarquez que if(!a) équivaut à if(a==0), de même if(a) équivaut à if(a!=0). Un moyen mnémotechnique consiste à se souvenir que "non nul" c'est "quelque chose" et que "nul" c'est "rien". Ainsi while(a) signifiera "tant que a vaut quelque chose" et while(!a) "tant que a ne vaut pas quelque chose" et donc "tant que a est nul".

On suppose avoir préalablement déclaré un pointeur de caractères au début du programme (ou au début de la fonction) par exemple char* PtrFic; PtrFic est donc un pointeur qui pointe un élément ou une suite d'éléments du type char.

Il faut donc maintenant réserver une zone mémoire de LongFic octets à partir de ce pointeur. On utilise malloc et l'on écrit :

Notez que si LongFic est nul, cela revient à demander 0 octet via malloc qui renvoie logiquement NULL. C'est pourquoi nous avons écarté ce cas précédemment, à ce stade du programme on sait que LongFic est non nul.

Remarquez aussi la façon de concaténer les chaînes de caractères. On écrit entre quotes une première chaîne puis une deuxième à la ligne suivante et ainsi de suite. Cela évite d'avoir des lignes trop grandes. Le compilateur comprend qu'il s'agit d'une seule et même chaîne.

La fonction C malloc renvoie NULL si la demande d'allocation mémoire a échoué. Cela n'arrive pratiquement jamais avec nos ordinateurs d'aujourd'hui dotés de 64 voire 128 MO mais c'est toujours possible si l'utilisateur a ouvert trop d'applications en même temps. De toute façon il faut toujours tester un code retour pour une bonne qualité de programme, c'est ce qu'on appelle la programmation paranoïaque (defensive programmation), c'est le seul cas où il est excellent d'être parano. Faites attention au nombre et à la place des parenthèses. Si l'allocation a réussi, PtrFic pointe le premier octet d'une zone mémoire de LongFic octets. Dans ces conditions on peut lire le fichier en une seule fois ainsi :

où NbData est un unsigned long int. Comme la fonction fread renvoie le nombre d'octets effectivement lus, il suffit de comparer le nombre d'octets à lire (ici LongFic) au nombre d'octets effectivement lus (ici NbData) pour savoir si la lecture s'est bien passée. Voyez l'aide en ligne pour le détail de fread. Vous accédez à chacun de ces octets en mettant entre crochets son numéro d'ordre qui ira de 0 à LongFic - 1, par exemple PtrFic[i] est le ième octet pointé par PtrFic, i étant un unsigned long int (codé sur 4 octets donc sur 32 bits).

Pour libérer cette mémoire allouée, il faudra écrire free(PtrFic);

Il faut se souvenir que malloc renvoie toujours un pointeur qui pointe le premier élément d'un série d'éléments d'un certain type. Par exemple, vous voulez allouer à partir d'un pointeur d'unsigned long int Longueur (nom arbitraire de ce pointeur) une zone mémoire de NbULI unsigned long int, vous écrirez :

Dans cet exemple si la mémoire n'a pu être allouée, le pointeur est égal à NULL et il y aura ici retour de la fonction sinon on continue. Notez que cette écriture suppose que vous ayez déclaré au début (ou quelque part avant l'appel à malloc) la variable Longueur comme pointeur sur un unsigned long int ainsi :

unsigned long int* Longueur;

Notez que malloc peut être utilisé au moment de la déclaration d'une variable, par exemple :

char* P=(char*)malloc(1000);

Le compilateur C de C++ Builder exige que l'on reprécise clairement au moment du malloc le type char* même dans ce cas bien qu'il y ait redondance. La réservation mémoire est tellement dérisoire que le code retour du malloc n'est pas testé dans ce cas. Cette instruction réserve une zone de mille octets à partir de l'adresse P et est équivalente à char P[1000] si ce n'est que cette dernière notation ne permettra pas par la suite la possibilité d'une réallocation via realloc.

Supposons qu'on déclare la structure suivante :

struct StructureEssai

Cette structure contient trois éléments, un caractère CAR et deux entiers N1 et N2. StructureEssai est le nom de ce type de structure et STE une variable de ce type. Vous n'êtes pas tenu de déclarer ces deux éléments. Si vous ne voulez qu'une seule variable de ce genre, la structure n'a alors pas besoin de nom et il vous suffit d'écrire :

Si vous n'avez pas besoin de variable mais seulement de la déclaration de la structure, vous écrirez :

auquel cas la structure n'existe qu'à titre de prototype.

Si vous déclarez la variable STE (nom arbitraire, structure essai), vous accédez au caractère de cette structure STE par la syntaxe STE.CAR et aux entiers via STE.N1 et STE.N2. Remarquez le point qui sert à désigner un des éléments de la structure.

On veut maintenant déclarer via malloc une zone mémoire d'une longueur de NBS fois cette structure (NBS étant un nombre arbitraire non connu à l'avance, NBS est le nom arbitraire de cette variable pour nombre de structures) avec un pointeur qui de pointera la première structure de la série. Dans ce cas, la variable STE ne vous sert à rien, vous n'avez besoin que du prototype de la structure.

On déclare le pointeur ainsi :

StructureEssai* PointeurStruc;

PointeurStruc est donc un pointeur qui pointe un élément de type StructureEssai.

On réserve via malloc la mémoire ainsi :

D'une part vous allouez NBS fois une structure de longueur StructureEssai et d'autre part PointeurStruc pointe le premier élément de cette structure.

Soit i un entier non signé (unsigned int ou unsigned long int) compris entre 0 et NBS-1,

PointeurStruc[i].Car sera le caractère de la ième structure,

PointeurStruc[i].N1 sera le premier int de la ième structure,

PointeurStruc[i].N2 sera le deuxième int de la ième structure,

avec toujours ce fameux point pour accéder à un élément de la ième structure.

Notez que si vous déclarez la variable STE comme c'est possible (revoir plus haut dans ce même alinéa les différentes possibilités de déclaration), vous pouvez alors lire en une seule fois la ième structure ainsi : STE = PointeurStruc[i]; et dans ce cas vous accédez au caractère de la structure STE qui vient d'être lue par la syntaxe STE.CAR et aux entiers via STE.N1 et STE.N2 comme nous le disions déjà plus haut.

Si vous déclarez un tableau de pointeurs vers ces structures par exemple StructureEssai* PointeurStruc[50]; qui déclare un tableau de 50 pointeurs vers une structure de type StructureEssai, vous déclarerez la kème allocation mémoire via malloc par :

k étant supposé compris entre 0 et 49 puisque dans notre exemple nous déclarons 50 pointeurs vers une structure (les autres variables ont la même signification que précédemment).

Dans ce cas, pour accéder au caractère de la ième structure de la kème série de structures il faudra écrire : PointeurStruc[k][i].CAR; où il faut bien sûr remarquer les deux doubles crochets, le premier invoque le kème pointeur, il pointe donc la kème série de structures de ce type et le second la ième structure de cette série numéro k, la bonne structure étant maintenant pointée, on complète par le point et le nom de l'élément à invoquer ici CAR.

Quand une zone mémoire allouée par malloc s'avère insuffisante dans la contexte, on réalloue cette mémoire via l'instruction standard C realloc mais il ne faut pas oublier que realloc renvoie la nouvelle position du pointeur qu'il faut assigner au pointeur courant. Par exemple vous avez besoin d'une zone mémoire de bloc octets, bloc étant une constante arbitraire du programme initialisée ainsi : const int bloc = 1000; Vous avez déclaré un pointeur P sur une chaîne de caractères ainsi char* P; vous initialisez la longueur de la zone LZ à bloc (LZ = bloc; LZ étant un unsigned int) et vous déclarez une zone de LZ octets via malloc pointée par P :

P = (char*) malloc (LZ);

À ce stade du programme P pointe le premier octet d'une zone de LZ octets. Un offset o initialisé à 0 naviguera dans cette mémoire et y écrira via une syntaxe du type P[o] = aliquid; (le oème octet pointé par P prend la valeur aliquid, comme c'est un octet, aliquid ira de 0 à 255 ou de -128 à +127 si vous êtes en signé). Mais quand o, suite à une incrémentation sera égal à LZ, il sera hors zone (la zone ne va que de 0 à LZ-1), il faudra donc réallouer la mémoire pour l'agrandir et y ajouter par exemple un bloc à cette zone, on écrira donc :

ou encore en une seule ligne :

P=(char*) realloc(P,LZ+=bloc);

Notez bien cette syntaxe du realloc qui a deux arguments, pointeur et longueur et qui renvoie la nouvelle position du pointeur après réallocation. La longueur de la zone LZ toujours pointée par P est rallongée de bloc octets (première instruction) et P pointe maintenant cette nouvelle zone mémoire plus longue de bloc octets. Si P==NULL après ce realloc, la réallocation a échoué, cela devrait ne jamais se produire mais s'il faut toujours tester un code retour par sécurité (programmation paranoïaque). Il se peut que P n'ait pas bougé de position s'il se trouve possible à ce moment-là du point de vue du système de rallonger la zone sans ce changement mais il se peut tout aussi bien que P ait complètement changé de position dans la mémoire. Cela ne vous regarde en rien, le programme continue comme si de rien n'était, toutes vos données sont bien sûr conservées mais la nouvelle zone est maintenant plus grande. On peut faire autant de realloc que l'on veut. Dans tous les cas, ne pas oublier de libérer la mémoire après utilisation via free(P);

La nouvelle réservation peut aussi être plus petite que l'ancienne (utilisation probablement rare mais possible), dans ce cas, seule la section commençante des données de l'ancienne zone est disponible dans la nouvelle.

La fonction realloc est très utile quand on ne sait pas à l'avance combien de mémoire sera nécessaire. On procède alors par blocs. Un premier malloc crée une première réservation. On surveille de près l'offset d'accès en lecture-écriture, dès que cet offset est hors zone, on agrandit alors l'allocation via realloc en testant le code retour (si le pointeur est égal à NULL, il y a échec de l'allocation et donc probablement arrêt pur et simple du programme qui ne peut pas continuer). Si vous y allez par incrémentation, l'offset est hors zone dès qu'il est exactement égal à la longueur de la zone, si o est cet offset et LZ la longueur réservée à un moment donné, o ne pourra aller que de 0 à LZ-1, dès que o = LZ il est en dehors de la zone, a fortiori si o > LZ, et c'est à ce moment-là qu'une réallocation peut s'avérer nécessaire dans le contexte.

Quand vous ne voulez pas considérer le complément à deux d'une valeur binaire, il faut faire la précision unsigned au moment de sa déclaration. Par exemple un élément du type char est un octet. Par défaut il sera considéré comme signé (si toutefois vous considérez ce char comme un entier ce qui est toujours possible) si vous ne faites aucune précision c'est-à-dire qu'on ira de -128 à +127. Si vous ne voulez pas de ce signe il faut le préciser par le mot clé unsigned, par exemple :

unsigned char C;

C est donc un unsigned de type char (octet unique), on ira donc de 0 à 255 puisque le signe est ignoré.

Il en va de même pour les int (sur 2 octets) et les long int (sur 4 octets). Par exemple, dans un alinéa précédent, vous écrivions PointeurStruc[i]Car pour accéder au caractère de la ième structure, il est évident que i est un unsigned, il faut donc le déclarer ainsi :

unsigned int i;

Ainsi on ira sur 16 bits de 0 à 65535 (sinon, si cette précision n'avait pas été faite, le nombre aurait été considéré comme codifié en complément à 2 et l'on irait de -32768 à +32767). Si votre zone mémoire contient un nombre de structures inférieur ou égal à 32767, ça marcherait quand même puisque dans ce cas le nombre serait toujours positif même en considérant le complément à deux mais à partir de 32768 et en l'absence de la précision unsigned, le programme considérerait que i est négatif, vous pointeriez donc n'importe où dans la mémoire. Le mieux est donc de toujours préciser unsigned et même, pour les zones mémoire dont vous ignorez la longueur mais qui peuvent être assez grande, d'utiliser un unsigned long int, le pointeur d'éléments est alors codifié sur 4 octets donc sur 32 bits, vous êtes ainsi sûr de pointer toujours correctement la mémoire sans surprise par une possibilité de nombres négatifs.

Ce signe s'utilise pour exprimer un pointeur qui pointe un élément d'un certain type, par exemple

char * P;

Cette notation signifie que P est un pointeur sur un élément de type caractère, on peut aussi considérer que P pointe le premier caractère d'une chaîne de caractères ou encore le premier octet d'une série d'octets, c'est le contexte du programme qui le dira. De façon assez curieuse dans cette notation, l'étoile "appartient" plus au pointeur P qu'au type char, c'est une convention arbitraire même si cela peut paraître inattendu. Cela se voit quand vous avez à déclarer deux pointeurs P1 et P2, il faut écrire char *P1, *P2; où l'étoile a dû être répétée car la notation char *P1, P2; déclarerait non pas deux pointeurs mais un pointeur P1 et un caractère P2. Avec la première déclaration, vous pourriez écrire dans le cours du programme P1 = P2 ce qui signifie que le pointeur P1 prend la position du pointeur P2 mais cette possibilité serait interdite avec la deuxième déclaration car alors le compilateur vous dira qu'il ne peut convertir un char* en char.

En revanche, quand vous déclarez le prototype d'une fonction, le type char* se met à exister. Imaginons une fonction ESSAI qui renvoie un entier et qui a pour argument un pointeur sur octets ou sur caractères. Le prototype de cette fonction se déclarera ainsi int ESSAI(char*); où l'étoile "appartient" cette fois-ci au type char et non à une variable qui d'ailleurs n'est pas mentionnée. L'étoile appartient donc à la variable au moment de la déclaration d'un pointeur mais au type au moment de la déclaration d'un prototype.

Notez également la quasi-équivalence qu'il y a entre les notations * et [ ], étoile et crochets. L'exemple précédent pourrait tout aussi bien être déclaré par int ESSAI(char[ ]); il en est de même au moment de l'appel de la fonction, vous pouvez aussi bien écrire nombre_entier = ESSAI(char* P) que nombre_entier = ESSAI(char P[ ]); ces deux écritures sont équivalentes du point de vue du compilateur et du fonctionnement du programme. En revanche le compilateur refusera les crochets au moment de la déclaration de la variable, la notation par étoile est alors nécessaire par exemple

char *P;

Si vous voulez changer de police de caractères pour l'affichage de votre code, cliquez sur le bouton droit de la souris dans un fenêtre de code C puis choisissez l'option propriétés tout en bas du menu déroulant. Là, sélectionnez l'onglet affichage. C'est dans ce menu que vous décidez de votre police et de sa taille pour l'affichage du source. Il semble que la police proposée par défaut (courrier New taille 9) soit excellente pour du code C, les lignes sont ainsi assez longues, les italiques des commentaires entre les signes /* et */ (ou après le signe // pour un commentaire monoligne) sont très lisibles et les caractères gras des mots clés bien prononcés mais sans excès.

La recherche d'une chaîne de caractères dans le source se fait via Ctrl F (contrôle F, Find). Après avoir saisi le mot recherché et validé par OK, le curseur se positionne sur la première occurrence trouvée et la fenêtre appelée par Ctrl F disparaît. Pour trouver l'occurrence suivante, faites F3 (et F3 à nouveau pour la suivante etc.). Si vous recherchez un mot qui se trouve à l'écran, positionnez le curseur dessus (ou juste avant) puis faites Ctrl F, le mot visé est déjà écrit dans la zone de recherche du formulaire, ce qui vous en épargne la saisie.

On utilise deux fois le signe * (étoile) pour déclarer un pointeur de pointeurs. Imaginons que vous vouliez réserver NZM zones mémoire à chaque fois de longueur variable parce leur longueur dépend du contexte informatique (e.g. chargement de fichiers) ou humain (e.g. entrée de données au clavier). NZM n'est pas connu à l'avance, il faut donc, une fois ce nombre connu réserver une zone qui contiendra NZM pointeurs. En premier lieu on déclare un pointeur de pointeurs PP ainsi :

À ce stade, vous disposez que NZM pointeurs, PP[0], PP[1] etc. jusqu'à PP[NZM-1].

Pour chacun de ces pointeurs PP[i], vous allez devoir réserver une zone mémoire de bloc octets (bloc étant soit une constante définie par vous soit un nombre positif quelconque même assez grand). La fonction test ESSAI ci-dessous procède à ces déclarations et remplit arbitrairement la mémoire allouée puis fait une réallocation. Ce type de remplissage n'a d'autre but que de montrer que la zone mémoire est bien accessible.

Si l’augmentation d’une zone mémoire via la fonction realloc se fait à l’intérieur d’une fonction, il faut alors déclarer le pointeur de la zone mémoire en référence grâce à l’opérateur & et ce, parce que realloc peut modifier la position du pointeur. Il faut donc que le programme appelant récupère cette nouvelle valeur en cas de changement. C'est un des avantages du C++ à savoir l'utilisation de ce signe qui, à lui seul, exprime la référence. En C pur, la référence était plus difficile à exprimer. Si par exemple on voulait qu'un entier i soit du type référence dans une fonction C, il fallait prendre trois précautions :

1. Déclarer que l'argument de la fonction est int* (pointeur sur un entier)
2. appeler la fonction en utilisant &i comme argument.
3. Affecter (*i) dans la fonction elle-même.

C++ a apporté une grande simplification à cette problématique puisque vous n'aurez qu'à déclarer non plus i mais &i, l'opérateur & à lui seul exprime la référence. Notez qu'il y a donc en C++ un dual relativement à la référence puisque l'ancienne syntaxe est tout à fait possible (C++ intégrant la totalité des notations C).

Imaginons un programme qui déclare une zone mémoire de bloc octets, bloc étant une constante arbitraire, et qui va écrire très longtemps dans cette zone mémoire et l’allonger dès que nécessaire. On initialise un entier LZ (longueur de la zone) à bloc qui est bien la première longueur de cette zone. On écrit dans cette zone mémoire réservée en la pointant par incrémentation d’un offset. Dès que cet offset est égal à LZ, il pointe le premier octet hors zone, on décide alors d’augmenter la zone de bloc octets par la fonction booléenne ALLOC qui renvoie « true » si l’allocation a réussi, « false » en cas d’échec et qui a deux arguments, le pointeur envoyé par référence avec l’opérateur & et la nouvelle longueur de réallocation.

Remarquez bien sûr la concision de la syntaxe. P pointe la nouvelle adresse de la réallocation et est en même temps comparé à !=NULL. Si c’est vrai (true), le pointeur ne pointe pas NULL après le realloc ce qui signifie que l’allocation a réussi, sinon, si P pointe NULL, l’allocation a échoué. On peut donc considérer que la fonction booléenne ALLOC répond à la question : la réallocation mémoire a-t-elle réussi ? true oui, false non.

Si cette précaution n’avait pas été prise à savoir celle de déclarer le pointeur par référence avec la syntaxe char *&P, la nouvelle position en cas de changement de position mémoire du realloc ne serait pas transmise au programme appelant, par conséquent ça ne pourrait jamais marcher car le pointeur pointerait n’importe où après un changement de position de cette zone. Ça ne marcherait qu'aussi longtemps que la réallocation se situerait par hasard au même endroit. Faites-en l’expérience en supprimant le signe & aussi bien dans le prototype que dans la fonction. Durant l’exécution, vous aurez très vite le message « une erreur d’application s’est produite, violation d’accès etc. » et ce, parce que la zone mémoire allouée a changé d’adresse à un moment donné alors que Pointeur pointe toujours l’ancienne adresse, laquelle n’est plus d’aucune utilité. L'instruction d'écriture en mémoire Pointeur[i++]='a' est alors fautive car on pointe n'importe où.

Dans cet exemple, la variable Pointeur du programme appelant est transmise à P de la fonction par référence c’est-à-dire par l’adresse mémoire de ce pointeur. Comme ce contenu de la mémoire est modifié par le realloc, ce nouveau contenu est comme retransmis à la variable Pointeur du programme appelant.

Il est toujours très important de savoir si une variable, argument d’une fonction, doit être retournée ou non à l’appelant. Si non, on n’écrit que le nom de la variable, si oui, on préfixe le nom de cette variable par l’opérateur &. Dans le premier cas, la fonction travaille avec une copie de la variable, son contenu à l’issue de l’exécution n’est pas retransmis à l’appelant. Dans le second cas, on donne à la fonction non pas la variable mais son adresse mémoire (c’est la signification de l’opérateur &). Si donc la fonction écrit dans cette mémoire, ce contenu sera logiquement répercuté par la variable de l’appelant qui pointe précisément cette mémoire.