Programiranje u C++-u - pitanja i odgovori

Evo brljotine. Kompliciranije je nego što sam planirao zato što se nisam mogao suzdržati ubacivanja svega i svačega.

#include <stdlib.h>
#include <time.h>
#include <windows.h>

typedef struct
{
    int x;
    int y;
} VECTOR, *PVECTOR;

typedef struct
{
    COLORREF color;
    VECTOR size;
    VECTOR position;
    VECTOR oldPosition;
    VECTOR speed;
} OBJECT, *POBJECT;

typedef struct
{
    int count;
    POBJECT list;
} OBJECTS, *POBJECTS;

typedef struct
{
    HWND hwnd;
    int doubleBuffering;
    int runThread;
    HDC hdcBack;
} ARGUMENTS, *PARGUMENTS;

#define IDM_SINGLE  500
#define IDM_DOUBLE  501
#define IDM_CLOSE   502

#define GetWidth(x) (x.right - x.left)
#define GetHeight(x) (x.bottom - x.top)

LRESULT CALLBACK WindowProcedure(HWND, UINT, WPARAM, LPARAM);
DWORD WINAPI AnimationFunction(void *param);
void DrawCircles(HWND hwnd, POBJECTS objects, float delta, HDC hdcBack, int doubleBuffer);
void CreateBackBuffer(HWND hwnd, HDC *hdcBack, HBITMAP *backBufferBitmap);
void DestroyBackBuffer(HDC hdcBack, HBITMAP backBufferBitmap);

int WINAPI WinMain(HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nCmdShow)
{
    HWND hwnd;
    MSG message;
    WNDCLASS wc = {0};
    HMENU mainMenu = CreateMenu(),
          applicationMenu = CreateMenu();

    wc.hInstance      = hThisInstance;
    wc.lpszClassName  = "GDIAnimationAppClass";
    wc.lpfnWndProc    = WindowProcedure;
    wc.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground  = COLOR_SCROLLBAR + 1;

    if (!RegisterClass(&wc))
        return 0;

    AppendMenu(mainMenu, MF_POPUP | MF_STRING, (UINT_PTR)applicationMenu, "Application");
    AppendMenu(applicationMenu, MF_STRING, IDM_SINGLE, "Use single buffering");
    AppendMenu(applicationMenu, MF_STRING | MF_CHECKED, IDM_DOUBLE, "Use double buffering");
    AppendMenu(applicationMenu, MF_SEPARATOR, IDM_SINGLE, " ");
    AppendMenu(applicationMenu, MF_STRING, IDM_CLOSE, "Close");

    hwnd = CreateWindow("GDIAnimationAppClass", "GDI animation test",
                        WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_VISIBLE,
                        CW_USEDEFAULT, CW_USEDEFAULT, 500, 500,
                        NULL, NULL, hThisInstance, NULL);

    SetMenu(hwnd, mainMenu);

    while (GetMessage(&message, NULL, 0, 0))
    {
        TranslateMessage(&message);
        DispatchMessage(&message);
    }

    return message.wParam;
}

LRESULT CALLBACK WindowProcedure(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static ARGUMENTS arguments;
    static HANDLE thread;
    HMENU mainMenu, applicationMenu;
    RECT windowRect;

    switch (message)
    {
        case WM_CREATE:
            arguments.hwnd            = hwnd;
            arguments.doubleBuffering = TRUE;
            arguments.runThread       = TRUE;
            thread = CreateThread(NULL, 0, AnimationFunction, (void*)&arguments, 0, NULL);
            break;

        case WM_DESTROY:
            arguments.runThread = FALSE;
            WaitForSingleObject(thread, 100);
            PostQuitMessage(0);
            break;

        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDM_SINGLE:
                    arguments.doubleBuffering = FALSE;

                    mainMenu = GetMenu(hwnd);
                    applicationMenu = GetSubMenu(mainMenu, 0);

                    ModifyMenu(applicationMenu, 0,
                               MF_CHECKED | MF_BYPOSITION | MF_STRING,
                               IDM_SINGLE, "Use single buffering");
                    ModifyMenu(applicationMenu, 1,
                               MF_UNCHECKED | MF_BYPOSITION | MF_STRING,
                               IDM_DOUBLE, "Use double buffering");
                    break;

                case IDM_DOUBLE:
                    arguments.doubleBuffering = TRUE;

                    mainMenu = GetMenu(hwnd);
                    applicationMenu = GetSubMenu(mainMenu, 0);

                    ModifyMenu(applicationMenu, 0,
                               MF_UNCHECKED | MF_BYPOSITION | MF_STRING,
                               IDM_SINGLE, "Use single buffering");
                    ModifyMenu(applicationMenu, 1,
                               MF_CHECKED | MF_BYPOSITION | MF_STRING,
                               IDM_DOUBLE, "Use double buffering");

                    GetClientRect(hwnd, &windowRect);
                    FillRect(arguments.hdcBack, &windowRect, COLOR_SCROLLBAR + 1);
                    break;

                case IDM_CLOSE:
                    arguments.runThread = FALSE;
                    WaitForSingleObject(thread, 100);
                    PostQuitMessage(0);
                    break;
            }
            break;

        default:
            return DefWindowProc(hwnd, message, wParam, lParam);
    }

    return 0;
}

DWORD WINAPI AnimationFunction(void *arguments)
{
    HWND hwnd = ((PARGUMENTS)arguments)->hwnd;
    int *doubleBuffering = &((PARGUMENTS)arguments)->doubleBuffering;
    RECT windowRect;
    const int updatesPerSecond = 25;
    const int skipTicks = 1000 / updatesPerSecond;
    const int numberOfCircles = 20;
    float delta;
    DWORD nextTick = GetTickCount();
    OBJECTS objects;
    HDC hdcBack;
    HBITMAP backBufferBitmap;

    srand(time(NULL));
    GetClientRect(hwnd, &windowRect);

    CreateBackBuffer(hwnd, &hdcBack, &backBufferBitmap);
    ((PARGUMENTS)arguments)->hdcBack = hdcBack;

    objects.list = LocalAlloc(LMEM_FIXED, sizeof(OBJECT) * numberOfCircles);
    objects.count = numberOfCircles;

    // stvori kružnice nasumične veličine, boje, smijera i brzine
    for (int n = 0; n < objects.count; n++)
    {
        objects.list[n].color = RGB(rand() % 255, rand() % 255, rand() % 255);

        objects.list[n].position.x    = 10;
        objects.list[n].position.y    = 10;
        objects.list[n].oldPosition.x = 10;
        objects.list[n].oldPosition.y = 10;
        objects.list[n].speed.x       = rand() % 10 + 1;
        objects.list[n].speed.y       = rand() % 10 + 1;
        objects.list[n].size.x        = rand() % 100 + 1;
        objects.list[n].size.y        = objects.list[n].size.x;
    }

    while (((PARGUMENTS)arguments)->runThread)
    {
        // procesiraj kružnice
        if (GetTickCount() > nextTick)
        {
            for (int n = 0; n < objects.count; n++)
            {
                // provjeri je li trenutna kružnica udarila u jedan od 4 ruba
                // prozora i promijeni joj smijer ako jest
                if (objects.list[n].position.x +
                    objects.list[n].speed.x +
                    objects.list[n].size.x > GetWidth(windowRect))
                {
                    objects.list[n].speed.x *= -1;
                }

                if (objects.list[n].position.y +
                    objects.list[n].speed.y +
                    objects.list[n].size.y > GetHeight(windowRect))
                {
                    objects.list[n].speed.y *= -1;
                }

                if (objects.list[n].position.x +
                    objects.list[n].speed.x < 0)
                {
                    objects.list[n].speed.x *= -1;
                }

                if (objects.list[n].position.y +
                    objects.list[n].speed.y  < 0)
                {
                    objects.list[n].speed.y *= -1;
                }

                // pomakni kružnicu
                objects.list[n].position.x += objects.list[n].speed.x;
                objects.list[n].position.y += objects.list[n].speed.y;
            }

            nextTick += skipTicks;
        }

        // nacrtaj sve kružnice
        delta = (GetTickCount() - (nextTick - skipTicks)) / (float)skipTicks;
        DrawCircles(hwnd, &objects, delta, hdcBack, *doubleBuffering);

        // pauziraj glavnu petlju na 15 milisekundi
        // kako bi ograničili količinu crtanja na nešto više od 60
        // sličica u sekundi i rasteretili procesor
        Sleep(15);
    }

    // thread završava, oslobodi resurse...
    LocalFree(objects.list);
    DestroyBackBuffer(hdcBack, backBufferBitmap);

    return 0;
}

void DrawCircles(HWND hwnd, POBJECTS objects, float delta, HDC hdcBack, int doubleBuffer)
{
    HDC hdcFront = GetDC(hwnd),
        hdcTarget = doubleBuffer ? hdcBack : hdcFront;

    HBRUSH eraseBrush = CreateSolidBrush(GetSysColor(COLOR_SCROLLBAR)),
           colorBrush,
           oldBrush;

    HPEN erasePen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_SCROLLBAR)),
         colorPen = CreatePen(PS_SOLID, 0, RGB(0, 0, 0)),
         oldPen;

    int xStep, yStep;
    RECT windowRect;

    GetClientRect(hwnd, &windowRect);

    // odaberi pen i brush koji čemo koristiti za brisanje
    // i sačuvaj originalni pen i brush
    oldPen = SelectObject(hdcTarget, erasePen);
    oldBrush = SelectObject(hdcTarget, eraseBrush);

    // izbriši sve kružnice
    for (int n = 0; n < objects->count; n++)
    {
        Ellipse(hdcTarget,
                objects->list[n].oldPosition.x, objects->list[n].oldPosition.y,
                objects->list[n].oldPosition.x + objects->list[n].size.x,
                objects->list[n].oldPosition.y + objects->list[n].size.y);
    }

    // nacrtaj kružnice na novim pozicijama
    SelectObject(hdcTarget, colorPen);
    for (int n = 0; n < objects->count; n++)
    {
        colorBrush = CreateSolidBrush(objects->list[n].color);
        SelectObject(hdcTarget, colorBrush);

        // interpoliraj fini pomak između dva updatea kako bi
        // animacija bila glađa
        xStep = objects->list[n].speed.x * delta;
        yStep = objects->list[n].speed.y * delta;

        Ellipse(hdcTarget,
                objects->list[n].position.x + xStep,
                objects->list[n].position.y + yStep,
                objects->list[n].position.x + objects->list[n].size.x + xStep,
                objects->list[n].position.y + objects->list[n].size.y + yStep);

        objects->list[n].oldPosition.x = objects->list[n].position.x + xStep;
        objects->list[n].oldPosition.y = objects->list[n].position.y + yStep;

        DeleteObject(colorBrush);
    }

    // kopiraj back buffer u front buffer
    if (doubleBuffer)
    {
        BitBlt(hdcFront, 0, 0, GetWidth(windowRect), GetHeight(windowRect),
               hdcBack, 0, 0, SRCCOPY);
    }

    // oslobodi sve GDI objekte i odaberi stari pen i brush
    DeleteObject(erasePen);
    DeleteObject(colorPen);
    DeleteObject(eraseBrush);

    SelectObject(hdcTarget, oldPen);
    SelectObject(hdcTarget, oldBrush);
    ReleaseDC(hwnd, hdcFront);
}

void CreateBackBuffer(HWND hwnd, HDC *hdcBack, HBITMAP *backBufferBitmap)
{
    RECT windowRect;

    GetClientRect(hwnd, &windowRect);
    HDC hdcFront = GetDC(hwnd);

    *backBufferBitmap = CreateCompatibleBitmap(hdcFront, GetWidth(windowRect),
                                               GetHeight(windowRect));
    *hdcBack = CreateCompatibleDC(hdcFront);

    SelectObject(*hdcBack, *backBufferBitmap);
    FillRect(*hdcBack, &windowRect, COLOR_SCROLLBAR + 1);

    ReleaseDC(hwnd, hdcFront);
}

void DestroyBackBuffer(HDC hdcBack, HBITMAP backBufferBitmap)
{
    DeleteObject(backBufferBitmap);
    DeleteDC(hdcBack);
}

Nema GDI leakova i ja više nego zadovoljan za prvi put. Kratio sam linije što više kako bi izgledalo koliko-toliko pristojno na forumu pa zato neke stvari izgledaju malo čudno. Ali toplo preporučam kopiranje u IDE i analiziranje koda odatle...

Nije za one slabih živaca

Najbitnija stvar je da imaš dvije bitmape u dva device contexta.

Prvi (nazovimo ga front buffer) je u biti površina prozora i sve što po njemu crtaš je odmah vidljivo.

Drugi (nazovimo ga back buffer) nije vidiljiv nigdje na ekranu, u njega crtaš sve što trebaš kao da crtaš na ekran, i onda kada si gotov sa crtanjem samo kopiraš cijeli BackBuffer u FrontBuffer u jednom potezu pozivom na BitBlt. I tako frame po frame crtaš, svaki puta pozoveš BitBlt kada je frame spreman za prikazivanje na ekran.

Najbitnije stvari su ti u funkciji CreateBackBuffer gdje možeš vidjeti kako se stvara dodatni device context i u funkciji DrawCircles gdje možeš vidjeti kako izgleda crtanje kada radiš double buffering.

Pa onda ova linija:

hdcTarget = doubleBuffer ? hdcBack : hdcFront;

U kojoj se ovisno o vrijednosti doubleBuffer varijable selektira hdcBack ili hdcFront za crtanje. Tako je implementirano prebacivanje između single i double bufferinga u meniju. Odabereš recimo single buffering i "doubleBuffer" varijabla poprimi vrijednost 0 (False) i onda uvjet nije zadovoljen pa se koristi hdcFront za crtanje. U biti cijeli taj konstrukt je ternarni operator pa si možeš to pogledati ako te zbunjuje.

u biti to ti je isto kao da piše ovo:

if (doubleBuffer)
    hdcTarget = hdcBack;
else
    hdcTarget = hdcFront;

i onda kada smo odredili što će biti "meta" po kojoj ćemo crtati (hdcFront ako koristimo single buffering, ili hdcBack ako koristimo double buffering) samo dalje crtamo po tome sve dok ne dođemo do:

if (doubleBuffer)
{
    BitBlt(hdcFront, 0, 0, GetWidth(windowRect), GetHeight(windowRect),
           hdcBack, 0, 0, SRCCOPY);
}

Ovo se izvršava samo ako je aktiviran double buffering, i time cijeli sadržaj back buffera (hdcBack) kopiramo u front buffer (hdcFront) čime frame postaje vidljiv na ekranu. Obrati pozornost da to nije potrebno ako koristimo single buffering jer onda već crtamo po front bufferu pa je sve odmah vidljivo.

Doma xD. Nije ti ovo ništa komplicirano, samo ti tako izgleda zato što se koristi puno API funkcija koje nisi još vidio a i zato što nisi napisao taj kod pa ne znaš gdje je što. Nema nikakvih kompliciranih algoritama ili nešto (doslovno samo linearne iteracije po elementima polja), i korištenje dodatnog threada za animirano crtanje.

A i vjerojatno moja "vještina" pridonosi nečitkosti programa

Uzmeš liniju po liniju i pratiš program kako se izvršava i sve će ti sjesti na svoje mjesto. Mijenjaj kod, igraj se. Stavi neke dijelove pod komentar i vidi kako se program ponaša bez njih.

Treba ti handle od prozora, kada imaš handle onda možeš jednostavno dohvatiti Device Context sa GetDC.

Ajde neki hacker neka mi se javi ili bilo tko ko zna oko hack toolova i tih gluposti :)

Treba ti polje od 10 cijelih brojeva u koje ćeš spremiti taj svoj skup od deset brojeva, i onda koristeći petlju i neku funkciju za unos sa tipkovnice svakom članu polja dodijeliš neku vrijednost koju će korisnik upisati na tipkovnici.

Dalje, također samo dereš kroz to polje sa petljama i radiš ono što se dalje traži u zadatku. Provjeriti je li neki broj djeljiv sa nekim drugim brojem možeš pomoću modulo operatora koji ti daje ostatak dijeljenja s nekim brojem, pa ako je taj ostatak 0 onda znači da je broj djeljiv.

Sad sam već malo pohvatao program :D

No kad crtam po DirectX programu koristeći double buffering filcker je još gori nego u slučaju single. :( tak da izgleda ništa od GDI-a

Ispisuješ adrese varijabli broj i umno.

& znači adresa varijable, kod scanf-a se koristi da se ta vrijednost pohrani na tu adresu, dok kod printf-a, se ispisuje vrijednost varijable, dakle ne treba ti adresa (&).

Ne :) zašto bi mi za to trebao GDI. A i ne volim uništavati igrice koje volim.

Radi se o posve legitimnom addonu koji pokazuje neke dodatne informacije, kao chat history, neke skripte, etc. Pitao sam i developere, nemaju ništa protiv mog programa.

Ima, ali ti neće niko htjeti to raditi, zašto nisi učio? A da, sad ćeš reći da je profesor munjen i da ne zna objašnjavati.

Tražim neku jednostavnu funkciju tipa

int broj=CreateDialogForEnteringInt("Upišite cijeli broj");

znači program već ima svoj parent window, no neznam kako handlati dodatan prozor. Znači kad se pozove funkcija otvori se novi prozor s tekstom "Upište cijeli broj", ispod toga polje u koje se upisuje broj i gumb OK, koji se stisne po završetku unosa. Kad se stisne OK, prozor nestane, funkcija završava i vraća mi unešeni int broj.

Čovječe koliko posla za jednu formu, što dobijem sa jednom linijom koda u C#, odnosno VS-u Form1 novaForma = new Forrm1(this)

Sad kužim zašto je onaj C++ builder onako skup.

Slažem se, a i kôd je 90% isti bez obzira o kojem se jeziku radilo, tako da je lako dalje prevesti u BASIC, pascal i ostale .NET neovisne jezike.

Oko 5 godina sam programirao u dvije ovakve biblioteke a to su Borlandov OWL i MS MFC i ne mogu se složiti da je to nikakav posao. Pogotovo kada se uzmu u obzir malo veći projekti koji se sastoje od 10ak i više prozora to postane jednostavno ogromna količina koda u kojoj se s vremenom sve teže snaći, dok je i samom compileru to sve teže "sažvakati". Sjećam se da smo na fakultetu jedan MFC projekt od 27 prozora pustili da se compilira kroz cijelu noć, dok bi ga testirali tek kroz zasebne module i dll-ove.

Obje tvrtke (Borland i MS) su se odrekli ovakvih pristupa programiranju. MS je razvio .NET i "zaboravio" MFC, a Borland umjesto OWL-a razvio VCL. Nema više identifikatora za objekte, objektih mapa za praćenje događaja, već unikatno i .NET i VCL koriste event-e. Rezultat je puno manje koda i puno brže compiliranje. Također je i sam razvoj brži jer programer ne mora ručno deklarirati objekte unutar dijalog klasa, indentifikatore za njih, povezivati identifikatore s funkcijama za događaje i sl., već je to sve automatizirano samim IDE-om.

EDIT:

Činjenica je da tehnologija konstantno napreduje i trebalo bi biti u toku s njom. Primjerice, čak i VCL polako pada u zaborav. Iako je trenutno još uvijek jako zastupljen u Delphiju i C++ Buileru Embarcadero se trudi developere prebacivati na novu FireMonkey biblioteku koja podržava win, mac, ios, android, a uskoro i linux, dok VCL tek win platformu. Tako da, za par godina VCL će također biti depricated...

Qt i Qt Creator?

offtopic