Initialiser des variables dans une méthode Statique

Version imprimable

Bonsoir,

Je cherche à faire une Classe Chrono afin de pouvoir l'utiliser de façon simple dans mon programme. Ce que je souhaite faire, c'est utiliser des méthodes statiques afin de ne pas avoir à instancier d'objet.

J'ai ce code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 unit Chrono; interface uses Windows; type TChrono=class private FFrequency : Int64 ; // Fréquence du compteur hautes performances. FStart, FStop : Int64 ; // Valeurs du compteur au début et à la fin du chrono. public class Procedure Start; class Function Stop:Extended; end; implementation class procedure TChrono.Start; begin QueryPerformanceFrequency(FFrequency); QueryPerformanceCounter(FStart) ; end; class function TChrono.Stop:Extended; begin Result:=(FStop-FStart)/FFrequency; end; end.
Et j'ai ces messages d'erreurs :

Citation:

[Erreur] TChrono.pas(22): Variable instance 'FFrequency' inaccessible ici
[Erreur] TChrono.pas(23): Variable instance 'FStart' inaccessible ici
[Erreur] TChrono.pas(27): Variable instance 'FStop' inaccessible ici
[Erreur] TChrono.pas(27): Variable instance 'FFrequency' inaccessible ici

Est-ce possible de faire ce que je veux ? On utiliserai ainsi mon Chrono de cette façon :
Code:

1 2 3 4 5 6 7 8 procedure TForm1.Button1Click(Sender: TObject); var Temps:Extended; begin TChrono.Start; //Traitement Temps:=TChrono.Stop; end;
Merci d'avance
Cordialement

06/12/2007, 23h37
TicTacToe

Ceci est normal, les variables sont accessibles seulement si la classe est instanciée.

sinon pour déclarer des variables de classes
ca dépends de la version de Delphi.
J'ai pas encore essayé mais (je dis peut être une anerie) il me semble que dans la derniere version on peut définir des variables de classe.

Sinon, tu peux toujours ruser en définissant une variables globale à l'unité déclarée dans l'implémentation et y accéder par des méthodes de classes de ta classe
(je crois d'ailleurs que l'astuce est énoncée dans la FAQ ;) )

edit: confirmé ici
07/12/2007, 10h51
ero-sennin

Salut TicTacToe,

Je viens de lire le post de la FAQ et c'est vrai que celà fonctionne. Néanmoins, il me faudra faire attention de ne pas utiliser les variables globales de la classe TChrono dans mon programme principal, parce que là j'y accède ...

Dommage que l'on ne puisse pas déclarer les variables dans la section private de la classe. Ca aurait arrangé certaines choses...

Merci ;)

Normalement, comme ceci, tu ne peux pas accéder aux variable en dehors de l'unité, surtout qu'une seule valeur n'a besoin d'être partagée

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
unit Chrono;
 
interface
 
uses Windows;
 
type TChrono=class
  public
    class Procedure Start;
    class Function Stop: Extended;
end;
 
 
implementation
 
var
  _ChronoStart: Int64;    // Valeurs du compteur au début du chrono.
 
class procedure TChrono.Start;
begin
  QueryPerformanceCounter(_ChronoStart) ;
end;
 
class function TChrono.Stop: Extended;
var
  Frequency, Stop: Int64;
begin
  QueryPerformanceFrequency(Frequency);
  QueryPerformanceCounter(Stop) ;
 
   Result:= (Stop - _ChronoStart) / Frequency;
end;
 
end.

Sinon, tu peux aussi faire quelque chose de plus simple

appel

Code:

1
2
3
4
5
6
7
var
  StartTime: Int64;
begin
  GetBeginTime(StartTime);
  // Traitement
  ShowMessage(FormatMS(ElapsedTime(StartTime)));
end;

implementation

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
function FormatMS(MilliSecondes: Cardinal): string;
var
  Hour, Min, Sec: Cardinal;
begin
  Hour := MilliSecondes div 3600000; MilliSecondes := MilliSecondes mod 3600000;
  Min := MilliSecondes div 60000; MilliSecondes := MilliSecondes mod 60000;
  Sec := MilliSecondes div 1000; MilliSecondes := MilliSecondes mod 1000;
  Result := Format('%.2d:%.2d:%.2d:%.3d', [Hour, Min, Sec, MilliSecondes]);
end;
 
procedure GetBeginTime(var Value: Int64);
begin
  QueryPerformanceCounter(Value);
end;
 
function ElapsedTime(var BeginTime: Int64): Cardinal;
var
  EndTime, TickPerSec: Int64;
begin
  QueryPerformanceCounter(EndTime);
  QueryPerformanceFrequency(TickPerSec);
  Result := Round((EndTime - BeginTime) / TickPerSec * 1000);
end;

Salut ShaiLeTroll,

Merci pour ce code, je vais le regarder dans le courant de l'après midi :P.

Sinon, j'ai quelques questions :

Citation:

Envoyé par ShaiLeTroll

Normalement, comme ceci, tu ne peux pas accéder aux variable en dehors de l'unité, surtout qu'une seule valeur n'a besoin d'être partagée

C'est parce que tu as défini la variable commençant par un tiret bas ?
Code:

1 2 3 4 implementation var _ChronoStart: Int64; // Valeurs du compteur au début du chrono.
Seconde question :
Code:

1 2 3 4 procedure GetBeginTime(var Value: Int64); begin QueryPerformanceCounter(Value); end;
Je comprends pas trop le var dans le passage de paramètres. Ca a quelle(s) répercution(s) si on le met ou pas ? Comparé au code ci dessous, qu'est ce permet le tient avec le mot clé var :
Code:

1 2 3 4 procedure GetBeginTime(Value: Int64); begin QueryPerformanceCounter(Value); end;
Dernière question, en ce qui concerne mon code. Là, je ne parle plus de méthode à portée de classe mais uniquement d'instanciation d'objet. Est ce que ce code est correct :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 unit Chrono; interface uses Windows; type TChrono=class private FFrequency : Int64 ; // Fréquence du compteur hautes performances. FStart, FStop : Int64 ; // Valeurs du compteur au début et à la fin du chrono. public constructor Start; function Stop:Extended; end; implementation constructor TChrono.Start; begin QueryPerformanceFrequency(FFrequency); QueryPerformanceCounter(FStart) ; end; function TChrono.Stop:Extended; begin QueryPerformanceCounter(FStop) ; Result:=(FStop-FStart)/FFrequency; Self.Free; end; end.
Merci d'avance et désolé si mes questions paraissent un peu bêtes :oops:

07/12/2007, 12h33
TicTacToe

Citation:

Envoyé par ero-sennin

Salut TicTacToe,

Je viens de lire le post de la FAQ et c'est vrai que celà fonctionne. Néanmoins, il me faudra faire attention de ne pas utiliser les variables globales de la classe TChrono dans mon programme principal, parce que là j'y accède ...

Non, si ces variables globales sont déclarées dans la partie implémentation, seules des méthodes (de classes ou non) pourront accéder à ces var.
Ces variables sont "privées" à l'unité et donc non modifiables par les autres unités.

Bonjour,

Pour ma part j'ai laissé tomber l'utilisation du compteur hautes performances pour mes chronométrages depuis que j'ai appris que Windows piquait la main pour faire d'autres besognes quand cela lui chantait et le nombre de fois qu'il le voulait pendant les chronométrages et je me contente du code suivant où le chrono est encapsulé dans un object ce qui est suffisant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
type      oChrono = object TopDepart,Duree : longWord; // milliSecondes
                           procedure Top;
                           function  Mis(Format : byte) : string;
                           // Format=1 renvoie par ex 12h 15m 4s 45ms
                           // Format=2 renvoie        12:15:04:045
                           // Format=3 renvoie        44104045 ms
                    end;
 
procedure oChrono.Top;
begin     TopDepart:=GetTickCount; end;
 
function  oChrono.Mis(Format : byte) : String;
var       msp,he,mi,se,ms : longWord; s : string; t : shortString;
 
          function calibre(t : shortString; n : byte) : shortString;
          begin    while length(t)<n do t:='0'+t;
                   calibre:=t;
          end;
 
begin     Duree:= GetTickCount-TopDepart; // millisecondes passées
          //Duree:=12*60*60*1000 + 15*60*1000 + 4*1000 + 45; //12h 15m 4s 45ms
          msp:=Duree;
          ms:= msp mod 1000; msp:= msp div 1000;
          se:= msp mod 60;   msp:= msp div 60;
          mi:= msp mod 60;   msp:= msp div 60;
          he:= msp mod 60;   s:='';
          if Duree<=1000 then Format:=3;
          case format of
               1 : begin if he<>0 then s:=s+intToStr(he)+'h ';
                         if mi<>0 then s:=s+intToStr(mi)+'m ';
                         if se<>0 then s:=s+intToStr(se)+'s ';
                         s:=s+intToStr(ms)+'ms'; end;
               2 : begin t:=intToStr(he); s:=s+t+':'; //12:15:04:045
                         t:=intToStr(mi); t:=calibre(t,2); s:=s+t+':';
                         t:=intToStr(se); t:=calibre(t,2); s:=s+t+':';
                         t:=intToStr(ms); t:=calibre(t,3); s:=s+t; end;
               3 : s:=intToStr(Duree)+' ms';
          end;
          Mis:=s;
end;

... avant ceci pour essayer de conserver le compteur hautes hautes performances j'ai pensé qu'en fixant la priorité du chronométrage avec REALTIME_PRIORITY_CLASS cela empêcherait Windows de piquer la main pendant les chronométrages mais ça n'a servi à rien et depuis je me contente du GetTickCount.

A+:D

07/12/2007, 13h21
ero-sennin

Citation:

Envoyé par TicTacToe

Non, si ces variables globales sont déclarées dans la partie implémentation, seules des méthodes (de classes ou non) pourront accéder à ces var.
Ces variables sont "privées" à l'unité et donc non modifiables par les autres unités.

J'avais pas fait attention à ce détails! C'est désormais noté :aie:. Merci

Citation:

Envoyé par Gilbert Geyer

Bonjour,
Pour ma part j'ai laissé tomber l'utilisation du compteur hautes performances pour mes chronométrages depuis que j'ai appris que Windows piquait la main pour faire d'autres besognes quand cela lui chantait et le nombre de fois qu'il le voulait pendant les chronométrages...

Ah, je ne savais pas celà ... Les écarts ne doivent pas être très important. Avec tout ces bouts de code sous la main, j'ai de quoi faire :P

Je ne regrette pas d'avoir posé ma question, j'en ai appris des choses!
Merci

Re-bonjour,

Citation:

Ero-sennin a écrit :
Les écarts ne doivent pas être très important

... il m'est arrivé que les écarts varient du simple au double entre deux chronométrages successifs de processus courts ... ce qui exige pour les processus courts de refaire le test plusieurs fois pour éliminer les résultats où visiblement c'est d'autres besognes que j'ai chronométré par contre pour des processus qui durent 5 minutes les écarts relatifs ne perturbent pas trop mais mon poste n'est pas en réseau et est donc moins perturbé par des tâches qui s'exécutent en arrière plan. En plus je m'arrange toujours afin qu'un test ne dépasse pas les 5 minutes ... c'est déja long et en général quand on se lance dans des tests de vitesse on est parti pour en faire toute une série.

Par contre je pensais que quelqu'un allait apporter une réponse à comment donner la priorité immédiate au chronométrages et voiçi sur quoi je me suis basé sans succès pour mes essais :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 Pour changer la priorité de l'application ex : lancer Prio($80) pour la placer en priorité haute, et Prio($20) pour revenir à une priorité normale. Cela "peut" accélérer certains processus procedure Prio(const PriorityClass : Cardinal); var hProcess, pid : Cardinal; begin pid := GetCurrentProcessId(); hProcess := OpenProcess($40, true, pid); SetPriorityClass(hProcess, PriorityClass); CloseHandle(hProcess); end; dwPriorityClass : valeurs HIGH_PRIORITY_CLASS : pour tâches à executer immediatement. : $80 = 128 IDLE_PRIORITY_CLASS : pour tâches à exécuter lorsque le système est désoeuvré. (sauvegarde d'écran par exemple ) : $40 = 64 NORMAL_PRIORITY_CLASS : pour process sans besoin spécial : $20 = 32 REALTIME_PRIORITY_CLASS : pour process à executer avec la plus haute priorité possible y compris face à des opérations du système : $100 = 256
... donc si quelqu'un a une idée pour empêcher Windows de piquer la main ce serait intéressant de le savoir.

A+:D

Citation:
Envoyé par ero-sennin
Code:

1 2 3 4 procedure GetBeginTime(var Value: Int64); begin QueryPerformanceCounter(Value); end;
Je comprends pas trop le var dans le passage de paramètres. Ca a quelle(s) répercution(s) si on le met ou pas ? Comparé au code ci dessous, qu'est ce permet le tient avec le mot clé var :
Code:

1 2 3 4 procedure GetBeginTime(Value: Int64); begin QueryPerformanceCounter(Value); end;
sans Var, Value est une copie de la variable appelante, la modifier n'a aucun implact
avec Var, Value est un pointeur sur la variable appelante, la modifier modifie la valeur dans le fonction appelante

F1 t'expliquera tout en détail (surtout le chapitre "Sémantique des paramètres")
Citation:
Envoyé par ero-sennin
Dernière question, en ce qui concerne mon code. Là, je ne parle plus de méthode à portée de classe mais uniquement d'instanciation d'objet. Est ce que ce code est correct :
Code:

1 2 3 4 5 6 function TChrono.Stop:Extended; begin QueryPerformanceCounter(FStop) ; Result:=(FStop-FStart)/FFrequency; Self.Free; end;
Correct, il l'est, il est juste peu fiable, pour une forme, il faudra utiliser Release, ... tu un risque de violation d'acces, si en théorie cela peut fonctionner, personne ne le fait ... mais tu peux oser ceci
Code:

1 2 3 4 5 6 7 destructor TChrono.Stop(out ResultChrono :Extended); begin QueryPerformanceCounter(FStop) ; ResultChrono :=(FStop-FStart)/FFrequency; inherited Destroy(); end;
Bon, cela retire la protection du Free, sur l'objet nil, mais bon, c'est pas grave, moi je l'ai utilisé comme ceci, pour rendre mon code assez lisible et que la libération soient natutelle (Create\Free, Begin\End ...)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 type TMaster = class(TObject) public class function BeginTask(TypeTask: TTaskType): TCustomTask; end; TCustomTask = class(TObject) public destructor EndTask(); end; TCustomTaskClass = class of TCustomTask; TTaskHello = class(TCustomTask); implemenation const TASK : array[TTaskType] of TCustomTaskClass = (TTaskHello, TTaskGoodBye); class function TMaster.BeginTask(TypeTask: TTaskType): TCustomTask; begin Result := TASK[TypeTask].Create(); end; //----------------------------------------------// with TMaster.BeginTask(ttHello) do try ... finally EndTask(); end;
Il faut savoir que n'importe quelle API Windows permet à ce dernier, de prendre la main au programme en toute sécurité (contexte de pile, thread, ...) et pas spécialement avec le Compteur, sinon, avec GetTickCount, il est difficile d'avoir un temps plus précis que 10ms, d'ailleurs, si tu as fais des tests, tu as souvent pour un traitement court, des temps variant entre 0 ms, 15-16 ms ou 30-31 ms, puis passer ces temps, cela devient plus précis, c'est tout simple, qu'il a relaché la main aussi, ...

je rappelle que windows c'est multi-processus, on est pas sous DOS où cela bloque tout, un programme ne doit pas bloquer l'opération des autres programmes, d'ailleurs, même un programme qui occupe le processeur à 100% en faisiant ni sleep, ni waitmessage, ni d'appel à une API, genre le code qui suit, tu peux toujours utiliser tes autres applis, parce que windows ne se gène pas pour allouer du temps processeur aux autres processus ... et heureusement d'ailleurs, car comment faire un virus bien chiant et ultra simple, dès le démarrage de windows un programme qui bouffe tout le temps processeur, qui ne relache jamais la main, et donc rend impossible l'utilisation de l'ordinateur ... c'est ce qui arrivait avec Win98 qui était plus fragile à ce sujet, et pouvait bloquer plus facilement, parfois Win2K, mais les Pack on améliorer cela, imagine, tu as lancé ton programme, il tourne à fond mais il fait des conneries, tu veux le killer, tu es bien content que le système aie la main pour afficher le gestionnaire de processus (même avec difficulté car peu de temps processeur pour le faire)
Code:

1 2 For I := 0 to MaxInt do Inc(K);
Maintenant, avec les processeurs multi-core, c'est encore plus complexe, windows pouvant te changer de processeur selon les besoins ... et cela dépasse de loin mes connaissances

Citation:

Envoyé par ShaiLeTroll

sans Var, Value est une copie de la variable appelante, la modifier n'a aucun implact
avec Var, Value est un pointeur sur la variable appelante, la modifier modifie la valeur dans le fonction appelante

F1 t'expliquera tout en détail (surtout le chapitre "Sémantique des paramètres")

Oui, je viens de comprendre la chose, la variable est passé par adresse et non par valeur ce qui a pour effet de la modifier dans le corps de la procédure ou fonction.
Citation:
Envoyé par ShaiLeTroll
Bon, cela retire la protection du Free, sur l'objet nil, mais bon, c'est pas grave, moi je l'ai utilisé comme ceci, pour rendre mon code assez lisible et que la libération soient natutelle (Create\Free, Begin\End ...)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 type TMaster = class(TObject) public class function BeginTask(TypeTask: TTaskType): TCustomTask; end; TCustomTask = class(TObject) public destructor EndTask(); end; TCustomTaskClass = class of TCustomTask; TTaskHello = class(TCustomTask); implemenation const TASK : array[TTaskType] of TCustomTaskClass = (TTaskHello, TTaskGoodBye); class function TMaster.BeginTask(TypeTask: TTaskType): TCustomTask; begin Result := TASK[TypeTask].Create(); end; //----------------------------------------------// with TMaster.BeginTask(ttHello) do try ... finally EndTask(); end;
En effet, à la lecture, on voit bien le Begin et End, ce qui est appréciable pour une question de maintenance. Je me vois bien pencher vers cette solution.

Citation:

Envoyé par ShaiLeTroll

Avec GetTickCount, il est difficile d'avoir un temps plus précis que 10ms, d'ailleurs, si tu as fais des tests, tu as souvent pour un traitement court, des temps variant entre 0 ms, 15-16 ms ou 30-31 ms, puis passer ces temps, cela devient plus précis, c'est tout simple, qu'il a relaché la main aussi, ...

Oui, c'est d'ailleurs pour celà que je m'étais dirigé vers le compteur Haute Performance

Merci pour ces informations bien utiles ... et puis, j'ai pu voir à quoi servait VAR et aussi OUT.

A+ ;)