Salut à tous,

J'ai quelques soucis avec la gestion des pointeurs en C# :
voici le code que je désire gérer :

using System;

namespace ltest
{
    public class test
    {
        static unsafe ltest.test* root;       // racine
        string str;                          // string
        unsafe ltest.test* right;             // pointeur de droite
        unsafe ltest.test* left;              // pointeur de gauche
 
        public test(string p_str)
        {
          str=p_str;
        }

        public static unsafe bool find(string p_srch){
            ltest.test* l_ptr=root;
            while(l_ptr!=null){
                if(l_ptr.str.CompareTo(p_srch)==0) return true;
                else {
                    if(l_ptr.mot.CompareTo(p_srch)>0) l_ptr=&l_ptr.right;
                    else l_ptr=&l_ptr.left;
                }
            }
            return false;
        }
    }
}

Le code ne compile pas : [Task:File=/ltest/ltest/Main.cs, Line=10, Column=33, Type=Error, Priority=Normal, Description=Cannot take the address of, get the size of, or declare a pointer to a managed type `ltest.test'(CS0208)]

Malgré tous mes efforts, j'ai du mal à comprendre pourquoi (l'option autoriser le code non sur est activée).

Merci de votre aide.
Halicorne.
    Pas de projection, c'est ici et maintenant que se font les choses !!!

Salut,

As tu regarder ceci ? : [ Lien ]



/*
coq
MVP Visual C#
CoqBlog
*/

Salut,

Comme le dit le lien de coq, l'arithmétique des pointeurs n'est pas permises avec les types managés. Pour ma part, je pense que l'unsafe a été conservé en C# pour tout ce qui est accès en mémoire de type "données", pour les streams, les buffers, etc...
Mais que, comme le traduit ton erreur, on ne devrait pas utiliser ces pointeurs pour manipuler des objets.

Mon avis est qu'il est possible de (à peu près allez...) tout faire (des choses conventionnelles disons...) avec ce que nous propose C# sans l'arithmétique de pointeurs, et que tu devrais repenser ton code, mais je peux me tromper...

J'ai l'impression en regardant ton code, que tu as déclaré tous tes objets membres de type "test" en tant que pointeur comme on l'aurait fait en C++. Sais-tu qu'en C#, toute déclaration d'objet est faite nativement par référence ?

Donc déclarer
Object* myObject;       //En C++
Revient à déclarer
Object myObject;         //En C#

Pardonne moi de paraitre "trop didactique" si tu es déjà au courant de toutes ces choses, on ne sait jamais sur qui on tombe, avec quelle expérience, sur le forum après un message

---

Julien.

Merci beaucoup pour vos conseils avisés.

En fait, je cherchais à pouvoir (comme en C ou C++) affecter les attributs left ou right (pointeurs d'instances) d'une structure/classe locale à une fonction, qui pointerait sur une variable existant ailleurs que dans le bloc.

J'ai trouvé la solution sans utilisation de l'option unsafe :

public static void add(string p_str,ref ltest p_mot){
    if(p_mot==null) {
        p_mot=new Mot(p_str);
    } else {
        if(p_mot.mot.CompareTo(p_str)>0) add(p_str,ref p_mot.right);
        else add(p_str,ref p_mot.left);
    }
}

Problème réglé !!!!
Merci encore.
Halicorne

    Pas de projection, c'est ici et maintenant que se font les choses !!!