Jak najlepiej zwolnić pętle i problem z wyświetlaniem win 7

[GoldWolf]

Mam taki problem oto on:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

while(sekundy != 0){
                Sleep(500);
                MonitorCPU(hWnd);
                Sleep(500);
                MonitorCPU(hWnd);
        }

Czy jest do tego jakaś alternatywa.

Sorry, że tak dwa na jednym ale dotyczą tego przykładu.
Funkcja MonitorCPU(hWnd); oparta jest na budowie, która tutaj opisałem - viewtopic.php?f=5&t=1441&p=10657#p10630
Monitoruje ona obciążenie CPU, do wyświetlania użyłem:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//fragment funkcji  MonitorCPU(hWnd);
char* strPath=(char*)bstrPath;
        char mam[50];
        mam[0] = '\0';
        if (SUCCEEDED(hRes)){
                //strcpy_s(mam, "Procent użycia CPU - ");
                //sprintf_s(mam1, "%*ld", WIDTH, statex.dwMemoryLoad);
                strcat_s(mam, strPath);
                SetWindowText(hStatic3, mam);
                        //MessageBoxA(NULL, strPath, 0, 0);
                mam[0] = '\0';
        }else
                MessageBoxA(NULL,"Error in getting object", 0, 0);

Tylko, że na XP to działa co 0,5 s wyświetlana jest wartość obciążenia, a na win 7 tylko raz.

To jest o tyle dziwne, że mam inną funkcję do obliczania czasu do końca testu i ona działa poprawnie na obu systemach operacyjnych.

[Cyfrowy Baron]

Czy jest do tego jakaś alternatywa.

Tak jest! Użyj zegara TTimer, ustaw sobie interwał jaki jest potrzebny i usuń te funkcje Sleep, gdyż wstrzymują one całą aplikację.
Pro co dwa razy wywołujesz tą samą funkcję?

Użyj TTimer, ustaw mu Interval = 500; (1000 = 1 sekunda). Zegar będzie tykał teoretycznie co pół sekundy, ale różne operacje wykonywane przez system mogą zakłócać ten interwał. W zdarzeniu OnTimer umieść tylko taki kod:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
  if(sekundy != 0) MonitorCPU(hWnd);
}

Oczywiście zmienne sekundy i hWnd muszą być zmiennymi prywatnymi, publicznymi lub globalnymi.

[GoldWolf]

Pro co dwa razy wywołujesz tą samą funkcję?

Próbowałem czy to coś zmieni dla W7 jeśli chodzi o wyświetlanie, ale tak się nie stało.

Dobra to biorę się za ten czas najpierw.

[GoldWolf]

CO do wyświetlania to problem stanowi ten fragment kodu:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

if (CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT,
    RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0) != S_OK)
    return 0;

NA XP gdy wywołamy funkcję to wszystko działa, a na W7 ten if wykona się tylko raz. Czyli ja oczywiście nie wiem dlaczego tak jest, ale w "7" musimy zrobić coś takiego:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

        if (i == 0)
                if (CoInitializeSecurity(NULL, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_PKT,
                        RPC_C_IMP_LEVEL_IMPERSONATE, NULL, EOAC_NONE, 0) != S_OK){
        //              MessageBox(0, "Test 1", 0, 0);
                //      return 0;
                                i++;
        }

I działa poprawnie, tak jak chciałem, a czy nie jest to jakiś błąd programistyczny, tego nie wiem.

Co do pętli to na razie nie znałazłem nic co by zastąpiło Sleep-a, trafiłem na coś takiego - http://msdn.microsoft.com/en-us/library ... 85%29.aspx
Niestety mocno to obciąża procesor, więc na razie zostaje Sleep. Nie mogę użyć TTimera bo mam inny kompilator.

[Cyfrowy Baron]

Funkcję CoInitializeSecurity wywołuje się tylko raz, najlepiej przy uruchomieniu programu. Można to umieścić w konstruktorze klasy formularza.

---

Co do pętli to na razie nie znałazłem nic co by zastąpiło Sleep-a,

Jak już powiedziałem użyj zegara TTimer i zdania nie zmienię.

[GoldWolf]

Ta po za zatrzymaniem pętli, tak czy inaczej, czy jest jakiś sposób, by coś wykonywało się w koło o ten sam odstęp czasu?
Akurat po za zastosowaniem pętli, to jestem ciekaw czy można to inaczej zrobić. Oczywiście można by zrobić rekurencje, funkcja która wykonuje sama siebie, a jeszcze inaczej?

[Cyfrowy Baron]

Rekurencja?! Chyba nie wiesz o czym piszesz! Rekurencja to odwoływanie się funkcji samej do siebie i służy do coraz głębszego zagłębiania się w coś. Przykład rekurencji masz w sewisie Cyfrowy Baron w poradzie: wyszukiwanie folderów, podfolderów i plików, gdzie rekurencja pozwala zagłębiać się w podkatalogi przeszukiwanego katalogu, aż do czasu, gdy nie ma już niżej żadnego katalogu. Rekurencja kiedyś musi się skończyć, gdyż takie zagłębianie się w nieskończoność musi w końcu spowodować zawieszenie programu.
Uważasz, że rekurencja pozwala wykonywać zadanie w określonych odstępach czasu? A niby jak? To jeszcze gorzej niż wywoływanie funkcji w pętli

---

czy jest jakiś sposób, by coś wykonywało się w koło o ten sam odstęp czasu?

No jest to właśnie TTimer.
Możesz wyjaśnić jaki masz problem z tym Timer-em?! Czy może chodzi o to, że nie wiesz jak użyć Timera w aplikacji konsolowej?!

Prosty przykład dla Embarcadero RAD Studio C++Builder 2010. Mapowanie ustawione na wchar_t z obsługą Unicode, czyli z polskimi znakami diakrytycznymi.

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include <tchar.h>
#include <iostream>
#include <windows.h>
#include <ctime>

//---------------------------------------------------------------------------

#pragma argsused

using namespace std;

bool Timer(int interval)
{
 double sec1 = time(0);
 while(1)
 {
  double sec2 = time(0);

  if(sec2 >= sec1 + interval) return true;
 }
}

int _tmain(int argc, _TCHAR* argv[])
{
 setlocale(LC_CTYPE, ""); /* by obsługiwać Unicode - Polskie znaki diakrytyczne */

 int tick = 5;

 while(1)
 {
  if( Timer(tick) )
  {
    /* tutaj zegar tyka z określoną częstotliwością */
        wprintf(L"Upłnęło %d sekund.\n\n", tick); /*wprintf zamiast printf dla Unicode */
  }

 }

 cin.get();

 return 0;
}
//---------------------------------------------------------------------------
 

---

Funkcja, którą wykorzystujesz do sprawdzania temperatury oparta jest na WMI i niestety nie będzie działać na każdym sprzęcie, gdyż nie każdy producent sprzętu dostarcza odpowiednie protokoły i rozszerzenia dla swojego sprzętu. U mnie np. ten kod zwraca komunikat o braku sensora, a mam ich cztery.

[GoldWolf]

Już tłumaczę, pisałem o tym:
"Kompilator: Microsoft Visual Studio 2010 Version 10.0.30319.1" nie ma TTimera po prostu.

Trafiłem na rozwiązanie, które miało to robić, ale za bardzo obciąża mi procesor. Teraz jeszcze znalazłem coś takiego, ale nie sprawdziłem tego jeszcze:
http://www.codeproject.com/KB/cpp/Templ ... play=Print

[Cyfrowy Baron]

Już tłumaczę, pisałem o tym:
"Kompilator: Microsoft Visual Studio 2010 Version 10.0.30319.1" nie ma TTimera po prostu.

jakiś timer musi mieć, jeżeli nie jako komponent to jako zwykłą bibliotekę. Podałem zresztą kod z wykorzystaniem biblioteki ctime, która na pewno występuje również u ciebie, a jeżeli nie masz ctime to na pewno masz bibliotekę time.h, w której również występuje funkcja time.

Pod tym adresem C++MiscHighResTimer masz przykładowy projekt timera dla visual studio.

[GoldWolf]

Działa, ale trochę tego nie kumam. Funkcja ta liczy czas jaki jest poświęcony na wykonanie części kodu.
"In this video lesson, we create a timer class, which we will be able to use to time sections of code for optimization and for creating real-time games."
"To time a section of code, we get the count at the beginning and the count at the end."
Innymi słowy nie można za jej pomocą, zatrzymać czas na określony przez nas czas.

Znalazłem również pewną alternatywę: http://msdn.microsoft.com/en-us/library ... 85%29.aspx - dopiero jak przetestuje powiem, która wybrałem.

[Cyfrowy Baron]

W podanym przeze mnie przykładzie masz funkcję:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

bool Timer(int interval)
{
 double sec1 = time(0);
 while(1)
 {
  double sec2 = time(0);

  if(sec2 >= sec1 + interval) return true;
 }
}

Jak widzisz w funkcji znajduje się pętla while, która działa w nieskończoność. Przed uruchomieniem pętli do zmiennej sec1 zapisywana jest aktualna wartość z funkcji time, która to funkcja zwraca czas jaki upłynął od uruchomienia systemu, w pętli masz drugą zmienną, która również pobiera ten czas, a ten czas płynie, więc zmienna sec1 przechowuje czas przeszły, a zmienna sec2 czas teraźniejszy, gdy różnica między czasem przeszłym sec1 a czasem teraźniejszym sec2 jest równa zadanemu interwałowi (zmienna interval), to funkcja return przerywa działanie pętli while i zwraca wartość true, tym samym działanie funkcji zostaje przerwane.
Dalej:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

 while(1)
 {
  if( Timer(tick) )
  {
    /* tutaj zegar tyka z określoną częstotliwością */
        wprintf(L"Upłnęło %d sekund.\n\n", tick); /*wprintf zamiast printf dla Unicode */
  }

 }

Jak widać tutaj również mamy pętlę działającą w nieskończoność. W pętli sprawdzana jest wartość jaką zwraca funkcja Timer. Gdy Timer zwróci true, w oknie konsoli wypisywane jest tekst.

Jeżeli masz u siebie bibliotekę mmsystem.h lub mmsystem.hpp to mogę podać Tobie kod na bardziej funkcjonalny Timer. Z takiego kodu można zrobić sobie nawet komponent.

[polymorphism]

mmsystem.h pochodzi z PSDK, więc co jak co, ale VS (z wyjątkiem VS 2005 EE) będzie miał ten plik i bibliotekę. Odnośnie pętli. Wato tam dać gdzieś Sleep(1), żeby nie zarżnąć CPU.

[Cyfrowy Baron]

Gotowy przykład Timer-a z wykorzystaniem biblioteki mmsystem.h:

Projekt dla środowiska Embarcadero RAD Studio C++ Builder 2010:

Plik nagłówkowy np. Unit1.h

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void CALLBACK TimerProc(unsigned int uID, unsigned int uMsg, DWORD dwUser, DWORD dw1, DWORD dw2);

class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TButton *ButtonStartTimer;
        TLabel *Label1;
        TButton *ButtonStopTimer;
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
        void __fastcall ButtonStartTimerClick(TObject *Sender);
        void __fastcall ButtonStopTimerClick(TObject *Sender);

private:        // User declarations

                int TimerID;

                void __fastcall EnableTimer(int Interval);
                void __fastcall DisableTimer(void);

public:         // User declarations
        __fastcall TForm1(TComponent* Owner);

           void __fastcall OnTimer(void);
};

Plik źródłowy np. Unit1.cpp

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

#include <mmsystem.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}

/* FUNKCJE ZEGARA */
//---------------------------------------------------------------------------
void __fastcall TForm1::EnableTimer(int Interval)
{
 TimerID = timeSetEvent(Interval, 1, TimerProc, 0, TIME_PERIODIC);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DisableTimer(void)
{
 timeKillEvent(TimerID);
}
//---------------------------------------------------------------------------

/* funkcja CALLBACK */
void CALLBACK TimerProc(unsigned int uID, unsigned int uMsg, DWORD dwUser,
    DWORD dw1, DWORD dw2)
{
 Form1->OnTimer();
}
//---------------------------------------------------------------------------

/* zdarzenie OnTimer, to tutaj czas jest odmierzany */
void __fastcall TForm1::OnTimer(void)
{
 static int tick = 0;

 Label1->Caption = (String)tick;

 tick++;

 if(tick > 100)
 {
  DisableTimer();
  tick = 0;
 }
}
//---------------------------------------------------------------------------

/* ZDARZENIA */
void __fastcall TForm1::ButtonStartTimerClick(TObject *Sender)
{
 EnableTimer(100); /* tutaj interwał = 100 milisekund; 1 sekunda = 1000 */
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonStopTimerClick(TObject *Sender)
{
 DisableTimer();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
 DisableTimer();
}
//---------------------------------------------------------------------------
 

---

[polymorphism]

Drobna uwaga, timeSetEvent odpala timer w oddzielnym wątku, zatem trzeba pamiętać o synchronizacji dostępu do współdzielonych zasobów z wnętrza TimerProc.

Z drugiej strony wydaje mi się, że zwykły timer okienkowy do tego zadania wystarczy. Użycie timera multimedialnego to lekki przerost formy.

---

Mała poprawka:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

class TForm1 : public TForm
{
private:
        static void CALLBACK TimerProc(unsigned int uID, unsigned int uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
        {
                ((TForm1*)dwUser)->OnTimer();
        }
       
        ...
};

/* CPP */

void __fastcall TForm1::EnableTimer(int Interval)
{
        TimerID = timeSetEvent(Interval, 1, TimerProc, this, TIME_PERIODIC);
}

[Cyfrowy Baron]

Z drugiej strony wydaje mi się, że zwykły timer okienkowy do tego zadania wystarczy. Użycie timera multimedialnego to lekki przerost formy.

Tak! Tylko jak pisze GoldWolf:

Już tłumaczę, pisałem o tym:
"Kompilator: Microsoft Visual Studio 2010 Version 10.0.30319.1" nie ma TTimera po prostu.

Dlatego podałem jak można sobie zrobić taki Timer.

---

Mała poprawka:

Poprawka do poprawki:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

TimerID = timeSetEvent(Interval, 1, TimerProc, (ULONG)this, TIME_PERIODIC);

Cały kod po poprawkach powinien wyglądać tak:

Plik nagłówkowy np. Unit1.h

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

class TForm1 : public TForm
{
__published:    // IDE-managed Components
        TButton *ButtonStartTimer;
        TLabel *Label1;
        TButton *ButtonStopTimer;
        void __fastcall FormClose(TObject *Sender, TCloseAction &Action);
        void __fastcall ButtonStartTimerClick(TObject *Sender);
        void __fastcall ButtonStopTimerClick(TObject *Sender);
private:        // User declarations

                int TimerID;

                void __fastcall EnableTimer(int Interval);
                void __fastcall DisableTimer(void);

        static void CALLBACK TimerProc(unsigned int uID, unsigned int uMsg, DWORD dwUser, DWORD dw1, DWORD dw2)
        {
          ((TForm1*)dwUser)->OnTimer();
        }

public:         // User declarations
        __fastcall TForm1(TComponent* Owner);

        void __fastcall OnTimer(void);
};

Plik źródłowy np. Unit1.cpp

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

#include <mmsystem.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}

/* FUNKCJE ZEGARA */
//---------------------------------------------------------------------------
void __fastcall TForm1::EnableTimer(int Interval)
{
 TimerID = timeSetEvent(Interval, 1, TimerProc, (ULONG)this, TIME_PERIODIC);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::DisableTimer(void)
{
 timeKillEvent(TimerID);
}
//---------------------------------------------------------------------------

/* zdarzenie OnTimer, to tutaj czas jest odmierzany */
void __fastcall TForm1::OnTimer(void)
{
 static int tick = 0;

 Label1->Caption = (String)tick;

 tick++;

 if(tick > 100)
 {
  DisableTimer();
  tick = 0;
 }
}
//---------------------------------------------------------------------------

/* ZDARZENIA */
void __fastcall TForm1::ButtonStartTimerClick(TObject *Sender)
{
 EnableTimer(100); /* tutaj interwał = 100 milisekund; 1 sekunda = 1000 */
}
//---------------------------------------------------------------------------
void __fastcall TForm1::ButtonStopTimerClick(TObject *Sender)
{
 DisableTimer();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
{
 DisableTimer();
}
//---------------------------------------------------------------------------