Discussion :

[LucieBdC]

Bonjour !
J'écris un programme pour approximer le problème à N corps. Bref.

J'ai un main et une classe Planete.

Dans mon main, je déclare un tableau de Planete "systeme" de taille aléatoire calculée en début de programme.

Code :

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

1
2
tailleSysteme=rand()%(systemsizeMax-systemsizeMin)+systemsizeMin;
Planete systeme[tailleSysteme];

Jusque là tout va bien.

Sauf que, dans une de mes fonctions dans la classe Planete, j'ai besoin de parcourir le tableau systeme, et que je reçois l'erreur "tailleSysteme not declared in this scope".

Que faire ?

Merci de prendre le temps de m'aider ! Si mon post manque de précision, n'hésitez pas à me demander des détails :)

[ternel]

Pourrais-tu nous mettre un peu de code, pour nous donner plus de précisions?

A priori, il suffirait de donner le tableau (et sa taille, si c'est un [] au lieu d'un vector/array) en argument aux fonctions.
Tu peux aussi envisager de le donner comme référence constante au constructeur des planetes

[bacelar]

Votre conception objet me paraît assez bancale.

Le système est constitué de corps célestes, donc pas que des planètes.

En faisant une entorse à la POO et en faisant de tous les corps célestes des planètes, ton tableau systeme ne serait qu'un repository de tous les objets de type Planete créé.

Pour une application mono-thread, l'approche classique est d'avoir un champs statique dans la classe contenant la liste des instances de la classe créée, que le constructeur de la classe modifiera pour ajouter l'objet en cours de création, que le destructeur de la classe modifiera pour supprimer l'objet en cours de destruction.

Mais si cela vous semble confus, on va se rabattre sur un bricolage plus simple.

Primo, votre code, c'est du C99 et pas du C++, ni même du C pré-1999.
En C++ ou en C "standard", il est impossible de définir des tableaux de taille défini à l'exécution.
En C++, on utilisera un std::vector ou un autre conteneur, en fonction de son utilisation dans le programme
http://www.cplusplus.com/reference/vector/vector/

De plus, la fonction rand, c'est du C et pas du C++11. Le compilateur et les normalisateurs de C++ sont sympa avec vous et avec le vieux code des années 80, mais c'est uniform_int_distribution qui est devenu la version "standard" du C++ depuis 2011.
http://www.cplusplus.com/reference/r..._distribution/

Après ces mises aux points, une solution :
Utilisez un std::vector<Planete> pour y stocker, via sa méthode push_back, les planète que vous créerez dans une boucle.

Passez ce std::vector en paramètre des méthodes qui ont besoin de l'ensemble des planètes du système.

P.S.: Ce genre de besoin m'indique vraisemblablement un problème de conception des méthodes de ma classe planète. Je réfléchirai à la création d'une classe systeme en charge de ces calculs plutôt que de les donner à la classe Planete?

[Bousk]

Planete systeme[tailleSysteme];

Cette syntaxe est déjà fausse.
Les VLA c'est spécifique à une certaine version du C, certainement pas du C++.

Pour ton "problème", revois la partie "portée des variables" de ton cours.

[_zzyx_]

La réponse est dans ta question

Sauf que, dans une de mes fonctions dans la classe Planete, j'ai besoin de parcourir le tableau systeme, et que je reçois l'erreur "tailleSysteme not declared in this scope".

Est-ce qu'il y a une varriable tailleSysteme dans ta classe ? Il faut un peu de temps pour comprendre les messages d'erreurs du compilateurs mais c'est souvent une info suffisante pour trouver l'erreur.
D'ailleurs du point de vue conception (j'y reviendrai) comment une planète peut-elle connaitre la taille du système ?

Une autre remarque de conception (l'argumentaire de bacelar se tient, mais c'est peut-etre overkill)

* Ta classe planète ne devrait contenir que les infos propre à une planète c'est à dire (en 3D) au moins x,y,z, px, py, pz, m (et peut-etre d'autres que j'oublies, ainsi que des méta-info par exemple id )

* Tu auras en plus une classe système, qui contient tailleSysteme planètes. (et donc taille Systeme sera contenu dedans)

Par contre j'avoue que là comme ça je sais pas si il vaut mieux intégrer le calcul de la position des planètes à la classe système, ou avoir une fonction/classe qui fait le calcul en prenant comme argument un système (en fait une référence d'un système), mais là on va peut etre trop loin pour ton projet.

[ternel]

Dans ton programme, l'astre est une donnée du problème. Ce n'est pas à lui d'avoir de l'intelligence.
Après tout, tu ne demandes pas à une voiture de faire le plein, ou à une fleur de s'arroser.

pour moi, la conception de ton programme devrait ressembler à ceci:

Chaque planète connait ses caractéristiques physiques propres (masse, position, vitesse)
Une fonction permet de calculer la force appliquée entre deux astres (classe force)

à chaque instant, calculer un vecteur de force appliquée par chaque astre sur les autres, puis appliquer ces forces aux astres.

classes requises:
astre, point, vecteur (au sens physique).

utilitaires:
int, double, std::vector<>, std::string (pour nommer les planetes

fonctions:
force attraction(astre const& source, astre const& cible) ou force astre::attraction(astre const& autre) const,
force& operator+=(force const&),
void astre.appliquer(force const&);

[LucieBdC]

Voilà où j'en suis : j'ai créé une classe "Systeme", je vous met le .h :

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
 
#ifndef SYSTEME_H_
#define SYSTEME_H_
 
#include <iostream>
 
#include <vector>
 
using namespace std;
 
class Planet;
 
class Systeme
{
    public:
    Systeme(int s);
    ~Systeme();
    void calcDistanceX();
    void calcDistanceY();
    void calcDistance();
    void calcAttraction();
 
    //accès en lecture
    int getSystemesize();
    double getDistance(int A,int B);
    double getAttractionX(int a);
    double getAttractionY(int a);
 
    private:
    int systemesize;
    vector<vector<double> > distance;
    vector<vector<double> > distanceX;
    vector<vector<double> > distanceY;
    vector<vector<double> > attraction;
    vector<Planet> systeme();
};
#endif

je trouve le programme plus organisé comme ça... mais maintenant c'est dans mon Systeme.cpp le problème... dès que je fais appel à system[i] dans une boucle, j'ai droit à

"error: invalid types ‘<unresolved overloaded function type>[int]’ for array subscript".

EDIT : comme dans cette fonction par exemple :

Code :

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

1
2
3
4
5
6
7
 
void Systeme::calcDistanceX()
{
    for(int i=0;i<systemesize;i++)
        for(int j=0;j<systemesize;j++)
            distanceX[i][j]=abs(systeme[i].getCoordX()-systeme[j].getCoordX());  //ici
}

[_zzyx_]

vector<Planet> systeme();
Est-ce que systeme est une fonction qui retourne un vector<Planet> ou est-ce que systeme est un vector<Planet> ?
vu comment est organisé ton code, je parierais vers la seconde solution

[ternel]

C'est étrange comme construction.

Il n'y a que deux types de classes les entités du problème, et les solutions d'un problème technique à un certain niveau d'abstraction.

Une planete est une de tes entités, tandis qu'un vector est une solution technique.
Ton système, c'est quoi?

Normalement, un programme (non graphique) est composé d'un main() qui crée les entités initiales, et calcule la solution, en s'aidant de solutions techniques.

Si ton système est une entité, il ne doit pas attendre qu'on lui dise "tiens, c'est quoi la force entre 11 et 17" et "applique 18,5 N sur 13".
Si c'est un helper, il ne dois pas proposer toutes ces fonctions publiques de mise à jour (les calculMachin())

Un objet est toujours dans un état correct.

Après n'importe quel appel de fonction, n'importe quel autre doit être exact.

Si tu tiens à une classe Systeme, je te propose qu'elle ressemble à ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class Systeme {
public:
    //ajout par copie, retour de l'index
    int add(Planete const&);
 
    //évolution de la situation, d'un pas de temps dt
    void avance(float dt);
 
    Planete const& get(int i) const;
private:
    //ce que tu veux
};