Pointeur passe en argument par "&Pointeur"

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 :

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 @+

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.

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.

 

 

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 <iostream>
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;

}