Déroulement d'un programme C++ et compréhension

**ternel** · 27/07/2015, 16h22

En fait, tu ne sais pas du tout ce qu'est l'architecture d'un développement professionnel, n'est-ce pas?

Le code source, généralement regroupé dans un dossier src ou sources est l'ensemble du code à compiler pour assembler le programme ou la bibliothèque.

Les tests unitaires sont des codes qui incluent une partie des sources du programme et valident différents points suspect de ce code.
Par exemple, pour une fonction racine carrée, il y aurait des tests pour vérifier que 4 donne 2, 9 donne 3, 0 donne 0, -1 provoque bien une erreur, etc.
Ces tests sont des programmes à compiler et à exécuter. Le moindre défaut de compilation est un soucis.
De même, à l'exécution, ils doivent en gros afficher des séries de OK, tout autre résultat étant une faille.
L'un des enjeux majeurs étant d'écrire ces tests de façon à garantir que tout le code est sans faille. Du moins, on l'espère.

Les tests non-unitaires, dont les tests d'intégrations, servent à vérifier que l'ensemble du projet fonctionne correctement.
Par exemple, un cas de test, pour un jeu, serait de parvenir à le lancer, puis à sortir du jeu, sans provoquer de plantage ni de fuite mémoire.
Ces tests-ci sont beaucoup plus délicats à écrire, et demande en général une participation active du testeur.

Les exemples, pour une bibliothèque, sont des programmes qui utilisent cette bibliothèque, illustrant la manière souhaitée de l'utiliser.
Ce sont des tutos déjà fini, si tu préfères.

Un add-on est une extension du projet. Parce qu'un programme ou une bibliothèque peut prévoir un système de modules externes/complémentaires.
Exactement comme les extensions d'un navigateur.
Le code principal contiend normalement un chargeur d'extensions (plugin loader, addons, etc).

**bacelar** · 27/07/2015, 17h35

Comme ça part dans tout les sens, dfshr8, pourrais-tu synthétiser tes demandes non encore répondus correctement ?
Faire plusieurs sujets dans plusieurs files de messages, ça serait aussi cool pour ceux qui passent derrières.

**dfshr8** · 27/07/2015, 20h13

Envoyé par bacelar

Comme ça part dans tout les sens, dfshr8, pourrais-tu synthétiser tes demandes non encore répondus correctement ?
Faire plusieurs sujets dans plusieurs files de messages, ça serait aussi cool pour ceux qui passent derrières.

Oui je vais tacherd e m'en occuper demain car là j'ai les yeux comme des pasteques

**dfshr8** · 10/08/2015, 14h42

Bonjour,

Devant la complexité du programme que je suis censé décrypter , j'ai eu l' occasion de découvrir d'autres programmes (fait avec d'autres langages de programmatio) pour le même algorithme (Fast Multipole Methode).
En fait ma première tâche (théorique) était de comprendre l'algorithme (et sa validité au sens mathématiques). Ayant finit cette étape, je voulais le coder à ma sauce (donc le plus simplement possible) pour bien vérifier ma compréhension...

Dès lors je me suis aperçu de pas mal de choses:
- si j'utilise un langage de script pour faire mon prototype de programme ça ira beaucoup plus vite (car moins de lignes de codes, la possibilité de tester mon algo au fur et à mesure).

J'ai donc pensé à Matlab: mais le fonctionnement est assez étrange! Pour améliorer la lisibilité du programme (et pas avoir un gros script linéaire dégueulasse) l'astuce consiste à découper notre programme en plein de fonctions que l' on peut ensuite utiliser dans notre script principal. Je crois que celà s'appel "la programmation modulaire".
Le problème c'est que je trouve ça un peu fouilli car on se retrouve vite avec pleins de fichiers (un par fonctions! car matlab n'autorise qu'un fichier .m par fonction). Pourtant conceptuellement il peut y avoir des fonctions qui sont similaires et que l'on voudrit regrouper dans un même fichier.

Dans ce cas : le langage C ou Fortran réponds à mon besoin, car il semble axé sur la notion de modularité! On est amené à découper notre fichier en plusieurs fichiers (dans lesquelles on peut regrouper plusieurs fonctions par fichiers!). Je cherhais donc un analogue en langage interprété au langage C et il me semble que Python peut aussi être découpé en plussieurs fichiers.

Le truc c'est que mon initiative pour évoluer vers le C++ vient de : "si j'essai de coder en C++ 'est surtout parce que l'on me l'a recommendé niveau lisibilité de part son côté orienté objet!" Du coup il faut que je code encore un peu différemment il va falloir que je penses en termes d'objets/classe et pas seulement fonction! J'avoue que pour le moment je ne sais pas penser objet! Qu'est ce qui est une structure, une classe? Est ce que je complique pas tout ? Du coup là j'ai l'impression que 'est super lourd et je n'avance pas.

Donc je ne sais pas trop comment coder un petit prototype de l' algo ni avec quel langage... Je suis paumé

1) Coder avec quel langage ?
En tout cas j'ai constaté:
- le Java m'est plus facile à comprendre qie le C++ à la lecture (peut être car les auteurs du projet Java ont voulu faire qqch de plus simple quitte à le rendre plus lent...)
- Le python j' n lis beaucoup de bien et semble offrir le confort d'un langage interprété et le concept d'orienté objet, Il semble un candidat idéal.

2) Comment coder ?
Comment découper le programme ? Un main et pleins de fonctions (comme en Matlab ?)
Un main et pleins de Classes ?
D'ailleurs lorsque je lis le programme (déjà réalisé en Java) je ne sais pas comment procéder:
utiliser le debugger ? Faire un diagramme de classe ? Commencer par la doc (très peu fournie) pour piger le fonctionnement globale ?

3) Finalement quel est le plus simple ? Si je veux me focaliser sur l'algorithme ... (et non sur l'architectur du programme)

**bacelar** · 10/08/2015, 15h22

Ça repart dans tout les sens.

- si j'utilise un langage de script pour faire mon prototype de programme ça ira beaucoup plus vite (car moins de lignes de codes, la possibilité de tester mon algo au fur et à mesure).

Ça, c'est assez discutable. Sur des petits projets et de l'Edit-And-Continue de VS, il est possible de faire le même type d'expérimentation qu'en interpréter.
Ce qui compte vraiment, c'est les outils offerts par le langage pour la résolution du problème. Donc majoritairement, c'est les bibliothèques du langage qui font la différence, bien plus que le langage lui-même.
Les langages orientés mathématiques disposent de bibliothèques mathématiques puissantes mais le C++, malgré son caractère généraliste, dispose de bon nombre de bibliothèques mathématiques.

Si vous avez compris l'algorithme, le choix d'un type de langage ou un autre est plutôt fonction de son implémentation par les paradigmes offerts par le langage.
Mais des langages avec les mêmes paradigmes auront des implémentations très proche de l'algorithme. JAVA et la POO de C++ sont assez proche, mais C++ n'est pas que POO, il est procédurale, fonctionnel, et meta-programmation en plus de la POO.

Le problème c'est que je trouve ça un peu fouilli car on se retrouve vite avec pleins de fichiers

Bien au contraire, on se retrouve avec des fonctions bien isolées (pas d'effet de bord), correctement nommées, etc...

Pourtant conceptuellement il peut y avoir des fonctions qui sont similaires et que l'on voudrit regrouper dans un même fichier.

Regroupe les dans un même répertoire alors.

Qu'est ce qui est une structure, une classe?

C'est la même chose, pas besoin de les distinguer lors de la conception.

Donc je ne sais pas trop comment coder un petit prototype de l' algo ni avec quel langage... Je suis paumé

Toujours avec un papier et un crayon.
Si t’arrive pas avec un papier et un crayon, pas la peine d'essayer de la programmer dans un langage X ou Y.

Pourquoi cette fixette sur la POO, votre algorithme n'est peut-être pas adapté à la POO.

En POO, il faut distinguer les entités/nom qui donnent généralement les classes et les actions sur ces entités qui seront généralement des méthodes de la classe.

**dfshr8** · 10/08/2015, 16h31

Merci pour ces préisions

Ps: je me demandais:
Pourquoi il vaut mieux écrire le constructeur comme celà:

Code :

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

1
2
3
4
 
#include "Point.h"
 
Point::Point(double xx, double yy): x(xx), y(yy){};

Plutôt que comme celà:

Code :

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

1
2
3
4
5
6
#include "Point.h"
 
Point::Point(double xx, double yy){
x=xx 
y=yy
};

Ps: un peu d aide http://www.developpez.net/forums/d12...er-projet-cpp/

**bacelar** · 10/08/2015, 16h48

http://www.cprogramming.com/tutorial...lists-c++.html

**dfshr8** · 10/08/2015, 17h12

Je n'arrive pas à faire un tableaux de points (mon objet!)

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
 
int main()
{
    srand(time(0));
 
    int N = 10; //Nombre particules
    int threshold = 5;
    int P=5; //ordre du dévelopement
 
 
    vector<Point> z[N];
    double m[N];
    double p_dir[N];
 
 
// Création d'une distribution de 10 Particules au sein du cube [0,1]x[0,1]x[0,1]
    for( int i=0; i<N; i++ )
    {
        z[i].getX() = rand()/(1.+RAND_MAX); //Erreur ici!
        z[i].getY()= rand()/(1.+RAND_MAX);
        m[i] = 1.0/N;
        cout<<x[i]<<" "<<m[i]<<endl;
    }

**dragonjoker59** · 10/08/2015, 17h20

Si tu veux te focaliser sur l'algorithme, je pense que Python est un bon candidat.

**dfshr8** · 11/08/2015, 13h37

Bon je me lance en C++:
- car après l'objectif de mon stage est de modifier une librairie écrite en C++ donc autant m'y habituer (même si Python est très attractif)
- même si ce n'est pas un langage de script mais de compilation, en lançant le build and Run je peux voir immédiatement ce qui se passe en affichant au fur et à mesure du dévellopement les variables que j'utilise.

Je souhaite dévelloper l' algorithme FMM pour calculer le potentiel en un point généré par des charhes ponctuels. En gros je veux refaire ceci: www.umiacs.umd.edu/~ramani/fmm/files/fmmdemo.jar mais sans la partie graphique (pas besoin de l'animation je veux juste faire les calculs). Pour ceux qui voudraient une idée plus précise de l'algo, je m'appuie sur le document suivant (je garderas toutes les notations de ce doc): http://www.umiacs.umd.edu/labs/cvl/p...M_tutorial.pdf.
Je procéderait par essai erreur donc toutes vos remarques me seront utiles au cours du dévellopement!

Voici le début de mon code:

1) Je crée une distribution uniforme de N Particules dans le carré
2) On veut calculer le potentiel en la cible y_j par calcul directe. On considère tout le long de l'algo un potentiel en 1/r (on parle du Kernel) (ie) le potentiel en un point y arbitraire généré par toutes les sources x_i est $\phi(y_j)=\sum_{i=1}^n 1/\|y-x_i\|$ (peut on mettre du latex dans le forum ?)

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
#include<iostream>
#include <ctime>
#include<cstdlib>
#include<cmath>
using namespace std;
 
 
int main()
{
    srand(time(0));
 
    int N = 10; //Nombre particules
    int threshold = 5;
    int P=5; //ordre du dévelopement
 
    double x[N],y[N],m[N],p_dir[N];
 
 
// Création d'une distribution de 10 Particules au sein du cube [0,1]x[0,1]
    for( int i=0; i<N; i++ )
    {
        x[i] = rand()/(1.+RAND_MAX);
        y[i] = rand()/(1.+RAND_MAX);
        m[i] = 1.0/N;
        cout<<x[i]<<" "<<m[i]<<endl;
    }
 
//Calcul directe du potentiel en la cible y_j: $\phi(y_j)=\sup_{i=1}^n 1/\|y-x_i\|$
    double dx,dy,dz;//Représente la distance entre le centre et la particule concernée
    double r;
    for( int j=0; j<N; j++ )
    {
        for( int i=0; i<N; i++ )
        {
            if (i==j) continue;
            dx = x[i]-x[j];
            dy = y[i]-y[j];
 
            r = sqrt(dx*dx+dy*dy+dz*dz);
            p_dir[j] += m[i] / r;
        }
        cout<<"Le potentiel par calcul directe est p["<<j<<"]: "<<p_dir[j]<<endl;
    }

Remarques: On aura différent moyen (de qualité croissante: rapidité/précision) de calculer le potentiel en chacune des charges:
*calcul directe
* Middleman
* PreFmm/ Middleman amélioré
* SLFMM
*MLFMM
Donc je pensais mettre chaque méthode dans une fonction.

**dfshr8** · 11/08/2015, 14h05

Pour les méthodes de calculs suivantes c'et plus complexe. il faut que je partitionne/subdivise mon espace (mon carré) en niveaux (découpages en carrés cf. animation) et que je puisse détecter si une particule appartient à quel niveau/feuille. Pour ça je ne sais pas comment procéder.

PS: pour ceux qui comme moi ne savent pas comment voir l'animation, il suffit de faire java -jar fmm_demo2.jar.
PS: Dans l'animation, pour comprendre le partitionnement de l' espace, on choisit le nombre de niveaux et on a un découpage

**Bousk** · 11/08/2015, 14h18

Ca part dans tous les sens et ce sujet n'en a plus beaucoup.
Il semble te manquer des bases de C++ et de programmation/algorithmie...

Pourrais-tu ouvrir 1 sujet par question comme demandée dans les règles du forum ? Ca aidera déjà un peu à suivre tout ce truc.

**dfshr8** · 11/08/2015, 14h22

Envoyé par Bousk

Ca part dans tous les sens et ce sujet n'en a plus beaucoup.
Il semble te manquer des bases de C++ et de programmation/algorithmie...

Pourrais-tu ouvrir 1 sujet par question comme demandée dans les règles du forum ? Ca aidera déjà un peu à suivre tout ce truc.

Ok pas de problème! Je pensais ouvrir un sujet dont le thème est de coder ce fameux algo, j'ouvre tout de suite un sujet à ce topic

Déroulement d'un programme C++ et compréhension

C++

Discussions similaires

Partager

Partager