Hallo,
ich habe ein C-Konsolen-Anwendung für Windows geschrieben. Diese
soll ein Dialog-Fenster öffnen, in dem ich die Werte mehrerer
Variablen, die sich ständig ändern, ausgeben möchte. In der
Konsole ist mir das jetzt zu unübersichtlich geworden.
Wenn es geht, soll das Dialog-Fenster ohne MFC erstellt werden,
vielleicht auch in C.
Geht das irgendwie? Kann mir jemand helfen?
Danke.
Ja, du kannst in reinem C Win32 Anwendungen schreiben - mit reiner Win32 API eben. Aber, wie du dies mit einer Konsolenanwendung machst, weiß ich nicht - ich glaub' das geht gar nicht. Bei der reinen Win32 API Programmierung gibt es kein void main() sondern eine WinMain! Du must Fensterklassen bei Windows registrieren usw. Ich empfehle dir nicht!!!, mit Win32 API etwas zu schreiben, da man sich damit gut auskennen sollte und viel viel viel Zeit braucht! (Nacktes Fenster etwa 3 Din-A4 Seiten!)
[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]
ich habe ein C-Konsolen-Anwendung für Windows geschrieben.
Diese
soll ein Dialog-Fenster öffnen, in dem ich die Werte mehrerer
Variablen, die sich ständig ändern, ausgeben möchte. In der
Konsole ist mir das jetzt zu unübersichtlich geworden.
Wenn es geht, soll das Dialog-Fenster ohne MFC erstellt
werden,
vielleicht auch in C.
Ich empfehle dir nicht!!!, mit
Win32 API etwas zu schreiben, da man sich damit gut auskennen
sollte und viel viel viel Zeit braucht! (Nacktes Fenster etwa
3 Din-A4 Seiten!)
Gibt es denn da keine Bibliothek oder sowas?
Es muß doch schon mal jemand auf dei Idee gekommen sein, Windows-Programme ohne MFC zu entwickeln!
Vor vielen, vielen Jahren gab es noch keine MFC (Win 3.x - Zeiten). Da mussten alle Programmierer mit dem vom Betriebssystem bereitgestellten Funktionen (wie bei DOS mit Borland C++ auch) auskommen. Diese Sammlung von C-Funktionen (reines C) nannte man (ab Win95) WIN32-API (Application Programming Interface). Mit diesen vielen tausend Funktionen kann man eine windows-basierende Anwendung schreiben. Die Entwickler von Microsoft dachten sich jedoch, dass man die Features von C++ (OOP usw.) ausnutzen könnte und die Win32 API in viele Klassen zu kapseln. Die MFC (Microsoft Foundation Classes) wurden geboren! Mit diesen Klassen war das Programmieren von WIN32 Anwendungen nun um einiges einfacher! Wenn du nun ein konsolen-orientiertes Programm hast und du Windows-Controls verwenden willst, dann musst du so vorgehen, wie Ben es geschrieben hat - mit reiner Win32-API eben.
Um dies jedoch zu ermöglichen musst du dein Programm auf seine Struktur ändern...
d.h.:
* Die Philosophie von linearem Programmieren auf nachrichten-orientieren Stil ändern
* Eine WinMain statt main verwenden
* usw.
Mein Vorschlag:
* Steige auf MFC um
* oder bleib' bei Win32 Konsolenanwendungen
Solltest du es trotzdem wagen, dich in die Win32-API-Welt zu stürtzen, dann viel Glück! Ach, du fängst am Besten mit "Win32 - Anwendung" bei Datei-Neu-Projekte in Visual C++ 6 an, kopierst den Source von Ben, und adaptierst deine Source (ob das dafür steht, musst du selber entscheiden!?).
[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]
danke für deine Hilfe
Die Win32-API war mir dann doch zu kompliziert, ich habe es mit
MFC hinbekommen. Es war gar nicht so schwer. Man braucht nur ein
CWinApp-Objekt, MFC initialisieren und bei Bedarf die Dialogbox
öffnen - und das alles in einer Konsolenanwendung. Ich finde das
toll. Und wie du schon gesagt hast: mit MFC ist es natürlich
einfacher.
Hier der Beispiel Code fuer ein kleines Dialog Programm. Ich selber bin vor geraumer Zeit auf die MFC umgestiegen, weil sie doch wesentlich bequemer ist. Allerdings habe ich beim Win32 API Programmieren vieles gebraucht was ich immer mal wieder gebrauchen kann. Der Code ist so nicht lauffaehig, er braeuchte noch ein Resource Header File (resource.h), und ausserdem muesste eine Resourcedatei (*.rc) mit im Projekt sein welches Dialoge und Menues definiert. Allerdings kannst du den Krempel auch erst einmal herausnehmen, aber dann hast du wirklich nur ein Fenster. Ich glaube du musst eine Win32 Console Application erstellen.:
#define STRICT
#include <windows.h>
#include <stdlib.h>
#include <strstrea.h>
#include <string.h>
#include "resource.h"
LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsgId, WPARAM wParam, LPARAM lParam );
BOOL CALLBACK DlgProc( HWND hWndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
HINSTANCE globalHInstance;
int WINAPI WinMain(
HINSTANCE hInstance, // Handle der aktuellen Instanz
HINSTANCE hPrevInstance, // Handle der vorher gehenden Instanz (?allways zero?)
LPSTR pszCmdLine, // pointer to command line (if prog was started over a command line)
int nCmdShow // Fensterstatus
)
{
static char szAppName[] = "TimerTest";
HWND hWnd;
MSG msg;
WNDCLASSEX wndClass;
globalHInstance = hInstance;
// zuerst die Fensterklasse registrieren
wndClass.cbSize = sizeof(wndClass);
wndClass.style = 0 ;
wndClass.lpfnWndProc = WndProc;
// Rückruf-Funktion (Callback-Funktion)
wndClass.cbClsExtra = 0;
wndClass.cbWndExtra = 0;
wndClass.hInstance = hInstance;
wndClass.hIcon = 0;
wndClass.hCursor = 0;
wndClass.hbrBackground = (HBRUSH__ *)GetStockObject (WHITE_BRUSH); //don't know why I have to
//cast that
wndClass.lpszMenuName = MAKEINTRESOURCE( MENUNAME ); //here the identifier of the Menu that should be used, set to NULL if you don't want a menu yet
//menu must be in a resource file
wndClass.lpszClassName = szAppName;
wndClass.hIconSm = 0;
if ( !RegisterClassEx(&wndClass) ) return 0;
// Nun das Fenster der Anwendung erzeugen
hWnd = CreateWindow(
szAppName, // name of the windowclass!! this must be a registerd one
szAppName, // Fenstertitel
WS_OVERLAPPEDWINDOW,// Fensterstil
CW_USEDEFAULT, // initiale X- und...
CW_USEDEFAULT, // ...Y-Position CW_USEDEFAULT
CW_USEDEFAULT, // Fenstergröße in vertikaler
CW_USEDEFAULT, // und horizontaler Ausrichtung
NULL, // Handle des Elternfensters
NULL, // Handle für das Menü
hInstance,// Handle der Programminstanz
NULL); // Parameter für die Erzeugung
if ( hWnd == NULL ) return 0;
ShowWindow( hWnd, nCmdShow );
UpdateWindow( hWnd );
while ( GetMessage(&msg, NULL, 0, 0) ) // message processing queue
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
return msg.wParam;
}
LRESULT CALLBACK WndProc(
HWND hWnd, // Handle des Fensters
UINT uMsgId, // Nachrichtenkennung
WPARAM wParam, // Erster Parameter
// der Nachricht
LPARAM lParam) // Zweiter Parameter
{
switch ( uMsgId )
{
// Abarbeiten
case WM_LBUTTONDOWN:
{
DialogBox(globalHInstance, MAKEINTRESOURCE(DIALOG_NAME), hWnd, DlgProc);
//this create a dialog from a template that must be given in a resource file, remove this if you don't to do this on a left click (was only for testing for myself)
break;
}
case WM_PAINT:
{
HDC hDC;
PAINTSTRUCT paintStruct;
hDC = BeginPaint( hWnd, &paintStruct );
EndPaint( hWnd, &paintStruct );
break;
}
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
// Windows die Abarbeitung aller anderen
// Nachrichten überlassen
return DefWindowProc(hWnd, uMsgId, wParam, lParam);
}
return( 0 );
}
// is only needed for the Dialog
BOOL CALLBACK DlgProc( HWND hWndDlg, // handle to dialog box
UINT uMsg, // message
WPARAM wParam,// first message parameter
LPARAM lParam)// second message parameter
{
switch(uMsg)
{
case WM_COMMAND:
switch(wParam)
{
case IDOK:
EndDialog(hWndDlg, 1);
break;
case IDCANCEL:
EndDialog(hWndDlg, 1);
break;
default
return FALSE;
}
break;
default:
return FALSE;
}
return TRUE;
}
Zur Windows Programmierung ohne MFC und den ganzen Krempel, empfehle ich das Buch "Windows Programmierung" von Charles Petzold. Es ist denke ich immer lohnenswert, wenn man sich mit der Win32API gut auskennt und auch auf MFC verzichten kann.