Sprawdzanie zużycia pamięci

[krusade]

Chciałem sobie stworzyć ten program http://cyfbar.republika.pl/api3.html#api3 a dokładnie "Sprawdzanie zużycia pamięci przez procesy uruchomione w systemie" przy próbie uruchomienia wyskakuje mi błąd

[polymorphism]

No nie żartuj, wystarczy przetłumaczyć sobie komunikat błędu i zajrzeć do helpa

PS. I zamień to:

Kod: Zaznacz cały

if(!AnsiString(WindowName).IsEmpty())

na

Kod: Zaznacz cały

if(*WindowName != '\0')

[krusade]

Nie wiem co to ma do mojego błędu, tym bardziej że zamiana na co podałeś nie pomaga i błąd jest dalej ten sam.

[polymorphism]

Nie ma nic do twojego błędu, bo to co podałem jest w post scriptum. To po pierwsze. Po drugie, jakbyś zajrzał do plików pomocy, to zauważyłbyś, że klasa TStrings nie ma takiej właściwości jak Items, co zresztą kompilator dość jasno zasygnalizował. Podpowiem, że klasa ta posiada metodę IndexOf, więc wystarczy, że zajrzysz do helpa, wyciągniesz odpowiednie wnioski i poprawisz ten drobny błąd sam

[Cyfrowy Baron]

Mój błąd. To jest właśnie to o czym już pisałem w wyjaśnieniach dla polymorphism do pewnego postu. Kod testowałem w oparciu o ListBox, a potem postanowiłem uczynić go bardziej uniwersalnym i klasę TListBox zastąpiłem w argumentach funkcji klasą TStrings zapominając o całej reszcie.
Kod na stronie już poprawiłem.
Dla Twojej wiadomości całość powinna wyglądać tak:

► KOD: 

---

Kod: Zaznacz cały

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include <psapi.h>
#include <tlhelp32.h>
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
}
//---------------------------------------------------------------------------
AnsiString GetMemory(DWORD ThreadID)
{
typedef BOOL (_stdcall *PGetProcessMemoryInfo)(HANDLE, void*, DWORD);
String Result;
PGetProcessMemoryInfo Memproc;
HMODULE hMod;
PROCESS_MEMORY_COUNTERS ProcMem;

memset(&ProcMem, 0, sizeof(ProcMem));
ProcMem.cb = sizeof(ProcMem);

hMod = ::LoadLibrary("psapi.dll");

HANDLE ProcessHandle = OpenProcess(PROCESS_QUERY_INFORMATION , true, ThreadID);

if(!hMod) return "access denied";
Memproc = (PGetProcessMemoryInfo)::GetProcAddress(hMod, "GetProcessMemoryInfo");
if(!Memproc) return "access denied";
if((*Memproc)(ProcessHandle, &ProcMem, sizeof(ProcMem)))
  Result = FloatToStrF(ProcMem.WorkingSetSize / 1024, ffNumber, 7, 0) + " KB";
else
  Result = "access denied";

FreeLibrary(hMod);
return Result;
}
//---------------------------------------------------------------------------
bool CALLBACK EnumWindowsProc(HWND hWnd, TStrings *EnumList)
{
char WindowName[255];
DWORD ID;
GetWindowText(hWnd, WindowName, 255);
GetWindowThreadProcessId(hWnd, &ID);

if(!AnsiString(WindowName).IsEmpty())
{
  if(IsWindowVisible(hWnd) >= 1)
  {
   String tmp = (String)WindowName + " - " + GetMemory(ID);
   if(EnumList->IndexOf(tmp) < 0)
    EnumList->Add((String)WindowName + " - " + GetMemory(ID));
  }
}
return true;
}
//---------------------------------------------------------------------------
void __fastcall GetProcess(TStrings *ProcList)
{
HWND Snap;
PROCESSENTRY32 proces;

Snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
proces.dwSize = sizeof(PROCESSENTRY32);

if(Process32First(Snap, &proces))
{
  do
  {
   if(proces.szExeFile[0] != '[')
   {
    ProcList->Add((String)(String)proces.szExeFile + " - " + GetMemory(proces.th32ProcessID));
   }
  }
  while(Process32Next(Snap , &proces));
}
CloseHandle(Snap);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
ListBox1->Items->Clear();
EnumWindows((WNDENUMPROC)EnumWindowsProc, (LPARAM)ListBox1->Items);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
ListBox1->Items->Clear();
GetProcess(ListBox1->Items);
}
//---------------------------------------------------------------------------


---

zmiany występują tutaj:

if(EnumList->IndexOf(tmp) < 0)
EnumList->Add((String)WindowName + " - " + GetMemory(ID));

i tutaj:

EnumWindows((WNDENUMPROC)EnumWindowsProc, (LPARAM)ListBox1->Items);

rozumiem, że jesteś początkujący i mogłeś nie zauważyć, że chodzi o klasę TStrings a nie TListBox, właściwość Items klasy TListBox jest właśnie typu TStrings.

---

---

a to:

if(!AnsiString(WindowName).IsEmpty())

nie jest błędem, aczkolwiek to:

if(*WindowName != '\0')

jest lepszym rozwiązaniem. Ja nawykłem korzystać kiedy to tylko możliwe ze zmiennych AnsiString dlatego często konwertuję typ char na typ AnsiString.

TStrings nie ma takiej właściwości jak Items

Items jest typem TStrings.

[krusade]

Dziękuje za pomoc.

[polymorphism]

Ja nawykłem korzystać kiedy to tylko możliwe ze zmiennych AnsiString dlatego często konwertuję typ char na typ AnsiString.

OK, ale to nie zawsze ma sens. W tym przypadku nie ma. Co innego gdybyś zrobił tak:

Kod: Zaznacz cały

bool CALLBACK EnumWindowsProc(HWND hWnd, TStrings *EnumList)
{
   char WindowName[255];
   DWORD ID;
   GetWindowText(hWnd, WindowName, 255);
   GetWindowThreadProcessId(hWnd, &ID);

   AnsiString win_name(WindowName); //<--- TU
   
   if(!win_name.IsEmpty())
   {
      if(IsWindowVisible(hWnd) >= 1)
      {
         String tmp = win_name + " - " + GetMemory(ID);
         if(EnumList->IndexOf(tmp) < 0) EnumList->Add(tmp);
      }
   }
   return true;
}

Z trzech konwersji WindowName na AnsiStringa mamy tylko jedną, a użycie IsEmpty jest jak najbardziej uzasadnione

Items jest typem TStrings.

Nie rozumiem

[Cyfrowy Baron]

Właściwość Items obiektu TListBox jest właściwością typu TStrings, tak jak np. właściwość Cpation obiektu TLabel jest typu AnsiString - o to chodzi.

Co do tego:

if(!AnsiString(WindowName).IsEmpty())

to droga na skróty: AnsiString(WindowName) - została dokonana konwersja WindowName na typ AnisString dlatego jest to teraz typ AnisString i można użyć funkcji IsEmpty. Kod działa bez zarzutu, taka skrótowość jest dopuszczalna w języku C++, być może zamazuje nieco kod, ale błędem nie jest.

To co wyżej może być też zapisane tak:

if(!((String)WindowName).IsEmpty())

można by się zastanawiać, czemu więc się nie przyczepiłeś do tego:

EnumList->Add((String)WindowName + " - " + GetMemory(ID));

jest jednak oczywiste, że tutaj ta konwersja jest niezbędna, gdyż oczekiwana jest wartość typu AnsiString a nie char.
można to zapisać również tak:

EnumList->Add(AnsiString(WindowName) + " - " + GetMemory(ID));

a analogicznie do tego co Ty proponujesz powinno to wyglądać tak:

AnsiString win_name(WindowName);
EnumList->Add(win_name + " - " + GetMemory(ID));

tylko po jaką cholerę tworzyć dodatkową zmienną tam gdzie nie jest ona konieczna, dlatego to:

AnsiString win_name(WindowName);
if(!win_name.IsEmpty())

jest równoznaczne z tym:

if(!AnsiString(WindowName).IsEmpty())

tylko dodatkowa zmienna nie jest tworzona.
Ja sobie tego nie wymyśliłem, tego typu konwersje są często spotykane w książkach poświęconych temu językowi.

[polymorphism]

tylko po jaką cholerę tworzyć dodatkową zmienną tam gdzie nie jest ona konieczna

No przecież napisałem dlaczego:

Z trzech konwersji WindowName na AnsiStringa mamy tylko jedną

Zwróć uwagę, że WindowName jest wykorzystywane w dalszej części kodu, a tam znowu będzie konwertowane na AnsiStringa. Jeśli tak, to robię jedną konwersję na potrzeby późniejszego kodu. To są podstawy optymalizacji.

tylko dodatkowa zmienna nie jest tworzona.

Jeśli chodzi ci o pamięć, to jest tworzona. Niejawnie, tymczasowo.

Ja sobie tego nie wymyśliłem, tego typu konwersje są często spotykane w książkach poświęconych temu językowi.

Wiem, że są. Często je stosuje, ale tylko wtedy, gdy jest to konieczne. Przykład:

Kod: Zaznacz cały

vector<string> vec;
const char*   p1 = "abcd 1234 abcd";
const char*   p2 = p1 + strlen(p1);
const char*   p3;

/* Tu sobie parsuje tekst */
while(p1 != p2 && !isdigit(*p1))++p1;
p3 = p2;
while(p3 != p2 && isdigit(*p3))++p3;

/*** teraz do vectora muszę dodać wycinek tekstu określony przez p1 i p2 ***/

vec.push_back(string(p1,p3));

W żadnej dobrej książce nie znajdziesz takich konstrukcji jak ta z IsEmpty.

[Cyfrowy Baron]

Nie przekonałeś mnie. Uważam, ze mój sposób jest lepszy.
Zamykam post, żeby go dalej nie zaśmiecać jałową dyskusją.