accéder à un attribut privé

slm,
j'ai un petit problème que j'éspère trouver sa solution chez vous:D
j'ai définit une classe qui a un vector d'objets comme attribut privé,lors du programmatiom j'avais besoin d'accéder à ce vector hors de cette classe (dans une autre),donc je me trouvais obligée soit de reprototyper la fonction oú je veut utiliser mon vector comme friend dans l aclasse concernée (une solution bizarre au niveau conception ),soit de faire une méthode get(accesseur à ce vector)(solution encore pire au niveau de gestion de mémoire ),soit le mettre en public(qui est la plus pire!!!!!!!!!!!!!!!!!!!)
avez vous une autre solution meilleure ????????
ps:urgennnnnnnnnnnnnnnnnnnnnnnnnnt
Merciiiiiiiiiiiiiiiiiiiiiiiiiii

j'avais besoin d'accéder à ce vector hors de cette classe

Explique plus la nature de l'accès que tu veux faire ...

voici en résumé c'est que je veux faire:
l'idée du mon programme est faire une simulation physique des grains en interaction avec d'autres grains et des obstacles ,j'ai implémenté pour cela une classe grain ,une classe obstacle et une une classe systeme qui posséde entre autres une collection hétérogène des grains et une des obstacles .
cette classe système posséde une méthode evolue() qui fait évoluer (bouger ) les grains suivant les lois des mouvements .
donc il faut que j'ajoute à l'attribut force du grain toutes les forces appliquées par les autres grains et celles appliqées par les obstacles .
voici le code de cette méthode evolue():

Code:

void Systeme::evolue(double t)
{

    cout << "======================================================================" << endl;
//boucle parcourant tout le vector du grains pour ajouter à chaque grain les forces exercés sur lui
    for(unsigned int i(0);i
    {
        cout << i+1 << "a) calcul de la force 'perso'  : " << endl;

        //afficher l'attribut "force" , le coefficient de frottement
        cout << "f=" << grains[i]->getF() << "--(l=" << grains[i]->coeffrot(cte::p_air, cte::n_air);//p_air et n_air ce sont des ctes du milieu là c'est l'air

        //ajouter à l'attribut "force" la valeur "masse*g-l*vitesse"
        grains[i]->ajouteForce(cte::p_air, cte::n_air);

        //afficher le nouveau "force"
        cout << ")--> f=" << grains[i]->getF() << endl;
       

        cout << i+1 <<"b) calcul des forces obstacles : " << endl;
//boucle parcourant tous les obstacles pour ajouter au garin grains[i] les forces appliqués par tous les obstacles
        for(unsigned int j(0);j
        {
            Vecteur3D d(obstacles[j]->PointPlusProche(grains[i]->getPos()));//calcule du point le plus proche au grain i sur l'obstacle j

            //afficher sa valeur
            cout << "    point plus proche de l'obstacle " << j << " =" << d << endl;

            //calcul et affichage de l'écart entre l'obstacle j et le grain i
            cout << "    ecart à l'obstacle " << j+1 <<" =" << d-(grains[i]->getPos()) << endl;

            //calcul et affichage de la distance entre l'obstacle j et le grain i(la norme du vecteur trouvé dans l'écart)
            double a(sqrt((d-(grains[i]->getPos())).norme_carre()));
            cout << "    distance à l'obstacle " << j+1 << " =" << a << endl;

           
            cout << "    intensite de la force(" << a << ") =";
            Vecteur3D k(grains[i]->forceLJ(obstacles[j]->getPos()));//calcul de la forceLJ appliquée sur le grain i

            //introduire le produit scalaire entre la forceLJ  et le vecteur unitaire normal de l'obstacle pour déterminer le signe de l'intensité de la force
            if(k*(obstacles[j]->getV_U())<0.0){
                cout << -(sqrt((k.norme_carre()))) << endl;
            } else {
                cout << sqrt(k.norme_carre()) << endl;
            }

            //calcul et affichage de la force appliquée sur le grain i par l'obstacle j
            cout << "    df=" << grains[i]->ajouteForce(obstacles[j]);

            //mettre à jour la force appliquée sur le grain i en ajoutant "df" à "force"
            cout << ", f=" << grains[i]->getF() << endl;
           
           
        }
        cout << i+1 <<"c) calcul des forces des autres grains : " << endl;
        //boucle parcourant les garins de la position suivante de celle du courant(grains[i])pour lui  ajouter  forces appliqués par ces grains et ajoutant au grain en interaction avec grains[i](i.e grains[k]) la force opposé
        for(unsigned int k(i+1);k
        {
            Vecteur3D s(grains[k]->getPos()-grains[i]->getPos());//le vecteur de la distance entre le grain i et le grain k
            double b(sqrt(s.norme_carre()));//sa norme
            cout << " distance grain " << i+1 << " - grain " << k+1 << " : " << b << endl;
            cout << "    intensite de la force(" << b << ") =";
            Vecteur3D h(grains[i]->forceLJ(grains[k]->getPos()));//calcul de la forceLJ appliquée sur le grain i
            //introduction du produit scalaire comme dans le cas précédent
            if((h*s)<0.0){
                cout << -(sqrt(h.norme_carre())) << endl;
            } else {
                cout << sqrt(h.norme_carre()) << endl;
            }
            //calcul et affichage de la force appliquée par le grain k sur le grain i
            cout << "  df=" << grains[i]->ajouteForce(grains[k]);
            //mettre à jour la force appliquée sur le grain i en ajoutant "df" à "force"
            cout << ", f=" << grains[i]->getF() << endl;
            //
            grains[k]->ajouteForce(-(grains[i]->ajouteForce(grains[k])));//ajouter la force opposée au grain grains[k]
        }

        //déplacement du grain i
        cout << i+1 <<"d) bouger : " << endl;
        cout << " f =" << grains[i]->getF() << endl;//afficher la force totale appliquée sur le grain i
        Vecteur3D v_prec(grains[i]->getVit());//vitesse du grain i avant le déplacement
        Vecteur3D x_prec(grains[i]->getPos());//position du grain i avant le déplacement
        grains[i]->bouger(t,cte::p_air, cte::n_air);//déplacer le grain i pendent un pas de temps "t" dans l'air
        cout << "dv =" << (grains[i]->getVit()-v_prec) << endl;//afficher la différence entre la nouvelle et l'ancienne vitesse du grain
        cout << "dx =" << (grains[i]->getPos()-x_prec) << endl;//afficher la différence entre la nouvelle et l'ancienne position du grain
        cout << "x =" << grains[i]->getPos() << endl;//position du grain i après le déplacement
        cout << "v =" << grains[i]->getVit() << endl;//vitesse du grain i après le déplacement
    }
   
   
   
       
}


peut être c'est pas tout clair mais ça donne idée au moins
une autre question :
j'ai utilisé pour cette evolue() l'algorithme 1:

• calculer la force ne dépendant pas des autres grains ni
  obstacles (méthode ajouteForce())
  
• Pour tous les obstacles, ajouter la force qu'exerce l'obstacle
  sur le grain (méthode ajouteForce(Obstacle))
  
• Pour tous les autres grains non encore considérés (i.e. les
  grains suivants), ajouter la force qu'exerce ce grain
  sur le grain courant, et ajouter l'opposé de cette force au grain en
  question (méthodes ajouteForce(Grain) et ajouteForce(Vecteur))
  
• déplacer le grain en utilisant la méthode d'Euler-Cromer (méthode bouger)
  

Un autre algorithme (algorithme 2), extrêmement proche
consiste à effectuer les étapes 1 à 3 pour tous les grains, puis
ensuite dans une seconde boucle sur tous les grains à effectuer 4.Quelle est la complexité de ces deux algorithmes
ci-dessus ?
Merciiiiiiiiiiiiiiiiiiiiiiii

En lisant ce qui est demandé dans ce petit projet, j'imagine qu'il faut au moins définir :
- l'objet GRAIN,
- l'objet OBSTACLE,
- l'objet FORCE (vecteur),
- l'objet ENVIRONNEMENT,
- l'objet SIMULATION.

Un objet GRAIN doit connaitre les informations suivantes:
- les coordonnées de son centre de gravité dans un repère,
- son vecteur vitesse à un instant t,
- son vecteur accélération à instant t.

L'objet OBSTACLE doit connaitre :
- des informations sur sa forme telles que ses frontières: c'est l'une des données les plus difficiles à définir vu que ça peut être soit une forme standard: cercle,triangle... ou une forme quelconque.
- des informations sur la nature physique de la matière qui le compose: ça peut être intéressant dans l'évaluation des forces résultantes pendant un choc GRAIN / OBSTACLE: mou, élastique, perte ou conservation de quantité de mouvement...
- vecteurs vitesse et accélération de l'obstacle si jamais un obstacle est mobile.

L'objet FORCE représente un simple vecteur à 2 dimensions. Il peut modéliser la force de frottement par exemple:
- vecteur directeur,
- intensité,

L'objet ENVIRONNEMENT rassemble tous les objets définies ci-dessus. En fait, à un instant t donné, l'environnement est formé de plusieurs Grains se déplaçant en respectant l'existence de certains Obstacles et en tenant compte de certaines Forces spéciales pouvant apparaitre. Ca peut être une liste d'objets de différentes natures (vive le polymorphisme).

L'objet SIMULATION contient les paramètres de la simulation physique. Il permet de faire évoluer l'objet ENVIRONNEMENT ainsi que toutes ses composantes en fonction du temps:
- attribut: Intervalle de rafraichissement du système

à suivre.

slm,
en fait ce programme était le sujet de notre petit projet de semestre et ma première question qui était précise vient dans le cadre d'amélioration de mon code.
En tout cas j'ai rendu mon projet le dimanche (donc à l'heure où cette intervention était écrite,j'étais en train de faire les dernières retouches c'est pour ça que j l'ai pas lu immédiatement ,j'aurait dû poser ma question avant:roll:)
Je te félicite pour cette description assez simple, assez claire du programme!!!!!!!!!!!
C'est presque que j'avait fait, la force n'était pas elle même une classe mais j'avait définit une classe Vecteur3D représentant les vecteurs (au sens mathématique(x,y,z))dans l'espace donc elle me servait à bien définir les positions des grains et des obstacles,leurs vitesses ,les vecteurs normales (directeurs) des obstacles et les forces.
ce n'est qu'un petit projet pour des débutants en C++,comme tu l'as déjà dit ,donc on a bien simplifié le problème disant que l'obstacl est immobile et ne peut prendre qu'une forme standard !
donc si j'ai bien compris ton analyse ton ENVIRONNEMET sera mon Systeme (écrit dans le code là en haut).
mais ce que j'ai pas trop saisi c'est ton objet SIMULATION qui a pour but,je pense d' évoluer le systeme et qui correspond normalemennt dans mon code à la méthode evolue(dt) de la calsse Systeme.
est-il,selon toi, plus propre de définir cette classe SIMULATION que plutôt définir une méthode evolue dans la classe Systeme?
et pour évoluer le systeme ,tu définit ,je suppose,une méthode evolue dans la classe SIMULATION qui prend en paramètre un système,et donc pour appeler cette méthode ,on fait :
simulation.evolue(systeme);
au lieu de faire
systeme.evolue(dt);

en tout cas merci pour ta réponse

En définissant la classe SIMULATION, c'est plus clair, plus simple et plus ouvert à des extensions du projet:

Code:

SIMULATION sim = new SIMULATION(freq,nCycle,&env,&result)

En fait, il y a quelques paramètres qui décrivent la simulation que tu veux faire; en est exemple :

- la fréquence de rafraichissement (freq) du système, pouvant s'exprimer en nombre de millisecondes, ou aussi pouvant servir pour une simulation à évènements discrets...

- le nombre de cycles (nCycle) ou aussi durée de vie de la simulation,

- l'environnement (env) donné à l'objet (sim) pour qu'il soit traité,

- le résultat de la simulation (result) un objet pouvant éventuellement stocker tous les déplacements qui ont eu lieu par exemple, ou quelques statistiques sur l'environnement (énergie totale du système, la chaleur dégagée etc... on peut imaginer plusieurs choses) ...


I hope it helps !

Concernant ces paramétres,d'un part j'ai définit la fréquence de rafraichissemnt comme un attribut statique dans ma classe systeme d'autre part, j'ai passé le nombre de cycles en argument au main,mais bien évidemment ton idée parrait plus propre et plus claire!!!
enfin pour &result,il me parrait que ça sera un flot pour rediriger le résultat(i.e un ostream),non?

&result : peut être un pointeur sur un objet "DATA", une classe mère de laquelle on peut dériver plusieurs autres classes:
- sauvegarde dans un fichier texte
- sauvegarde dans un fichier excel
- sauvegarde dans une liste dans la mémoire, ou toute autre structure de donnée,...

DATA devrait disposer d'une méthode virtuelle (ou abstract method) du type:

Code:

public int DATA::Add(Object obj);

à suivre...