Discussion :

[Algernon2]

Bonjour,

j'ai une question dont je n'arrive pas à trouver de réponse exacte.

Ci-dessous vous trouverez une fonction template très simple, où elle prend un type T et fais la somme avec une autre variable sum de type T (théoriquement je devrais l'initialisé à 0).
Le problème, c'est que si je sais que lors de l'appel à cette fonction le type T sera int ou double par exemple, le compilateur me dit que il ne peut pas faire la méthode += sur des type T, ce que je comprends, mais alors comment je fais pour ne pas avoir à écrire le même code pour double ou int ?? Faut-il que je convertisse input en double ou int avant ? (grâce à typeof)

Code C# :

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

1
2
3
4
5
public T function<T>(T input)
{
   T sum;
   sum += input;
}

Merci

Algernon

[Pol63]

je pense que tu vas devoir écrire une méthode par type, comme c'est le cas dans le framework pour les méthodes qu'on trouve dans system.math par exemple

les expressions trees du fx4 peuvent être une solution, mais si ca reste plus compliqué à écrire qu'une méthode par type

après ce n'est peut être pas nécessaire de gérer des types pour un méthode qui fait des calculs, si la méthode demande des doubles seulement, rien ne t'empeche de fournir des int et de convertir le retour

[Nathanael Marchand]

Malheureusement ca n'est pas possible.
Lorsque tu fais ceci, le framework considère que T est un objet quelconque (donc un Object). Or l'opération + n'existe pas entre deux Object.
Pour que ca soit possible, il faudrait éventuellement ajouter une contrainte sur T mais int et double n'ont que Object comme type commun (normal ce sont des types valeurs)

[Algernon2]

Bonjour et merci de vos réponses

j'ai testé cette implémentation :

Code :

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

1
2
3
4
5
6
7
8
public T function<T>(T input)
{
    if (typeof(T) == typeof(int))
    {
        Object o = (object)input;
        int inputCastInt = (int)o;
        int sum += inputCastInt;
}

Ca fonctionne mais bon maintenant ça me fait faire deux boucle avec le même code pour les int et les double.

Merci

Algernon

[Nathanael Marchand]

Oui mais bon, autant faier ca directement dans ce cas là:

Code :

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

1
2
3
4
public int function(int input)
{
    int sum += input;
}

D'ailleurs ta fonction ne retourne rien, c'est normal?

[Algernon2]

oui en fait j'aurais du retourné la valeur et c'est aussi vrai que utiliser un object "Object" puis caster ça en int c'est long et inutile, mais bon c'est que je m'intéresse aux templates et e voulais juste savoir si ça se faisais.

Je vais évidement utiliser la méthode que tu as écrite

Merci

Algernon

[tomlev]

Ci-dessous vous trouverez une fonction template très simple, où elle prend un type T et fais la somme avec une autre variable sum de type T (théoriquement je devrais l'initialisé à 0).

Ce que tu as fait fonctionnerait avec les templates de C++, mais pas avec les génériques de .NET. Cela est dû à une différence fondamentale entre les templates et les génériques :

- En C++, c'est le compilateur qui vérifie si le code d'un template est valide pour tous les paramètres de type que tu utilises, et le compile séparément pour chacun des paramètres de type. Dans le code compilé, le template n'existe plus : il a été remplacé par autant d'implémentations spécifiques que nécessaire.

- En .NET, le compilateur génère un seul code pour la méthode générique : c'est à l'exécution que des types spécifiques sont créés en fonction des paramètres de type utilisés. Le type générique existe en tant que tel dans le code compilé, donc on ne sait pas à l'avance avec quels paramètres de type il sera utilisé : il faut donc que le code soit valable avec n'importe quel type (ou du moins n'importe quel type qui vérifie les contraintes, si tu spécifies des contraintes).

(et en Java c'est encore un peu différent...)

Puisqu'il n'existe pas de contrainte qui garantisse l'existence d'un opérateur +(T, T), le code n'est pas valable. Par contre, il y a une astuce qui consiste à générer les opérateurs dynamiquement en utilisant les expressions trees. Par exemple la classe suivante implémente les opérateurs + - * / :

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
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
using System;
using System.Linq.Expressions;
 
...
 
public static class Operators<T>
{
    private static readonly Func<T, T, T> _add;
    private static readonly Func<T, T, T> _subtract;
    private static readonly Func<T, T, T> _multiply;
    private static readonly Func<T, T, T> _divide;
 
    static Operators()
    {
        _add = CreateBinaryOperator(ExpressionType.Add);
        _subtract = CreateBinaryOperator(ExpressionType.Subtract);
        _multiply = CreateBinaryOperator(ExpressionType.Multiply);
        _divide = CreateBinaryOperator(ExpressionType.Divide);
    }
 
    private static Func<T, T, T> CreateBinaryOperator(ExpressionType expressionType)
    {
        var x = Expression.Parameter(typeof(T), "x");
        var y = Expression.Parameter(typeof(T), "y");
        var body = Expression.MakeBinary(expressionType, x, y);
        var expr = Expression.Lambda<Func<T, T, T>>(body, x, y);
        return expr.Compile();
    }
 
    public static T Add(T x, T y)
    {
        return _add(x, y);
    }
 
    public static T Subtract(T x, T y)
    {
        return _subtract(x, y);
    }
 
    public static T Multiply(T x, T y)
    {
        return _multiply(x, y);
    }
 
    public static T Divide(T x, T y)
    {
        return _divide(x, y);
    }
}

Tu peux l'utiliser comme ça :

Code :

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

1
2
// sum = sum + input
sum = Operators<T>.Add(sum, input);

Attention, ça ne fonctionnera pas avec tous les types : il faut que ces types supportent effectivement les opérateurs utilisés, sinon ça va planter à l'exécution.

Le principe est expliqué plus en détails ici