einbinden vom c und c++
Du musst die Module auch erstmal importieren, damit sie bekannt sind.
Also zuerst: und dann
ne0h
Also zuerst:
Code: Alles auswählen
import math
Code: Alles auswählen
dir(irgendwas)
ne0h
- gerold
- Python-Forum Veteran
- Beiträge: 5555
- Registriert: Samstag 28. Februar 2004, 22:04
- Wohnort: Oberhofen im Inntal (Tirol)
- Kontaktdaten:
Man muss ``ctypes`` vorher importieren, bevor man es mit ``dir`` analysieren kann.sechsrad hat geschrieben:bei dir(ctypes) kommt "NameError: name 'ctypes' is not defined"
EDIT:
Und du glaubst, du bist langsam?ne0h hat geschrieben:Warum bin ich immer zu langsam...
http://halvar.at | Kleiner Bascom AVR Kurs
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Wissen hat eine wunderbare Eigenschaft: Es verdoppelt sich, wenn man es teilt.
Eine andere, meines Erachtens einfachere Variante, da die C-Funktionen nicht umständlich angepasst werden müssen, wäre mit restype:Masaru hat geschrieben:So wie du das da versuchst sechsrad, funktioniert es bei mir auch nicht ...
Code: Alles auswählen
import ctypes
f = ctypes.cdll.LoadLibrary('test.dll')
f.mult.restype = ctypes.c_float
print f.mult(ctypes.c_float(34.3))
print 3.7 * 34.3
Code: Alles auswählen
#include <math.h>
float mult(float n) {
float a;
a = n * 3.7;
return a;
}
MfG
HWK
die variante von masaru funktioniert jetzt :
und die dll:
ergebnis ist dieses hier :
Code: Alles auswählen
#!/usr/bin/env python
from ctypes import *
f =cdll.LoadLibrary("test.dll")
ff=pointer(c_float())
tt=pointer(c_char_p())
b=c_float(10.0)
f.mult(b,ff)
print ff.contents.value
b=c_float(10.8)
f.div(b,ff)
print ff.contents.value
f.text(tt)
print tt.contents.value
Code: Alles auswählen
#include <math.h>
void mult(float n, float* r) {
*r=n*3.7;
}
void div(float n, float* r) {
*r=n/2.0;
}
void text(int* r) {
char text[] = "hurra, es geht !\n";
*r=text;
}
ergebnis ist dieses hier :
D:/Python25/pythonw.exe -u "D:/Python25/test-py/dll/dll1.py"
37.0
5.40000009537
hurra, es geht !
Aua. Ich hoffe mal, dass nur dein Testcode so aussieht.sechsrad hat geschrieben:Code: Alles auswählen
void text(int* r) { char text[] = "hurra, es geht !\n"; *r=text; }
aua, es ging nur darum, wie man text aus einer dll übertragen kann, aua.
das andere ergibt dann die feinarbeit. die funktion steht jetzt erstmal im vordergrund.
wie man dieses char jetzt ausfüllt, da gibt es ja verschiedene möglichkeiten in c.
eine textfunktion aus einer dll hatte ich hier im ganzen forum noch nicht gefunden.
es funktioniert erst einmal, das ist wichtig.
das andere ergibt dann die feinarbeit. die funktion steht jetzt erstmal im vordergrund.
wie man dieses char jetzt ausfüllt, da gibt es ja verschiedene möglichkeiten in c.
eine textfunktion aus einer dll hatte ich hier im ganzen forum noch nicht gefunden.
es funktioniert erst einmal, das ist wichtig.
Warum auch....das hier ist kein C-Forum.sechsrad hat geschrieben: eine textfunktion aus einer dll hatte ich hier im ganzen forum noch nicht gefunden.
du hast übrigens noch immer nicht diese unglaublich komplexen Rechnungen gezeigt, die in Python zu langsam sind.
nochmals danke für die hilfe mit einer dll in python einbinden.
mein ziel ist erreicht, klappt wunderbar mit allen was ich mir vorgestellt habe.
danke.
mfg
mein ziel ist erreicht, klappt wunderbar mit allen was ich mir vorgestellt habe.
danke.
mfg
ich meine, eine zeigerübergabe ist kein zufall, ich glaube(gehe auch in die kirche) das ist die einfachste lösung.Nur damit das klargestellt ist: es ist reiner Zufall, dass die text-Funktion funktioniert.
Das stimmt, das Übergebens eines Zeigers ist kein Zufall. Jedoch befindet sich der String auf dem Stack und damit ist nach Abarbeitung der Funktion auch der Inhalt auf den der Zeiger zeigt undefiniert.sechsrad hat geschrieben:ich meine, eine zeigerübergabe ist kein zufall, ich glaube(gehe auch in die kirche) das ist die einfachste lösung.
Ich weiß ja nicht, was Du da gemacht hast, bei mir kommt jedenfalls folgendes heraus:sechsrad hat geschrieben:da kommt dieses als ergebnis : -1.#IND
mfg
Code: Alles auswählen
C:\Programme\Python24\Scripts\Test>type test.py
#!/usr/bin/env python
import ctypes
f = ctypes.cdll.LoadLibrary('test.dll')
f.mult.restype = ctypes.c_float
print f.mult(ctypes.c_float(34.3))
print 3.7 * 34.3
C:\Programme\Python24\Scripts\Test>test.py
126.909996033
126.91
HWK
@EyDu: Die Zeichenkette sollte sich nicht auf dem Stack befinden. Das würde ja bedeuten, dass die Zeichenkette bei jedem Aufruf von woanders dort hin kopiert werden müsste, und da literale Zeichenketten "read only" sind, wäre das ziemlich unsinnig.
Aber die Funktion ist trotzdem total falsch. Erstens ist das Rückgabeargument vom Typ ``int*`` und dann wird nicht die Zeichenkette zurückgegeben, sondern die Adresse als Zahl. Wenn man den Rückgabeargumenttyp auf ``char*`` korrigieren würde, ist es immer noch nicht richtig, da dann versucht würde einen Zeiger in ein Zeichen zu konvertieren.
Aber die Funktion ist trotzdem total falsch. Erstens ist das Rückgabeargument vom Typ ``int*`` und dann wird nicht die Zeichenkette zurückgegeben, sondern die Adresse als Zahl. Wenn man den Rückgabeargumenttyp auf ``char*`` korrigieren würde, ist es immer noch nicht richtig, da dann versucht würde einen Zeiger in ein Zeichen zu konvertieren.
Und meine Variante:
Python-ScriptDLLAusgabeMfG
HWK
Python-Script
Code: Alles auswählen
#!/usr/bin/env python
import ctypes
f = ctypes.cdll.LoadLibrary('test.dll')
f.mult.restype = ctypes.c_float
f.div.restype = ctypes.c_float
f.text.restype = ctypes.c_char_p
print f.mult(ctypes.c_float(10))
print f.div(ctypes.c_float(10.8))
print f.text()
Code: Alles auswählen
#include <math.h>
char TEXT[] = "Das ist ein Test\n";
float mult(float n) {
return 3.7 * n;
}
float div(float n) {
return n / 2;
}
char* text() {
return TEXT;
}
Code: Alles auswählen
>C:\Programme\Python24\pythonw -u "test.py"
37.0
5.40000009537
Das ist ein Test
>Exit code: 0
HWK
Das mag ja durchaus sein, dass eine Compiler in diesem Fall optimiert, aber im allgemeinen Fall kann man nicht davon ausgehen:BlackJack hat geschrieben:@EyDu: Die Zeichenkette sollte sich nicht auf dem Stack befinden. Das würde ja bedeuten, dass die Zeichenkette bei jedem Aufruf von woanders dort hin kopiert werden müsste, und da literale Zeichenketten "read only" sind, wäre das ziemlich unsinnig.
Code: Alles auswählen
void text(int* r) {
char text[] = "hurra, es geht !\n";
text[4] = **a random character**;
*r=text;
}
übergabestring, erweiterung,rückgabe
python-code:
---------------------------------------------
print-ausgabe:
dies ist ein text ,es geht !
----------------------------------------------
dll:[/code]
python-code:
Code: Alles auswählen
#!/usr/bin/env python
from ctypes import *
f =cdll.LoadLibrary("test.dll")
tt=pointer(c_char_p())
text=c_char_p("dies ist ein text")
f.text_out_in(text,tt)
print tt.contents.value
print-ausgabe:
dies ist ein text ,es geht !
----------------------------------------------
dll:
Code: Alles auswählen
void text_out_in(char* text, int* r){
char neustr[12]=" ,es geht!\0";
strcat (text,neustr);
*r=text;
}
Zuletzt geändert von sechsrad am Donnerstag 10. April 2008, 07:50, insgesamt 1-mal geändert.
Jetzt schreibst du irgendwo in der Gegend rum. Du musst schon einen String übergeben, der ausreichend Platz für das Ergebnis hat.
Und du bist dir wirklich sicher, dass du deine Programme mit C "optimieren" willst?
Und du bist dir wirklich sicher, dass du deine Programme mit C "optimieren" willst?
BlackJack hat schon recht, wie man hier am Assemblercode vonEyDu hat geschrieben:Das mag ja durchaus sein, dass eine Compiler in diesem Fall optimiert, aber im allgemeinen Fall kann man nicht davon ausgehen:BlackJack hat geschrieben:@EyDu: Die Zeichenkette sollte sich nicht auf dem Stack befinden. Das würde ja bedeuten, dass die Zeichenkette bei jedem Aufruf von woanders dort hin kopiert werden müsste, und da literale Zeichenketten "read only" sind, wäre das ziemlich unsinnig.
Code: Alles auswählen
void text(int* r) { char text[] = "hurra, es geht !\n"; text[4] = **a random character**; *r=text; }
Code: Alles auswählen
char* text() {
char TEXT[] = "Das ist ein Test\n";
return TEXT;
}
Code: Alles auswählen
6ABC11AC ASCII "Das ist ein Test\n",0
6ABC11BE PUSH EBP
6ABC11BF MOV EBP,ESP
6ABC11C1 SUB ESP,28
6ABC11C4 MOV EAX,DWORD PTR DS:[6ABC11AC]
6ABC11C9 MOV DWORD PTR SS:[EBP-28],EAX
6ABC11CC MOV EAX,DWORD PTR DS:[6ABC11B0]
6ABC11D1 MOV DWORD PTR SS:[EBP-24],EAX
6ABC11D4 MOV EAX,DWORD PTR DS:[6ABC11B4]
6ABC11D9 MOV DWORD PTR SS:[EBP-20],EAX
6ABC11DC MOV EAX,DWORD PTR DS:[6ABC11B8]
6ABC11E1 MOV DWORD PTR SS:[EBP-1C],EAX
6ABC11E4 MOV AX,WORD PTR DS:[6ABC11BC]
6ABC11EA MOV WORD PTR SS:[EBP-18],AX
6ABC11EE LEA EAX,DWORD PTR SS:[EBP-28]
6ABC11F1 LEAVE
6ABC11F2 RETN
MfG
HWK