furax13
Messages postés90Date d'inscriptionmardi 28 octobre 2003StatutMembreDernière intervention24 avril 2008
-
1 août 2006 à 09:25
furax13
Messages postés90Date d'inscriptionmardi 28 octobre 2003StatutMembreDernière intervention24 avril 2008
-
2 août 2006 à 09:16
bonjour,
j'ai plusieurs classes à créer en delphi.
classe optimisationattributs<?xml:namespace prefix o ns "urn:schemas-microsoft-com:office:office" /??>
Integer Type
Integer Mode
string texture
Integer nbContraintes
COContrainte** pListecontraintes
Integer nbCoils
CMCoil* pListeCoil
pTableauIndicateurEtatDesPhasesRefroidissement;
classe COContrainte
attributs
integer Type
string Nom
double temps
Integer validite
Integer nbIteration
Integer nbIterationMaxTolere
Integer numeroCoil
COOptimisation* pOptim
classe CMCoil
attribut
string nom
string texture
double masse
double diametre
double epaisseur
double largeur
string typeOptimisation
COOptimisation* pOptim
J'ai créé la classe suivante :
CMCoil = class(Tobject)
private
FMasse: Double;
FDiametre: Double;
FEpaisseur: Double;
FLargeur: Double;
FNomBobine: string;
FTypeOptimisation: string;
FTexture: string;
end;
comment préciser que l'objet COContrainte pointe sur la classe COOptimisation?
comment dire que la classe COOptimisation est constituée d'une liste de CMCoil et de COContraintes?
Pour créer mes classes, existe-il une méthode pour créer automatiquement les assesseurs d'un attribut de classe? (les get et les set)
f0xi
Messages postés4205Date d'inscriptionsamedi 16 octobre 2004StatutModérateurDernière intervention12 mars 202235 1 août 2006 à 14:12
Il y a une difference entre Pointé et Herité ...
comme le dis cirec pour l'heritage c'est simple :
TNouvelleClasseHerite = class(TClasseAncetre);
ensuite ici tu n'a pas completer tes classes correctement.
Private determine des variables et methodes privées accessible uniquement dans cette classe.
il faut donc declarer des propriétés grace au mots reservé "Property" dans une zone Public et/ou Published.
pour cela, tu dois connaitre la difference entre ces zones (Private, Protected, Public, Published)
ce n'est pas bien compliqué, l'aide delphi explique cela trés bien.
deja, vus que tes classes font appel a des types que tu n'a pas encore créés, il faut declarer d'abord ceci :
type
CMCoil = class;
COOptimisation = class;
COContrainte = class;
ce qui permet de forwardé les identifiants de classes avant meme de les declarer.
et donc par exemple, CMCoil peut contenir sans probleme une variable de type COContrainte ou COOptimisation.
ensuite
COContrainte** pListecontraintes
CMCoil* pListeCoil
COOptimisation* pOptim
determine
un pointeur sur tableau d'objet ... il faut donc créer ces types :
pListeContraintes = ^TListeContraintes;
TListeContraintes = array of TCOContrainte;
pListeCoil = ^TListeCoil;
TListeCoil = array of TCMCoil;
pListeOptim = ^TListeOptim
TListeOptim = array of TCOOptimisation;
le mieux serait d'utiliser des TList pour les Liste ... ça ce fait en quelque minutes ...
soit :
type
TListeContrainte = class(TList);
TListeCoil = class(TList);
TListeOptim = class(TList);
ce qui permet de gere les objets aussi facilement qu'avec un listbox.
on peu egalement ajouter des fonctions Add, Delete, LoadFromFile, SaveToFile dans les objets TList pour eviter de travailler directement avec les pointeurs et pour sauvegarder le travail.
par contre, cela necessite de tout coder ... mais au final ca faciliteras l'utilisation.
pour les propriétés dans les classes, plusieurs cas possible, exemple :
(rappel : D'une maniere generale on utilise pour les flottants :
Single (precision correcte a 4 .. 6 decimale)
Extended (grande precision a +12 decimale)
les types real, double sont a proscrire )
- propriété publique en R/W sans methodes appliquées :
ici on ecrit directement dans fMasse.
property Masse : single read fMasse write fMasse;
- propriété publique en RO sans methodes appliquées :
on ne peu que la lire.
property Masse : single read fMasse;
- propriété publique en R/W avec methode appliquées :
ici la valeur assignée a Masse est d'abord soumise a la methode fSetMasse,
la valeur assignée a fMasse est soumise a fGetMasse avant d'etre retransmise a
Masse lors de la lecture de cette derniere.
cela permet de declancher des evenements, de verifier l'interval, d'appliquer
des formules ect... ect... certains type et notement les type objets sont obligatoirement
a declarer de cette façon dés lors ou il sont créer par cette classe (TStrings, TBitmaps
etc...)
CONSTRUCTOR COOptimisation.creation(modeOptim, nbBobines, nbConstraints: integer; textur: STRING; typeOptim: integer; nomOptim: STRING);
VAR
I : integer;
fconstraints : COContrainte;
BEGIN
//construction de l'objet fOptimisation
fOptimisation := create;
WITH fOptimisation DO
BEGIN
setMode(modeOptim);
setNbcoils(nbBobines);
setNbContraintes(nbConstraints);
setTexture(textur);
setTypeOptimisation(typeOptim);
setNomTypeOptimisation(nomOptim);
END;
IF nbConstraints > 0 THEN
BEGIN
fOptimisation.AlloueListeContraintes(nbConstraints);
FOR I := 0 TO nbConstraints - 1 DO
BEGIN
fconstraints := COContrainte.creation(15, 'nameManu' + IntTOStr(i), 254.12, 0, 100 + i, 200 + i, 1);
fOptimisation.setcontrainteParindex(I, fconstraints);
END;
END
ELSE
ShowMessage('Pas de contraintes associées.');
END;
FUNCTION COOptimisation.getContrainteParIndex(valeur: integer): COContrainte;
BEGIN
IF ((valeur >= 0) AND (valeur < NbContraintes)) THEN
BEGIN
Result := FContrainte[valeur];
END;
END;
PROCEDURE COOptimisation.AlloueListeContraintes(valeur: integer);
BEGIN
setlength(FContrainte, valeur);
END;
PROCEDURE COOptimisation.setContrainteParIndex(valeur: integer; constraint: COContrainte);
BEGIN
IF ((valeur >= 0) AND (valeur < NbContraintes)) THEN
BEGIN
self.FContrainte[valeur] := constraint;
END;
END;
FUNCTION COOptimisation.getMode: integer;
BEGIN
Result := FMode;
END;
PROCEDURE COOptimisation.setMode(valeur: integer);
BEGIN
FMode := valeur;
END;
FUNCTION COOptimisation.getNbcoils: integer;
BEGIN
Result := FNbcoils;
END;
PROCEDURE COOptimisation.setNbcoils(valeur: integer);
BEGIN
FNbcoils := valeur;
END;
FUNCTION COOptimisation.getNbContraintes: integer;
BEGIN
Result := FNbContraintes;
END;
PROCEDURE COOptimisation.setNbContraintes(valeur: integer);
BEGIN
FNbContraintes := valeur;
END;
FUNCTION COOptimisation.getTexture: STRING;
BEGIN
Result := FTexture;
END;
PROCEDURE COOptimisation.setTexture(valeur: STRING);
BEGIN
FTexture := valeur;
END;
FUNCTION COOptimisation.getTypeOptimisation: integer;
BEGIN
Result := FTypeOptimisation;
END;
PROCEDURE COOptimisation.setTypeOptimisation(valeur: integer);
BEGIN
FTypeOptimisation := valeur;
END;
FUNCTION COOptimisation.getNomTypeOptimisation: STRING;
BEGIN
Result := FNomTypeOptimisation;
END;
PROCEDURE COOptimisation.setNomTypeOptimisation(valeur: STRING);
BEGIN
FNomTypeOptimisation := valeur;
END;
CONSTRUCTOR COContrainte.creation(typeConstraint: integer; name: STRING; time: double;
validity, nbIter, nbMaxIter, noCoil: integer);
BEGIN
//construction de l'objet fOptimisation
fconstraints := create;
WITH fconstraints DO
BEGIN
setTypeContrainte(typeConstraint);
setNomContrainte(name);
setTemps(time);
setValidite(validity);
setNbIteration(nbIter);
setNbIterationMaxTolere(nbMaxIter);
setNumeroCoil(noCoil);
END;
END;
FUNCTION COContrainte.getTypeContrainte: integer;
BEGIN
Result := FTypeContrainte;
END;
PROCEDURE COContrainte.setTypeContrainte(valeur: integer);
BEGIN
FTypeContrainte := valeur;
END;
FUNCTION COContrainte.getNomContrainte: STRING;
BEGIN
Result := FNomContrainte;
END;
PROCEDURE COContrainte.setNomContrainte(valeur: STRING);
BEGIN
FNomContrainte := valeur;
END;
FUNCTION COContrainte.getTemps: double;
BEGIN
Result := FTemps;
END;
PROCEDURE COContrainte.setTemps(valeur: double);
BEGIN
FTemps := valeur;
END;
FUNCTION COContrainte.getValidite: integer;
BEGIN
Result := FValidite;
END;
PROCEDURE COContrainte.setValidite(valeur: integer);
BEGIN
FValidite := valeur;
END;
FUNCTION COContrainte.getNumeroCoil: integer;
BEGIN
Result := FNumeroCoil;
END;
PROCEDURE COContrainte.setNumeroCoil(valeur: integer);
BEGIN
FNumeroCoil := valeur;
END;
FUNCTION COContrainte.getNbIteration: integer;
BEGIN
Result := FNbIteration;
END;
PROCEDURE COContrainte.setNbIteration(valeur: integer);
BEGIN
FNbIteration := valeur;
END;
FUNCTION COContrainte.getNbIterationMaxTolere: integer;
BEGIN
Result := FNbIterationMaxTolere;
END;
PROCEDURE COContrainte.setNbIterationMaxTolere(valeur: integer);
BEGIN
FNbIterationMaxTolere := valeur;
END;
END.
Pour tester, j'ai fait ce petit bout de code :
dans unit1.pas
VAR
fOptimisation : COOptimisation;
PROCEDURE TForm1.FormCreate(Sender: TObject);
VAR
i : integer;
contrainteCourante : COContrainte;
nbTrouveContraintes : integer;
BEGIN
//construction de l'objet fOptimisation
fOptimisation := COOptimisation.creation(1, 4, 10, '415', 4, 'DoublePenteBreme');
//destruction de l'objet fOptimisation
nbTrouveContraintes := fOptimisation.getNbContraintes;
FOR i := 0 TO nbTrouveContraintes - 1 DO
BEGIN
contrainteCourante := fOptimisation.getContrainteParIndex(I);
contrainteCourante.destroy;
END;
fOptimisation.setNbContraintes(0);
fOptimisation.Destroy;
END;
je vais lire attentivement les dernières remarques qui semblent répondre exactement à mon besoin.
Vous n’avez pas trouvé la réponse que vous recherchez ?
CONSTRUCTOR COOptimisation.creation(modeOptim, nbBobines, nbConstraints: integer; textur: STRING; typeOptim: integer; nomOptim: STRING);
VAR
I : integer;
BEGIN
//construction de l'objet fOptimisation
inherited create;
WITH self DO
BEGIN
setMode(modeOptim);
setNbcoils(nbBobines);
setNbContraintes(nbConstraints);
setTexture(textur);
setTypeOptimisation(typeOptim);
setNomTypeOptimisation(nomOptim);
END;
IF nbConstraints > 0 THEN
BEGIN
FListeContrainte := TList.create;
FOR I := 0 TO nbConstraints - 1 DO
BEGIN
FListeContrainte.add(COContrainte.creation(15, 'nameManu' + IntTOStr(i), 254.12+i, 0, 100 + i, 200 + i, 1));
END;
END
ELSE
ShowMessage('Pas de contraintes associées.');
END;
function COOptimisation.getContrainteDepuisListe(position : integer) : COContrainte;
var
M: COContrainte;
begin
M := FListeContrainte.Items[position];
result := M;
end;
FUNCTION COOptimisation.getMode: integer;
BEGIN
Result := FMode;
END;
PROCEDURE COOptimisation.setMode(valeur: integer);
BEGIN
FMode := valeur;
END;
FUNCTION COOptimisation.getNbcoils: integer;
BEGIN
Result := FNbcoils;
END;
PROCEDURE COOptimisation.setNbcoils(valeur: integer);
BEGIN
FNbcoils := valeur;
END;
FUNCTION COOptimisation.getNbContraintes: integer;
BEGIN
Result := FNbContraintes;
END;
PROCEDURE COOptimisation.setNbContraintes(valeur: integer);
BEGIN
FNbContraintes := valeur;
END;
FUNCTION COOptimisation.getTexture: STRING;
BEGIN
Result := FTexture;
END;
PROCEDURE COOptimisation.setTexture(valeur: STRING);
BEGIN
FTexture := valeur;
END;
FUNCTION COOptimisation.getTypeOptimisation: integer;
BEGIN
Result := FTypeOptimisation;
END;
PROCEDURE COOptimisation.setTypeOptimisation(valeur: integer);
BEGIN
FTypeOptimisation := valeur;
END;
FUNCTION COOptimisation.getNomTypeOptimisation: STRING;
BEGIN
Result := FNomTypeOptimisation;
END;
PROCEDURE COOptimisation.setNomTypeOptimisation(valeur: STRING);
BEGIN
FNomTypeOptimisation := valeur;
END;
END.
la création de la contrainte devient :
CONSTRUCTOR COContrainte.creation(typeConstraint: integer; name: STRING; time: double;
validity, nbIter, nbMaxIter, noCoil: integer);
BEGIN
//construction de l'objet fOptimisation
inherited create;
WITH self DO
BEGIN
setTypeContrainte(typeConstraint);
setNomContrainte(name);
setTemps(time);
setValidite(validity);
setNbIteration(nbIter);
setNbIterationMaxTolere(nbMaxIter);
setNumeroCoil(noCoil);
END;
END;
L'utilisation est :
PROCEDURE TForm1.FormCreate(Sender: TObject);
VAR
i : integer;
contrainteCourante1 : COContrainte;
contrainteCourante : COContrainte;
nbTrouveContraintes : integer;
fOptimisation : COOptimisation;
BEGIN
//construction de l'objet fOptimisation
fOptimisation := COOptimisation.creation(1, 4, 10, '415', 4, 'DoublePenteBreme');
//destruction de l'objet fOptimisation
nbTrouveContraintes := fOptimisation.NbContraintes;
FOR i := 0 TO nbTrouveContraintes - 1 DO
BEGIN
//On récupère la ième contrainte
contrainteCourante := fOptimisation.getContrainteDepuisListe(I);
ShowMessage('Le nom est :' +contrainteCourante.NomContrainte);
ai-je bien compris et mis en pratique tes remarques?
n'hésite pas à critiquer ces 2 classes. Cet exemple me servira de base pour un développement plus que proche.
if fNbConstraints > 0 then begin
fConstraintsList := TList.create;
for I := 0 to fNbConstraints-1 do
fConstraintsList.add(
COConstraint.create(15, 'nameManu'+InttoStr(i), 254.12+i, 0, 100 + i, 200 + i, 1)
);
end else
MessagDlg('Pas de contraintes associées.',mtWarning,[mbOk],0);
end;
destructor TCOOptimisation.Destroy;
begin
if Assigned(fConstraintsList) then
fConstraintsList.Free;
inherited Destroy;
end;
procedure TCOOptimisation.SetInteger(index : integer; val : integer);
begin
case index of
0: fMode := val;
1: fNbCoils := val;
2: fNbConstraints := val;
3: fOptimType := val;
end;
end:
procedure TCOOptimisation.SetString(index : integer val : string);
begin
case index of
0: fOptimTypeName := val;
1: fTexture := val;
end;
end;
function TCOOptimisation.GetConstraintFromList(const index : integer) : TCOConstraint;
var
Item : TCOConstraint;
begin
Item := fConstraintsList.Items[index];
result := Item;
end;
end.
procedure TForm1.FormCreate(Sender: TObject);
var
i : integer;
Optm : TCOOptimisation;
for i := 0 TO
Optm
.NbConstraints-
1 do
with
Optm
.GetConstraintFromList(I) do begin
MessageDlg('Le nom est :'
+ ConstraintName,mtInformation,[mbOk],0);
Free;
end;
Optm
.NbConstraints := 0;
finally
Optm
.Free;
end;
end;
aprés faut voir par rapport a ton prog final ... hesite pas a regarder dans l'aide delphi et egalement dans les sources de delphi
(repertoire Borland\Delphi\Sources)
regarder comment ils gerent les TList et autres objets ...
furax13
Messages postés90Date d'inscriptionmardi 28 octobre 2003StatutMembreDernière intervention24 avril 2008 2 août 2006 à 09:16
Merci pour ton aide.
une dernière petite question, j'espère :
j'aimerai que ma classe TCOConstraint fasse référence à la classe TCOoptimisation
en c++, cela donne cela :
CMDonneesParcs
constituée de n CMParcs
constituée de n CMTravees
constituées de n CMTas
constituée de n CMCouche
constituée de n CMPoint
dans .h de CMParc
class CMParc : public ClasseMetier
{
private :
// Données du parc
CMDonneesParcs* _pDonneesParcs;
// Nom du parc
char* _pNomParc;
int _numeroParc;
...
}
dans .cpp de CMParc
// pour copie
CMParc::CMParc(CMDonneesParcs* i_pDonnees,CMParc* i_pParc)
: ClasseMetier(i_pParc)
{
// initialisation
_pDonneesParcs=i_pDonnees;
_longueurParc=i_pParc->getLongueurParc();
_largeurParc=i_pParc->getLargeurParc();
_pNomParc=strdup(i_pParc->getNomParc());
_numeroParc=i_pParc->getNumeroParc();
..
}
j'appelle cela le chainage arriere.
cela me permet de connaitre pour chaque instance de mon objet son parent
comment fait-on cela en delphi?
dans le fichier OPT_Contrainte.pas :
UNIT OPT_Contrainte;