GDI+ & Instanzen

  • C++

Es gibt 26 Antworten in diesem Thema. Der letzte Beitrag () ist von Gonger96.

    GDI+ & Instanzen

    Hey,
    ich arbeite im Moment an einer Lib mit diversen Controls. Um mir das schön einfach zu machen benutz ich GDI+ und nicht GDI ^^ Das Problem ist Folgendes: Vor GDI+ Zeichenoperationen & Co muss ich GdiplusStartup aufrufen und vor beenden des Programms GdiplusShutdown. Das kann ich aber nicht im Konstruktor & Destruktor machen, weil ich mehrere Instanzen hab und die Funktionen öfters aufgerufen werden würden. Gibt es eine elegantere Lösung als in WinMain als erstes StartUp und vorm return ShutDown aufzurufen ?

    Ist übrigens natives C++, kein CLI

    Naja, am einfachsten würde ich mir vorstellen, ne Statische Variable mitzuzählen, wie viele Instanzen du hast. Wenn die erstellte die erste Instanz ist, dann rufst du Startup auf, und wenn sie die letzte zerstörte Instanz ist, dann rufst du Shutdown auf.
    Ist dann halt so, dass wenn du die letzte Instanz zerstörst und du danach wieder ne neue erstellst, zwischendurch Shutdown und dann wieder Startup aufgerufen wird. Ich weiß nicht, ob das irgendwie nicht erwünscht sein könnte.

    Das geht leider nicht. Den Zähler müsst ich ja wieder in die Maindatei packen und da kann ichs gleich in WinMain machen. Ich hab etliche Klassen die untereinander auch erben, die können nicht Instanziert ja schlecht auf einander zugreifen

    (Edit: Artentus hatte wahrscheinlich genau die gleiche Idee.)

    Ich kenne mich nicht mit C++ direkt aus, aber ich hätte ein Konzept, das Du verwenden kannst:

    VB.NET-Quellcode

    1. Class DeineKlasse
    3. Public Sub New()
    4. InstanceCreated()
    5. End Sub
    7. Public Sub Dispose() 'Oder wie der Destruktor halt in C++ aussieht
    8. InstanceDestroyed()
    9. End Sub
    11. '...
    13. Private Shared InstanceCounter As Integer = 0
    15. Private Shared Sub InstanceCreated()
    16. If InstanceCounter = 0 Then
    17. GdiplusStartup()
    18. End If
    19. InstanceCounter += 1
    20. End Sub
    22. Private Shared Sub InstanceDestroyed()
    23. InstanceCounter -= 1
    24. If InstanceCounter = 0 Then
    25. GdiplusShutdown()
    26. End If
    27. End Sub
    29. End Class


    Sobald die erste Instanz erstellt wird, wird GdiplusStartup() aufgerufen. Und sobald alle Instanzen zerstört wurden, wird GdiplusShutdown() aufgerufen.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    @Gonger96: Lagere die statischen Funktionen aus.

    VB.NET-Quellcode

    1. Class DeineKlasse
    3. Public Sub New()
    4. GDIHelper.InstanceCreated()
    5. End Sub
    7. Public Sub Dispose() 'Oder wie der Destruktor halt in C++ aussieht
    8. GDIHelper.InstanceDestroyed()
    9. End Sub
    11. End Class
    13. Class GDIHelper
    15. Private Shared InstanceCounter As Integer = 0
    17. Public Shared Sub InstanceCreated()
    18. If InstanceCounter = 0 Then
    19. GdiplusStartup()
    20. End If
    21. InstanceCounter += 1
    22. End Sub
    24. Public Shared Sub InstanceDestroyed()
    25. InstanceCounter -= 1
    26. If InstanceCounter = 0 Then
    27. GdiplusShutdown()
    28. End If
    29. End Sub
    31. End Class

    Dann geht's von jeder Klasse aus.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Da es sich dabei ja um (zumindest so ne Art) Controls handelt, werden diese Klassen ja alle von der gleichen Basisklasse erben. In dieser legst du eine static-Variable an. In ihrem Konstruktor prüfst du, ob diese Variable 0 ist, wenn ja, rufst du die Methode auf, dann inkrementierst du die Variable. Im Desruktor dekrementierst du die Variable und prüfst anschließen, ob sie 0 ist. Wenn ja, dann rufst du die zweite Methode auf.

    So in etwa:

    C-Quellcode

    1. Class Conrol
    2. int count;
    4. Control()
    5. {
    6. if (count == 0)
    7. GdiplusStartup();
    8. count++;
    9. }
    11. ~Control
    12. {
    13. count--;
    14. if (count == 0)
    15. GdiplusShutdown()
    16. }
    17. }

    Ich wollte das eigentlich viel früher posten, hatte aber verbindungsprobleme. Ich möchte euren Kommentarfluss nicht unterbrechen, aber ich poste es einfach, damit es gesagt ist.

    Im Laufe des Programmes darf die Situation nicht auftreten, dass alle Klassen verworfen werden und dann nochmal eine neue erstellt wird. Sonst wird GdiplusStartup() nochmal aufgerufen.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Klasse A und B erben beispielsweise von Control & von InstanceCounter. Im Konstruktor von A wird der Counter inkrementiert und im Destruktor dekrementiert, sowie bei Klasse B. Wenn im Konstruktor der Counter == 0 ist wird StartUp aufgerufen. A wird instanziert, war noch nie da also StartUp, B wird instanziert und der Counter ist ebenfalls 0 dann wird StartUp erneut aufgerufen

    Ich hab das zwar nicht ausprobiert, aber da die Variable ja static ist müssten doch eigentlich alle Instanzen, egal ob von A oder B, auf die selbe Variable zugreifen, oder irre ich mich da?
    Wenn ich mich da täusche tuts mir leid, ich hab noch nie mit Mehrfachvererbung gearbeitet.

    @Gonger96: Ich hätte erwartet, Du weißt, was Shared (bzw. Static)-Variablen sind.
    Beispiel:

    VB.NET-Quellcode

    1. Sub Main()
    2. MessageBox.Show(TestClass.InstanceCounter.ToString) '0
    3. Dim Instance1 As New TestClass
    4. MessageBox.Show(TestClass.InstanceCounter.ToString) '1
    5. Dim Instance2 As New TestClass
    6. MessageBox.Show(TestClass.InstanceCounter.ToString) '2
    7. Instance1.Dispose()
    8. MessageBox.Show(TestClass.InstanceCounter.ToString) '1
    9. Instance2.Dispose()
    10. MessageBox.Show(TestClass.InstanceCounter.ToString) '0
    11. End Sub
    13. Class TestClass
    15. Public Sub New()
    16. InstanceCreated()
    17. End Sub
    19. Public Sub Dispose()
    20. InstanceDestroyed()
    21. End Sub
    23. Public Shared InstanceCounter As Integer = 0
    25. Private Shared Sub InstanceCreated()
    26. If InstanceCounter = 0 Then
    27. GdiplusStartup()
    28. End If
    29. InstanceCounter += 1
    30. End Sub
    32. Private Shared Sub InstanceDestroyed()
    33. InstanceCounter -= 1
    34. If InstanceCounter = 0 Then
    35. GdiplusShutdown()
    36. End If
    37. End Sub
    39. End Class
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Klar weiß ich was statische Variablen/Funktionen sind. Ich probier Artentus Vorschlag grad aus, müsste nicht der Counter nicht jeweils in den erbenden Klassen statisch sein, oder ist der für die Beerbte statisch ? Wahrscheinlich hab ich grad n ziemlichen Gedankenfehler :/

    Genaugenommen erben die abgeleiteten Klassen den Counter garnicht. Denn statische Variablen sind eben keine Instanz-Variablen.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

Facebook