Mit reinem C GUI-Progranne programmieren

Gibt es eine Möglichkeite (möglichst mit Visual Studio) mit reinem C Code (ohne objektorientierte Programmierung (mag keine Forms und meterlange Klassenzugriffe)) eine Programm mit grafischer Oberfläche bequem zu erstellen und zu erwalten?

Stelle mir das mit sogenannten Panels vor, die bei Events die zugeteilte Callback Funktion aufrufen, wobei die Oberfläche streng vom Quellcode (bis auf die Callbacks) getrennt ist?
Eigentlich sowas wie CVI (nur eben erschwinglich für privaten Gebrauch).

Bin ein Fan von GetCtrlAttr, GetCtrlVal etc. Funktionen.

Besten Dank.

Gibt es eine Möglichkeite (möglichst mit Visual Studio) mit
reinem C Code (ohne objektorientierte Programmierung (mag
keine Forms und meterlange Klassenzugriffe)) eine Programm mit
grafischer Oberfläche bequem zu erstellen und zu erwalten?

Die GUI-Bibliothek GTK funktioniert zum Beispiel auf reiner C-Basis (wenngleich sie auch versucht, gewisse Herangehensweisen der Objektorientierung auch in C zu verwirklichen). Wenn ich mich richtig erinnere, lassen sich Callback-Funktionen mit den GUI-Elementen verbinden. Mehr dazu: http://www.gtk.org/

Ausserdem gibt es wohl unter Windows (ich gehe wegen deiner Erwähnung von Visual Studio mal davon aus, dass das deine Zielplattform ist) auch Möglichkeiten, die Win32-API direkt zu benutzen. Nach allem, was ich so höre, ist das aber nicht besonders angenehm. Wenn du es trotzdem versuchen möchtest, könntest du nach Tutorials googeln.

Viele Grüße,
Sebastian

Gibt es eine Möglichkeit […] mit reinem C Code [grafischer Oberfläche zu erstellen]?

Ich kann die WXC empfehlen. Das gehört zu WXWidgets und ist ursprünglich für C++ gedacht. WXC ist ein Aufsatz um das ganze mir reinem C zu machen. WXWidgets benutzt unter Windows die Windowsgui Bibliothek. (Unter Linux GTK und unter MAC Cocoa; das hat den Vorteil, das deine Programme auch unter anderen Betriebsystemen laufen können und dort auch nativ/natülich aussehen)

Links:
http://wxc.sourceforge.net/
http://www.wxwidgets.org/

Ausserdem gibt es wohl unter Windows (ich gehe wegen deiner
Erwähnung von Visual Studio mal davon aus, dass das deine
Zielplattform ist) auch Möglichkeiten, die Win32-API direkt zu
benutzen. Nach allem, was ich so höre, ist das aber nicht
besonders angenehm. Wenn du es trotzdem versuchen möchtest,
könntest du nach Tutorials googeln.

Wie hat man den früher Programme mit grafischer Oberfläche erstellt, als OOP noch nicht gab?

Wie hat man den früher Programme mit grafischer Oberfläche
erstellt, als OOP noch nicht gab?

Deutlich umständlicher…

Wie hat man den früher Programme mit grafischer Oberfläche
erstellt, als OOP noch nicht gab?

Also einerseits gibt es die Idee der Objektorientierung an sich schon ewig. Viel GUI wurde da vorher nicht gemacht, und es war lange vor meiner Zeit. Andererseits habe ja schon Beispiele für GUI-APIs genannt, die zumindest nicht auf einer objektorientierten Programmiersprache fußen. Ich weiß also nicht genau, worauf du hinauswillst.

Viele Grüße,
Sebastian

Hallo

Die Lib „Rad-C++“ heisst zwar so, geht aber dem Autor zufolge auch mit C:
„It is as easy for plain C language developers…“
siehe hier:
http://devpaks.org/details.php?devpak=171

Ich habe es mit C++ ein wenig angeguckt und muss sagen, ist wirklich interessant, weil sehr einfach und leicht zu lernen. Mit Doku ist nicht viel los, braucht man aber nicht wirklich.

Das „Rad-C++“ ist gratis, aber nicht quelloffen. Ich habe es mit Dev-C++ automatisch installiert, über das Menü von der Webseite oben.

lG
Martin B

Wie hat man den früher Programme mit grafischer Oberfläche
erstellt, als OOP noch nicht gab?

Das steht im Buch Charles Petzold „Windows-Programmierung“, hat so 1200 Seiten, findest Du bei Amazon. Die Beispiele sind dort rein in C geschrieben.

lG
Martin B

Gibt es eine Möglichkeite (möglichst mit Visual Studio) mit
reinem C Code (ohne objektorientierte Programmierung (mag
keine Forms und meterlange Klassenzugriffe)) eine Programm mit
grafischer Oberfläche bequem zu erstellen und zu erwalten?

Hallo,

warum ganze Räderwerke neu erfinden? Lies ein Buch aus der Anfangszeit von Windows (Petzold, Norton - hab ich glaube ich alle weggeworfen), da wird Windows nur in C programmiert (Event handler mit case usw.). So haben wir alle angefangen, sofern wir damals schon am Leben und programmierfähig waren. Es gibt wahrscheinlich nichts, was man nicht so verwirklichen könnte.

Gruss Reinhard

Gibt es eine Möglichkeite (möglichst mit Visual Studio) mit
reinem C Code (ohne objektorientierte Programmierung (mag
keine Forms und meterlange Klassenzugriffe)) eine Programm mit
grafischer Oberfläche bequem zu erstellen und zu erwalten?

Die Möglichkeit gibt es sicher. Ich habe das leider auch noch nie richtig gemacht, weil ich dann meistens auf Dialoge aus Ressourcen umgestiegen bin, weil sich die leichter „zusammenbauen“ lassen. Aber vielleicht kann ich dir dennoch etwas helfen. Ich arbeite mit Code::Blocks und wenn ich da ein leeres Win32 GUI Projekt anlege, starte ich mit folgendem Code:

#include 

/\* Declare Windows procedure \*/
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nCmdShow)
{
 HWND hwnd; /\* This is the handle for our window \*/
 MSG messages; /\* Here messages to the application are saved \*/
 WNDCLASSEX wincl; /\* Data structure for the windowclass \*/

 /\* The Window structure \*/
 wincl.hInstance = hThisInstance;
 wincl.lpszClassName = "CodeBlocksWindowsApp";
 wincl.lpfnWndProc = WindowProcedure; /\* This function is called by windows \*/
 wincl.style = CS\_DBLCLKS; /\* Catch double-clicks \*/
 wincl.cbSize = sizeof (WNDCLASSEX);

 /\* Use default icon and mouse-pointer \*/
 wincl.hIcon = LoadIcon (NULL, IDI\_APPLICATION);
 wincl.hIconSm = LoadIcon (NULL, IDI\_APPLICATION);
 wincl.hCursor = LoadCursor (NULL, IDC\_ARROW);
 wincl.lpszMenuName = NULL; /\* No menu \*/
 wincl.cbClsExtra = 0; /\* No extra bytes after the window class \*/
 wincl.cbWndExtra = 0; /\* structure or the window instance \*/
 /\* Use Windows's default colour as the background of the window \*/
 wincl.hbrBackground = (HBRUSH) COLOR\_BACKGROUND;

 /\* Register the window class, and if it fails quit the program \*/
 if (!RegisterClassEx (&wincl))
 return 0;

 /\* The class is registered, let's create the program\*/
 hwnd = CreateWindowEx (
 0, /\* Extended possibilites for variation \*/
 szClassName, /\* Classname \*/
 "Code::Blocks Template Windows App", /\* Title Text \*/
 WS\_OVERLAPPEDWINDOW, /\* default window \*/
 CW\_USEDEFAULT, /\* Windows decides the position \*/
 CW\_USEDEFAULT, /\* where the window ends up on the screen \*/
 544, /\* The programs width \*/
 375, /\* and height in pixels \*/
 HWND\_DESKTOP, /\* The window is a child-window to desktop \*/
 NULL, /\* No menu \*/
 hThisInstance, /\* Program Instance handler \*/
 NULL /\* No Window Creation data \*/
 );

 /\* Make the window visible on the screen \*/
 ShowWindow (hwnd, nCmdShow);

 /\* Run the message loop. It will run until GetMessage() returns 0 \*/
 while (GetMessage (&messages, NULL, 0, 0))
 {
 /\* Translate virtual-key messages into character messages \*/
 TranslateMessage(&messages);
 /\* Send message to WindowProcedure \*/
 DispatchMessage(&messages);
 }

 /\* The program return-value is 0 - The value that PostQuitMessage() gave \*/
 return messages.wParam;
}


/\* This function is called by the Windows function DispatchMessage() \*/
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
 switch (message) /\* handle the messages \*/
 {
 case WM\_DESTROY:
 PostQuitMessage (0); /\* send a WM\_QUIT to the message queue \*/
 break;
 default: /\* for messages that we don't deal with \*/
 return DefWindowProc (hwnd, message, wParam, lParam);
 }

 return 0;
}

Damit wird einmal ganz grundlegend eine Fensterklasse registriert und ein Fenster erstellt mit zugehöriger Callback erstellt. Wenn du mehr Informationen brauchst, musst du im MSDN nachlesen, ich bin da auch nicht so ein Fachmann^^

Hier findest du dann auch Informatinen zu den verschiedensten Windows Controls (Funktionen, Messages für die Callback, etc.)
http://msdn.microsoft.com/en-us/library/bb773169.aspx

Viel mehr kann ich dir leider nicht geben, aber ich denke, damit hast du schon einmal etwas, mit dem du anfangen kannst^^

mfg dixxi

Habe ja nur gefragt, ob es sowas schon für C gibt.

LabWindows/CVI ist zum Beispiel so, wie ich es mir vorstelle. Nur ist das sehr teuer und auch nicht für den privaten Gebrauch gedacht.

Da kannst du grafisch, ähnlich wie bei Visual Studio, Panels (Fenster), Buttons und alle anderen möglichen Controls erstellen und einrichten.
Ein rechtsklick auf das Control -> Generate Callback function und es wird eine CALLBACK Funktion generiert, die bei jedem Event auf dieses Control aufgerufen wird.
Dort kannst du dann einfach die Events abfangen, auswerten und Aktionen/ Funktionen ausführen.

Mit den Controls kann man einfach im Programm Kontakt aufnehmen. Da stehen eine Menge funktionen bereit: GetCtrlAttr, SetCtrlAttr, G/SetCtrlVal, G/SetCtrlIndex.

Ist wirklich einfach und bequem. Kann es mir nicht vorstellen, dass man es mit OOP schneller ansteuern kann.

Ist wirklich einfach und bequem. Kann es mir nicht vorstellen,
dass man es mit OOP schneller ansteuern kann.

Das geht mit jedem halbwegs brauchbaren GUI-Framework so einfach. Sonst wäre das Framework ja Mist.

OOP spielt seine Stärken aber primär nicht dadurch aus, dass du irgendwas „schneller ansteuern“ kannst, sondern dass du bestehenden Code mittels Vererbung erweitern kannst und diesen nach Belieben wiederverwenden kannst.

OOP spielt seine Stärken aber primär nicht dadurch aus, dass
du irgendwas „schneller ansteuern“ kannst, sondern dass du
bestehenden Code mittels Vererbung erweitern kannst und diesen
nach Belieben wiederverwenden kannst.

Wenn man guten Code schreibt, ist das mit C auch möglich. D.h. man muss funktionen sehr allgemein schreiben, dann kann man sie Problemlos wiederverwenden.
Alternativ kann man auch einfach den alten Code kopieren und ein zwei Zeilen für das aktuelle Projekt anpassen.
Und wie oft kommt es vor, dass man alten Code wiederverwenden kann?
Allgemeine Funktionen, z.B. mathematische, formuliert man i.d.R. sowieso allgemein und anwendungsübergreifend.

Zudem finde ich das ziemlich unsauber und unelegant, wenn man Klassen vererben tut und sie dann noch überschreiben tut. Das erschwert die Lesbarkeit der Funktion. Da ist strukturiertes Formulieren in allgemeine Funktionen deutlich eleganter und für jeden leicht verständlich und einfacher wartbarer.
Das andere ist meiner Meinung nach nur Geflicke.

1 Like

YMMD
Hallo!

Zudem finde ich das ziemlich unsauber und unelegant, wenn man
Klassen vererben tut und sie dann noch überschreiben tut. Das
erschwert die Lesbarkeit der Funktion. Da ist strukturiertes
Formulieren in allgemeine Funktionen deutlich eleganter und
für jeden leicht verständlich und einfacher wartbarer.

Deine Beiträge sind einfach köstlich. Das gibt ein YMMD-Sternchen :wink:

Jan

Zudem finde ich das ziemlich unsauber und unelegant, wenn man
Klassen vererben tut und sie dann noch überschreiben tut.

class TextField {

 setText(String text);
 String getText();
 boolean validate();
 
}

class DateField extends TextField {

 boolean validate() {
 return (text ist gueltiges-Datums-Format);
 }

}

Was ist jetzt da bitte „unsauber“, „unelegant“ oder schwer lesbar?
Mach mal das gleiche in ner prozeduralen Sprache dann siehst du was unsauber, unelegant und schwer lesbar ist.

Das erschwert die Lesbarkeit der Funktion. Da ist strukturiertes
Formulieren in allgemeine Funktionen deutlich eleganter und
für jeden leicht verständlich und einfacher wartbarer.
Das andere ist meiner Meinung nach nur Geflicke.

LOL… klar.

[] Du hast Ahnung von OOP.

Prozedurale Sprachen haben ihren Sinn sicher in Low-Level Programmierung. Damit heute noch ein Projekt für eine Desktop-Applikationen zu beginnen, ist IMO ziemlicher Unsinn. Selbst das gute Gnome benutzt einen objektorientierten Aufsatz für ihren C-Code und wenn die heute damit nochmal anfangen würden, dann würden sie gleich C++ oder ne noch höhere Sprache verwenden.

Hallo,

Das geht mit jedem halbwegs brauchbaren GUI-Framework so
einfach. Sonst wäre das Framework ja Mist.

In der Tat. Und wenn man ein IDE für die Entwicklung einer GUI nutzt, dann ist es dem Programmierer auch wurscht, ob das jetzt OOP, prezedural, AOP oder sonstwas ist.

OOP spielt seine Stärken aber primär nicht dadurch aus, dass
du irgendwas „schneller ansteuern“ kannst, sondern dass du
bestehenden Code mittels Vererbung erweitern kannst und diesen
nach Belieben wiederverwenden kannst.

Leider gibt es mehr Beweise für die Existenz von UFOs als Beweise dafür, dass diese Stärke zu besser handhabbarem oder schnellerem oder einfacherem Code führt.

Man kann mit OOP kein Problem lösen, was man mit prozeduraler Programmierung nicht auch lösen könnte. Manche Lösung wird dadurch umfangreicher, manche nicht.

Wenn man die Wahl hat, dann sollte stets in der Sprache und dem Paradigma programmieren, in dem man sich am wohlsten fühlt.

Gruß

Fritze