Discussion :

[RatJeux]

Bonjour, j'ai recemment decider d'apprendre le C# et pour cela je refait les projets que j'avais fait pour apprendre le C++ (ayant encore les docs et testsuites autant m'en resservir).

Autant j'ettais pret a perdre une partie du control en faisant confiance a l'interpreteur, autant je ne pensais pas galerer autant avec l'objet.

Voila mon probleme: je refait un compilo, et l'implementation de(s classes) mon AST me semble inutilemment complique due a l'obligation d'utilise plein d'interfaces pour compenser l'abscence d'heritage multiple.

Je me doute que ma facon de l'implementer est probablement biaisee a cause de mon passee avec le C++.

Ma question est donc la suivante: Quel est la facon de faire un AST propre en C#? 8un lien ne serait pas de refus, je n'ais rien trouve de satisfaisant9

Merci pour votre temps

[popo]

J'ai du mal à saisir certains de tes propos.

Autant j'ettais pret a perdre une partie du control en faisant confiance a l'interpreteur, autant je ne pensais pas galerer autant avec l'objet.

Voila mon probleme: je refait un compilo, et l'implementation de(s classes) mon AST me semble inutilemment complique due a l'obligation d'utilise plein d'interfaces pour compenser l'abscence d'heritage multiple.

Déjà C# n'est pas interprété, de quelle interpréteur tu parles ?
Ensuite, mise à part l'absence d'héritage multiple, c'est surtout une question de syntaxe alors quel est la galère avec l'objet ?


Sinon, dans ce que j'ai compris je voudrais apporter quelques rectifications.
Le but d'une interface n'est pas de compenser l'absence d'héritage multiple.
Tu pourrais très bien t'en passer, ça fonctionnerai pareil.
Le seul avantage à en tirer c'est que tu ne compilera pas si tu n'a pas respecté le contrat de l'interface et tu t'en rendras compte plus facilement.
L'objectif premier est de définir un contrat qui sera l'unique chose visible lors de communications entre deux entités.
L'objectif second est la diminution du couplage car le contrat est quelque chose d'abstrait, d'indépendant de l'implémentation

Tu peux compenser l'absence d'héritage multiple en faisant de l'agrégation (ou plutôt la composition).
Tu as tes classes A et B qui ont leurs comportements respectif (par exemple une méthode X dans A et une méthode Y dans B.
Tu les incorpores dans une classe C et les initialise dans le constructeur de C (ou lorsque tu en as besoin).
Tu définis des méthodes X et Y dans C qui appelleront les méthodes A.X et B.Y.
Tu peux éventuellement ajouter une interface pour définir quelles méthode de A et B doivent être implémentées dans C.

[RatJeux]

C# est pas interprete, autant pour moi, je croyais qu'on avait besoin d'une vm pour le faire tourner, apres j'ai pas regarder/verifier *je fais confiance au compilo du coup*

Je suis pas sur d'avoir saisie, j'ai mon objet C qui contient A et B, et je creer C.Y et C.X qui sont des appel a A.Y et B.X contenu dans C (jusque lq c'est clairs)
Mais imaginons que les fonctions que j'appel on justement besoin d'avoir acces a C pour par exemple renvoyer l'adresse de C et pas de A contenu dans C me donner le type de l'objet, dans ce cas j'appel C.donneMoiTonType qui appeleras A.donneMoiTonType qui me repondras A alors que j'attendais C.

Merci pour la reponse

[Pol63]

il y a bien une machine virtuelle pour l'exécution du C#
visual studio compile le code C# en MSIL, language intermédiaire qui n'est pas dépendant d'une architecture processeur et plus proche de l'assembleur que du C#
lors de l'exécution sur une machine finale, le MSIL est compilé en code natif optimisé pour la machine et managé par une VM (la CLR sur windows) qui contient aussi le garbage collector

après j'ai toujours pas compris le besoin
au lieu de dire ce que tu n'arrives pas à transcrire du C++ vers C# il faudrait exprimer ce que tu veux faire sans être lié à un langage
je ne suis pas qu'essayer de transcrire soit une bonne approche, il faut partir du besoin le modéliser puis voir comment faire au mieux dans le langage

donc précise les propriétés ou méthodes que tu veux avoir et sur quelles classes et pourquoi

[popo]

Mais imaginons que les fonctions que j'appel on justement besoin d'avoir acces a C pour par exemple me donner le type de l'objet, dans ce cas j'appel C.donneMoiTonType qui appeleras A.donneMoiTonType qui me repondras A alors que j'attendais C.

Il est contraire à la POO de vouloir qu'une classe parente connaisse les classes dérivées.
Si c'est bien que ce que tu cherche à faire, j'ignorais que C++ permettait ce genre de chose (à vrai dire, je ne m'étais jamais posé la question).
En tout cas, C# ne le permet pas.

Par contre, il est possible de virtualiser des méthodes et de les surcharger dans les classes dérivées.
Et là effectivement, les choses se compliquent un peu si tu veux compenser l'absence d'héritage multiple car, à moins que je dise une grosse connerie (les puriste me corrigeront s'ils passent par ici), tu vas être obligé de déclarer des descendant à tes classes et initialiser ces descendants dans C.

Un exemple ici :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class A
{
    public void Foo()
    {
        Console.WriteLine("A");
        DoSomethingElse();
    }
 
    protected virtual void DoSomethingElse()
    {
        Console.WriteLine("Base");
    }
}
 
public class APrime : A
{
    protected override void DoSomethingElse()
    {
        Console.WriteLine("Prime");
    }
}
 
public class B
{
    public void Bar()
    {
        Console.WriteLine("B");
        DoSomethingElse();
    }
 
    protected virtual void DoSomethingElse()
    {
        Console.WriteLine("Base");
    }
}
 
public class BPrime : B
{
    protected override void DoSomethingElse()
    {
        Console.WriteLine("Prime");
    }
}
 
public class C
{
    A a = new APrime();
    B b = new BPrime();
 
    public void Foo()
    {
        a.Foo();
    }
 
    public void Bar()
    {
        b.Bar();
    }
}

Une petite application console pour regarder ce qui se passe :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Program
{
    static void Main(string[] args)
    {
        var C = new C();
 
        C.Foo();
        C.Bar();
 
        Console.ReadKey(); 
    }
}

Le résultat est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
A
Prime
B
Prime

[popo]

Oops, fausse manip

[RatJeux]

Il est contraire à la POO de vouloir qu'une classe parente connaisse les classes dérivées.
Si c'est bien que ce que tu cherche à faire, j'ignorais que C++ permettait ce genre de chose (à vrai dire, je ne m'étais jamais posé la question).
En tout cas, C# ne le permet pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    public class A
    {
        public Type WhatAmI()
        {
            return this.GetType();
        }
    }
 
    public class B: C 
    {
        public Type whatami()
        {
            A a = new A { };
            return a.WhatAmI();
        }
    }

Ce que je voyais c'etait ca et ici on obtient A quand on fait du B.WhatAmI() et justement en C++ j'aurais fait heriter B de C et A et le whatami aurais match le this directement avec l'objet de B

Mais la discussion n'as plus vraiment lieu d'existe mon probleme etais tout betes, j'avais juste mal foutu mon visiteur (enfin ca ma l'air tres probable)