Questions en vrac: librairie std,objet cout.

**prgasp77** · 07/07/2015, 16h01

L'opérateur . est prioritaire sur l'opérateur * (source). Ainsi, *ptr.field est équivalent à *(ptr.field) ce qui n'est pas correct. C'est là toute l'utilité de l'opérateur ->.

Je lis la phrase suivante dans ton énoncé

il faut donc affecter les maisons dès l'initialisation.

On peut voir comment tu as interprété ceci stp ?

**white_tentacle** · 07/07/2015, 16h21

Envoyé par dfshr8

Il semble que le compilateur réclame:

Code :

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

(p.home)->adresse

C’est un problème de priorités. Tu peux écrire (*p.home).adresse ou p.home->adresse qui sont équivalents, mais si tu écris *p.home.adresse, alors le compilateur va comprendre d’utiliser l’opérateur . sur p.home, qui est un pointeur, ce qui ne fonctionne donc pas, et l’opérateur de déréférencement * s’applique à l’ensemble de l’expression (qui n’est déjà pas valide).

C’est d’ailleurs pour cela que l’opérateur -> existe : écrire (*machin).toto est beaucoup trop lourd.

**dfshr8** · 07/07/2015, 16h23

Envoyé par prgasp77

Je lis la phrase suivante dans ton énoncé
On peut voir comment tu as interprété ceci stp ?

En fait lorsque je déclare Personne je dois simultanément l'initialiser. (Alors que pour maison j'aurais pu découpler es deux étapes)

20) Je ne comprends toujours pas bien les notions de bibliothèque, STL,SL. Au vu des explications du début de ce post: j'ai compris que le C++ est très modulaire. On crée des fonctions, des objets bien utiles (et qui permettent une utilisation un peu plus avancé que des simples entiers ou réels et opérations arithmétiques). Pour nepas réinventer la roue des programmeurs ont créer des sorte de paquets se rapportants à certaines notions:
- le paquet/module String (qui gèrent les chaines de caractères/tableaux de caractères)
-le paquet/module Iostream (qui gère les entrées sorties)
....
Ces paquets correspondent chacun à des bibliothèques: ainsi on a la bibliothèque <String>, la bibliothèque <iostream> (ou peut on voir toutes les bibliothèques ?). Toutes ces bibliothèques "de base" (fonctionnalités se base aucquel un utilisateur s'attend à pouvoir accéder directement) font partie d'un plus gros paqut qu'est a STL la "Bibliothèque standard".

Mais après o me parle de Template qui permettent d'afgir sur des classes définies par l'utlisateur (donc ça doit être très "flexible" pour agir sur ce que crée l' utilisateur). Par exempe les "vector" (ie tableaux dynamiques) d'objets . On arrive dans qqch de plus en plus abstrait et dynamique...
J suis un peu perdu et malgrès toutes les expliations 'est floue pour moi (j'ai l'impression d'être un groos naze en info ...désolé pour les questions stupides/ les redites etc..)

Remarque: ou puis je consulter une version de "introduction à la programmation avec iso c++ michel michaud " (apperement ce n'est pas à la fnac) pour voir si je l'achète ? (J'ai l'impression qu'il n'est dans aucune librairie pourtant son plan me plait bien)

21)

Pourquoi (j'apprend la partie POO du boouquin maintenant) le code :

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
#include <iostream>	
using namespace std;
 
//Déf de la classes
class MaClass{//Pour différencier les: types de variables/type des objets(instances de classes)=classe : les classes prenent une majusule
 
public://On déclare publicles méthodes que l'on veut utiliser
	 double accesseur_set_att1() const {return attribut1;} //Un accesseur ne modifie pas les attributs donc est const. Il permet 'accéder aux attributs pur les affichés. Come il renvoit/retourn/affiche il faut préciser le type de l'attribut retourné.
	 void manipulateur_get_att1(double new_variable) {attribut1=new_variable;}//
	 double methode (int increment);//On déclare le prototype de la méthode que l'on va définir en dehors de la lasse
 
private:// On déclare privé les attributs et certaines méthodes (on ne peut donc y avoir accès, toute affectation ou utilisation produit un erreur de compilation). C'est la philosophie de l'encapsulation!
	double attribut1;
	char attribut2;
};//Ne pas oublier le ;!
 
//Définition des méthdes de la classes en dehors de la classe (ce qui pse fait via la syntaxe:
double MaClass::methode(int increment){//La méthode à acces à tous les attributs de la classe donc pas besoin de délarer dans les argumnt de la fonctions "attribut1"
return increment+attribut1;
}
 
int main()
{
	MaClass instance_MaClass; //Déclaration objet
 
	//utilisation des méthodes: objet.methode();
	instance_MaClass.manipulateur_get_att1(4);//Permet d'initialiser attribut1 à 5
	cout<<instance_MaClass.accesseur_set_att1()<<endl;
 
	instance_MaClass.methode(2);//on incrémente de 1
	cout<<instance_MaClass.accesseur_set_att1()<<endl;//	
 
	return 0;
}

Me retourne

Code :

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

Au liu de 4 et 6 ? J'ai une méthode qui inrémente de 2!

**LandReagan** · 07/07/2015, 21h40

Salut, à mon tour un peu...

Alors d'abord, l'anglais : "set" est un mutateur et sert plutôt à changer la valeur de l'attribut, et "get" , l'accesseur, à la récupérer. Du coup, ces fonctions, usuellement "inline" et dans ce cas généralement codées dans les déclarations publics des méthodes de la classe, ressemblent à:

Code :

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

1
2
3
 
void set(const int& value) {attribut = value;} // si l'attribut est un int...
int getAttribut() const {return attribut;} // pour l'accès en lecture seule avec copie de l'attribut, par exemple.

Déjà là, est-ce-que tu comprends chaque mot et signe du code et pourquoi il est là? C'est important.

De même, pour la méthode : le but est d'incrémenter l'attribut de la valeur passée à la méthode.

- Aucune valeur de retour n'est requise, puisqu'il ne s'agit que changer l'attribut : "void"
- On passe l'incrément qui est une information dont on a besoin mais qui ne doit pas être changé. Pour s'éviter une copie inutile, on prend l'habitude de passer ces paramètres en référence constante, donc "const int& parametre". Evidemment, il ne s'agit que d'un int dans cet exemple alors le coût de recopie n'est pas exorbitant. Ce ne sera pas toujours le cas.

On en arrive à:

Code :

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

1
2
3
4
 
void methode(const int& increment){
attribut += increment;
}

En espérant avoir fait avancer le schmilblick no 21... Bon courage !

PS: Oups, c'était des "double", au temps pour moi. Il faut changer mes int par des double, même si en l'occurence ça marcherait "as is".

**prgasp77** · 08/07/2015, 10h14

Envoyé par dfshr8

Au liu de 4 et 6 ? J'ai une méthode qui inrémente de 2!

En complément du message de LandReagan (

), je réponds plus directement à ta question.

Ton code ne te retourne pas ce que tu souhaites car il est très ambigu.

Code :

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

1
2
3
double MaClass::methode(int increment){
    return increment+attribut1;
}

On voit que methode() ne modifie pas attribut1 ; elle ne fait que retourner increment+attribut1 sans effet de bord. Elle devrait être déclarée const. Ainsi, dans le main() alors qu'attribut1 vaut 4 :

Code :

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

1
2
instance_MaClass.methode(2);
cout<<instance_MaClass.accesseur_set_att1()<<endl;

La première ligne retourne 6, qui est implicitement ignoré* ; la seconde ligne retourne 4, puisqu'attribut1 n'est pas modifié par methode().

* Prendre la bonne habitude d'ignorer les valeurs de retour de manière explicite. Ainsi, tu dis clairement que tu sais que ladite fonction te retourne une valeur mais que tu n'en a pas besoin. Par exemple :

Code :

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

1
2
3
4
5
6
7
bool doSomething();
 
int main(void)
{
    (void) doSomething();
    return 0;
}

**dfshr8** · 08/07/2015, 20h04

Merci pour les réponses précédentes (effetivementc'était ambigu je voulis faire une affectation et pas simplement un return)

Dans mon cours je ne pige plu rien, voici un extrait de code syntaxiquement correcte (mêm si ce n'est pas conseillé car il est mentionné qu'il vaut mieux faire usage d'initialiseur!. Mais je ne comprend me pas la syntaxe dans les accolades du constructeur. On fait une initialisation sans déckaration...Je suis paumé

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
class MaClass{//Pour différencier
 
public:
	MaClass(double h,double L,char c) //Constructur(est toujours public)
	{
		rectangle=Rectangle(h,L);//La partie droite : Rectagle(h,L); est un appel à un constructeur et le fait de ne pas mettre de nom de variable créer en fait une variable anonyme (un peu comme Rectangle anonyme (h,L). La partie gauche est une initialisatin sans délaration!
		couleur=c;
	}
 
 
 
private:
	Retangle attribut1;//Attribut qui est en fait un Objet (et utilise lui même deux argument hauteur et largeur)
	Couleur attribut2;//Couleur pourrait être un type énuméré par exemple
}

**prgasp77** · 09/07/2015, 10h05

Salut !

La ligne rectangle=Rectangle(h,L); fait trois choses ; mais il va falloir revenir à la ligne qui la précède : l'accolade ouvrante du constructeur. Puisqu'aucune liste d'initialisation n'est utilisée, les attributs de la classe sont construits avec leur constructeurs par défaut. Donc 1° { : Rectangle rectangle() est construit. Maintenant 2° rectangle=Rectangle(h,L); a trois effets :

un Rectangle anonyme est créé ;
rectangle est affecté de cet objet anonyme ;
le rectangle anonyme est détruit.

La ligne couleur=c; est très similaire, si ce n'est qu'elle appelle implicitement le constructeur Couleur::Couleur(char c).

**LandReagan** · 09/07/2015, 11h44

Envoyé par dfshr8

On fait une initialisation sans déckaration...Je suis paumé

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
class MaClass{//Pour différencier
 
public:
	MaClass(double h,double L,char c) //Constructur(est toujours public)
	{
		rectangle=Rectangle(h,L);//La partie droite : Rectagle(h,L); est un appel à un constructeur et le fait de ne pas mettre de nom de variable créer en fait une variable anonyme (un peu comme Rectangle anonyme (h,L). La partie gauche est une initialisatin sans délaration!
		couleur=c;
	}
 
 
 
private:
	Retangle attribut1;//Attribut qui est en fait un Objet (et utilise lui même deux argument hauteur et largeur)
	Couleur attribut2;//Couleur pourrait être un type énuméré par exemple
}

La déclaration des attributs de type Rectangle et Couleur devrait être dans la partie privée de la déclaration de ta classe, je pense (encapsulation des attributs). Tu aurais dû écrire:

Code :

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

1
2
3
4
 
private:
   Rectangle rectangle;
   Couleur couleur;

Ce devrait être syntaxiquement et logiquement correct, ensuite! ;-)

**dfshr8** · 10/07/2015, 11h56

Bonjour , je n'ai pas bien compris l' histoire de l' accolade ouvrante...

Pouvez vous corriger ce que j'énonce (mon interprétation du fonctionnement des constructeurs au vu du cours/livre) ? [message en cours de rédation, compléter tout au long de la matinée!]

Objectif: Le constructeur permet d'initialiser les attributs d'une classe sans fair appel à chacun des manipulateurs (get...) de chacun des attributs.

Déclaration d'un constructeur au sein d'une classe
On déclare le constructeur en public au sein de la classe donc en dehors du main.
Il obéit à la syntaxe suivante:

même nom que la classe
pas de valeur de retour (pas même void)

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
#include <iostream>	
using namespace std;
 
class MaClass{
public:
 
//2) Le constructeur sera en public pour initialiser les attributs
	MaClass(/*liste_arguments pour initialiser les attributs*/)
	{
 
	}
 
private: //1)Les attributs sont private
	Retangle retangle;
	Couleur couleur;
};
 
 
int main()
{
 
 
	return 0;
}

Maintenant voyons comment initialiser les attributs, par une première méthode (peu recommendable):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class MaClass{
public:
 
	MaClass(double h, double L, Couleur c)//liste d'arguments pour initialiser les attributs de la classe
	{
		/*3) Le rectangle anonyme est détruit*/ rectangle /*2) Initialisation/affectation de l' attribut rectangle (qui a déjà été déclaré dans private)*/=Rectangle(h,L) /*1) Création d'une instance de classe/un objet de type Rectangle anonyme (car pas de nom de variable) faisant appel au constructeur de la classe rectangle*/;
		couleur=c;
	}
 
private: 
	Rectangle retangle;
	Couleur couleur;
};

Question 1:
Lorsque l'on écrit:

Code :

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

rectangle=Rectangle(h,L);

la variable/ attribut rectangle est déclaré dans private donc en dessous de public. Du coup le compileur de C++ ne lit pas de haut en bas séquentiellement les instructions ? Car sinon il dirait qu'il ne sait pas ce qu'est rectangle car ça n'a pas été déclaré (en fait c'est déclaré plus bas

Code :

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

1
2
private: 
	Rectangle retangle;

.

Le problème de cette méthode c'est que :e

Lorsqu'une instance de MaClasse est déclarée: il y a appel au constructeur de MaClasse qui réserve de la mémoire pour stocker un tel objet. Puis (voir 1) dans le code)une instance de la classe Rectangle (notre rectangle anonyme) est appelée en faisant appel au coonstructeur de la classe rectangle. Puis " Retangle anonme" est copié dans l'instance de MaClasse. Puis rctangle anonyme est détruit.Ainsi on à un coût d'une copie (ce qui est idiot car rectangle anonyme est détruit à la fin). On préfère faire appel au constructeur de la classe rectangle directement , sans faire de copie...

On a donc une deuxième méthode: il s'agit des listes d'initialisations!

Listes d'initialisations

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
class MaClass{
public:
 
	MaClass(/*liste d'arguments pour initialiser les attributs de la classe :*/ double h, double L, Couleur c)
	//liste d'initialisation
	:/*attribut1(...) //Appel au constructeur de attribut1*/rectangle(h,L),
	couleur(c) //Appel au constructeur de attribut2
	{
		//Définition du constructeur
	}
 
private: 
	Rectangle retangle;
	Couleur couleur;
};

**dfshr8** · 12/07/2015, 12h01

21)Je ne omprends pas pourquoi ça ne marche pas? Pourtant "this" fait bien référence à l' objet courant...

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
#include <iostream>	
#include <string>	
using namespace std;
 
class Peluche {
private:
    string espece;
    string nom;
    double prix;
 
public:
    string getEspece() const  { return espece ; }
    string getNom()    const  { return nom    ; }
    double getPrix()   const  { return prix   ; }
 
    void setPrix(double valeur) { prix = valeur; }
    void etiquette() {
   	   cout << "Hello, mon nom est " << this.getNom() << endl
         << "Je suis un " << this.getEspece() << " et je coute "
         << this.getPrix() << " francs." << endl;
}
 
};
 
 
int main() {
    Peluche bobo;   // On utilise le constructeur par défaut
    cout << "Etiquette :" << endl;
    bobo.etiquette();
    return 0;
}

22) Si dans ma lasse je ne met aucun constructeur, je ne comprendspas commment le compilateur peut affecter un constructeur par défaut!! Dans le cas des types de base: int,... je crois que les attributs ne peuvent être initialisés et lrs d'un affichage c'est ignoré. Dans le cas d'un attribut objet, le compilateur va sans doute farfouiller dans la classe de cet attribut objet pur voir s'il y a un constructeur fournit j'imagine...
Un peu paumé

**LandReagan** · 12/07/2015, 15h52

Salut!

21:
Je pense qu'il serait temps que tu te plonges dans la FAQ. Elle peut paraître rebutante au début, puisque c'est une classification des différents concepts du langage, mais en fait tout y est. Par exemple, je tape "this" dans la barre de recherche et hop! le deuxième résultat est: Qu'est-ce que "this"?

Ni une, ni deux, je clique. Et là je lis:

Qu'est-ce « this » ?
this est un pointeur créé par défaut et qui désigne l'objet lui-même. À noter que this est un pointeur non modifiable, l'adresse pointée ne peut être changée (ce qui est d'ailleurs parfaitement logique).

Et paf! this est un pointeur. Du coup il ne référence pas l'objet courant, il pointe dessus. Et du coup dans le code je ne peux pas écrire:

Code :

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

this.unemethode();

... mais plutôt:

Code :

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

this->unemethode();

22:
La même chose, tudieu!
http://cpp.developpez.com/faq/cpp/?p...eur-par-defaut
En l'occurence, pour tes attributs de type std::string, le constructeur par défaut de string construit un objet string vide (sans caractère).

Bonne lecture!

**dfshr8** · 13/07/2015, 09h53

Dans la aq, je lis:

Code :

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

1
2
3
4
5
class MaClasse3 
{ 
public: 
    MaClasse3( int i ); // ceci n'est pas le constructeur par défaut  
};

Pourquoi ? Est ce parce qu'il n'y a pas d'initialisation dans ce construteur paramétrique ?

Sous Wikipédia on a la meme structure (onstructeur paramétrique

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
class Object
{
    public :
        Object ();                      // Constructeur par défaut
        Object (int n) : nombre(n){};   // Constructeur paramétrique
        Object (const Object&);         // Constructeur par recopie
        ~Object ();                     // Destructeur
        int nombre;
};
 
int main ()
{
    Object obj, *p_obj;         // Appel du constructeur par défaut pour obj
    p_obj=new Object(27);       // Appel du constructeur paramétrique pour créer un objet pour p_obj
    Object obj2(obj);           // Appel du constructeur par recopie pour obj2
    delete p_obj;               // Appel du destructeur pour détruire l'objet contenu dans p_obj
}                               // Appel du destructeur pour obj et obj2

Or à la compilatin ça ne passe pas, pourquoi ?

Code :

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

1
2
3
4
5
6
7
8
9
laurent@Ellington:~/Dropbox/Code_C++/Pedagodie_prog$ g++  -std=c++11 -o wiki wiki.cpp
/tmp/cc7GlNgL.o: In function `main':
wiki.cpp:(.text+0x11): undefined reference to `Object::Object()'
wiki.cpp:(.text+0x42): undefined reference to `Object::Object(Object const&)'
wiki.cpp:(.text+0x53): undefined reference to `Object::~Object()'
wiki.cpp:(.text+0x6c): undefined reference to `Object::~Object()'
wiki.cpp:(.text+0x78): undefined reference to `Object::~Object()'
wiki.cpp:(.text+0x8b): undefined reference to `Object::~Object()'
collect2: error: ld returned 1 exit status

**LittleWhite** · 13/07/2015, 10h05

Bonjour,

D'après vous, le code de la classe (la partie qui détermine son comportement), on le trouve où ? (car c'est cette même question que se pose le compilateur.)

**dfshr8** · 14/07/2015, 16h27

Entre les accolades mais je ne voitpas en quoi celà répond à la quetsion?

Afin de bien comprendre les constructeurs par défauts voici mon code:

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
#include <iostream>	
using namespace std;
 
class Position
{
	public:
    	double getX()   const  { return x   ; }
    	double getY()   const  { return y   ; }
    	Position(double abs,double ord)
    	{
    		x=abs;
    		y=ord;
    	}
	private:
		double x;
		double y;
};
 
class Rectangle
{
    public :
         double getLargeur()   const  { return largeur; }
		double getHauteur()   const  { return hauteur; }
		Position getPosition()   const  { return pos; }
 
    private :
        double largeur;//types de base non initialisés, ??
        double hauteur;
        Position pos;//Objet initialisé
};
 
 
void etiquette(Rectangle p) {
    cout << "Ma hauteur " << p.getHauteur() << endl
         << "Ma largeur " << p.getLargeur() << " et ma position";
        << p.getPosition() ;//<< " Position:" << endl;
}
 
 
int main ()
{
   Rectangle rect;
   cout << "Etiquette:"<<endl;
   etiquette(rect);
   return 0;
}

mais apperement ça pose pbm:

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
rectangle.cpp: In function ‘void etiquette(Rectangle)’:
rectangle.cpp:36:9: error: expected primary-expression before ‘<<’ token
         << p.getPosition() ;//<< " Position:" << endl;
         ^
rectangle.cpp: In function ‘int main()’:
rectangle.cpp:42:14: error: use of deleted function ‘Rectangle::Rectangle()’
    Rectangle rect;
              ^
rectangle.cpp:19:7: note: ‘Rectangle::Rectangle()’ is implicitly deleted because the default definition would be ill-formed:
 class Rectangle
       ^
rectangle.cpp:19:7: error: no matching function for call to ‘Position::Position()’
rectangle.cpp:19:7: note: candidates are:
rectangle.cpp:9:6: note: Position::Position(double, double)
      Position(double abs,double ord)
      ^
rectangle.cpp:9:6: note:   candidate expects 2 arguments, 0 provided
rectangle.cpp:4:7: note: constexpr Position::Position(const Position&)
 class Position
       ^
rectangle.cpp:4:7: note:   candidate expects 1 argument, 0 provided
rectangle.cpp:4:7: note: constexpr Position::Position(Position&&)
rectangle.cpp:4:7: note:   candidate expects 1 argument, 0 provided

Pourquoi ?

**dfshr8** · 14/07/2015, 17h24

Voici un version sans doute un peu plus propre (je viens d m' apercevoir que je ne peux affichr un objet avec "cout"

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
#include <iostream>	
using namespace std;
 
class Position
{
	public:
    	double getX()   const  { return x   ; }
    	double getY()   const  { return y   ; }
 
    	Position(double abs=0.,double ord=0.)    	 //constructeur explicite
    	:x(abs),y(ord)
    	{
      	}
	private:
		double x;
		double y;
};
 
class Rectangle //Pas de constructeur pour étudier le constructeur par défaut
{
    public :
         double getLargeur()   const  { return largeur; }
		double getHauteur()   const  { return hauteur; }
		Position getPosition()   const  { return pos; }
 
    private :
        double largeur;//types de base non initialisés, ??
        double hauteur;
        Position pos;//Objet initialisé
};
 
 
void etiquette(Rectangle p) {
 
	double ab=p.getPosition().getX();
	double ord=p.getPosition().getY();
    cout << "Ma hauteur " << p.getHauteur() << endl
         << "Ma largeur " << p.getLargeur() << " et ma position "     <<ab  << endl;
}
 
 
int main ()
{
   Rectangle rect;//Déclaration d'une instance (donc appel au constructeur)
   cout << "Etiquette:"<<endl;
   etiquette(rect);
 
   Rectangle rect2
 
   return 0;
}

Mais comment puis je initialiser l position ?

**koala01** · 14/07/2015, 20h47

C'est toujours la même chose : pour initialiser un membre de classe, il faut fournir les valeur cohérentes au constructeur de la classe...

Donc, si ton rectangle a besoin d'une position, d'une hauteur et d'une largeur, il faut que son constructeur dispose des informations qui lui permettront de définir ces trois valeurs. En respectant la loi de Déméter qui nous dit (mais je vais un peu loin, je l'admet

) que l'utilisateur de la classe Rectangle n'a absolument pas besoin de connaitre la classe Position pour pouvoir manipuler son rectangle, tu pourrait prévoir un code proche de

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
class Rectangle{
public:
    Rectangle(double posX, double posY, double hauteur, double largeur):
        position_(posX, posY),hauteur_(hauteur),largeur_(largeur){}
    /* renvoie la coordonnée X de la position de ton rectangle */
    double x() const{
        return position_.getX();
    }   
    /* renvoie la coordonnée Y de la position de ton rectangle */
    double y() const{
        return position_.getY();
    }   
    /* renvoie la hauteur de ton rectangle */
    double hauteur() const{
        return hauteur_;
    }
    /* renvoie la largeur de ton rectangle */
    double largeur() const{
        return largeur_;
    }
private:
   Position position_;
   double hauteur_;
   double largeur_;
};

(oui, je suis allergique au "get"

)

je viens d m' apercevoir que je ne peux affichr un objet avec "cout"

Si tu peux, mais tu dois lui dire comment s'y prendre, en surchargeant l'opérateur << pour qu'il prenne un rectangle

Par exemple, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
ostream & operator<< (ostream & os, Rectangle const & rect){
    os<<"position x = "<<rect.x()<<"\n"
       <<"position y = "<<rect.y()<<"\n"
       <<"hauteur = "<<rect.hauteur()<<"\n"
       <<"largeur = "<< rect.largeur()<<"\n";
    return os;
}

**dfshr8** · 15/07/2015, 12h51

22) Petite question HS

Pour mon stage je m'interesse au Fast Multiple Methode. Or sous Wikipédia ils proposent un lien vers une animation qui me donne pleins de fichirs .class
J'ai vu qu'il s'agit de fichiers en Java, du coup je me suis dit il suffit de lancer Main.class
!J'ai donc fait:

Code :

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

java Main

etla console me renvoit

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
 java Main 
Exception in thread "main" java.lang.NoClassDefFoundError: Main (wrong name: fmm/Main)
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:800)
	at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
	at java.net.URLClassLoader.defineClass(URLClassLoader.java:449)
	at java.net.URLClassLoader.access$100(URLClassLoader.java:71)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:361)
	at java.net.URLClassLoader$1.run(URLClassLoader.java:355)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(URLClassLoader.java:354)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:425)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:358)
	at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:482)
laurent@Ellington:~/fmm$ java Main.class
Erreur : impossible de trouver ou charger la classe principale Main.class
laurent@Ellington:~/fmm$ ^C

Et j' en a besoin d'urgence ....

PS: ca semble bien installé

Code :

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

1
2
3
4
java -version 
java version "1.7.0_79"
OpenJDK Runtime Environment (IcedTea 2.5.5) (7u79-2.5.5-0ubuntu0.14.04.2)
OpenJDK 64-Bit Server VM (build 24.79-b02, mixed mode)

Mais je n'ai pas javac:

Code :

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

1
2
3
4
5
6
7
8
9
 javac -version
The program 'javac' can be found in the following packages:
 * default-jdk
 * ecj
 * gcj-4.8-jdk
 * openjdk-7-jdk
 * gcj-4.6-jdk
 * openjdk-6-jdk
Try: sudo apt-get install <selected package>

d'ailleurs pour l'installer lequel des packages me conseillez vous ? (je suis aussi un peu novice linux, donc en général je copie colle les lignes de commandes dasns le terminal pour installer automatiquement les logiciels. Je ne sais pas comment télécharger des fichiers en ligne de commande et je laisse faire la console pour s'occuper des dossiers...

**ternel** · 15/07/2015, 13h47

Pour java, demande dans le forum dédié, ce sera plus simple. A tout hasard, installe un EDI comme eclipse, colle tes classes, et tout sera magique

**prgasp77** · 15/07/2015, 14h31

Envoyé par dfshr8

java.lang.NoClassDefFoundError: Main

La classe contenant le public static void main ne s'appelle pas Main. Il est aussi possible qu'il s'agisse d'un ensemble de classes à utiliser comme bibliothèque.

A tout hasard, installe un EDI comme eclipse, colle tes classes, et tout sera magique

**dfshr8** · 16/07/2015, 17h41

Un étudiant en thèse m' a juste fait la commande : java -jar fmmdemo2.jar et celà à réer l' executable. en fait c'était plutôt simple (quand on connait..).

22) Par contre il a fait plein de manip sur le terminal et je suis super embété car je ne peux remonter indéfiniment le curseur de la console!
Avec history, je peux voir les commandes qu'il a exécuté, mais il a aussi utilisé "gdb" et j voudrait voir ce qu'il a tap dans le programme en ligne de commande or je ne sais pas comment accéder à tous l' affichage de la console (peut être que c'est éffacé au fur et à mesure ??)

23) La je me retrouve perdu (mon tuteur veut que je commence à mettre mon nez dans le code:

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
// ===================================================================================
// ===================================================================================
// Copyright ScalFmm 2011 INRIA, Olivier Coulaud, Berenger Bramas, Matthias Messner
// olivier.coulaud@inria.fr, berenger.bramas@inria.fr
// This software is a computer program whose purpose is to compute the FMM.
//
// This software is governed by the CeCILL-C and LGPL licenses and
// abiding by the rules of distribution of free software.  
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public and CeCILL-C Licenses for more details.
// "http://www.cecill.info". 
// "http://www.gnu.org/licenses".
// ===================================================================================
 
#include <iostream>
#include <iomanip>
 
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
 
#include  "ScalFmmConfig.h"
#include "Utils/FTic.hpp"
#include "Utils/FParameters.hpp"
 
#include "Files/FFmaGenericLoader.hpp"
#include "Kernels/P2P/FP2P.hpp"
#include "Kernels/Interpolation/FInterpMatrixKernel.hpp"
 
#include "Utils/FParameterNames.hpp"
//
/// \file  DirectComputation.cpp
//!
//! \brief DirectComputation: Driver to compute direct interaction between N particles for 1/r kernel.
//!
//! DirectComputation: Driver to compute direct interaction between N particles for 1/r kernel.
//! the particles are read from file given by -fin argument and potential, forces are stored in FMA format.
//!  <b> General arguments:</b>
//!     \param   -help (-h)      to see the parameters available in this driver
//!     \param   -fin name:  file name  to convert (with extension .fma (ascii) or bfma (binary).
//!                             Only our FMA (.bma, .bfma) is allowed "
//!     \param    -fout filenameOUT   output file  with extension (default output.bfma)
//!      \param   -verbose : print index x y z Q V fx fy fz
//!
 
// Simply create particles and try the kernels
int main(int argc, char ** argv){
    FHelpDescribeAndExit(argc, argv,
                         ">> This executable has to be used to compute  interaction either for periodic or non periodic system.\n"
                         ">> Example -fin filenameIN.{fma or bfma)     -fout filenameOUT{fma or bfma) \n"
                         ">> Default input file : Data/unitCubeXYZQ20k.fma\n"
                         ">> Only our FMA (.bma, .bfma) is allowed as input.\n"
                         ">> Output file  with extension (default output.bfma).",
                         FParameterDefinitions::InputFile, FParameterDefinitions::OutputFile,
                         FParameterDefinitions::EnabledVerbose);
 
    //////////////////////////////////////////////////////////////
    typedef double FReal;
    const std::string defaultFile(/*SCALFMMDataPath+*/"../Data/unitCubeXYZQ20k.fma");
    const std::string filenameIn(FParameters::getStr(argc,argv,FParameterDefinitions::InputFile.options,  defaultFile.c_str()));
    const std::string filenameOut(FParameters::getStr(argc,argv,FParameterDefinitions::OutputFile.options, "output.bfma"));
    //
    FTic counter;
 
    // -----------------------------------------------------
    //  LOADER
    //  -----------------------------------------------------
    // ---------------------------------------------------------------------------------
    // Read  particles in the Octree
    // ---------------------------------------------------------------------------------
    std::cout << "Opening : " << filenameIn << "\n";
    //
    FFmaGenericLoader<FReal> loader(filenameIn);
    //
    FSize nbParticles = static_cast<int>(loader.getNumberOfParticles());
    std::cout << "Read " << nbParticles << " particles ..." << std::endl;
    double BoxWith=loader.getBoxWidth();
    FPoint<FReal> Centre(loader.getCenterOfBox().getX(), loader.getCenterOfBox().getY() , loader.getCenterOfBox().getZ());
    std::cout << "\tWidth : " <<BoxWith << " \t center x : " << loader.getCenterOfBox().getX()
              << " y : " << loader.getCenterOfBox().getY() << " z : " << loader.getCenterOfBox().getZ() << std::endl;
 
    counter.tic();
    //
    FmaRWParticle<FReal, 4,8> *  particles = new FmaRWParticle<FReal, 4,8>[nbParticles];
    memset(particles, 0, sizeof(FmaRWParticle<FReal, 4,8>) * nbParticles) ;
    //
    double totalCharge = 0.0;
    //
    //	int nbDataToRead = particles[0].getReadDataNumber();
    for(int idx = 0 ; idx<nbParticles ; ++idx){
        //
        loader.fillParticle(particles[idx].getPtrFirstData(), particles[idx].getReadDataNumber());
        //	loader.fillParticle(particles[idx].getPtrFirstData(), nbDataToRead);    // OK
        //  loader.fillParticle(particles[idx]); // OK
        //    std::cout << idx <<"  "<<  particles[idx].getPosition() << " "<<particles[idx].getPhysicalValue() << " "<<particles[idx].getPotential()
        //			<<"  " << particles[idx].getForces()[0]<<"  " <<particles[idx].getForces()[1]<<"  " <<particles[idx].getForces()[2]<<"  " <<std::endl;
        //
        totalCharge += particles[idx].getPhysicalValue() ;
    }
 
    counter.tac();
 
    std::cout << std::endl;
    std::cout << "Total Charge         = "<< totalCharge <<std::endl;
    std::cout << std::endl;
 
    std::cout << "Done  " << "(@ reading Particles  " << counter.elapsed() << " s)." << std::endl;
    //
    // ----------------------------------------------------------------------------------------------------------
    //                                   COMPUTATION
    // ----------------------------------------------------------------------------------------------------------
    // interaction kernel evaluator
    typedef FInterpMatrixKernelR<FReal> MatrixKernelClass;
    const MatrixKernelClass MatrixKernel;
    FReal denergy = 0.0;
    //
    //  computation
    //
    {
        printf("Compute :\n");
        counter.tic();
#pragma omp parallel shared(nbParticles, particles,denergy)
        {
#pragma omp for
            for(int idxTarget = 0 ; idxTarget < nbParticles ; ++idxTarget){
                //
                // compute with all other except itself
                //
                // Compute force and potential between  particles[idxTarget] and particles inside the box
                //
                for(int idxOther = 0; idxOther < nbParticles ; ++idxOther){
                    if( idxOther != idxTarget ){
                        FP2P::NonMutualParticles(
                                    particles[idxOther].getPosition().getX(), particles[idxOther].getPosition().getY(),
                                    particles[idxOther].getPosition().getZ(),particles[idxOther].getPhysicalValue(),
                                    particles[idxTarget].getPosition().getX(), particles[idxTarget].getPosition().getY(),
                                    particles[idxTarget].getPosition().getZ(),particles[idxTarget].getPhysicalValue(),
                                    &particles[idxTarget].setForces()[0],&particles[idxTarget].setForces()[1],
                                &particles[idxTarget].setForces()[2],particles[idxTarget].setPotential(),&MatrixKernel);
                    }
                }
            } // end for
            // Compute the energy
#pragma omp  for reduction(+:denergy)
            for(int idx = 0 ; idx < nbParticles ; ++idx){
                denergy +=  particles[idx].getPotential()*(particles[idx].getPhysicalValue()) ;
            }
        } // end pragma parallel
        //
        denergy *= 0.5 ;
        counter.tac();
        //
        printf("Energy =   %.14e\n",denergy);
        //
        std::cout << "Done  " << "(@ Direct computation done = " << counter.elapsed() << " s)." << std::endl;
        std::cout << "\n"<< "END  "
                  << "-------------------------------------------------------------------------"
                  << std::endl << std::endl ;
    } // END
 
    //
    // ----------------------------------------------------------------
    //  Save  computation in binary format
    //
    //
 
    std::cout << "Generate " << filenameOut <<"  for output file" << std::endl;
    //
    std::cout << " nbParticles: " << nbParticles <<"  " << sizeof(nbParticles) <<std::endl;
    std::cout << " denergy: " << denergy <<"  " << sizeof(denergy) <<std::endl;
    std::cout << " Box size: " << loader.getBoxWidth() << "  " << sizeof(loader.getBoxWidth())<<std::endl;
    //
    FFmaGenericWriter<FReal> writer(filenameOut) ;
    writer.writeHeader(Centre,BoxWith, nbParticles,*particles) ;
    writer.writeArrayOfParticles(particles, nbParticles);
    //
    // end generate
    // -----------------------------------------------------
    //
    if(FParameters::existParameter(argc, argv, FParameterDefinitions::EnabledVerbose.options)){
        denergy = 0 ;
        for(int idx = 0 ; idx < nbParticles ; ++idx){
            std::cout << ">> index " << idx << std::endl;
            std::cout << " x   " << particles[idx].getPosition().getX() << " y  " << particles[idx].getPosition().getY() << " z  " << particles[idx].getPosition().getZ() << std::endl;
            std::cout << " Q   " << particles[idx].getPhysicalValue()   << " V  " << particles[idx].getPotential() << std::endl;
            std::cout << " fx  " << particles[idx].getForces()[0]       << " fy " << particles[idx].getForces()[1]       << " fz " << particles[idx].getForces()[2] << std::endl;
            std::cout << "\n";
            denergy +=  particles[idx].getPotential()*particles[idx].getPhysicalValue() ;
        }
    }
    std::cout << " ENERGY " << denergy << std::endl;
    //
    delete[] particles;
    return 0;
}

Or il y a pas mal de choses que je ne comprends pas (ca fait que 10 jours que j'apprends à programmer (avec c++). Je vais essayer de refaire un code plus simple en m'inspirant de celui proposer car j'imagine qu'il ya pas mal de choses inuitiles

Questions en vrac: librairie std,objet cout.

C++

Discussions similaires

Partager

Partager