• In diretta da GamesVillage.it
    • News
    • -
    • In Evidenza
    • -
    • Recensioni
    • -
    • RetroGaming
    • -
    • Anteprime
    • -
    • Video
    • -
    • Cinema

Pag 1 di 2 12 UltimoUltimo
Visualizzazione risultati da 1 a 15 di 19

Discussione: [Pillola] Come creare un programma in ambiente win32

Cambio titolo
  1. #1
    Utente
    Registrato il
    07-04
    Messaggi
    1.289

    Come creare un programma in ambiente win32

    COME CREARE UN PROGRAMMA IN AMBIENTE WIN32

    Software necessario:

    • Microsoft Visual C++ 6

    Conoscenze necessarie:

    • Le basi del C/C++

    Altre conoscenze consigliate:

    • Una conoscenza basilare di MS Visual C++

    Salve ragazzi, benvenuti nella prima lezione di questa guida!
    Bando alle ciance, cominciamo subito!
    Innanzitutto avviamo VC++, clicchiamo su File -> New..., quindi clicchiamo su “Win32 Application”, dopodichè nel campo Project Name inseriamo il nome del progetto. Io ho messo “programma win32”. A questo punto clicchiamo su OK. Clicchiamo su “empty project” dal momento che vogliamo creare un progetto vuoto e non un’applicazione semplice win32 già preparata oppure un programma di esempio. Cliccando su OK ci apparirà il solito riepilogo, chiudiamolo cliccando sempre su OK.
    A questo punto ci apparirà la schermata vuota, apriamo il TAB FileView, ed estendiamo il progetto “programma win32”, quindi facciamo doppio click sulla cartella Source Files come in figura:



    A questo punto non ci resta che cliccare su File -> New... e quindi nella scheda Files cliccare su C++ Source File. Specifichiamo il nome nel campo File name (mettiamo main.cpp) quindi clicchiamo su OK per confermare.

    Prima di iniziare a fare sul serio, è necessario sapere qualche cosuccia teorica.
    Innanzitutto come tutti sappiamo Windows è un sistema operativo multitasking (cioè può eseguire più di un processo alla volta).
    La gestione dei processi in Windows è affidata allo scheduler, che attribuisce a ogni processo un tempo per eseguire il codice del programma stesso, oltre che attribuirgli la priorità.
    Inoltre ogni processo ha un ciclo che contiene una coda di eventi che servono per verificare se ci sono messaggi che il S.O. ha inviato al programma. Se ad esempio l’utente ridimensiona la finestra dell’applicazione, Windows genera il relativo messaggio ( WM_SIZE ) e lo aggiunge ad una coda. I messaggi vengono gestiti dalla funzione apposita WndProc (Windows Procedure). Se non ci avete capito una mazza lo capirete nel corso del tutorial e magari con qualche esercitazione!

    OK, finalmente possiamo iniziare a programmare su main.cpp.
    Cominciamo con lo scrivere le prime righe di codice necessarie alla corretta compilazione del codice:

    #include < windows.h > //include l’header con le funzioni di base per windows
    #define WIN32_LEAN_AND_MEAN /*esclude dagli headers di windows funzioni usate
    raramente*/

    //FUNZIONE PRINCIPALE
    int WINAPI WinMain(HISTANCE hInstance, HINSTANCE hPrevInstance, LPSTR IpCmdLine,
    int nShowCmd)
    {

    //codice programma
    return 0;

    }

    Dunque, andiamo a esaminare la funzione principale visto che le altre righe sono commentate. Se non avete mai programmato in ambiente Win32 dovete sapere che il nome della funzione principale non è main() bensì WinMain(). Ora andiamo a esaminare i parametri di WinMain:
    hInstance: è un handle all’istanza del programma, un handle vuol dire dall’inglese “maniglia” ed è un oggetto che in pratica ci permette di riferirci al programma che ci interessa utilizzare.
    hPrevInstance: non ci interessa dal momento che è una variabile che veniva usata per applicazioni sotto Win 3.x quindi lasceremo sempre come NULL.
    LPSTR IpCmdLine: è un puntatore alla stringa di testo che viene digitata per avviare il programma (per es. programma win32.exe parametro).
    nShowCmd: ci permette di specificare in che modo avviare la finestra del nostro programma.

    Se proviamo a compilare il programma vedremo che dopo aver compilato e linkato non apparirà nulla; logico, non c’è nulla nella funzione principale!
    Proviamo a far comparire una finestrella ( MessageBox ) con del testo; scriviamo al posto di “//codice programma” la seguente riga di codice:

    MessageBox(0,”Ciao bello, come va la vita?”,”Hola!”,0);

    Ecco fatto, proviamo ad avviare l’applicazione! Divertente? Ma se ancora non abbiamo fatto nulla di serio... (appunto!). Comunque sia, spieghiamo un po’ come funge questa funzione dal momento che ci ritroveremo a usarla molto spesso nelle nostre applicazioni.
    Il primo parametro è un handle alla finestra, ma visto che non abbiamo una finestra, per ora è settato a 0 (oppure NULL). Il secondo parametro è il testo che apparirà nel MessageBox, tra virgolette visto che è una stringa. Il secondo è il titolo del MessageBox, sempre una stringa, ovviamente.
    Il quarto parametro ci permette di fare cosuccie abbastanza utili e divertenti, provate ad esempio a mettere una cifra da 1 a 6 al posto di 0 e avviate! (più in là vedremo anche come programmare i pulsanti di un MessageBox).

    Qualcuno potrà obbiettare che stiamo facendo solo cavolate... In effetti è vero, quindi cominciamo la creazione della nostra benedetta finestra! Per creare una finestra, in generale, c’è bisogno di effettuare quattro operazioni:

    1. Settare gli attributi della Window Class
    2. Registrarla
    3. Crearla
    4. Generare un ciclo che gestisca la coda degli eventi

    Ehi, ma quante cose che dobbiamo fare! Già sento le solite urla dannate e vedo i lettori di questo tutorial strapparsi i capelli e rotolarsi sul pavimento... Su, la soddisfazione vi ripagherà di tutti gli sforzi compiuti!!

    Innanzitutto leviamo da mezzo la linea del MessageBox e aggiungiamo il seguente codice PRIMA della chiamata a WinMain:

    //Windows Procedure
    LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
    //codice della WndProc
    return 0;
    }

    Nella chiamata a WinMain scriviamo invece le seguenti righe:

    HWND hWnd; //handle alla finestra
    MSG msg; //messaggio
    bool done; //serve a sapere quando l’applicazione sarà terminata

    Abbiamo aggiunto tre variabili commentate e la funzione Windows Procedure che, come ho detto prima, serve a far comunicare S.O. e applicazione tra loro (visto quanto crasha Windows, chissà quante cazzate si dicono ).
    Vediamo un po’ di che tipo è WndProc e a che cavolo servono i suoi parametri:
    LRESULT: memorizza un intero lungo, e quindi sarà un intero lungo che WndProc restituirà come risultato.
    HWND hWnd: beh, questa la sappiamo, no? Crea un window handle, cioè una “maniglia” alla finestra che ci permette di identificarla.
    UINT message: memorizza il tipo di messaggio a cui la funzione è stata legata.
    wParam, lParam: determinano il tipo del messaggio.

    Di messaggi ce ne sono tanti, noi ne useremo pochissimi, giusto quelli che ci servono per creare una bel programmino con cui potremo, tramite un menu, selezionare il testo che dovrà apparire sullo schermo!

    OK, ora che abbiamo analizzato tutti i parametri di WndProc, andiamo a scrivere il contenuto della funzione:

    PAINTSTRUCT PaintStruct;
    HDC hDC; //device-context
    char testo[]=”Scegliere un testo da visualizzare”;

    switch(message)
    {
    case WM_CREATE: //messaggio: la finestra è stata creata
    return 0;
    break;

    case WM_CLOSE: //messaggio: la finestra è stata chiusa
    PostQuitMessage(0); //manda il messaggio di chiusura
    return 0;
    break;

    case WM_PAINT: //messaggio: la finestra deve essere ridisegnata
    hDC=BeginPaint(hWnd, &PaintStruct);

    SetTextColor(hDC,COLORREF(0x00FF0000)); //colore del testo blu

    /* qui scriveremo in seguito il codice per la gestione
    dei menu che ci permetteranno di cambiare il contenuto
    della variabile testo, quindi ciò che apparirà sullo
    schermo! */

    //setta la posizione del testo al centro
    TextOut(hDC,150,150,testo,sizeof(testo)-1);

    EndPaint(hWnd,&PaintStruct);
    return 0;
    break;

    default:
    break;
    }

    return (DefWindowProc(hWnd,message,wParam,lParam));

    Via con le spiegazioni!

    PaintStruct è una variabile che serve a disegnare la finestra e a creare un device-context (DC) che sarebbe una struttura dati per l’output, nel nostro caso è la grafica della nostra applicazione, ma può essere anche, ad esempio, una stampante o qualunque altro dispositivo di output.
    Per ottenere il DC abbiamo utilizzato la funzione BeginPaint che accetta due parametri d’ingresso a differenza della più semplice getDC. I parametri per BeginPaint sono l’handle alla finestra ( hWnd ) e il riferimento a una PaintStruct (&PaintStruct, che si riferisce alla variabile creata più sopra).

    Lo switch-case permette una semplice e veloce gestione dei messaggi. Se l’utente chiude l’applicazione, Windows invierà al programma il messaggio di chiusura; di conseguenza il programma leggerà il codice contenuto nel case WM_CLOSE, cioè la chiamata alla funzione PostQuitMessage() che chiude l’applicazione; così ovviamente anche per gli altri case contenuti nello switch.

    Sempre tramite il device-context abbiamo settato il colore del testo tramite la funzione SetTextColor, a cui abbiamo passato come parametri il DC (ovviamente) e la funzione COLORREF che ci permette di definire un colore tramite valori esadecimali. Ad esempio per scrivere il colore blu che corrisponde a 00 00 FF dobbiamo invertire le cifre esadecimali, ottenendo quindi FF 00 00 che vanno scritte dopo 0x00. Il risultato è quindi 0x00FF0000.
    Se non sbaglio potete vedere i valori esadecimali di qualsiasi colore con Paint Shop Pro, ma non posso assicurarvi nulla dal momento che non ho il programma a portata di mano (anche se mi pare di aver visto una cosa del genere nella tavolozza dei colori).
    Alla funzione TextOut passiamo vari parametri come la posizione in cui vogliamo far apparire il testo, e la stringa che vogliamo stampare su schermo.
    Tutte queste funzioni di disegno sono comprese tra BeginPaint e EndPaint, perciò può essere utile utilizzare l’indentatura come se fossero le parentesi graffe di una funzione (il sorgente sarà completamente indentato come si deve! )

    Perfetto, ora che abbiamo creato la coda di messaggi non ci resta che andare a creare la cosa sicuramente più importante per permetterci di interagire con la nostra applicazione: la finestra!

    Torniamo a WinMain e sotto alle dichiarazioni dell’handle e della variabile messaggio, dobbiamo creare un’istanza della window class e settare varie cosuccie anche divertenti da personalizzare. Aggiungiamo perciò il seguente codice:

    WNDCLASSEX window; //window class
    //setting della finestra
    window.cbSize = sizeof(WNDCLASSEX); //dimensioni struttura WNDCLASSEX

    window.style = CS_HREDRAW | CS_VREDRAW; //setta lo stile della finestra
    window.lpfnWndProc = WndProc; //identifica l’indirizzo della WndProc
    window.cbClsExtra = NULL; //info extra per la classe
    window.cbWndExtra = NULL; //info extra per la finestra
    window.hInstance = hInstance; //l’handle all’istanza del programma
    window.hIcon = LoadIcon(NULL,IDI_APPLICATION); //icona standard
    window.hCursor = LoadCursor(NULL,IDC_ARROW); //puntatore mouse standard
    window.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); //sfondo
    window.lpszMenuName = NULL; //senza menu, ce ne occuperemo più avanti
    window.lpszClassName = “my_class”; //il nome della window class
    window.hIconSm = LoadIcon (NULL,IDI_WINLOGO); //icona standard di windows

    Ecco fatto... l’unica cosa che spiegherei visto che il resto è tutto commentato, è che CS_HREDRAW e CS_VREDRAW permettono all’applicazione di ridimensionare la finestra quando l’utente modificherà le proprietà di larghezza e altezza.
    Inoltre possiamo cambiare il colore dello sfondo per esempio mettendo BLACK_BRUSH al posto di WHITE_BRUSH in GetStockObject che abbiamo usato in hbrBackground.
    Oltre ovviamente all’icona dell’applicazione, al cursore, ecc.
    Per personalizzare ancora di più la nostra applicazione abbiamo la possibilità di scegliere tra queste di Windows; ovviamente in seguito vedremo come inserire la nostra.

    IDI_APPLICATION Applicazione di default
    IDI_ASTERISK Fumetto
    IDI_ERROR Errore
    IDI_EXCLAMATION Punto esclamativo
    IDI_INFORMATION Informazione (fumetto)
    IDI_QUESTION Punto interrogativo
    IDI_WARNING Punto esclamativo
    IDI_WINLOGO Logo di Windows
    Ultima modifica di [PW]Hangman; 21-02-2005 alle 19:36:16

  2. #2
    Utente
    Registrato il
    07-04
    Messaggi
    1.289
    Ora siamo pronti per registrare e creare la finestra, tenetevi pronti che ci siamo quasi!

    Sempre in WinMain inseriamo il seguente blocco di codice:

    //registrazione window class
    //la registrazione è avvenuta con successo?
    if (!RegisterClassEx(&window))
    return 0;

    //creazione finestra
    hWnd = CreateWindowEx
    (
    NULL, //stili estesi
    “my_class”, //nome classe
    “Applicazione Win32”, //nome applicazione
    WS_OVERLAPPEDWINDOW | WS_VISIBLE, //stile
    100,100, //ascissa e ordinata
    640,480, //larghezza e altezza
    NULL, //handle della base (non abbiamo una classe base)
    NULL, //handle al menu (non abbiamo nemmeno un menu)
    hInstance, //istanza applicazione (l’abbiamo definita prima)
    NULL //altri parametri
    );

    Andiamo ad analizzare i parametri che abbiamo passato alla funzione CreateWindowEx. Il primo serve ad aggiungere stili particolari che non ci interessano; il secondo è il nome della classe che vogliamo creare tra quelle registrate, in questo caso abbiamo creato solo my_class; il terzo parametro è il titolo che comparirà sulla barra del titolo dell’applicazione; il quarto definisce gli stili, WS_OVERLAPPEDWINDOW ad esempio racchiude molti degli stili classici di una finestra Windows come la possibilità di ingrandire, rimpicciolire o ridurre a icona l’applicazione, inoltre WS_VISIBLE serve a rendere inizialmente visibile la nostra applicazione; il quinto e sesto parametro rappresentano le coordinate a partire dalle quali verrà disegnata mentre il settimo e ottavo parametro definiscono la larghezza e l’altezza della finestra; il nono parametro è un handle alla classe base, settato a NULL visto che non abbiamo una classe base; il decimo si riferisce all’handle del menu ma anche questo l’abbiamo settato a NULL visto che non vogliamo includere alcun menu per ora; come ultimi parametri passiamo l’istanza dell’applicazione e NULL visto che non vogliamo passare parametri extra per la creazione della finestra.

    Proviamo ora a compilare e avviare l’applicazione: vedremo che comparirà la finestra per meno di un secondo e scomparirà subito dopo. Perchè questo? Semplice: non abbiamo creato un ciclo, più precisamente un ciclo per la gestione degli eventi.
    Andiamo a vedere come fare.
    Sempre in WinMain aggiungiamo il seguente blocco di codice:

    if (!hWnd)
    return 0;

    done = false; //inizializzazione della variabile del ciclo

    //loop principale
    while (!done)
    {
    PeekMessage(&msg,hWnd,NULL,NULL,PM_REMOVE);

    if (msg.message == WM_QUIT) //se il messaggio è WM_QUIT
    {
    done=true; //fine del ciclo
    }
    else
    {
    TranslateMessage(&msg); //traduce il messaggio
    DispatchMessage(&msg); //invia il messaggio a WinProc
    }

    } //fine loop principale
    return msg.wParam; //ritorna un intero


    La prima istruzione if verifica se la creazione della finestra è andata a buon fine; se così è passa al loop gestito dalla variabile booleana done. PeekMessage preleva il messaggio in testa alla coda degli eventi e lo attribuisce a msg, il primo parametro passato; il secondo identifica l’applicazione a cui appartiene la coda; il terzo e il quarto servono a filtrare i messaggi, noi li lasciamo settati a NULL visto che non ci interessano. L’ultimo PM_REMOVE serve a cancellare un messaggio una volta processato. Una volta ottenuto il messaggio con questa funzione, viene verificato se è il messaggio di chiusura, altrimenti viene tradotto attraverso la funzione TranslateMessage e inviato alla Windows Procedure con la funzione DispatchMessage.
    Se il messaggio è uguale a WM_QUIT, allora si setta la variabile done a true, in modo da terminare il ciclo; quando ciò succede ritorniamo un intero utilizzando wParam nella struttura msg.

    Ora non ci resta che creare un bel menu!
    Innanzitutto creiamo due files, salvandoli uno come “resource.rc” e l’altro come “resource.h”.
    In main.cpp inseriamo la seguente riga all’inizio del file:

    #include "resource.h"

    A questo punto possiamo andare ad editare il file che abbiamo appena incluso in main.cpp (resource.h ) una volta aperto scriviamo il seguente blocco di codice:

    #include < windows.h > //funzioni di Windows standar
    #include < stdio.h > //funzioni di I/O

    #define IDR_MENU 101
    #define IDM_OPTIONS 40001
    #define IDM_EXIT 40003

    Le prime due righe sono commentate e inoltre dovreste sapere bene cosa fanno!
    Le altre tre dichiarano i tre elementi che ci servono per creare questo piccolo menu formato da due opzioni: la prima, l’intero menu; la seconda, l’opzione “Opzioni”, e infine la terza, l’opzione “Esci”. Ora fiondiamoci in resource.rc a creare le opzioni appena dichiarate!

    Dopo aver aperto resource.rc inseriamo il seguente blocco di codice:

    #include "resource.h" //Header File for Header Files and IDs

    IDR_MENU MENU DISCARDABLE
    BEGIN
    POPUP "&File"
    BEGIN
    MENUITEM "Opzioni", IDM_OPTIONS
    MENUITEM SEPARATOR
    MENUITEM "Esci", IDM_EXIT
    END
    END

    Come vedete le istruzioni vanno date tra BEGIN e END; abbiamo creato il menu Opzioni, specificando ovviamente che si riferisce a IDM_OPTIONS, e stessa cosa l’abbiamo fatta per Esci; tutto ciò nel menu a tendina (popup) File.
    Ora non ci resta che specificare il menu appena creato nella funzione della creazione della finestra. In main.cpp, nella funzione WinMain, cambiamo quindi il seguente pezzo di codice da così:

    WNDCLASSEX window; //window class
    //setting della finestra
    window.cbSize = sizeof(WNDCLASSEX); //dimensioni struttura WNDCLASSEX
    window.style = CS_HREDRAW | CS_VREDRAW; //setta lo stile della finestra
    window.lpfnWndProc = WndProc; //identifica l'indirizzo della WndProc
    window.cbClsExtra = NULL; //info extra per la classe
    window.cbWndExtra = NULL; //info extra per la finestra
    window.hInstance = hInstance; //l'handle all'istanza del programma
    window.hIcon = LoadIcon(NULL,IDI_APPLICATION); //icona standard
    window.hCursor = LoadCursor(NULL,IDC_ARROW); //puntatore mouse standard
    window.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); //sfondo
    window.lpszMenuName = NULL; //senza menu
    window.lpszClassName = "my_class"; //il nome della window class
    window.hIconSm = LoadIcon (NULL,IDI_WINLOGO); //icona standard di windows

    a così:

    WNDCLASSEX window; //window class
    //setting della finestra
    window.cbSize = sizeof(WNDCLASSEX); //dimensioni struttura WNDCLASSEX
    window.style = CS_HREDRAW | CS_VREDRAW; //setta lo stile della finestra
    window.lpfnWndProc = WndProc; //identifica l'indirizzo della WndProc
    window.cbClsExtra = NULL; //info extra per la classe
    window.cbWndExtra = NULL; //info extra per la finestra
    window.hInstance = hInstance; //l'handle all'istanza del programma
    window.hIcon = LoadIcon(NULL,IDI_APPLICATION); //icona standard
    window.hCursor = LoadCursor(NULL,IDC_ARROW); //puntatore mouse standard
    window.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); //sfondo
    window.lpszMenuName = MAKEINTRESOURCE(IDR_MENU); //il nostro menu!
    window.lpszClassName = "my_class"; //il nome della window class
    window.hIconSm = LoadIcon (NULL,IDI_WINLOGO); //icona standard di windows

    Proviamo ora a compilare ed avviare, ma... ORRORE! Se clicchiamo su qualsiasi voce del menu appena creato non accade nulla! Semplice... non l’abbiamo programmato!

    Andiamo nella funzione WinProc e aggiungiamo, prima delle righe:

    default:
    break;
    }

    return (DefWindowProc(hWnd,message,wParam,lParam));

    }

    il seguente codice:

    case WM_COMMAND:
    {
    switch(LOWORD(wParam))
    {
    case IDM_OPTIONS:
    {
    //finestra di dialogo: opzioni
    }
    break;

    case IDM_EXIT:
    {
    PostQuitMessage(0);
    return 0;
    }
    }
    }
    break;

    Il case WM_COMMAND controlla se clicchiamo su un’opzione del menu:
    Per esempio se clicchiamo su Esci, identificata con IDM_EXIT da noi in resource.h, allora il programma eseguirà il codice contenuto in quel case, cioè PostQuitMessage(0); e return 0; che chiude l’applicazione. Semplice no?
    Proviamo a compilare e avviare... Funziona solo l’opzione Esci! Logico, la funzione Opzioni la programmeremo nella prossima lezione!

    Per ora provate a fare questo esercizio:

    • Create un nuovo popup (come File, ad esempio) dal quale è possibile richiamare un MessageBox in cui apparirà il nostro nome o quello che ci pare e piace!

    Nella prossima lezione impareremo a:

    • Creare una finestra di dialogo dalla quale potremo settare le nostre opzioni!

    Se vi serve il codice sorgente... cliccate qui! Codice sorgente

    Byez!

    Hangman
    Ultima modifica di [PW]Hangman; 21-02-2005 alle 13:49:36

  3. #3
    Utente
    Registrato il
    07-04
    Messaggi
    1.289
    Per qualsiasi problema potete scrivermi qui sul forum o contattarmi via email, oppure potete consultare le MSDN dove troverete ogni funzione/struttura/classe ecc. delle WinAPI (ma anche delle DirectX e di tante altre cose) spiegata in ogni suo aspetto.

  4. #4
    ~ Over My Head ~ L'avatar di Finalfire
    Registrato il
    06-03
    Località
    Italy
    Messaggi
    5.013
    Grande
    Pillola meritatissima

  5. #5
    Oh my iPod! L'avatar di er patata
    Registrato il
    11-02
    Località
    Bari Downtown
    Messaggi
    13.136
    ci owni tutti Rosy

    A volte credo di essere fin troppo nerd. Naa, never too much.
    Vuoi personalizzare l'aspetto del forum di GamesRadar? Clicca qui!
    Consortium.ru 2004 3D Motion Demo, shocking graphics. (QuickTime 60MB)

    Vuoi guadagnare soldi velocemente? Clicca qui!

  6. #6
    Utente
    Registrato il
    02-05
    Messaggi
    12.335
    raga io ho il compilatore (o come si chiama) che è questo

    Dev-C++ 5.0 beta 9.2 (4.9.9.2) (9.0 MB) with Mingw/GCC 3.4.2

    lo posso usare per fare questo tutorial? se no mi date il link PRECISO del programma che serve?

    grazie ciao

  7. #7
    Fiero di essere TERRONE L'avatar di Peppigno
    Registrato il
    10-02
    Località
    Nel paese delle puttanone
    Messaggi
    39.071
    Citazione er patata
    ci owni tutti Rosy
    se se... e bravo a Rosariuccio

    @ Olimar85, c'è la versione Visual C++ 2005 Express Edition scaricabile gratuitamente dal sito della Microsoft... credo che ti andrebbe comodo

  8. #8
    Bannato L'avatar di hakkerz
    Registrato il
    12-05
    Messaggi
    317
    Citazione Peppigno
    se se... e bravo a Rosariuccio

    @ Olimar85, c'è la versione Visual C++ 2005 Express Edition scaricabile gratuitamente dal sito della Microsoft... credo che ti andrebbe comodo
    E why dovrebbe prendere una schifezza M$ quando può permettersi Dev-cpp?

  9. #9
    Utente
    Registrato il
    02-05
    Messaggi
    12.335
    Citazione Peppigno
    se se... e bravo a Rosariuccio

    @ Olimar85, c'è la versione Visual C++ 2005 Express Edition scaricabile gratuitamente dal sito della Microsoft... credo che ti andrebbe comodo
    noooooooooooooooooooooo

    mi serve l'SP2
    lo installai una volta e mi dette problemi8(


    altro?

  10. #10
    Utente
    Registrato il
    02-05
    Messaggi
    12.335
    Citazione hakkerz
    E why dovrebbe prendere una schifezza M$ quando può permettersi Dev-cpp?
    guarda mica l'ho comprato: l'ho scaricato...aspetta ti dò il link
    http://www.bloodshed.net/dev/devcpp.html
    http://downloads-zdnet.com.com/Blood...ml?tag=lst-0-1

  11. #11
    Fiero di essere TERRONE L'avatar di Peppigno
    Registrato il
    10-02
    Località
    Nel paese delle puttanone
    Messaggi
    39.071
    Citazione Olimar85
    noooooooooooooooooooooo

    mi serve l'SP2
    lo installai una volta e mi dette problemi8(


    altro?
    fai una partizione e installa WinXP SP2

  12. #12
    Bannato L'avatar di hakkerz
    Registrato il
    12-05
    Messaggi
    317
    Citazione Olimar85
    guarda mica l'ho comprato: l'ho scaricato...aspetta ti dò il link
    http://www.bloodshed.net/dev/devcpp.html
    http://downloads-zdnet.com.com/Blood...ml?tag=lst-0-1
    E io cosa intendevo?
    Intendevo: perche prendere schifezze, quando c'è l'open source?

  13. #13
    Fiero di essere TERRONE L'avatar di Peppigno
    Registrato il
    10-02
    Località
    Nel paese delle puttanone
    Messaggi
    39.071
    Citazione hakkerz
    E why dovrebbe prendere una schifezza M$ quando può permettersi Dev-cpp?
    non fa tanto schifo...

  14. #14
    megaman
    Ospite
    Citazione hakkerz
    E why dovrebbe prendere una schifezza M$ quando può permettersi Dev-cpp?
    puoi prenderla con qualsiasi prodotto M$, ma la sua linea di "tool" per sviluppo ( ide/rad/compilatori ) mi sembra tutt'altro che scadente...ok, ha alcune pecche però non mi sembra il caso di definire tali strumenti delle schifezze; considera pure che quasi tutte le software house professionali usano VS, comprese quelle per gamedev ( vedere errori generati con titolo della messagebox visual C++ 200x error o il sorgente di Quake III ). Oltretutto Dev Cpp come IDE è abbastanza vecchiotto, ed è inferiore di parecchio da un IDE come Code:locks. E poi un IDE non è necessario.

  15. #15
    StorieDallaSalaMacchine L'avatar di miniBill '90
    Registrato il
    08-05
    Località
    Bergerac
    Messaggi
    4.205
    allora:
    Window$ fa schifo sono daccordo
    ma i vari M$ Visual eccetera
    sono MOLTO avanti rispetto alla concorrenza open source
    ad esempio:
    vedere i varoli delle variabili e delle loro proprietà durante il debug
    MODIFICARLI AL VOLO(già, pareva impossibile anche a me, ma è vero!!!!!!!!!)
    metter il prog in pausa ed eseguirlo uno step alla volta
    la documentazione (programmino DA PAURA)
    niente da dire
    la M$ con gli IDE ha fatto proprio un buon lavoro

Pag 1 di 2 12 UltimoUltimo

Regole di Scrittura

  • Tu non puoi inviare nuove discussioni
  • Tu non puoi inviare risposte
  • Tu non puoi inviare allegati
  • Tu non puoi modificare i tuoi messaggi
  •