Discussion :

[ewaca]

bonjour,

j'essaye de faire un programme de calcul, et pour essayer de faire ça correctement et proprement, je souhaite utiliser des méthodes.

Alors j'ai lu pas mal de truc sur la question, on trouve une multitude d'exemple de code pour des fonctions, mais ils ne précise nul par où on peut stocker ça :/

je suis étonné parce que j'avais commencer a regarder le C++ avant de voir que le C# était plus adapté pour ce que je voulais faire, et dans les cours de C++ dès qu'on aborde les fonctions, on sait qu'on peut les stocker dans un autre .cpp et qu'on lie le tout avec un .h, mais là ... c'est assez floue je dois dire :/
si quelqu'un pouvait m'éclairer svp

merci

[PixelJuice]

Bonjour,

Ça peut paraitre déroutant pour quelqu'un qui a débuté en C++ mais en fait c'est simplifié en C#.

Code :

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

1
2
3
4
5
6
7
    public class Mathematique
    {
        static public int Addition(int a,int b)
        {
            return a + b;
        }
    }

Dans cette exemple , tu pourrais stocker tes méthodes de calculs dans une class Mathematique. Vu que la fonction Addition() nécessite que ses propres arguments pour fonctionner , tu peux la déclarer en static , ce qui signifie que tu peux y accéder en fesant :

Code :

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

int résultat = Mathematique.Addition(5,3);

Si , par contre , c'est une méthode qui nécessite un objet , il te faudra d'abord déclarer un objet pour accéder a la méthode , du genre :

Code :

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

1
2
Personne personne1 = new Personne();
personne1.Renommer("Robert");

Dans ce cas la , Renommer() se trouve aussi dans la classe Personne , mais non statique :

Code :

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

1
2
3
4
5
6
7
8
9
10
    class Personne
    {
        string prenom;
        string nom;
 
        public void Renommer(string prenom)
        {
            this.prenom = prenom;
        }
    }

En espérant que ma réponse a pu t'aider.

[ewaca]

ok, merci pour la réponse
du coup je peux stocker ça dans un autre fichier class si je veux avoir le code de mon programme plus claire ? (clic droid / ajouter /nouvel élement/ class)
et j'ai acces a ma méthode depuis mon main ?

[Pol63]

c'est ca
le mot clé Static signifie que le membre n'est pas lié aux instances de la classe, mais à la classe lui même
on peut donc l'appeler avec NomClasse.NomMembreStatic

[ewaca]

ok !
effectivement c'est simplifié par rapport au C++
merci pour vos réponses !

[ewaca]

j'avais mis la discussion en résolu mais je suis allé un peu trop vite, j'ai un autre soucis ...
avec ce que vous m'avez donné comme info j'en suis arrivé là

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
50
51
52
53
54
55
 
static public class Grav
    {
 
        //données
        static int Dg = -2;
        static int x1 = 10;
        static int x2 = 12;
        static int y1 = 10;
        static int y2 = 8;
        static double z1 = 0.00001;
        static double z2 = 2.00001;
        static int [] point = { 10, 10, 0 };
 
        //calcul des dx
 
        static int dx1 = x1 - point[0];
        static int dx2 = x2 - point[0];
 
        //calcul des dy
 
        static int dy1 = y1 - point[1];
        static int dy2 = y2 - point[1];
 
        //calcul des dz
 
        static double dz2 = z1 - point[2];
        static double dz1 = z2 - point[2];
 
        //calcul de la dustance du point a tous les bords du prisme
        static double R111 = Math.Sqrt(dx1 * dx1 + dy1 * dy1 + dz1 * dz1);
        static double R112 = Math.Sqrt(dx1 * dx1 + dy1 * dy1 + dz2 * dz2);
        static double R211 = Math.Sqrt(dx2 * dx2 + dy1 * dy1 + dz1 * dz1);
        static double R212 = Math.Sqrt(dx2 * dx2 + dy1 * dy1 + dz2 * dz2);
        static double R221 = Math.Sqrt(dx2 * dx2 + dy2 * dy2 + dz1 * dz1);
        static double R222 = Math.Sqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2);
        static double R121 = Math.Sqrt(dx1 * dx1 + dy2 * dy2 + dz1 * dz1);
        static double R122 = Math.Sqrt(dx1 * dx1 + dy2 * dy2 + dz2 * dz2);
 
        //Calcul des anomalies liees aux differents bords
 
        static double DG111 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx1 * dy1 / (dz1 * R111)) - dx1 * Math.Log(R111 + dy1) - dy1 * Math.Log(R111 + dx1));
        static double DG112 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx1 * dy1 / (dz2 * R112)) - dx1 * Math.Log(R112 + dy1) - dy1 * Math.Log(R112 + dx1));
        static double DG211 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx2 * dy1 / (dz1 * R211)) - dx2 * Math.Log(R211 + dy1) - dy1 * Math.Log(R211 + dx2));
        static double DG212 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx2 * dy1 / (dz2 * R212)) - dx2 * Math.Log(R212 + dy1) - dy1 * Math.Log(R212 + dx2));
        static double DG221 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx2 * dy2 / (dz1 * R221)) - dx2 * Math.Log(R221 + dy2) - dy2 * Math.Log(R221 + dx2));
        static double DG222 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx2 * dy2 / (dz2 * R222)) - dx2 * Math.Log(R222 + dy2) - dy2 * Math.Log(R222 + dx2));
        static double DG121 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx1 * dy2 / (dz1 * R121)) - dx1 * Math.Log(R121 + dy2) - dy2 * Math.Log(R121 + dx1));
        static double DG122 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx1 * dy2 / (dz2 * R122)) - dx1 * Math.Log(R122 + dy2) - dy2 * Math.Log(R122 + dx1));
 
        //somme des DG
 
        double anomalie = DG111 + DG112 + DG121 + DG122 + DG211 + DG212 + DG221 + DG222;
        return anomalie;
        }

et mon soucis c'est sur la fin ... je n'arrive pas a récupérer la valeur de mes calculs
"Jeton 'return' non valide dans la déclaration de membres de la classe, de la structure ou de l'interface"
"Jeton ';' non valide dans la déclaration de membres de la classe, de la structure ou de l'interface"
"'Grav.anomalie' est un 'champ' mais est utilisé comme un 'type'"

tout ça pour mes deux pauvre derniers mots, si c'est pas un epic fail .... ^^

(pour le moment mes premieres variables ont une valeur attribuée dans la méthode, mais c'est pour tester le passage du code en méthode, après j'essayerais de rentrer tout ça sous forme de paramètre de la méthode, mais j'y suis pas encore ^^)

[ewaca]

c'est bon c'est résolu, un petit coup de static et de public pour ma variable anomalie et elle est accessible depuis mon main

[PixelJuice]

Tu essayes de faire un return alors que tu es dans ta classe.

le mot-clé return ne se déclare qu'a la fin d'une méthode (qui possède un type de retour comme la méthode Addition() que j'ai mis plus haut).


Dans ton cas , il faudrait que tu encapsule tout tes calculs dans une méthode comme ceci :

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
50
51
52
53
54
55
56
57
    public class Grav
    {
       static public double CalculAnomalie()
        {
            //données
            int Dg = -2;
            int x1 = 10;
            int x2 = 12;
            int y1 = 10;
            int y2 = 8;
            double z1 = 0.00001;
            double z2 = 2.00001;
            int[] point = { 10, 10, 0 };
 
 
            //calcul des dx
 
            int dx1 = x1 - point[0];
            int dx2 = x2 - point[0];
 
            //calcul des dy
 
            int dy1 = y1 - point[1];
            int dy2 = y2 - point[1];
 
            //calcul des dz
 
            double dz2 = z1 - point[2];
            double dz1 = z2 - point[2];
 
            //calcul de la dustance du point a tous les bords du prisme
            double R111 = Math.Sqrt(dx1 * dx1 + dy1 * dy1 + dz1 * dz1);
            double R112 = Math.Sqrt(dx1 * dx1 + dy1 * dy1 + dz2 * dz2);
            double R211 = Math.Sqrt(dx2 * dx2 + dy1 * dy1 + dz1 * dz1);
            double R212 = Math.Sqrt(dx2 * dx2 + dy1 * dy1 + dz2 * dz2);
            double R221 = Math.Sqrt(dx2 * dx2 + dy2 * dy2 + dz1 * dz1);
            double R222 = Math.Sqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2);
            double R121 = Math.Sqrt(dx1 * dx1 + dy2 * dy2 + dz1 * dz1);
            double R122 = Math.Sqrt(dx1 * dx1 + dy2 * dy2 + dz2 * dz2);
 
            //Calcul des anomalies liees aux differents bords
 
            double DG111 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx1 * dy1 / (dz1 * R111)) - dx1 * Math.Log(R111 + dy1) - dy1 * Math.Log(R111 + dx1));
            double DG112 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx1 * dy1 / (dz2 * R112)) - dx1 * Math.Log(R112 + dy1) - dy1 * Math.Log(R112 + dx1));
            double DG211 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx2 * dy1 / (dz1 * R211)) - dx2 * Math.Log(R211 + dy1) - dy1 * Math.Log(R211 + dx2));
            double DG212 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx2 * dy1 / (dz2 * R212)) - dx2 * Math.Log(R212 + dy1) - dy1 * Math.Log(R212 + dx2));
            double DG221 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx2 * dy2 / (dz1 * R221)) - dx2 * Math.Log(R221 + dy2) - dy2 * Math.Log(R221 + dx2));
            double DG222 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx2 * dy2 / (dz2 * R222)) - dx2 * Math.Log(R222 + dy2) - dy2 * Math.Log(R222 + dx2));
            double DG121 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx1 * dy2 / (dz1 * R121)) - dx1 * Math.Log(R121 + dy2) - dy2 * Math.Log(R121 + dx1));
            double DG122 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx1 * dy2 / (dz2 * R122)) - dx1 * Math.Log(R122 + dy2) - dy2 * Math.Log(R122 + dx1));
 
            //somme des DG
 
            double anomalie = DG111 + DG112 + DG121 + DG122 + DG211 + DG212 + DG221 + DG222;
            return anomalie;
        }
    }

et comme paramètres de cette méthode tu passerais les données nécessaire aux calculs , dès que tu aurai fini de tester avec tes valeurs en dur

[Graffito]

Dans le code appelant :

Code :

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

1
2
double Grav_Anomalie = Grav.compute (-2,10,12,10,8,0.000001,2.00001,new Point[]
{ 10, 10, 0 }) ;

et on réécrit la classe de calcul ainsi :

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
static public class Grav 
{ 
  internal static double Compute(int Dg, int x1, int x2, int y1, int y2, double z1, double z2, int [] point) ;
    //calcul des dx
    int dx1 = x1 - point[0];
    int dx2 = x2 - point[0];
    //calcul des dy
    int dy1 = y1 - point[1];
    int dy2 = y2 - point[1];
    //calcul des dz double
    dz2 = z1 - point[2];
    double dz1 = z2 - point[2];
    //calcul de la dustance du point a tous les bords du prisme
    double R111 = Math.Sqrt(dx1 * dx1 + dy1 * dy1 + dz1 * dz1);
    double R112 = Math.Sqrt(dx1 * dx1 + dy1 * dy1 + dz2 * dz2);
    double R211 = Math.Sqrt(dx2 * dx2 + dy1 * dy1 + dz1 * dz1);
    double R212 = Math.Sqrt(dx2 * dx2 + dy1 * dy1 + dz2 * dz2);
    double R221 = Math.Sqrt(dx2 * dx2 + dy2 * dy2 + dz1 * dz1);
    double R222 = Math.Sqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2);
    double R121 = Math.Sqrt(dx1 * dx1 + dy2 * dy2 + dz1 * dz1);
    double R122 = Math.Sqrt(dx1 * dx1 + dy2 * dy2 + dz2 * dz2);
    //Calcul des anomalies liees aux differents bords
   double DG111 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx1 * dy1 / (dz1 * R111)) - dx1 * Math.Log(R111 + dy1) - dy1 * Math.Log(R111 + dx1));
   double DG112 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx1 * dy1 / (dz2 * R112)) - dx1 * Math.Log(R112 + dy1) - dy1 * Math.Log(R112 + dx1));
   double DG211 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx2 * dy1 / (dz1 * R211)) - dx2 * Math.Log(R211 + dy1) - dy1 * Math.Log(R211 + dx2));
   double DG212 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx2 * dy1 / (dz2 * R212)) - dx2 * Math.Log(R212 + dy1) - dy1 * Math.Log(R212 + dx2));
   double DG221 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx2 * dy2 / (dz1 * R221)) - dx2 * Math.Log(R221 + dy2) - dy2 * Math.Log(R221 + dx2));
   double DG222 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx2 * dy2 / (dz2 * R222)) - dx2 * Math.Log(R222 + dy2) - dy2 * Math.Log(R222 + dx2));
   double DG121 = -0.00667 * Dg * 1000 * (dz1 * Math.Atan(dx1 * dy2 / (dz1 * R121)) - dx1 * Math.Log(R121 + dy2) - dy2 * Math.Log(R121 + dx1));
   double DG122 = -0.00667 * Dg * 1000 * (dz2 * Math.Atan(dx1 * dy2 / (dz2 * R122)) - dx1 * Math.Log(R122 + dy2) - dy2 * Math.Log(R122 + dx1));
   //somme des DG
   return DG111 + DG112 + DG121 + DG122 + DG211 + DG212 + DG221 + DG222;
   } 
 
 // autres fonction de Grav, par exemple : 
 internal static int Addition(int x, int y)
 {
   return x+y ;
 }
}

Edit : grillé par PixelJuice

[ewaca]

merci pour vos réponses

je me disais bien qu'il devait y avoir un moyen de pas mettre static a toutes les lignes ^^
il me reste encore des trucs a comprendre sur les class et les méthodes. Sur le papier ça semble relativement claire mais dans le concret j'ai du mal a différencier :/

et en prime j'ai meme le droit a la fonctions avec les paramètres

encore merci pour votre aide

EDIT : je viens de tester les codes, le premier (pixel juice) fonctionne, mais le second ça me met des erreurs

il me dit pour mon fichier de programme :
Grav ne contient pas de définition pour compute
type ou nom d'espace de noms "Point" est introuvable

pour me fichier de class :
que mes variables n'existe pas dans le contexte actuel
qu'une référence d'objet est requis pour la proprieté, la méthode ou le champ non statique (pour toutes les variables)

et pour le return, que les jetons + sont non valide dans la déclaration de membre de la class, de la structure ou de l'interface

en soit c'est pas grave vu que le premier code fonctionne, mais je cherche a comprendre le pourquoi du comment plutot que de recopier betement

[Graffito]

Grav ne contient pas de définition pour compute

Grav.Compute

type ou nom d'espace de noms "Point" est introuvable

Il faut ajouter une clause "using System.Windows ;" ou "using System.Drawing ;" au début du source.

qu'une référence d'objet est requis pour la proprieté, la méthode ou le champ non statique (pour toutes les variables)

Si la methode est déclarée "static" on l'appelera avec le nom de la classe, par exemple : "Grav.MaMethode() ;" , sinon on l'appelera avec un objet, par exemple "Grav MyGravObject=new Grav() ; MyGravObject.MaMethode() ;".

[ewaca]

ok, merci pour les explications