erreur avec new

Je n'arrive pas a utiliser new correctement, j'ai le message:
"new peut uniquement être utilisé avec des types valeur simples" avant la compilation.
Si vous avez une idée, merci.

dans mon .h:

Code:

---

1 2 3 4 5 6 7 8 9

public ref class CppWrapperClass { private: Delaunay::DelaunayClass* pClass; public: CppWrapperClass(); ... }

---

dans mon .cpp:

Code:

---

1 2 3 4 5

CppWrapperClass::CppWrapperClass(void) { pClass = new Delaunay::DelaunayClass; <- !! }

---

Cela requiert l'utilisation d'un constructeur.
J'ajoute par principe le unique_ptr (que tu trouveras dans <memory>)
Il est rarissime d'avoir besoin de stocker un new en dehors d'un "smart pointer" tel que unique_ptr (ou shared_ptr, parfois)

Code:

---

1 2 3 4 5 6

public class CppWrapperClass { private: std::unique_ptr<Delaunay::DelaunayClass> pClass; public: CppWrapperClass(): pClass(new Delaunay::DelaunayClass() ) {} };

---

voire mieux encore:

Code:

---

1 2 3 4 5 6

public class CppWrapperClass { private: std::unique_ptr<Delaunay::DelaunayClass> pClass; public: CppWrapperClass(): pClass( std::make_unique<Delaunay::DelaunayClass>() ) {} };

---

Etant donné le public ref class tu n'es pas en C++ mais C++/CX ou CLI et une classe managée ne peut pas contenir d'allocation dynamique sur un type non managé ?
Pour allouer dynamiquement une classe managée, c'est ref new ou gcnew il me semble.

Je trouve bien ça sur SO https://stackoverflow.com/questions/...-managed-class qui indique que ça devrait marcher mais le message d'erreur en français ne retourne aucun résultat chez moi.

Je veux du C++, donc j'ai enlever le "ref".
J'ai la même erreur:
"new peut uniquement être utilisé avec des types valeur simples" avant la compilation.

.h:

Code:

---

1 2 3 4 5 6 7 8 9

public class CppWrapperClass { private: std::unique_ptr<Delaunay::DelaunayClass> pClass; public: CppWrapperClass(); ~CppWrapperClass(); }

---

.cpp:

Code:

---

1 2 3 4 5 6 7 8 9 10

CppWrapperClass::CppWrapperClass(void) { std::unique_ptr<Delaunay::DelaunayClass> pClass(new Delaunay::DelaunayClass); <- !! }   CppWrapperClass::~CppWrapperClass(void) { pClass.reset(); }

---

appelle ton constructeur. Il doit au minimum y avoir les parenthèses de l'appel.

Code:

---

new Delaunay::DelaunayClass /* entre là -> */() /* <- et là */

---

Cela dit, n'utilise pas new, mais make_unique.

Enfin, l'intérêt premier de unique_ptr, c'est de détruire son pointé quand lui-même est détruit.
reset n'est pas nécessaire dans le destructeur.

(Son autre intérêt, c'est de ne pas être copiable, mais transférable.)

Un peu de documentation:
utilisation de new
le RAII
<memory>

Je sais pas trop ce que tu trafiques, mais choisir de travailler en managé ou non c'est un peu plus complexe que d'enlever le ref de la déclaration d'une classe. :weird:
Pourrait-on avoir un semblant de contexte ou quoi que ce soit pour comprendre ce que tu espères faire ?

On peut avoir la déclaration de la classe "DelaunayClass" ?
Parce que, comme le dit @Bousk, on ne fait pas "comme on veut", à l'arrache.

Bon en fait je suis un peu perdu car je souhaite utiliser la classe "CppWrapperClass" en C# et c'est pour ça que j'avais mis ref, mais je ne sais plus si il le faut avec la définition de la classe pour l'appeler depuis C#

CppWrapper.h:

Code:

---

1 2 3 4 5 6 7 8 9

public class "ref?" CppWrapperClass { private: std::unique_ptr<Delaunay::DelaunayClass> pClass; public: CppWrapperClass(); ~CppWrapperClass(); };

---

CppWrapper.cpp:

Code:

---

1 2 3 4 5 6 7 8 9 10

CppWrapperClass::CppWrapperClass(void) { std::unique_ptr<Delaunay::DelaunayClass> pClass(std::make_unique<Delaunay::DelaunayClass>()); }   CppWrapperClass::~CppWrapperClass(void) { pClass.reset(); }

---

ClassCpp.h:

Code:

---

1 2 3 4 5 6 7

public class DelaunayClass { public: DelaunayClass(); ~DelaunayClass(); }

---

ClassCpp.cpp:

Code:

---

1 2 3 4 5 6 7 8

DelaunayClass::DelaunayClass(void) { }   DelaunayClass::~DelaunayClass(void) { }

---

A la compilation, j'ai l'erreur de jeton:

Citation:

---

Fichier:
CppWrapper.cpp
Code Description:
Erreur LNK2028 jeton non rÚsolu (0A0000F1) "public: __thiscall Delaunay::DelaunayClass::DelaunayClass(void)" (??0DelaunayClass@Delaunay@@$$FQAE@XZ) rÚfÚrencÚ dans la fonction "class std::unique_ptr<class Delaunay::DelaunayClass,struct std::default_delete<class Delaunay::DelaunayClass> > __cdecl std::make_unique<class Delaunay::DelaunayClass>(void)" (??$make_unique@VDelaunayClass@Delaunay@@$$V@std@@$$FYA?AV?$unique_ptr@VDelaunayClass@Delaunay@@U?$default_delete@VDelaunayClass@Delaunay@@@std@@@0@XZ) CppWrapper ..\CppWrapper\CppWrapper.obj 1

---

OK, c'est bien plus claire.
Pas de panique.

Je pense que le message d'erreur est là parce que "ClassCpp.cpp" n'est pas compilé.

Mais le problème n'est pas là.
Vous ne devez pas avoir de champ d'un type non managé dans un objet managé.
Votre objet est déplaçable en mémoire par le Garbage-Collector, pas votre champ natif.
Un pointeur, ça passe, mais un "std::unique_ptr", c'est pas un pointeur, c'est un objet qui gère la durée de vie d'un pointeur.

1- si je veux appeler CppWrapperClass depuis c#, je dois déclare ma classe managée:

Code:

---

1 2 3 4

public ref class CppWrapperClass { ... }

---

oui/non ?

2- std::unique_ptr<Delaunay::DelaunayClass> étant un type non managé, je ne peux pas l'utiliser avec:

Code:

---

std::unique_ptr<Delaunay::DelaunayClass> pClass;

---

mais plutot utiliser:

Delaunay::DelaunayClass* pClass; comme champs managé

oui/non ?

3- si 1 et 2 sont oui, alors mon constructeur n'est pas résolu:

Code:

---

1 2 3 4

CppWrapperClass::CppWrapperClass(void) { pClass = new Delaunay::DelaunayClass(); bug->voir 1er post }

---

comment résoudre mon constructeur?

1- Si "appeler simplement" : OUI
2- Oui
3- Dans votre 1er poste, il n'y avait pas "()" dans le code et le numéro d'erreur n'est pas mentionné.
Code + numéro d'erreur SVP.

Dans tous les cas, pourquoi faire une allocation dynamique dans le constructeur et pas utiliser une simple variable membre non pointeur ?

Citation:

---

il n'y avait pas "()" dans le code

---

Je ne pense pas qu'il s'agisse d'une erreur, tant que le type possède un constructeur par défaut qui sera appelé.

Le problème est le type non managé dans du code managé.

Citation:

---

Envoyé par Bousk

Dans tous les cas, pourquoi faire une allocation dynamique dans le constructeur et pas utiliser une simple variable membre non pointeur ?

---

Vous ne devez pas avoir de champ d'un type non managé dans un objet managé.

J'ai modifier mon pointeur * en ^ pour le rendre managé et remplacé new par gcnew: sa marche.

CppWrapper.h:

Code:

---

1 2 3 4 5 6 7 8 9

public ref class CppWrapperClass { private: Delaunay::DelaunayClass^ pClass; public: CppWrapperClass(); ~CppWrapperClass(); }

---

CppWrapper.cpp:

Code:

---

1 2 3 4 5 6 7 8 9 10

CppWrapperClass::CppWrapperClass(void) { pClass = gcnew Delaunay::DelaunayClass; }   CppWrapperClass::~CppWrapperClass(void) { delete pClass; }

---

et rendu ma classe Delaunay managée:

Code:

---

1 2 3 4 5 6 7

public ref class DelaunayClass { public: DelaunayClass(); ~DelaunayClass(); }

---

A priori le C++/CLI est la seule solution pour communiquer avec le C# (je pense?)

Citation:

---

Envoyé par ternel

appelle ton constructeur. Il doit au minimum y avoir les parenthèses de l'appel.

Code:

---

new Delaunay::DelaunayClass /* entre là -> */() /* <- et là */

---

[...]

Un peu de documentation:
utilisation de new

---

Je confirme les dires de Bousk : dans une expression avec new qui appelle le constructeur par défaut, les parenthèses du constructeur sont facultatives. Par exemple, le code suivant compile :

Code:

---

std::string* test = new std::string;

---

D'ailleurs, le lien que tu as donné en parle. Voir le passage : « If initializer is absent, the object is default-initialized. »

ah…
Merci pour ta question, rubisvert, j'aurai appris quelque chose en essayant d'y répondre.

J'ai utilisé gcnew pour résoudre mon problème, mais j'ai trouvé une vidéo "http://www.dailymotion.com/video/x32iyz7" où l'auteur utilise new et non gcnew dans sa classe managée, donc là j'y perds mon lation puisque c'est ce que j'ai essaué de faire sans succés ?!

il utilise:

MyStack.h:

Code:

---

1 2 3 4 5

class MyStack { ...   }

---

MyStackWrapper.h:

Code:

---

1 2 3 4 5 6 7

public ref class StackWrapper { ... private: MyStack* Stack; ... }

---

et dans son c#:

Code:

---

StackWrapper stack=new StackWrapper();

---

Il utilise new dans le code C#, qui n'est pas du C++.
gcnew est une fonction C++ (relative à C++/CLI)

C'est normal de perdre ton latin en lisant du grec. :mouarf:

Dans sa vidéo, c'est le new du constructeur dans MyStackWrapper.cpp qui m'interpelle, pas celui du c#.

MyStackWrapper.cpp:

Code:

---

1 2 3 4

MyStackWrapper::StackWrapper::StackWrapper() { stack=new Mystack(); }

---

puisque j'avais utiliser pour mon projet aussi un new dans mon constructeur et que ça ne marche pas ?!

Sa classe est un wrapper qui ne contient que cette donnée.
Jusque là on ne sait toujours rien de ton projet et ton code donc à part tergiverser sur la couleur de la lune je vois pas ce qu'on peut t'apporter de plus.
Ecrire un wrapper tu as des milliers de réponses sur Google
https://msdn.microsoft.com/en-us/library/ms235281.aspx
https://www.codeproject.com/Articles...han-minutes#A8
...