Objekt dynamisch allokieren



  • Hallo,

    im Rahmen meines Studiums programmiere ich gerade einen kleinen Video Player und bin auf ein Problem gestossen welches ich nicht Loesen kann, zwecks Entwicklung bekomme ich eine Klasse vor gegeben:

    MciVideo.h

    #ifndef MCIVIDEO_H
    #define MCIVIDEO_H
    
    #pragma warning (disable:4290) // Ausnahmespezifikation ignoriert
    
    class CMciVideo
    {
    public:
    // Öffnet den Video-Clip "AVI_Datei" für das Abspielen im "Fenster"
    // PRE:  AVI_Datei existiert und hat das richtige Format && 
    //       Fenster existiert als MFC-Objekt und hat ein zugeordnetes
    //       Windows-Objekt (erfolgt erst bei Aufruf von DoModal !) &&
    //       die Buttons im Fenster sind alle am Rand plaziert
    // POST: AVI_Datei ist vorbereitet zum Abspielen
       CMciVideo (CWnd* const Fenster, 
                  CString AVI_Datei="hangldi.avi")
          throw (char*);
    
    // Schließt den Video-Clip
    // PRE:  Der Clip ist geöffnet und läuft nicht
    // POST: alles vorbei
       ~CMciVideo () throw (char*);
    
    // Startet den Video-Clip
    // PRE:  Der Clip ist geöffnet, läuft nicht und steht nicht am Ende
    // POST: Der Clip läuft; 
    //       nach Ablauf wird MM_MCINOTIFY an das Abspielfenster gesendet
       void Play () throw (char*);
    
    // Hält den Video-Clip an
    // PRE:  Der Clip ist geöffnet und läuft
    // POST: Der Clip steht;
    //       MM_MCINOTIFY wird an das Abspielfenster gesendet
       void Stop () throw (char*);
    
    // Positioniert den Video-Clip an den Anfang
    // PRE:  Der Clip ist geöffnet und steht, aber nicht am Anfang
    // POST: Der Clip steht am Anfang
       void Rewind () throw (char*);
    
    // Liefert die Anzahl der Einzelbilder des Clips
    // PRE:  Der Clip ist geöffnet
    // POST: -
       long ClipLength ();
    
    // Liefert die Nummer des Bildes, das momentan abgespielt wird
    // PRE:  Der Clip ist geöffnet
    // POST: Ergebnis im Wertebereich 0 .. ClipLength()
       long ActualPosition ();
    
    protected:
       CWnd* const ZielFenster;
       long  Length;
       bool  ClipGeoeffnet; // falls beim Öffnen etwas schief geht
    
       bool  SendCommand (const char* Sender, const char* Command,
                         long* Result=NULL, char** ResultString=NULL);
       bool  ClipLaeuft ();
       void  AssertOrThrow (bool Assertion, char* Message)
          throw (char*);
    };
    
    #endif
    

    MciVideo.cpp

    #include "stdafx.h"
    
    #include <stdlib.h>
    #include <mmsystem.h>
    #include "mcivideo.h" 
    
    static const bool TraceMciCommands = FALSE;
    
    CMciVideo::CMciVideo (CWnd* const Fenster, CString AVI_Datei)
    // Öffnet den Video-Clip "AVI_Datei" für das Abspielen im "Fenster"
    // PRE:  AVI_Datei existiert und hat das richtige Format && 
    //       Fenster existiert als MFC-Objekt und hat ein zugeordnetes
    //       Windows-Objekt (erfolgt erst bei Aufruf von DoModal !) &&
    //       die Buttons im Fenster sind alle am Rand plaziert
    // POST: AVI_Datei ist vorbereitet zum Abspielen
    : ZielFenster (Fenster), Length (100), ClipGeoeffnet (FALSE)
    {  
    //	try {
    		AssertOrThrow (Fenster!=NULL,
    						  "CMciVideo::CMciVideo: Fenster existiert nicht als MFC-Objekt");
    		AssertOrThrow (Fenster->GetSafeHwnd()!=NULL,
    						  "CMciVideo::CMciVideo: Fenster existiert nicht als Windows-Objekt");
    
    		// Freifläche zur Darstellung des Videos ermitteln:
    		// Für jeden Button
    		// 1. alle vom Button belegten Randstreifen ermitteln
    		// 2. minimalen Randstreifen auswählen
    		// 3. an diesem Rand die verfügbare Freifläche beschneiden
    		CRect ControlRect, FensterRect, OrgRect, FilmRect;
    		ZielFenster->GetClientRect (&FensterRect);     // Client Koordinaten
    		FensterRect.NormalizeRect ();
    		OrgRect = FensterRect;                         // unbeschnittenes Fenster
    
    		CWnd* Control = ZielFenster->GetTopWindow ();  // erster Button
    		while (Control!=NULL) { // Vereinigungsfläche aller Buttons bilden
    		  Control->GetWindowRect (&ControlRect);      // Screen Koordinaten
    		  ZielFenster->ScreenToClient (&ControlRect); // Client Koordinaten
    		  ControlRect.NormalizeRect ();
    
    		  // belegte Fläche am jeweiligen Rand ermitteln:
    		  enum Rand {L=0, T, R, B};
    		  int RandBreite [4];
    		  RandBreite[L] = ControlRect.right - OrgRect.left; 
    		  RandBreite[R] = OrgRect.right - ControlRect.left;
    		  RandBreite[T] = ControlRect.bottom - OrgRect.top;
    		  RandBreite[B] = OrgRect.bottom - ControlRect.top;
    
    		  // welcher Rand ist der schmalste ?
    		  int MinimalerRand = L;
    		  for (int r=L; r<=B; r++)
    			  if (RandBreite[MinimalerRand] > RandBreite[r])
    				  MinimalerRand = r;
    
    		  // am schmalsten Rand vom verfügbaren Fenster abschneiden:
    		  if (RandBreite[MinimalerRand] > 0)
    			  switch (MinimalerRand) {
    				  case L: FensterRect.left   = ControlRect.right;  break; 
    				  case R: FensterRect.right  = ControlRect.left;   break;
    				  case T: FensterRect.top    = ControlRect.bottom; break;
    				  case B: FensterRect.bottom = ControlRect.top;    break;
    				  default:AssertOrThrow (false, "Programmfehler: MinimalerRand fehlerhaft"); break;
    			  }
    
    		  Control = Control->GetNextWindow ();        // nächster Button
    		}
    
    		// Videoclip öffnen
    		HWND WinFenster = ZielFenster->GetSafeHwnd();
    		CString cmd;
    		cmd.Format ("open %s alias clip style child parent %u wait", 
    					  AVI_Datei, (unsigned int)WinFenster);
    		ClipGeoeffnet = SendCommand ("OPEN", (const char*)(cmd));
    
    		if (ClipGeoeffnet) {
    		 // Ton abschalten (PCs im Praktikum haben keine Soundkarte)
    		 SendCommand ("SET",    "set clip audio all off wait");     
    
    		 // Länge des Videoclips ermitteln
    		 SendCommand ("SET",    "set clip time format frames wait");     
    		 SendCommand ("STATUS", "status clip length wait", &Length);
    
    		 // Videofenster in Freifläche zentrieren
    		 long lFilm;
    		 SendCommand ("STATUS", "status clip window handle wait", &lFilm);
    		 CWnd Film;
    		 Film.Attach (HWND(lFilm));
    		 Film.GetClientRect (&FilmRect);
    		 if ((FensterRect.Width()>=FilmRect.Width()) && 
    			  (FensterRect.Height()>=FilmRect.Height())) {
    			// ok, Freifläche groß genug
    			FilmRect.OffsetRect (FensterRect.left+(FensterRect.Width()-FilmRect.Width())/2, 
    										FensterRect.top+(FensterRect.Height()-FilmRect.Height())/2);
    			Film.MoveWindow (FilmRect, FALSE);
    		 }
    		 else
    			ZielFenster->MessageBox ("Freifläche von 'Fenster' zu klein\n", 
    											 "CMciVideo", MB_OK | MB_ICONSTOP);
    		 Film.Detach ();
    		 // Anfangsbild des Videoclips sichtbar machen
    		 SendCommand ("PUT", "put clip window wait");
    		}
    		else
    		 AssertOrThrow (false, "CMciVideo::CMciVideo: AVI-Datei kann nicht geöffnet werden");
    //	}
    //	catch (...) {
    //		delete this;
    		// Obiges "delete" ist notwendig in Konstruktoren von Klassen, deren Objekte  
    		// dynamisch allokiert werden. Beim Auswerfen einer Ausnahme aus dem Konstruktor
    		// wird dann nämlich der Ergebniszeiger von "new" nicht mehr zugewiesen und der
    		// gerade allokierte Speicherbereich hängt in der Luft. Er kann somit auch nicht
    		// mehr freigegeben werden und es entstehen "memory leaks".
    		// Wird allerdings das Objekt statisch oder automatisch allokiert, dann führt 
    		// dieses "delete" zum Programmabbruch per Assertion.
    		// Das ist natürlich sehr unschön, daß sich eine Klasse bezüglich der Art der
    		// Objektallokation festlegen muß !!! 
    		// Im Zweifelsfall nimmt man wohl besser die "memory leaks" in Kauf.
    //		throw;
    //	}
    }
    
    CMciVideo::~CMciVideo ()
    // Schließt den Video-Clip
    // PRE:  Der Clip ist geöffnet und läuft nicht
    // POST: alles vorbei
    {
      if (!ClipGeoeffnet) return;  // auch für die Release Version
      AssertOrThrow (!ClipLaeuft(), "CMciVideo::~CMciVideo: der Clip läuft noch");
      SendCommand ("CLOSE", "close clip wait");     
    }
    
    void CMciVideo::Play ()
    // Startet den Video-Clip
    // PRE:  Der Clip ist geöffnet, läuft nicht und steht nicht am Ende
    // POST: Der Clip läuft; 
    //       nach Ablauf wird MM_MCINOTIFY an das Abspielfenster gesendet
    {
      if (!ClipGeoeffnet) {        // auch für die Release Version
         ZielFenster->PostMessage (MM_MCINOTIFY, MCI_NOTIFY_FAILURE);
            // damit nicht endlos auf MM_MCINOTIFY gewartet wird
         return;
      }
      AssertOrThrow (ActualPosition()<ClipLength(),
    	              "CMciVideo::Play: der Clip steht bereits am Ende");
      AssertOrThrow (!ClipLaeuft(),
                     "CMciVideo::Play: der Clip läuft bereits");
      SendCommand ("PLAY", "play clip notify");     
    }
    
    void CMciVideo::Stop ()
    // Hält den Video-Clip an
    // PRE:  Der Clip ist geöffnet und läuft
    // POST: Der Clip steht;
    //       MM_MCINOTIFY wird an das Abspielfenster gesendet
    {
      if (!ClipGeoeffnet) return;  // auch für die Release Version
      AssertOrThrow (ClipLaeuft(),
    	              "CMciVideo::Stop: der Clip steht bereits");
      SendCommand ("STOP", "stop clip wait");     
    }
    
    void CMciVideo::Rewind ()
    // Positioniert den Video-Clip an den Anfang
    // PRE:  Der Clip ist geöffnet und steht, aber nicht am Anfang
    // POST: Der Clip steht am Anfang
    {
      if (!ClipGeoeffnet) return;  // auch für die Release Version
      AssertOrThrow (!ClipLaeuft(),
    	              "CMciVideo::Rewind: der Clip läuft noch");
      AssertOrThrow (ActualPosition()!=0,
    	              "CMciVideo::Rewind: der Clip steht bereits am Anfang");
      SendCommand ("REWIND", "seek clip to start wait");     
    }
    
    long CMciVideo::ClipLength ()
    // Liefert die Anzahl der Einzelbilder des Clips
    // PRE:  Der Clip ist geöffnet
    // POST: -
    {
      return Length;
    }
    
    long CMciVideo::ActualPosition ()
    // Liefert die Nummer des Bildes, das momentan abgespielt wird
    // PRE:  Der Clip ist geöffnet
    // POST: Ergebnis im Wertebereich 0 .. ClipLength()
    {
      long Position = 0;
      if (ClipGeoeffnet)
         SendCommand ("POS", "status clip position wait", &Position);
      return Position;
    }     
    
    bool CMciVideo::SendCommand (const char* Sender, const char* Command,
                                 long* Result, char** ResultString)
    // PRE:  Sender und Command sind nullterminierte Strings &&
    //       Command enthält einen gültigen MCI-Befehl &&
    //       Result ist nur dann !=NULL, wenn 
    //       (a) Command einen MCI-Befehl enthält, der eine einzelne Ganzzahl
    //           als Ergebnis liefert oder
    //       (b) CompareResult auf einen nullterminierten String zeigt
    // POST: Ergebnis = FALSE : MCI-Befehl wurde zurückgewiesen
    //       Ergebnis = TRUE  : MCI-Befehl wurde akzeptiert && 
    //          falls Result!=NULL und ResultString==NULL war
    //            dann *Result == Ergebnis des MCI-Befehls als Ganzzahl
    //          falls Result!=NULL und ResultString!=NULL war
    //            dann zeigt ResultString auf einen statischen Buffer mit dem 
    //            Ergebnis des MCI-Befehls als String
    {
      const int ReturnLength = 80;
      static char ReturnString [ReturnLength+1] = " ";
      bool ok;
    
      DWORD ErrorCode = mciSendString(Command,
                                ReturnString, ReturnLength, 
                                ZielFenster->GetSafeHwnd());
      if (ErrorCode==0) {
         if (TraceMciCommands)
            TRACE ("--- mci %s: ok %s\n", Sender, ReturnString);
         if (Result!=NULL) {
            if (ResultString==NULL) 
               *Result = atol (ReturnString);
            else
               *ResultString = ReturnString;
         }
         ok = TRUE;
      }
      else {
         if (!mciGetErrorString (ErrorCode, ReturnString, ReturnLength))
            ReturnString[0] = '\0';
         if (TraceMciCommands)
            TRACE ("--- mci %s: Fehler: %s\n", Sender, ReturnString);
         ok = FALSE;
      }
      return ok;
    }
    
    bool CMciVideo::ClipLaeuft ()
    // Testet, ob der Clip gerade läuft
    // PRE:  Der Clip ist geöffnet 
    // POST: Ergebnis = FALSE wenn der Clip nicht läuft
    //       Ergebnis = TRUE  wenn der Clip läuft
    {
      long dummy;
      char* Ergebnis = "?";
      SendCommand ("STATUS", "status clip mode wait", &dummy, &Ergebnis);
      return ((strcmp (Ergebnis, "Wiedergabe") == 0) ||   // VfW deutsch
              (strcmp (Ergebnis, "playing"   ) == 0) );   // VfW englisch
    }
    
    void CMciVideo::AssertOrThrow (bool Assertion, char* Message)
    // Wirft eine Exception aus, falls "Assertion" nicht wahr ist.
    // Zusätzlich wird die "Message" noch per TRACE ausgegeben für den Fall,
    // daß in der Umgebung noch keine Exception-Behandlung implementiert ist.
    // PRE:  -
    // POST: die Aufrufumgebung wird per Exception verlassen
    {
    	if (!Assertion) {
    		TRACE ("Exception %s\n", Message);	// falls die Exception nicht eingefangen wird
    		throw Message;
    		// im Debug-Fenster erscheint folgende Meldung trotz try...catch in der Aufrufumgebung:
    		// Nicht abgefangene Ausnahme in VideoPlayer.exe (KERNEL32.DLL): 0xE06D7363: Microsoft C++ Exception.
    		// Diese Meldung ist mir unerklärlich, aber glücklicherweise folgenlos.
    	}
    }
    

    Nun habe ich ein dialog bassierendes Win Programm generiert/programmiert.
    Wenn ich jetzt versuche das Objekt objMciVideo der Klasse CMciVideo dynamisch zu erstellen funktioniert dies nicht (Siehe privat part in MediaPlayerDlg.h und Konstruktor in MediaPlayerDlg.cpp)

    MediaPlayerDlg.h

    // MediaPlayerDlg.h : header file
    //
    
    #include <mmsystem.h>
    
    #include "Mcivideo.h"
    
    #if !defined(AFX_MEDIAPLAYERDLG_H__8E66DBC5_465A_4A65_9857_88386BF75514__INCLUDED_)
    #define AFX_MEDIAPLAYERDLG_H__8E66DBC5_465A_4A65_9857_88386BF75514__INCLUDED_
    
    #if _MSC_VER > 1000
    #pragma once
    #endif // _MSC_VER > 1000
    
    /////////////////////////////////////////////////////////////////////////////
    // CMediaPlayerDlg dialog
    
    class CMediaPlayerDlg : public CDialog
    {
    // Construction
    CMciVideo objMciVideo();
    public:
    	CMediaPlayerDlg(CWnd* pParent = NULL);	// standard constructor
    
    // Dialog Data
    	//{{AFX_DATA(CMediaPlayerDlg)
    	enum { IDD = IDD_MEDIAPLAYER_DIALOG };
    	CButton	m_PowerOff;
    	CButton	m_Stop;
    	CButton	m_Rewind;
    	CButton	m_Play;
    	//}}AFX_DATA
    
    	// ClassWizard generated virtual function overrides
    	//{{AFX_VIRTUAL(CMediaPlayerDlg)
    	protected:
    	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support
    	//}}AFX_VIRTUAL
    
    // Implementation
    
    	enum m_Zustand {StehtAnfang, StehtUnterwegs, StehtEnde, Laeuft, Bremst};
    
    protected:
    	HICON m_hIcon;
    
    	// Generated message map functions
    	//{{AFX_MSG(CMediaPlayerDlg)
    	virtual BOOL OnInitDialog();
    	afx_msg void OnPaint();
    	afx_msg HCURSOR OnQueryDragIcon();
    	afx_msg void OnPlay();
    	afx_msg void OnRewind();
    	afx_msg void OnStop();
    	//}}AFX_MSG
    	DECLARE_MESSAGE_MAP()
    };
    
    //{{AFX_INSERT_LOCATION}}
    // Microsoft Visual C++ will insert additional declarations immediately before the previous line.
    
    #endif // !defined(AFX_MEDIAPLAYERDLG_H__8E66DBC5_465A_4A65_9857_88386BF75514__INCLUDED_)
    
    // MediaPlayerDlg.cpp : implementation file
    //
    #include <mmsystem.h>
    #include "stdafx.h"
    #include "MediaPlayer.h"
    #include "MediaPlayerDlg.h"
    
    #ifdef _DEBUG
    #define new DEBUG_NEW
    #undef THIS_FILE
    static char THIS_FILE[] = __FILE__;
    #endif
    
    #include "Mcivideo.h"
    
    /////////////////////////////////////////////////////////////////////////////
    // CMediaPlayerDlg dialog
    
    CMediaPlayerDlg::CMediaPlayerDlg(CWnd* pParent /*=NULL*/)
    	: CDialog(CMediaPlayerDlg::IDD, pParent)
    {
    	//{{AFX_DATA_INIT(CMediaPlayerDlg)
    		// NOTE: the ClassWizard will add member initialization here
    	//}}AFX_DATA_INIT
    	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
    	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    	CMciVideo* objMciVideo = new CMciVideo();
    }
    
    void CMediaPlayerDlg::DoDataExchange(CDataExchange* pDX)
    {
    	CDialog::DoDataExchange(pDX);
    	//{{AFX_DATA_MAP(CMediaPlayerDlg)
    	DDX_Control(pDX, IDCANCEL, m_PowerOff);
    	DDX_Control(pDX, IDC_Stop, m_Stop);
    	DDX_Control(pDX, IDC_Rewind, m_Rewind);
    	DDX_Control(pDX, IDC_Play, m_Play);
    	//}}AFX_DATA_MAP
    }
    
    BEGIN_MESSAGE_MAP(CMediaPlayerDlg, CDialog)
    	//{{AFX_MSG_MAP(CMediaPlayerDlg)
    	ON_WM_PAINT()
    	ON_WM_QUERYDRAGICON()
    	ON_BN_CLICKED(IDC_Play, OnPlay)
    	ON_BN_CLICKED(IDC_Rewind, OnRewind)
    	ON_BN_CLICKED(IDC_Stop, OnStop)
    	//}}AFX_MSG_MAP
    END_MESSAGE_MAP()
    
    /////////////////////////////////////////////////////////////////////////////
    // CMediaPlayerDlg message handlers
    
    BOOL CMediaPlayerDlg::OnInitDialog()
    {
    	CDialog::OnInitDialog();
    
    	// Set the icon for this dialog.  The framework does this automatically
    	//  when the application's main window is not a dialog
    	SetIcon(m_hIcon, TRUE);			// Set big icon
    	SetIcon(m_hIcon, FALSE);		// Set small icon
    
    	// TODO: Add extra initialization here
    
    	return TRUE;  // return TRUE  unless you set the focus to a control
    }
    
    // If you add a minimize button to your dialog, you will need the code below
    //  to draw the icon.  For MFC applications using the document/view model,
    //  this is automatically done for you by the framework.
    
    void CMediaPlayerDlg::OnPaint() 
    {
    	if (IsIconic())
    	{
    		CPaintDC dc(this); // device context for painting
    
    		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
    
    		// Center icon in client rectangle
    		int cxIcon = GetSystemMetrics(SM_CXICON);
    		int cyIcon = GetSystemMetrics(SM_CYICON);
    		CRect rect;
    		GetClientRect(&rect);
    		int x = (rect.Width() - cxIcon + 1) / 2;
    		int y = (rect.Height() - cyIcon + 1) / 2;
    
    		// Draw the icon
    		dc.DrawIcon(x, y, m_hIcon);
    	}
    	else
    	{
    		CDialog::OnPaint();
    	}
    }
    
    // The system calls this to obtain the cursor to display while the user drags
    //  the minimized window.
    HCURSOR CMediaPlayerDlg::OnQueryDragIcon()
    {
    	return (HCURSOR) m_hIcon;
    }
    
    void CMediaPlayerDlg::OnPlay() 
    {
    	UpdateData(true);
    		m_Play.EnableWindow(false);
    		m_Rewind.EnableWindow(false);
    		m_PowerOff.EnableWindow(false);
    		m_Stop.EnableWindow(true);
    	UpdateData(false);
    }
    
    void CMediaPlayerDlg::OnRewind() 
    {
    	UpdateData(true);
    		m_Play.EnableWindow(true);
    		m_Stop.EnableWindow(false);
    		m_Rewind.EnableWindow(false);
    		m_PowerOff.EnableWindow(true);
    	UpdateData(false);
    }
    
    void CMediaPlayerDlg::OnStop() 
    {
    	UpdateData(true);
    		m_Play.EnableWindow(true);
    		m_Rewind.EnableWindow(true);
    		m_PowerOff.EnableWindow(true);
    		m_Stop.EnableWindow(false);
    	UpdateData(false);
    
    }
    

  • Administrator

    Also mal vorweg. Es hätte auch gereicht wenn du weniger Code angegeben hättest.
    Dann find ich dies eine geniale Aussage:

    Peter K. schrieb:

    Wenn ich jetzt versuche das Objekt objMciVideo der Klasse CMciVideo dynamisch zu erstellen funktioniert dies nicht (Siehe privat part in MediaPlayerDlg.h und Konstruktor in MediaPlayerDlg.cpp)

    Erstens, was soll man darunter verstehen, wenn du sagt funktioniert dies nicht??? Fehlermeldung hättest ja wirklich noch mitliefern können, oder was denn nicht läuft usw. usf.
    Und zweitens ich weiss ja nicht ob ich blind bin, aber ich sehe keinen Privat Abschnitt in MediaPlayerDlg.h ...

    Und um dir eine Lösung zu geben:
    Du rufst in dem Konstruktor, den Konstruktor CMciVideo() auf. Doch wenn ich mir MciVideo.h anschaue, sehe ich dort keinen einzigen deklarierten Konstruktor, welcher Null Parameter nimmt.

    Grüssli



  • Dravere schrieb:

    Und um dir eine Lösung zu geben:
    Du rufst in dem Konstruktor, den Konstruktor CMciVideo() auf. Doch wenn ich mir MciVideo.h anschaue, sehe ich dort keinen einzigen deklarierten Konstruktor, welcher Null Parameter nimmt.

    Grüssli

    Stimmt, nur weiss ich nicht genau was ich nun uebergeben muss. Ich wusste nicht genau wo das Problem liegt, deswegen dachte ich mit lieber mehr source posten als zu wenig.

    Hier die Fehlermeldung die ich vergessen hatte

    C:\temp_Pg2\MediaPlayer\MediaPlayerDlg.cpp(27) : error C2512: 'CMciVideo' : no appropriate default constructor available

    Also das Problem scheint ja nun eingekrenzt zu sein, ich muss irgend was an CWnd* const Fenster uebergeben (vermutlich irgend etwas vom Dialog Fenster) nur weiss ich nicht was, wenn mir da noch mal jemand auf die Spruenge helfen wuerde waere mir vermutlich sehr geholfen.

    Danke schon mal...


  • Administrator

    Na bitte geht doch. Die Fehlermeldung sagt ja im übrigen genau das was ich gesagt habe. Es gibt keinen solchen Konstruktor.

    Was du dem Konstruktor allerdings übergeben musst, müsstest du eigentlich den Fragen, von dem du den Code hast. Das kann dir der Compiler natürlich nicht sagen und hier drin eigentlich auch niemand. Bzw. hier drin muss sich jeder zuerst in den Code reinstudieren. Und das könntest ja eigentlich auch du machen nicht?

    Ich habe das jetzt mal schnell überflogen. Und wenn ich den Code richtig verstehe, dann braucht der einen Zeiger auf ein CWnd Objekt, in welchem das Video abgespielt werden soll. Wenn du einen Zeiger auf dein Dialog übergibst, dann wird einfach das ganze Dialog dafür verwendet um den Film zu zeigen. Ich denke es wäre sinnvoller du machst dir ein CustomControl oder sowas und übergibst dann den Zeiger von diesem CustomControll dem Konstruktor.

    Grüssli



  • Das ganze soll dann tatsaechlig in dem Dialog selber sein. Nun habe ich versucht einfach mal "CMediaPlayerDlg* dlg" zu uebergeben. Fehlermeldung ist dann folgende

    C:\Dokumente und Einstellungen\Administrator\Eigene Dateien\Studium\Programmieren II\Uebung 2\MediaPlayer\MediaPlayerDlg.cpp(27) : error C2065: 'dlg' : undeclared identifier
    C:\Dokumente und Einstellungen\Administrator\Eigene Dateien\Studium\Programmieren II\Uebung 2\MediaPlayer\MediaPlayerDlg.cpp(27) : error C2275: 'CMediaPlayerDlg' : illegal use of this type as an expression

    Klappt also immer noch nicht... hmmm weiss einfach nicht was genau ich dahin uebergeben muss...


  • Administrator

    Sag mal hast du schon jemals mit C++ programmiert?
    Bzw. liest du überhaupt die Fehlermeldungen, welche rauskommen?
    Oder verarschst du mich einfach?

    Grüssli


Log in to reply