pourquoi ca compile ?

Bonjour,

Dans une classe j'ai une methode
StatusCode BTagTool::tagJet(ParticleJet& jetToTag) { ... }

qui appelle

Trk::RecVertex VertInJet = m_BtagVertSec->GetVrtSec(jetToTag);


mais GetVrtSec ne prend en parametre que le type Jet ! :
Trk::RecVertex BTagVrtSec::GetVrtSec(const Jet & JetDir) {...}

Est ce que ca compile parce que les clases Jet et ParticleJet ont en
commun la classe P4PxPyPzE ?

Ci dessous les defs des classes Jet et ParticleJet

//The Jet definition :
class Jet : public Navigable<INavigable4MomentumCollection,double>,
public P4PxPyPzE,
virtual public INavigable4Momentum { ... }

// The ParticleJet definition :
class ParticleJet : public ParticleBase, public P4PxPyPzE { ... }

Merci !

Karim.

Ca ne devrait pas compiler.

Est tu sur que tu n'as pas une autre méthode GetVrtSec qui prend en
parametre ParticleJet & ?

Dans une classe j'ai une methode
StatusCode BTagTool::tagJet(ParticleJet& jetToTag) { ... }

qui appelle

Trk::RecVertex VertInJet = m_BtagVertSec->GetVrtSec(jetToTag);


mais GetVrtSec ne prend en parametre que le type Jet ! :
Trk::RecVertex BTagVrtSec::GetVrtSec(const Jet & JetDir) {...}

Est ce que ca compile parce que les clases Jet et ParticleJet ont en
commun la classe P4PxPyPzE ?

Ci dessous les defs des classes Jet et ParticleJet

//The Jet definition :
class Jet : public Navigable<INavigable4MomentumCollection,double>,
public P4PxPyPzE,
virtual public INavigable4Momentum { ... }

// The ParticleJet definition :
class ParticleJet : public ParticleBase, public P4PxPyPzE { ... }

Peut-être que la classe Jet a un constructeur non explicit qui prend
un ParticleJet ou une de ses classes de bases.

--
Sylvain Togni

Merci pour vos reponses ! la classe Jet est definie comme ceci :

031 class Jet : public Navigable<INavigable4MomentumCollection,double>,
032 public P4PxPyPzE,
033 virtual public INavigable4Momentum
034 {
035
036 public:
037
038 typedef INavigable4MomentumCollection collection_type;
039 typedef INavigable4Momentum constituent_type;
040 typedef Navigable<collection_type,double> navigable_type;
041 typedef navigable_type::object_iter constituent_iterator;
042 typedef navigable_type::external_index_type index_type;
043
044 /// brief default constructor produces empty jet without kinematics
045 Jet();
046
047 /// brief construct jets from INavigable4Momentum
048 Jet(const collection_type* theCollection,
049 const constituent_type* theConstituent,
050 double weight=1.0);
051 Jet(const collection_type* theCollection,
052 index_type& theIndex,
053 double weight=1.0);
054 /// brief construct jet with kinematics only from I4Momentum*
055 Jet(const I4Momentum* pFourVector);
056 /// brief construct jet with kinematics only from I4Momentum&
057 Jet(const I4Momentum& rFourVector);
058 /// brief construct jet with kinematics only from HepLorentzVector&
059 Jet(const HepLorentzVector& rFourVector);
060 /// brief construct jet with kinematics only from variables
061 Jet(double e, double px, double py, double pz);
062
063 /// brief copy constructor
064 Jet(const Jet* aJet );
065
066 /// brief jet builder dynamics support
067 bool addConstituent(const collection_type* theCollection,
068 const constituent_type* theConstituent,
069 double weight=1.0);
070 bool addConstituent(const collection_type* theCollection,
071 index_type& theIndex,
072 double weight=1.0);
073 bool removeConstituent(const constituent_type* theConstituent);
074 bool removeConstituent(const collection_type* theCollection,
075 index_type& theIndex);
076 bool addJet(const Jet* aJet, double weight=1.0);
077 bool addJet(const Jet* aJet, const JetOverlapHandler* aHandler,
078 double weight=1.0);
079
080 // Jet examination and manipulation not provided by navigation
081 bool reweight(const constituent_type* aConstituent, double weight);
082 bool reweight(const collection_type* aCollection,
083 index_type& anIndex,
084 double weight);
085
086 double getWeight(const constituent_type* aConstituent) const;
087 double getWeight(const collection_type* aCollection,
088 index_type& anIndex) const;
089 double getWeight(constituent_iterator iConstituent) const;
090 void setP(const HepLorentzVector& p);
091
092 bool cleanUp();
093
094 bool isIdentical(const Jet& aJet);
095 bool isIdentical(const Jet* aJet);
096
097 // overlap is stored in a Jet
098 Jet* getOverlap(const Jet* aJet) const;
099 Jet* getOverlap(const Jet& aJet) const;
100
101 constituent_iterator firstConstituent() const;
102 constituent_iterator lastConstituent() const;
103
104 HepLorentzVector constituent_sum4Mom() const;
105
106 // comparison operators
107 // bool operator==(const Jet& aJet) { return
this->isIdentical(aJet) ; }
108 // bool operator!=(const Jet& aJet) { return
!(this->isIdentical(aJet)) ; }
109 // bool operator<(const Jet& aJet) { return this->et() <
aJet.et() ; }
110 // bool operator>(const Jet& aJet) { return this->et() >
aJet.et() ; }
111
112 // algebra
113 // double operator*(const Jet& aJet) const; // dot product
114 // Jet* operator%(const Jet& aJet) const; // x-product
115
116 // Jet* operator+(const Jet& aJet) const; // copy & add
117 // Jet* operator-(const Jet& aJet) const; // copy &
subtract
118 // Jet* operator*(double scale) const; // copy & scale
119 // Jet* operator/(double scale) const; // copy & scale
120
121 // Jet* operator+=(const Jet& aJet); // add
122 // Jet* operator-=(const Jet& aJet); // subtract
123 // Jet* operator*=(double scale); // scale
124 // Jet* operator/=(double scale); // scale
125
126
127 // destructor
128 virtual ~Jet() { };
129
130 // clone method
131 virtual Jet* clone() const ;
132
133 protected:
134
135 // recombination scheme implementation (default)
136 virtual void updateKine(const constituent_type* aConstituent,
137 double weight=1.0);
138 virtual void updateKine(const HepLorentzVector& the4Mom,
139 double weight=1.0);
140 virtual void updateKine();
141
142 };

Sylvain Togni wrote:

Dans une classe j'ai une methode
StatusCode BTagTool::tagJet(ParticleJet& jetToTag) { ... }

qui appelle

Trk::RecVertex VertInJet = m_BtagVertSec->GetVrtSec(jetToTag);


mais GetVrtSec ne prend en parametre que le type Jet ! :
Trk::RecVertex BTagVrtSec::GetVrtSec(const Jet & JetDir) {...}

Est ce que ca compile parce que les clases Jet et ParticleJet ont en
commun la classe P4PxPyPzE ?

Ci dessous les defs des classes Jet et ParticleJet

//The Jet definition :
class Jet : public Navigable<INavigable4MomentumCollection,double>,
public P4PxPyPzE,
virtual public INavigable4Momentum { ... }

// The ParticleJet definition :
class ParticleJet : public ParticleBase, public P4PxPyPzE { ... }

Peut-être que la classe Jet a un constructeur non explicit qui prend
un ParticleJet ou une de ses classes de bases.

Pipo pipo wrote:

Merci pour vos reponses ! la classe Jet est definie comme ceci :

Tu postes à la fois trop, et pas assez. Sylvain t'as donné un
bon tuyau@: est-ce que Jet a un constructeur qui peut prendre un
ParticleJet comme paramètre. Du coup, ce qui est intéressant,
c'est les hièrarchies des deux classes, et les constructeurs de
Jet, et rien de plus. (Sauf des opérateurs de conversion
implicite, évidemment. Mais j'imagine que si tu en avais écrit,
tu saurais bien que la conversion implicite existe.)

031 class Jet : public Navigable<INavigable4MomentumCollection,double>,
032 public P4PxPyPzE,
033 virtual public INavigable4Momentum
034 {

036 public:

[...]

044 /// brief default constructor produces empty jet without kinematics
045 Jet();

En fait, seulement les constructeurs qui peuvent être appelés
avec un seul paramètre (de type classe) nous intéressent ici.
Donc, le constructeur par défaut n'est pas en cause.

047 /// brief construct jets from INavigable4Momentum
048 Jet(const collection_type* theCollection,
049 const constituent_type* theConstituent,
050 double weight=1.0);
051 Jet(const collection_type* theCollection,
052 index_type& theIndex,
053 double weight=1.0);

Ni les précédants, qui ont besoin d'au moins deux paramètres.

054 /// brief construct jet with kinematics only from I4Momentum*
055 Jet(const I4Momentum* pFourVector);

Ni celui-ci, qui ne prend qu'un pointeur.

056 /// brief construct jet with kinematics only from I4Momentum&
057 Jet(const I4Momentum& rFourVector);
058 /// brief construct jet with kinematics only from HepLorentzVector&
059 Jet(const HepLorentzVector& rFourVector);
060 /// brief construct jet with kinematics only from variables

Ces deux, en revanche, pouvaient en être la cause. Est-ce que
ParticleJet dériverait de I4Momentum ou de HepLorentzVector
(directement ou indirectement, mais toujours de façon publique) ?

Si oui, tu passes une référence à un nouvel objet, temporaire.
(Je ne sais pas si c'est ce que tu veux.)

C'est un assez bon automatisme de déclarer tous les
constructeurs qui prenent des paramètres (sauf celui de copie) «
explicit ». Donc, ici :

explicit Jet( I4Momentum const& rFourVector ) ;
explicit Jet( HepLorentzVector const& rFourVector ) ;

Ça empèche les conversions non-voulues.

061 Jet(double e, double px, double py, double pz);

063 /// brief copy constructor
064 Jet(const Jet* aJet );

Le commentaire est faux ici. Un constructeur de copie prend
toujours une référence (et non un pointeur). Donc, ici :
Jet( Jet const& aJet ) ;

Ceci dit : dans une classe polymorphique, il est parfois
intéressant à ce que le constructeur de copie soit privé, pour
éviter des copies intempestives (qui souvent, en plus, risque de
saucissonner l'objet, n'en copiant qu'une partie).

[...]

130 // clone method
131 virtual Jet* clone() const ;

Qui doit souvent être le seul utilisateur du constructeur de
copie.

[...]

142 };

Sylvain Togni wrote:

Enfin, ce que tu cites doit venir en tête, avec les parties sans
signification à ta réponse coupée. (Régarde comment Sylvain t'a
répondu.)

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34