kleinere Aufträge (DLL) gegen Bezahlung zu vergeben

quansol

Ich habe kleinere Auftragsarbeiten zu vergeben und suche Leute, die mit DLL-Programmierung und Anbindung an VBA und andere Systeme keine Probleme haben.
Wir haben derzeit kleinere finanzmathematische Projekte in Arbeit und können Mini-Projekte vergeben (natürlich gegen Entgeld).

Vorab eine kleine Fleißaufgabe zum drüberschauen:

Das Program besteht aus 6 dateien:
3 Quelltext Dateien: demo.cpp; CArray.cpp und CZins.cpp
2 Header Dateien: CArray.h und CZins.h
1 Def Datei: demo.def

// demo.cpp

#include <string>		// wegen function2
#include "CArray.h"		//wegen function6 & function7
#include "CArray.cpp"		//wegen function6 & function7
#include "CZins.h"      	//wegen function8
#include "CZins.cpp"      	//wegen function8
using namespace std;

double  __stdcall function1(long x, double y, long z)
    {
		double result;

		result = x + y*z + z*x + z + y + x*y ;
        return result;    
    }

double  __stdcall function2(char x)
  {
		double result;
		if (x=='y')
			result =80;
		else
			result =30;
        return result;
  }

double  __stdcall function3(string x)
    {
		double result;
		if (x=="hallo")
			result =100;
		else
			result =50;
        return result;    
    }

double  __stdcall function4(double myarray[8])
   {
		long i;
		double summe=0;
		for(i=0; i<8; ++i)
		{
			summe += myarray[i];
		}
	return summe;
   }

double  __stdcall function5(double kk, double daten[])
   {
		long i; 
		double summe =0;

		for (i=0; i < kk; ++i)
		{
			summe += daten[i];
		}

	return summe;
  }  

double  __stdcall function6(double x, CArray<double> mydata) 
  {
	double summe=0;
	long i;
		for (i = 0; i< x; ++i)
		{
			summe = summe + mydata(i);

		}

	return summe*x ;
  }

CArray<double>  __stdcall function7(long x)
  {
	CArray<double> myarray;
	myarray.setSize(x);
	long i;

		for (i=0; i<x; ++i)
			{
				myarray(i) = i*4.0 ;
			}

	return myarray;
  }

double  __stdcall function8(double w, CZins myzins) 
  {
	double result;
	if (myzins.stext=='y')
		result = 10 * myzins.x;
	else if (myzins.stext=='g')
		result = 6 * myzins.y + myzins.Kurve(3);
	else
		result = function6(w,myzins.Kurve);
	return result * w ;
  }

// CArray.h

#ifndef CARRAY_H
#define CARRAY_H

template <class T>
class CArray
{
public:

//  Constructors

    CArray () ;
    CArray ( long no_data ) ;

//  Copy 

    CArray ( CArray<T>& matrixx ) ;

//  Zuweisung

    CArray<T>& operator = ( CArray<T>& matrixx ) ;

//  Destruktor

    ~CArray () ;

//  Methode

    void setSize ( long no_data ) ;

//  Operator

    T& operator () ( long i ) ;

private:

    void copy (  CArray<T>& matrixx ) ;

//  Instanzvariablen

    long*    capacity ;			
    T*       contents ;
};

#endif

//CArray.cpp

#include "CArray.h"  

template <class T>
CArray<T> :: CArray ()
{
    capacity = 0 ;
    contents = 0 ;
}

template <class T>
CArray<T> :: CArray ( long no_data )
{
    setSize ( no_data ) ;
}

template <class T>
CArray<T> :: CArray ( CArray<T>& matrixx )
{							
    this -> copy ( matrixx ) ;
}

template <class T>
CArray<T> :: ~CArray ()
{
        delete [] capacity ;
        delete [] contents ;
}

template <class T>
CArray<T>& CArray<T> :: operator = ( CArray<T>& matrixx )
{										
    if ( this == &matrixx )
    {
        return *this ;
    }

        delete [] capacity ;
        delete [] contents ;

    this -> copy ( matrixx ) ;
    return *this ;
}

template <class T>
void CArray<T> :: copy ( CArray<T>& matrixx ) 
{
    long i;
    capacity = new long [1]; 
    long totalSize = 1 ;

	totalSize = matrixx.capacity [ 0 ] ;
	capacity[0]=matrixx.capacity [ 0 ] ;

    contents = new T [ totalSize ] ;
    for ( i = 0 ; i < totalSize ; i++ )
    {
        contents [ i ] = matrixx.contents [ i ] ;
    }
}

template <class T>
void CArray<T> :: setSize ( long no_data )
{
    capacity = new long [ 1 ] ;
    capacity [ 0 ] = no_data ;
    contents = new T [ no_data ] ;
}

template <class T>
T& CArray<T> :: operator () ( long i )
{
    return contents [ i ] ;
}

//CZins.h

#include "CArray.h"      //wegen function8

#ifndef CZINS_H
#define CZINS_H

class CZins
{
public:
	double x;
	double y;
	char stext;
	CArray<double> Kurve;

	//Konstruktor

	CZins ( );

};

#endif

//CZins.cpp

#include "CZins.h" 

CZins :: CZins ()
{
   x = 0 ;
   y = 0 ;
   stext='y';

}

//demo.def

LIBRARY	Mydemo
EXPORTS
	function1	@1
	function2	@2
	function3	@3
	function4	@4
	function5	@5
	function6	@6
	function7	@7
	function8	@8

Die Funktionen sollten simple Zahlen, -String und Array Operationen durchführen...

In VBA sind sie folgendermaßen angebunden:

'in Visual Basic:

Option Explicit

    Declare Function function1 Lib _
    "D:\Pfad\Demo.dll" _
    (ByVal x As Long, ByVal y As Double, ByVal z As Long) As Double

	'funktioniert!!!

    Declare Function function2 Lib _
    "D:\Pfad\Demo.dll" _
    (ByVal x As String) As Double

        'fehlerhaft: gibt immer 30 zurück!!!  WARUM????????

'bei function3 bis function8 erzeugt es einen Excel-Absturz???

Bei Fragen kann gerne auch unter Tel.: 03302/208750 Kontakt aufgenommen werden.

bIce

So einfach geht das ganze nicht. Da musst Du Variant-Typen verwenden. Wie das - mehr oder weniger gut - funktioniert, weiss ich aber nur für Delphi.
Für string sollte eigentlich wchar_t gehen. Strings sind in VB immer Multibyte-Strings (auch unter Win9x).
Für eigene Klassen musst Du wahrscheinlich Adapterklassen erstellen, die entweder IUnknown oder IDispatch implementieren (was VBA genau unterstützt weiß ich nicht, mit IDispatch bist Du aber der sicheren Seite, ist dafür aber anspruchsvoller).

Also am besten ist, wenn Du das als eine ActiveX-Bibliothek und nicht als einfache DLL implementierst. Aber wie gesagt kann ich dir da leider nicht weiterhelfen.

Unix-Tom

Im Grunde hast du Recht. Man kann nur die Datentypen verwenden die dafür vorgesehen sind.

z.B. ein BSTR

Ich habe aber auch Tel. Es geht nicht nur um VB/VBA sondern auch um DLL/so unter Windows/Linux u.s.w. Also im Grunde Library-Entwicklung für den Finanzbereich.

quansol

Da gerade Urlaubszeit ist, kann ich nicht gleich auf eure Angebote reagieren.
Wir müssen unsere "Problemchen" erst mal sammeln, dann trete ich noch mal an euch heran...
Auf jedenfall erst mal Danke für's drüberschauen.

quansol

illuminator

double  __stdcall function1(long x, double y, long z)
VB: Declare Funktion function1 lib "deinedll.dll" (byval x as long, byval y as double, byval z as long) as double

double  __stdcall function2(char x)
VB: Declare Dunction function2 lib "deinedll.dll" (byval x as byte) as double

double  __stdcall function3(string x)

- mit string lässt sich in vb(a) nix anfangen, nur native datentypen(long, double etc.) und Arrays
von diesen lassen sich von VB an externe Funktionen übergeben und dürfen als rückgabewerte verwendet werden
-> benutzte stattdessen char*

double __stdcall function3(char* x)
VB: Declare Funtion function3 lib "deinedll.dll" (byval x as string) as double

double  __stdcall function4(double myarray[8])
VB: Declare function function4 lib "deinedll.dll" ( byref myarray as double) as double

byref myarray muss das erste elemente eines VB-Double-arrays sein, z.B.

dim x(7) as double()
ret = function4( x(0))

double  __stdcall function5(double kk, double daten[])
VB: Declare function function5 (byval  kk as double, byref daten as double ) as double

Aufruf: siehe Beispiel oben

double  __stdcall function6(double x, CArray<double> mydata)

-> für CArray gilt das selbe wie für alle andere nicht nativen datentypen, s.o stattdessen double[] und
längendescriptor benutzen

double  __stdcall function6(double x, double mydata[], long mydatasize)

CArray<double>  __stdcall function7(long x)

s.o ,stattdessen double* + längendescriptor an VB als Referenz übergeben!

void __stdcall function7(long x, long* arraysize, double* retarray )
VB: Declare function function7 lib "deinedll.dll" ( byval x as long, byref arraysize as long, byref retarray as double )

double  __stdcall function8(double w, CZins myzins)

-> CZins, selber Fall wie string und CArray -> eventuell nachbilden mit mehreren nativen datentypen

illuminator

Nachtrag:
Wenn unbedingt mehr als native Datentypen benötigt wird, dann COM benutzen.