System.Array

Version imprimable

05/04/2007, 10h38
breezer911

[C++/CLI]Convert int* -> System.Array

Bonjours tout le monde,

j'ai une fonction non managé qui me renvoie un poiteur sur un tableau d'int, et je voudrais pouvoir convertir ce pointeur en un Array<int >^, afin de pouvoir le retourné dans un monde c#.

J'ai lu ce que msdn disait à ce propos, mais c'est jamais ce que je recherche. Ce que j'ai compris c'est que je dois utiliser un pin_ptr<int> qui lui va recevoir l'adresse de mon tableau "natif". Mais après comment dois-je faire pour convertir ce pin_ptr en un array<int>^?

je continue dans mes ptites expériences...

toujours dans le meme cadre => convert int* => array<int>^

j'ai une fonction non managée, qui me crée un tableau que je retourne en int*. Une autre fonction managée qui se charge de convertir le int* en array<int> ^.

Dans cette fonction je recupère mon int* dans pin_ptr. Dans les 2 fonctions j'affiche les adresses du pointeur de mon tableau, ainsi que la taille du tableau.

résultat : les adresses sont les mêmes mais pas les taille, ni les valeurs contenues...

De là, je pense que mes pointeurs sont sur 2 stacks différentes, un pointeur sur une stack managé, et l'autre sur une stack non managé.

Pourtant j'ai bien utilisé pin_ptr qui permet justement d'utilisé la pile non manager :s.

je laisse le code si quelqu'un peut m'aider :cry:

Fonction qui renvoit mon tableau.
Code:

1 2 3 4 5 6 7 int* NatifTest::getMyIntArray(void) { int size = sizeof(myArray)/sizeof(myArray[0]); cout << " adresse array "<< myArray << " taille "<< size <<endl; return myArray; }
fonction qui est sensée convertir mon int* en array<int>
Code:

1 2 3 4 5 6 7 8 9 10 array<int > ^ ManagedTest::getAnNativeArray() { array<int> ^ nums = gcnew array<int>(1); pin_ptr<int> anArray = n->getMyIntArray(); int size = sizeof(anArray)/sizeof(anArray[0]); cout << " adresse array "<< anArray << " taille "<< size <<endl; return nums; }

05/04/2007, 14h48
breezer911

Je rectifie le tir c'est une conversion de array<int^> ^ vers int* et int* vers array<int ^> ^, que je voudrais comprendre comment on fait...

Toujours personnes??:(
05/04/2007, 15h17
Médinoc

Pour int* vers array<int>^, je pense qu'il faut forcément faire une copie : Ça m'étonnerait que le CLR accepte de transformer un objet non-managé en objet managé.

Pour array<int> vers int*, le pin_ptr<int> permet un accès direct par pointeur aux données du tableau. Par contre, le tableau reste un tableau managé tant qu'on n'a pas recopié les données dans un tableau non-managé...

Pour des array<int^>, ce n'est carrément plus le même type, donc il faut forcément une copie, avec un gcnew int pour chaque case du tableau dans le cas d'une copie vers l'array.
05/04/2007, 15h52
breezer911

Je viens de voir justement la fonction Marshall.copies(), ca à l'air d'etre ce que je cherche oui, mais il y a encore quelque chose qui me chipote, c'est que la copie se fait dans un objet IntPtr, un pointeur sur un int, mais ce IntPtr je ne sais pas le cast en int*

donc maintenant j'en viens a poser la question comment je convertir ce IntPtr vers un int* et vice versa :?

c'est a ce tiré les cheveux le cli lol
05/04/2007, 15h59
Médinoc

Un bête reinterpret_cast<> ne marche-t-il pas ?
05/04/2007, 16h06
breezer911

nop, je viens d'essayer, et le compilo m'envoie ch*** :lol:. J'avais essayé avec safe_cast<int*> mais non plus
05/04/2007, 16h28
Médinoc

Je vois mal safe_cast<> marcher pour les types unsafe.

Autant passer par le pin_ptr<> et faire la copie, dans ce cas...
05/04/2007, 16h38
breezer911

J'ai trouver pour passer d'un IntPtr vers un int*, :

Code:

int* pintPtr = (int*)pnt.ToPointer();

maintenant je veux faire le contraire.. donc du int* vers un IntPtr.

ca avance ca avance :lol:
05/04/2007, 16h57
Médinoc

Un constructeur C++ de IntPtr prend un void* en paramètre.

en effet ;) . Avant de partir de mon lieu de stage j'ai trouvé hihi.

Bref pour ceux qui voudrais avoir le code tout fait...

d'un System::Array vers un int*

Code:

1
2
3
4
5
6
7
8
9
10
11
 
array<int> ^ arrayManaged = gcnew array<int>(5);
int size = Marshal::SizeOf(arrayManaged[0]) * arrayManaged->Length;
 
	IntPtr pnt = Marshal::AllocHGlobal(size);
 
	Marshal::Copy(arrayManaged, 0, pnt, arrayManaged->Length);
	int* pintPtr = (int*)pnt.ToPointer();
 
	//FAIRE CE QU'ON VEUT AVEC LE int*
	Marshal::FreeHGlobal(pnt);

d'un int* vers un System::Array

Code:

1
2
3
4
5
6
7
8
 
        int nm[5] = {1,2,3,4,5};
        array<int > ^ nums = gcnew array<int>(sizeof(nm)/sizeof(int));
 
	void* voidPtr = (void*) nm;
	IntPtr p = IntPtr(voidPtr);
	Marshal::Copy(p,nums,0,5);
delete []nm;

05/04/2007, 19h17
nico-pyright(c)

comme tu le disais, il faut utiliser marshall::copy
06/04/2007, 09h04
Médinoc

Le cast en (void*) est inutile.
Le cast en (int*) devrait être un static_cast<> : N'oublie pas que tu es en C++.
Vérifie si tu ne peux pas faire directement IntPtr p(voidPtr)...
06/04/2007, 09h51
breezer911

J'y penserai quand je devrais réutilisé cette méthode
merchi :king: