ZFX
ZFX Neu
Home
Community
Neueste Posts
Chat
FAQ
IOTW
Tutorials
Bücher
zfxCON
ZFXCE
Mathlib
ASSIMP
NES
Wir über uns
Impressum
Regeln
Suchen
Mitgliederliste
Membername:
Passwort:
Besucher:
4419845
Jetzt (Chat):
18 (0)
Mitglieder:
5239
Themen:
24223
Nachrichten:
234554
Neuestes Mitglied:
-insane-

ZFX
Coding-Foren
Sourcecode-Probleme
Re: Frage zu Klasse
Normal
AutorThema
marco_77 Offline
ZFX'ler


Registriert seit:
02.10.2007

Nordrhein-Westfalen
Frage zu KlasseNach oben.
Hallo,
ich möchte folgendes umsetzen, aber weiß nicht wie ich es schreiben muss...

Habe folgende 2 Klassen in 'EigenerNamespace' namens class cWindow und class cDirectX !
Diese rufe ich so auf:
Code:
EigenerNamespace::cWindow      Window;
EigenerNamespace::cDirectX     DirectX;



Nun möchte ich aber die erstellte Klasse Window an die DirectX Klasse übergeben.

Ich bekomme es hin, mit:
Code:
DirectX.EigeneFunktion(Window.HandleWindow);

Ich möchte aber nun nicht jede einzelne Variable übergeben müssen, sondern alles was in Window 'public' ist.

Wie gehe ich an die Sache heran?
Über ein Beispiel für mein Fall, würde ich mich sehr freuen.
11.01.2009, 12:18:22 Uhr
Aramis Offline
ZFX'ler


Registriert seit:
14.03.2007

Baden-Württemberg
406712329
Re: Frage zu KlasseNach oben.
Zitat:

Nun möchte ich aber die erstellte Klasse Window an die DirectX Klasse übergeben.

Stop! Du verwechselst da grade Klassen (= Vorlagen für Objekte) und Objekte (= Instanzen einer Klasse).

Code:
namespace X {

class Foo {
   int APrivateAndUglyOne;
public:
   int APublicOne;

   int GibMirWas() {
      return 5;
   };
};

class Bar {
public:
   int IHaveOneToo;

   void MeineFunktion (const Foo& DuDa) {
      IHaveOneToo += DuDa.APublicOne; 
      IHaveOneToo *= DuDa.GibMirWas();

      // Fehler: Zugriff auf privaten Member nicht möglich
      IHaveOneToo -= DuDa.APrivateAndUglyOne;  
   }
};

}

[...]

X::Bar b; 
X::Foo f;
b.MeineFunktion(f);


1 Mal gendert, zuletzt am 11.01.2009, 12:38:27 Uhr von Aramis.
11.01.2009, 12:36:42 Uhr
marco_77 Offline
ZFX'ler


Registriert seit:
02.10.2007

Nordrhein-Westfalen
Re: Frage zu KlasseNach oben.
Danke für die schnelle Antwort.

Meinte natürlich auch die erstellten Instanzen.
Werde den Code mal umsetzen. Wichtig waren mir die Zeilen:
Code:
void MeineFunktion (const Foo& DuDa)
X::Foo f;
X::Bar b; 
b.MeineFunktion(f);


Werde dann wohl alle nötigen Variablen aus f in Instanz b über b.MeineFunktion(f) setzen.

Code:
class Foo
{
   public:
     HWND HandleWindow;
     ...
}

class Bar
{
   public:
     HWND hwnd_von_b;

     void MeineFunktion (const Foo& DuDa)
     {
        hwnd_von_b = DuDa.HandleWindow;
        usw.
     }
}



X::Foo f;
X::Bar b; 

b.MeineFunktion(f);
11.01.2009, 13:20:17 Uhr
SPech Offline
OGL-Berater


Registriert seit:
07.03.2002

Deutschland
96302405
Re: Frage zu KlasseNach oben.
Statt öffentlicher variablen solltest du dir lieber getter und setter erstellen!
11.01.2009, 16:54:15 Uhr
SPech.de
6SidedDice Offline
Job-Moderator


Registriert seit:
16.10.2002

Nordrhein-Westfalen
161010163
Re: Frage zu KlasseNach oben.
Zitat:

Ich möchte aber nun nicht jede einzelne Variable übergeben müssen, sondern alles was in Window 'public' ist.


Dann übergib direkt cWindow

Code:
DirectX.EigeneFunktion(Window);


Aber eine wichtige Sache noch, bitte gewöhn dir eine Art von Stil beim bennen deiner Klassen, Methoden und Variablen an.
Denn beim ersten blick erkenne ich nicht ob Window nun eine Klasse oder eine Variable ist.
Ein erster Tipp, den viele auch so auf Anhieb verstehen
Klassen: Erster buchstabe groß, kein Prefix (Window, Renderer etc)
Methoden: 2 Möglichkeiten javastil = erster buchstabe klein, weil meistens verb bspw. (foo.printScreen(). oder aber erster Buchstabe groß foo.PrintScreen(). Reine Geschmackssache.
Variablen: Hab ehrlich gesagt noch nie gesehen das Variablen groß geschrieben werden also (screen_width, i, window).

Dann noch was was SPech schon erwähnt hat, public Variablen sind äusserst unschön und sollten nur über getter und setter erreichbar/veränderbar sein. Bzw. in C# direkt über Properties.

Code:
// unschön
class MyClass
{
public:
   int mySize;
};

MyClass inst;
inst.mySize = 5;


lieber

Code:
// besser
class MyClass
{
public:
   int GetMySize() const {return mySize;}
   void SetMySize(int aSize) { mySize = aSize;}
private:
   int mySize;
};

MyClass inst;
inst.SetMySize( 5 );
11.01.2009, 22:22:32 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Frage zu KlasseNach oben.
Hallo

Als ich C/C++ gelernt hab wurde mir vorgeschlagen bevor ich Klassen definiere soll ich mir erst Gedanken machen was abgebildet werden soll. Mit diesen Klassen ist ein Hilfsmittel gegeben dem Computer mitzuteilen was abstrakt modeliert werden soll ohne das der reale Bezug verloren geht. Mit anderen Worten.

Ich würde DirektX von Windows ableiten. Dann wird der gesammte Inhalt von Windows an DirektX vererbt. Damit wäre dein Problem auch gelöst.

mfg

1 Mal gendert, zuletzt am 20.01.2009, 23:12:09 Uhr von exploid.
20.01.2009, 23:08:24 Uhr
6SidedDice Offline
Job-Moderator


Registriert seit:
16.10.2002

Nordrhein-Westfalen
161010163
Re: Frage zu KlasseNach oben.
Zitat:

Ich würde DirektX von Windows ableiten.


oO
Ich weiß nicht ob das was du gelernt hast falsch war, oder du es falsch verstanden hast. Aber _das_ ist definitv nicht korrekt. Vererbung hat immer den Hintergrund etwas zu spezifizieren. So bin ich ein Mensch, ein Mensch ein Säugetier, ein Säugetier ein Lebewesen etc. Was genau haben denn DirectX und Windows gemeinsam?! Mir fällt auf anhieb wirklich keine Eigenschaft oder Methode ein die die beiden miteinander teilen könnten.
Das ist fast so als würdest du Motor von Auto ableiten.

Lies dir bitte mal das durch.

1 Mal gendert, zuletzt am 21.01.2009, 03:18:54 Uhr von 6SidedDice.
21.01.2009, 03:18:22 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Frage zu KlasseNach oben.
Also der Marco schreibt ja in seinem Fall von einem Fenster und nicht vom Betriebssystem Windows was ich als Beispiel gab.

Da stellt sich dann die Frage zu welchen Bereich dieses Fenster angegliedert ist.

Aber um auf mein Beispiel zurückzukommen denke ich doch das DirektX eine Untermenge von Windows ist. Da es ja das Interface für einen Programmierer zur Grafikkarte darstellt weil man anders unter Windows nicht an die Funktionalität der Graphikkarte gelangt. Interfaces sind Teile des Betriebssystems.

Wenn im oben genannten Bespiel der Namensbereich cWindow Teil der eigenen Software ist die für den Bereich DirektX zuständig sein soll ist meiner Meinung nach vererben nicht falsch.

Was in deinem Link diskutiert wird 6SidedDice halte ich für richtig.

2 Mal gendert, zuletzt am 21.01.2009, 18:19:49 Uhr von exploid.
21.01.2009, 18:17:05 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Frage zu KlasseNach oben.
Also, zuerst einmal gibt es keine DirectX-Klasse.

Die unterste Schicht ist DXGI, das DirectX Graphics Interface.

Diese bietet DXGI-Adapter, die einen physischen Adapter des Systems repräsentieren. Damit kann man sich ein D3D-Device bauen.

Jeder dieser Adapter hat wiederum einen oder mehrere Monitore (besser: Ausgabegeräte) angeschlossen, welche Teilbereiche des virtuellen Desktops sind. Auf jedem dieser Ausgabegeräte können sich ein oder mehrere Fenster befinden.

Diese Fenster müssen (müssen nicht, sollten aber streng empfohlen) von der GPU gefüllt werden, die den virtuellen Desktop betreut, auf dem sich das Fenster befindet.

Die Hierarchie lautet also korrekterweise:
Code:
class MyApplication
- DXGI-Factory
+ n × class Adapter
  - DXGI-Adapter
  - D3D-Device (nötig zum Rendern)
  + n × class OutputDevice
    - Virtueller Desktop (nötig um Fenster zu positionieren und Ausmaße des Vollbildmodus zu bestimmen)
    + n × class Window
      - DXGI-Swapchain
      - D3D-Bildschirmpuffer (z.B. Depth-Stencil, alles zum anzeigen eben)
Gruß, Ky

3 Mal gendert, zuletzt am 21.01.2009, 19:09:06 Uhr von Krishty.
21.01.2009, 18:36:32 Uhr
exploid Bin Kaffee holen
ZFX'ler


Registriert seit:
21.08.2005

Deutschland
Re: Frage zu KlasseNach oben.
hallo

Damit beschäftige ich mich seit 3 Tagen das ist dabei rausgekommen:
Code:
#include 
#include \"stdio.h\"
#include \"string.h\"
#include \"d3d10.h\"


#pragma comment(lib, \"DXGI.lib\")

int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdline, int nshowcmd )
{
    IDXGIFactory* pDXGIFactory;
    int OutputIndex = 0;
    IDXGIOutput* pOutput;
    IDXGIAdapter* pAdapter;
    int AdapterIndex = 0;
    DXGI_ADAPTER_DESC adapterDescription;
    FILE* pFile;
    wchar_t status[256];

    HRESULT hr = CreateDXGIFactory (__uuidof(IDXGIFactory), (void**)(&pDXGIFactory));
     
    if (hr != S_OK)
        return -1;

    pFile = fopen (\"loggraka.txt\",\"w\");
    if (pFile==NULL)
        // couldnt open file
        return -1;
    
     
    // Loop as long as DXGI returns valid adapters.
    while (pDXGIFactory->EnumAdapters (AdapterIndex, &pAdapter) == S_OK)
    {
        // Do something with the adapter object
        LARGE_INTEGER version;
 
        if (pAdapter->CheckInterfaceSupport (__uuidof (ID3D10Device), &version) != S_OK)
            // No D3D10
            printf(\"we have no support\");
        else {
            // Yes we can use D3D10
            printf(\"we have support\");    
            hr = pAdapter->GetDesc( &adapterDescription );
            fwprintf(pFile,L\"Grafikkarte: \");
            fwprintf(pFile,adapterDescription.Description);
            fwprintf(pFile,L\"\n\");

            DXGI_OUTPUT_DESC outputDescription;
            UINT numModes;
            
             
            while (pAdapter->EnumOutputs (OutputIndex, &pOutput) == S_OK)
            {
                // Do something with the output object
                pOutput->GetDesc(&outputDescription);
                // Es gibt z. Zeitpunkt der Programmierung 99 Elemente von DXGI_FORMAT
                for(int DXGI_test=0; DXGI_test<99; DXGI_test++) {
                    //Funktion sucht Anzahl der Modes und speichert diese in numModes
                    pOutput->GetDisplayModeList(    (DXGI_FORMAT)DXGI_test,//DXGI_FORMAT_R8G8B8A8_UNORM,
                                                    DXGI_ENUM_MODES_INTERLACED , 
                                                    &numModes,
                                                    0
                                                    );

                    if(numModes) { 
                        fwprintf(pFile,L\"Modien gefunden für DXGI_FORMAT = \");
                        _itow(DXGI_test,status,10); 
                        fwprintf(pFile,status);
                        fwprintf(pFile,L\"\n\");
                        fwprintf(pFile,L\"Anzahl der Modien: \");
                        _itow(numModes,status,10); 
                        fwprintf(pFile,status);
                        fwprintf(pFile,L\"\n\");

                        DXGI_MODE_DESC* mode=new DXGI_MODE_DESC[numModes];

                        pOutput->GetDisplayModeList    (    (DXGI_FORMAT)DXGI_test, 
                                                        DXGI_ENUM_MODES_INTERLACED,
                                                        &numModes,
                                                        mode
                                                    );

                        for(int n=0; nRelease ();
             
                OutputIndex++;
            }
        }
                 
        pAdapter->Release (); // Don't forget to release when you are done
     
        AdapterIndex++;
    }

    if(pFile) { 
        fclose (pFile); 
        pFile = 0; 
    }
    pDXGIFactory->Release ();
    
}


Das Progrämmchen loggt die möglichen Modien in eine Datei.

1 Mal gendert, zuletzt am 31.01.2009, 22:27:37 Uhr von exploid.
31.01.2009, 22:27:02 Uhr
Normal


ZFX Community Software, Version 0.9.1
Copyright 2002-2003 by Steffen Engel