Pointeur passe en argument par "&Pointeur"

[Résolu]
Signaler
Messages postés
9
Date d'inscription
jeudi 7 janvier 2010
Statut
Membre
Dernière intervention
28 juillet 2010
-
Messages postés
276
Date d'inscription
lundi 8 septembre 2008
Statut
Membre
Dernière intervention
15 avril 2013
-
Bonjour a tous,

Je travail actuellement sur un Tp ayant pour but de mettre en œuvre les notions d'héritage, de surcharge et de liste chainée.
J'ai a disposition deux fichiers: le MAIN et tp5.h (tp5.h contient deux classes dont VECTL).
Dans la classe VECTL on me demande de definir une fontion MOD qui permet de :

     o modifier les cinq nombres définissant le vecteur (cinq
premiers paramètres d’appel) ;
     o insérer le vecteur dans une liste chainée (deux derniers paramètres d’appel
qui contiennent, dans l’ordre : l’adresse du dernier vecteur (avant insertion)
de la liste, l’adresse de la tête de liste) (Notas : le pointeur contenant
l’adresse du dernier élément est modifié à chaque insertion dans la liste,
l’insertion à lieu à la fin de la liste) ;
      o calculer, si s’est possible, les vitesses telles que définies au TP N°4.

Mon problème vient des pointeurs passes en argument. Dans le MAIN, ils figurent avec "&".
J'ai effectue de multiples recherches et il me semble la notion de référence ne puisse pas résoudre mon problème.
Comment puis je traiter ce passage en argument?

NOTA: Le MAIN m'est impose. C'est a moi de créer la bibliothèque.

Appel dans le main
PV->MOD(XO,YO,XE,YE,TT,&PA,&TL);

Voici les deux tentatives:
Dans un fichier .h
1er) void VECTL::MOD(float a, float b,float c,float d,float temps,VECTL *dernier,VECTL *tete)
2e) void VECTL::MOD(float a, float b,float c,float d,float temps,char* dernier, char* tete)

Les deux essais ne fonctionnent pas.

Merci @+

4 réponses

Messages postés
276
Date d'inscription
lundi 8 septembre 2008
Statut
Membre
Dernière intervention
15 avril 2013
2
J'avais bon à moitié  

PA et TL sont des pointeurs sur VECTL donc pour que l'appel à MOD fonctionne la déclaration doit être :

void VECTL::MOD(float a, float b,float c,float d,float temps,VECTL **dernier,VECTL **tete)

Maintenant, à toi d'écrire le contenu de cette fonction.
Messages postés
1466
Date d'inscription
mardi 20 février 2007
Statut
Membre
Dernière intervention
7 février 2011
1
Salut,
En effet ce n'est pas un passage par référence mais par pointeur.
Présenté comme ça, on ne peut (je ne peux ?) pas expliquer pourquoi ça ne marche pas. Comment sont déclarés PA et TL ?
Je m'explique :
Imaginons que nous ayons une fonction de prototype : void fct(int *nbr);
La méthode de passage du paramètre ne sera pas la même selon la déclaration de l'entier.
Voici 2 cas d'appel :
int nombre; //Déclaration d'un entier
fct(&nombre); //Passage de l'adresse de l'entier
et
int *nombre; //Déclaration d'un pointeur sur un entier
fct(nombre); //Passage de la valeur du pointeur, autrement dit de l'adresse de l'entier pointé

Donc précise les types de tes variables passées en paramètres.

Cordialement, uaip.
Messages postés
276
Date d'inscription
lundi 8 septembre 2008
Statut
Membre
Dernière intervention
15 avril 2013
2
D'après ce que je comprends du sujet PA serait l'adresse d'un vecteur donc ta première déclaration est correcte, et TL l'adresse de la tête de liste donc probablement un pointeur sur un VECTL. Si tu dois passer cette valeur par adressse pour la modifier, il faudrait peut-être la déclarer comme un pointeur sur un pointeur sur un VECTL soit VECTL **tete ce qui donnerait :

void VECTL::MOD(float a, float b,float c,float d,float temps,VECTL *dernier,VECTL **tete)

Pour en être certain, il faudrait que tu nous donnes les déclarations de PA et TL dans le MAIN.


 


 
Messages postés
9
Date d'inscription
jeudi 7 janvier 2010
Statut
Membre
Dernière intervention
28 juillet 2010

CODE MAIN:







//-----------------------
//TP 5- programme principal
//-----------------------

#include "C:\TT\TP5.h"
void main()
{
    char TEST[12];
    char Cont='O';    //Pour réaliser la boucle de constitution de la liste
    VECTL * TL=NULL;//tete de la liste (au départ vide)
    float XO,YO,XE,YE,TT;//pour creation du vecteur
    VECTL * PA=NULL;    //pour adresse du vecteur "précédant"
    VECTL * PV;    //
   

while (Cont=='O'||Cont=='o')
{
PV=new(VECTL);    //<-- Creation un objet, par défaut, de la classe VECTL
cout<<"Coordonnes de l'origine du vecteur  ? "<<endl;
cout<<"\t X ?";
cin>>XO;
cout<<"\t Y ?";
cin>>YO;cout<<"Coordonnes de l'extremite du vecteur  ? "<<endl;
cout<<"\t X ?";
cin>>XE;
cout<<"\t Y ?";
cin>>YE;
cout<<"Temps ? "<<endl;
cin>>TT;
PV->MOD(XO,YO,XE,YE,TT,&PA,&TL);//actualisation des données et INSERTION dans la liste
// BOUCLE ?
cout<<"\n Voulez vous saisir un autre vecteur ?"<<endl;
cout<<"\n repondre par la lettre O ou o pour poursuivre"<<endl;
cin>>Cont;
}
    VL(TL);//Visualisation de la liste
    cout<<"\n PROGRAMME FINI"<<endl;
    cin>>TEST;
}









CODE tp5.h








#include <fstream>
#include
using namespace std;

class VECT
{
protected:
    float Xa,Ya;
    float Xb,Yb;

public:
    VECT()
    {
        cout<<"\nCoordonnees de l'origine du vecteur?\n\t";
        cout<<"Abcisse ?";
        cin>>Xa;
        cout<<"\tOrdonne?";
        cin>>Ya;
        cout<<"\nCoordonnees de l'extremite du vecteur?\n\t";
        cout<<"Abscisse?";
        cin>>Xb;
        cout<<"\tOrdonne?";
        cin>>Yb;
    }

    VECT (float P1,float P2)
    {
        Xa=0;
        Ya=0;
        Xb=P1;
        Yb=P2;
    };

    VECT (float P1,float P2, float P3, float P4)
    {
        Xa=P1;
        Ya=P2;
        Xb=P3;
        Yb=P4;
    };

    void VV()
    {
        cout<<"\nCoordonnees un vecteur :\n\t";
        cout<<"Origine:X="<<Xa<<"Y="<<Ya;
        cout<<"\nExtremite :X="<<Xb<<"Y="<<Yb<<"\n";
    };
};

/***************************************************************************************************************/
class VECTL:public VECT
{
    public:
    float DXO,DYO,DXE,DYE; //Derivees des coordonnees des extremites du vecteur
    bool calc; //Indique la reussite ou le cas echeant l'echec des derivations
    float TT; //Le temps
    VECTL *Lc; //Declaration du pointeur

    public:
        VECTL(float Xa=0, float Ya=0,float Xb=0,float Yb=0,VECTL *M = NULL);
       
        VECTL(float P1,float P2,float P3,float P4,float T,VECTL *P5 = NULL):VECT(P1,P2,P3,P4)   
        {
        TT=T;
        float DT;
        if(P5 == NULL)
        {
            calc = false;
        }
        else
        {
            P5->Lc=this;
            DT = TT-P5->TT;
            if(DT>0)
            {
                calc = true;
                DXO=(Xa-P5->Xa)/DT;
                DYO=(Ya-P5->Ya)/DT;
                DXE=(Xb-P5->Xb)/DT;
                DYE=(Yb-P5->Yb)/DT;
            }
            else
            {calc=false;};
        }
        }

    void VV()
    {

        VECT::VV();
        cout<<"\t TEMPS:: "<<TT<<endl;
        if(calc == true)
        {
            cout <<"\t Variations sur l'origine: en X="<<DXO<<" en Y="<<DYO<<endl;
            cout<<"\t Variations sur l'extremite: en X="<<DXE<<" en Y="<<DYE<<endl;
        }
        else
        {
            cout<<"\t\n PAS DE CALUL de difference "<<endl;
        }
    }

        void MOD(float a, float b,float c,float d,float temps,char* dernier, char** tete);
};

void VECTL::MOD(float a, float b,float c,float d,float temps,char* dernier, char** tete)
{
            VECTL laListe; //On creer un objet
            laListe.Lc = NULL; //Liste vide

            tete = Lc; //Adresse du premier element

            //Ajout d'un element
            VECTL *nouvel_element = new VECTL;
            if(nouvel_element == NULL) //L'element est a creer.
            {
                nouvel_element->Xa = a;
                nouvel_element->Ya = b;
                nouvel_element->Xb = c;
                nouvel_element->Yb = d;                nouvel_element->Lc Lc; //Le pointeur "suivant (Lc)" de "nouvel_element" pointe sur "Lc". Or "Lc NULL". C'est le dernier element de la liste.
                nouvel_element = Lc; //Le pointeur liant l'elem precedent pointe sur "nouvel_element" au lieu de "NULL"
                //dernier = nouvel_element->Lc; //Je recupere l'adresse du dernier element   
           
                float DT = temps - Lc->TT;
                if( DT > 0)
                {
                    DXO=(Xa-Lc->Xa)/DT;
                    DYO=(Ya-Lc->Ya)/DT;
                    DXE=(Xb-Lc->Xb)/DT;
                    DYE=(Yb-Lc->Yb)/DT;
                }
            }           
}

//**********************************************************************************************************
int VL(VECTL *tete) //Visualisation des objets
{
    puts("Coordonnees du vecteur:");
    cout<<"Origine  : X ="<<tete->DXO<<"  Y ="<<tete->DYO<<endl;
    cout<<"Extremite: X ="<<tete->DXE<<"  Y ="<<tete->DYE<<endl;
    cout<<"TEMPS    : t ="<<tete->TT<<endl;

}