Pointer auf Array mit Labview übertragen und darstellen

(17.07.2013 15:07 )jg schrieb:  Ich wiederhole mich ungern, aber:

(16.07.2013 22:13 )jg schrieb:  Unter der Annahme, dass der Datentyp int bei deinem C-System int32 ist und du unter einem 32bit-Betriebssystem arbeitest:
Wieso holst du die Adressen als U64 ab?
Wieso holst du die Werte als U64 ab?

Kannst du vielleicht die TestDLL.dll zu deinem letzten VI ebenfalls bereit stellen?

EDIT: Vielleicht stimmt auch die ByteOrder des abgeholten Wertes nicht. Das Resultat schon im HEX-Code angeschaut?

Gruß, Jens

Ups, deinen Beitrag habe ich leider nicht gesehen, daher hier die Antwort:
-> Ich arbeite unter einem x64-OS, int sollte normalerweise 32bit sein. VI und DLL ist im Anhang, der gesamte Code der DLL ist in den Tags (in obigem Post habe ich sämtliche unnötigen Funktionen einfach weggelassen, da ich sie ja ohnehin nicht aufrufe (stört ja auch nicht, oder?).
-> Wie schaue ich mir das Resultat im HEX-Code an?

Code:

#include "stdafx.h"
#include "Testdll.h"

int TEST = 4;
int DATABASE[5][5];
int **testptr = NULL;
int *ptr2 = NULL;
int DATA[5];
typedef boost::multi_array<int,2> array_type;
typedef array_type::index index;




int * writeFile(char * inputchar)
{
    int * ptr = &TEST;
    std::string inputstring = inputchar;
    std::ofstream out(inputstring, std::ofstream::out);
    out << "Hello World";
    return ptr;
};

char * readFile(char * inputchar)
{
    std::string inputstring = inputchar;
    std::ifstream in(inputstring, std::ifstream::in);
    std::string instring;
    std::getline(in,instring);
    char * buf = new char[instring.length()+1];
    strcpy(buf, instring.c_str());
    return buf;
};

__declspec(dllexport) int * gen_multiarr(int row)
{
    ptr2 = (int *)malloc(row*sizeof(int));
    for(int i = 0; i < row; i++)
        for(int j = 0; j < row; j++)
            ptr2[i] = i+j;
    return ptr2;
}

__declspec(dllexport) int * gen_multiarr2(int * ptr, int row, int col)
{

    ptr2 = ptr;
    for(int i = 0; i < row; i++)
        for(int j = 0; j < col; j++)
            ptr2[i] = i+j;
    return ptr2;
}

__declspec(dllexport) void del_multiarr(int ** ptr)
{
    delete[] *ptr;
    delete[] ptr;
};


void gen_Database(void)
{
    for(int i = 0; i < 5; i++)
    {
        for(int j = 0; j < 5; j++)
            DATABASE[i][j] = i+j;
    };
};

void gen_Data(void)
{
    for(int i = 0; i < 5; i++)
        DATA[i] = i;
};

int * ret_Database(void)
{
    int * ptr;
    gen_Database();
    ptr = &DATABASE[0][0];
    return ptr;
}

int * ret_Data(void)
{
    int * ptr;
    gen_Data();
    ptr = &DATA[0];
    return ptr;
};

Includefile:

Code:

#include <stdexcept>
#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <malloc.h>
#include <algorithm>
#include <iterator>
#include <cassert>
#include <tuple>
#include <sstream>
#include <math.h>
#include <boost\algorithm\string.hpp>
#include <boost\lexical_cast.hpp>
#include <boost\multi_array.hpp>
#include <boost\tuple\tuple.hpp>



__declspec(dllexport) int * writeFile(char * inputchar);
__declspec(dllexport) char * readFile(char * inputchar);
void gen_Database(void);
__declspec(dllexport) int * ret_Database(void);
void gen_Data(void);
__declspec(dllexport) int * ret_Data(void);
__declspec(dllexport) int * gen_multiarr(int row);
__declspec(dllexport) int * gen_multiarr2(int ** ptr, int row, int col);
__declspec(dllexport) void del_multiarr(int ** ptr);

Das strcpy unsafe ist, weiß ich, da ich aber kontrolliere, was übergeben wird, kann ich den Fakt ja vernachlässigen, oder?