Sonntag, 4. Oktober 2026

Windows C++ Programm: Kapazität eines Kugelkondensators

 

Das folgende Windows C++ Programm berechnet die Kapazität eines Kugelkondensators.

 

Der Kugelkondensator besteht aus den zwei konzentrischen Kugeln mit den Radien r1 (Innenradius des Kondensators) und r2 (Außenradius des Kondensators). Die Kapazität C des Kugelkondensators lässt sich nach folgender Formel berechnen:

wo ε - die Dielektrizitätskonstante des Dielektrikums. Zum Beispiel, beim Porzellan:

Die Kapazität des Kondensators liegt üblicherweise im Picofarad-Bereich (pF). Durch Betätigen der Drucktaste „Berechnen“ wird die Kapazität erneut berechnet. Das Ergebnis einer Berechnung wird im folgenden Bild dargestellt:


Der Quellcode wurde für Windows 64-Bit Desktop-Anwendung geschrieben. 

#include <Windows.h>
#include <string.h>
#include <tchar.h>
#include <stdio.h>

// Alle Ein- und Ausgabefelder werden definiert:
#define IDC_TEXTBOX1 1000
#define IDC_TEXTBOX2 1001
#define IDC_TEXTBOX3 1002
#define IDC_TEXTBOX4 1003
#define IDC_BUTTON1 2000

HINSTANCE hInst; // Ein Handle zur aktuellen Instanz der Anwendung
HWND hEdit1;    // Radius r1 für CreateWindowEx()
HWND hEdit2;    // Radius r2 für CreateWindowEx()
HWND hEdit3;    // Dielektrizitätskonstante epsilon für CreateWindowEx()
HWND hOutputC; // Kapazität C für CreateWindowEx()
HWND hButton1;  // Drucktaste

// Kapazitätsberechnung

double Kapazitatsberechnung(double innen, double aussen, double epsilonE)
{
    double Kugelkapazitat = 4 * 3.14159 * epsilonE * innen * aussen / (aussen - innen);
    return Kugelkapazitat;
}


LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); //Prototyp WndProc() wird in WNDCLASSEX-Struktur verwendet.

int WINAPI WinMain(
    _In_ HINSTANCE hInstance, // die aktuelle Instanz der Anwendung
    _In_opt_ HINSTANCE hPrevInstance, // die vorherige Instanz der Anwendung
    _In_ LPSTR    lpCmdLine,    // die Befehlszeile für die Anwendung
    _In_ int       nCmdShow     // nCmdShow steuert, wie das Fenster angezeigt werden soll.
)
{
    static TCHAR szWindowClass[] = _T("DesktopApp"); // Name der Hauptfensterklasse
    static TCHAR szTitle[] = _T("Kugelkondensator"); // Anwendungstitel

    WNDCLASSEX wcex; //Struktur

    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc; // Callback
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance; // Instanz der Anwendung
    wcex.hIcon = LoadIcon(wcex.hInstance, IDI_APPLICATION);
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = szWindowClass; // Name der Hauptfensterklasse
    wcex.hIconSm = LoadIcon(wcex.hInstance, IDI_APPLICATION);

    //Fensterklasse wird registriert.
    if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            szWindowClass,
            MB_ICONERROR);

        return 1;
    }


    hInst = hInstance; //Handle wird gespeichert.

    //Ein Fenster wird erstellt.
    HWND hWnd = CreateWindowEx(
        WS_EX_OVERLAPPEDWINDOW,
        szWindowClass, //Name der Hauptfensterklasse
        szTitle,  //Anwendungstitel
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, //Anfangsposition X
        CW_USEDEFAULT, //Anfangsposition Y
        1100, // Breite des Fensters
        250, // Höhe des Fensters
        NULL, //Ein Handle fürs übergeordnete Fenster (parent window handle)
        NULL, //Ein Handle zu einem Menu
        hInstance, //Ein Handle für die Instanz des Moduls
        NULL //lpParameter (Zeiger)
    );

    if (!hWnd)
    {
        MessageBox(NULL,
            _T("Call to CreateWindowEx failed!"),
            szWindowClass,
            MB_ICONERROR);

        return 1;
    }

    // Fenster wird sichtbar gemacht.
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);


    MSG msg; // MSG-Struktur für die Nachrichtenschleife
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return (int)msg.wParam;
} //Ende von WinMain()



LRESULT CALLBACK WndProc(
    _In_ HWND hWnd,
    _In_ UINT message,
    _In_ WPARAM wParam,
    _In_ LPARAM lParam
)
{
    PAINTSTRUCT ps;
    HDC hdc;
    TCHAR Kugel[] = _T("Zwei konzentrische Kugeln mit den Radien r1 und r2 haben die folgenden Abmessungen: ");
    TCHAR radius1[] = _T("Innenradius r1 = ");
    TCHAR radius2[] = _T("Aussenradius r2 = ");
    TCHAR epsilon[] = _T("Dielektrizitaetskonstante = ");
    TCHAR Kapazitat[] = _T("Kapazitaet des Kugelkondensators C = ");
    TCHAR meter[] = _T("m");
    TCHAR epsilonEinheit[] = _T("pF/m");
    TCHAR cEinheit[] = _T("pF");


    switch (message)
    {
    case WM_CREATE:
        hEdit1 = CreateWindowEx(
            WS_EX_CLIENTEDGE,
            (LPCWSTR)L"EDIT",
            (LPCWSTR)L"Eingabe",  // Eingabefeld
            WS_VISIBLE | WS_CHILD | WS_BORDER | ES_MULTILINE | ES_AUTOHSCROLL | ES_AUTOVSCROLL,
            115, //Anfangsposition X
            32, //Anfangsposition Y
            160, // Breite des Fensters
            24, // Höhe des Fensters
            hWnd,
            (HMENU)IDC_TEXTBOX1,
            hInst,
            NULL
        );
        hEdit2 = CreateWindowEx(
            WS_EX_CLIENTEDGE,
            (LPCWSTR)L"EDIT",
            (LPCWSTR)L"Eingabe",  // Eingabefeld
            WS_VISIBLE | WS_CHILD | WS_BORDER | ES_MULTILINE | ES_AUTOHSCROLL | ES_AUTOVSCROLL,
            125, //Anfangsposition X
            62, //Anfangsposition Y
            160, // Breite des Fensters
            24, // Höhe des Fensters
            hWnd,
            (HMENU)IDC_TEXTBOX2,
            hInst,
            NULL
        );
        hEdit3 = CreateWindowEx(
            WS_EX_CLIENTEDGE,
            (LPCWSTR)L"EDIT",
            (LPCWSTR)L"Eingabe",  // Eingabefeld
            WS_VISIBLE | WS_CHILD | WS_BORDER | ES_MULTILINE | ES_AUTOHSCROLL | ES_AUTOVSCROLL,
            195, //Anfangsposition X
            92, //Anfangsposition Y
            160, // Breite des Fensters
            24, // Höhe des Fensters
            hWnd,
            (HMENU)IDC_TEXTBOX3,
            hInst,
            NULL
        );
        hOutputC = CreateWindowEx(
            WS_EX_STATICEDGE,
            (LPCWSTR)L"STATIC",
            (LPCWSTR)L"Ausgabe",  // Ausgabefeld
            WS_VISIBLE | WS_CHILD | SS_RIGHT,
            270, //Anfangsposition X
            122, //Anfangsposition Y
            160, // Breite des Fensters
            24, // Höhe des Fensters
            hWnd,
            (HMENU)IDC_TEXTBOX4,
            hInst,
            NULL
        );
        hButton1 = CreateWindowEx(
            WS_EX_CLIENTEDGE,
            (LPCWSTR)L"BUTTON",
            (LPCWSTR)L"Berechnen",  // Ausgabefeld
            WS_VISIBLE | WS_CHILD | BS_VCENTER,
            370, //Anfangsposition X
            162, //Anfangsposition Y
            160, // Breite des Fensters
            24, // Höhe des Fensters
            hWnd,
            (HMENU)IDC_BUTTON1,
            hInst,
            NULL
        );
        break;
    case WM_COMMAND:
        if (LOWORD(wParam) == IDC_BUTTON1)
        {
            wchar_t r1[64];
            wchar_t r2[64];
            wchar_t eps[64];
            LPTSTR endPointer1, endPointer2, endPointer3;
            // Eingabefelder für die Berechnung der Kapazität:
            GetWindowTextW(hEdit1, r1, 128);
            GetWindowTextW(hEdit2, r2, 128); 
            GetWindowTextW(hEdit3, eps, 128);

            // Eingabefelder werden gespeichert:
            double innenRad = _tcstod(r1, &endPointer1); 
            double aussenRad = _tcstod(r2, &endPointer2);
            double epsi = _tcstod(eps, &endPointer3);

            double Csphere = Kapazitatsberechnung(innenRad, aussenRad, epsi); //Berechnung der Kapazität
            wchar_t ergebnis[128];
            swprintf_s(ergebnis, 128, L"%.15g", Csphere); //Von double nach string umwandeln.
            SetWindowTextW(hOutputC, ergebnis); //Ausgabe von Kapazität als string.
        }
        break;

    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);

        // Grafische 2D-Darstellung
        SetDCBrushColor(hdc, RGB(255, 235, 205));
        SelectObject(hdc, GetStockObject(DC_BRUSH));
        Ellipse(hdc, 600, 20, 780, 200);
        SetDCBrushColor(hdc, RGB(255, 255, 0));
        SelectObject(hdc, GetStockObject(DC_BRUSH));
        Ellipse(hdc, 630, 50, 750, 170);


        TextOut(hdc,
            5, 5,
            Kugel, static_cast<int>(_tcslen(Kugel)));

        TextOut(hdc,
            5, 35,
            radius1, static_cast<int>(_tcslen(radius1)));
        TextOut(hdc, 280, 35, meter, static_cast<int>(_tcslen(meter)));

        TextOut(hdc,
            5, 65,
            radius2, static_cast<int>(_tcslen(radius2)));
        TextOut(hdc, 290, 65, meter, static_cast<int>(_tcslen(meter)));

        TextOut(hdc,
            5, 95, epsilon, static_cast<int>(_tcslen(epsilon)));
        TextOut(hdc, 360, 95, epsilonEinheit, static_cast<int>(_tcslen(epsilonEinheit)));

        TextOut(hdc,
            5, 125,
            Kapazitat, static_cast<int>(_tcslen(Kapazitat)));
        TextOut(hdc, 445, 125, cEinheit, static_cast<int>(_tcslen(cEinheit)));


        EndPaint(hWnd, &ps);
        break;

    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
        break;
    }

    return 0;
} //Ende der Fensterprozedurfunktion


Keine Kommentare:

Windows C++ Programm: Kapazität eines Kugelkondensators

  Das folgende Windows C++ Programm berechnet die Kapazität eines Kugelkondensators.   Der Kugelkondensator besteht aus den zwei konzent...