ich schonwieder!

Habe nun meine übung etwas verstärkt, und wollte über eine klasse eine form aus einer dll verwalten:

DLL.h

#ifndef __FILE1_H
#define __FILE1_H

#include "Unit2.h"
class MyForm
{
 public:
  MyForm();
  ~MyForm();
  void ShowIt();
 private:
  TForm2* Form2;
};
#endif

dll.cpp

#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
	return 1;
}
//---------------------------------------------------------------------------
MyForm::MyForm()
{
    Form2 = new TForm2(0);
}

MyForm::~MyForm()
{
    if(Form2)
     delete Form2;
}

void MyForm::ShowIt()
{
    Form2->Show();
}

extern "C" __declspec(dllexport)MyForm* GetMyForm()
{
    return new MyForm;
}

extern "C" __declspec(dllexport)void FreeMyForm(MyForm* my)
{
    delete my;
}

Aufrufendes Programm

#include <vcl.h>
#pragma hdrstop

#include "Main.h"
#include "File1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
HINSTANCE h = LoadLibrary("Project1.dll");
if(h)
   {
    typedef MyForm*(*pFunc)();
    pFunc myformFunc;
    MyForm* mForm;

    myformFunc = (pFunc)GetProcAddress(h,"_GetMyForm");
    if(myformFunc)
       {
         mForm = myformFunc();
         mForm->ShowIt();
       }
    else
      ShowMessage("Klasse konnte nicht geladen werden");
   }
else
   {
       ShowMessage("Project1.dll konnte nicht geladen werden");
   }
}
//---------------------------------------------------------------------------

bekomme immer fehler.: unaufgelöste externe MyForm::ShowIt()! Wieso?

Woher soll deine Anwendung MyForm::ShowIt auch kennen, du importierst diese Klasse ja nicht aus der dll in dein Projekt.
Man kann eine Wrapperklasse für die dll-Funktionen schreiben aber
1. Diese Wrapperklasse muß dem Hauptprogramm vollständig bekannt sein (Deklaration und Definition)
2. Die in der Klasse verwendeten Funktionen bzw. Klassen aus der dll müssen auch alle aus der dll heraus importiert werden.

Ich mach sowas normalerweise so.
Die Wrapperklasse lädt die dll im Konstruktor (oder bei der ersten verwendung einer memberfunktion).
Sie hält Pointer auf alle von der dll importierten Funktionen (werden ebenfalls vor der ersten Verwendung initialisiert).
Die Memberfunktionen dieser Klasse rufen dann die aus der dll importierten Funktionen auf.
Die dll wird im Destruktor wieder entladen.

Bei dir würde es erstmal reicher aus ShowIt eine exportierbare dll-Funktion zu machen.

Und sollte der Zeiger auf die Klasse im aufrufenden Programm, besser ein Member der Form1 Klasse sein?

kannst du das vielleicht an meinem code etwas konkretisieren?
Mit wrapperklasse meinst du hier diese MyForm oder?

#include "Unit2.h"

#pragma argsused
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
    return 1;
}
//---------------------------------------------------------------------------

extern "C" __declspec(dllexport)TForm2* GetForm2()
{
    return new TForm2(0);
}

extern "C" __declspec(dllexport)void FreeForm2(TForm2* form)
{
    delete form;
} 	

extern "C" __declspec(dllexport)void ShowForm2(TForm2* form)
{
    form->ShowModal();
}

dll.h

class TForm2;

typedef TForm2 *(*getForm)();
typedef void (*useForm)();

class MyForm
{
	private:
	TForm2* form;
	getForm getForm2;
	useForm freeForm2, showForm2;
	HINSTANCE hdll;
	bool valid;

	public:
	MyForm() : valid(false), form(0)
	{
		hdll = LoadLibrary("Project1.dll");
		if( hdll )
		{
			getForm2 = (getForm)GetProcAddress(h,"_GetForm2");
			freeForm2 = (useForm)GetProcAddress(h,"_FreeForm2");
			showForm2 = (useForm)GetProcAddress(h,"_ShowForm2");
			if( getForm2 && freeForm2 && showForm2 )
            {
                valid = true;
			   form = getForm2();
            }
		}
	}
	~MyForm()
	{
		if( valid ) freeForm2(form);
		if( hdll ) FreeLibrary(hdll);
	}
	ShowIt()
	{
	  if( valid ) showForm2();
	}
	bool isValid() { return valid; }
}

Hauptprogramm

#include <vcl.h>
#pragma hdrstop

#include "Main.h"
#include "File1.h"
#include "dll.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
	 MyForm myform;
	 if( myform.isValid )
	 {
	    MyForm.ShowIt();
	 }
	 else
   {
       ShowMessage("Project1.dll konnte nicht geladen werden");
   }
}
//---------------------------------------------------------------------------

Hintergund: ich möchte einem MenüItem als OnClick eine Funktion aus der DLL zuordnen, dynamisch!