probleme passage de paramètre fonction avec const

Version imprimable

20/08/2015, 11h48
romainprogdebutant

probleme passage de paramètre fonction avec const

Bonjour,
J'aimerai avoir des précisions sur le pasage par référence constante, je vais montrer les exemple directement ce sera plus parlant :mouarf:

mon.h de ma classe comporte

Code:

bool intersect(const Ray &r, float t0, float t1) const;

monn/cpp de ma classe comporte

Code:

bool Box::intersect(const Ray &r, float t0, float t1) const {...

appel depuis le main :

Code:

b.intersect(r,0,4)

erreur :

Citation:

Error: il n'existe aucune conversion définie par l'utilisateur appropriée de Ray en const Ray

ok maintenant

mon.h de ma classe comporte

Code:

bool intersect(Ray &r, float t0, float t1) const;

monn/cpp de ma classe comporte

Code:

bool Box::intersect(Ray &r, float t0, float t1) const {...

appel depuis le main :

Code:

b.intersect(r,0,4)

erreur :

Citation:

Error: impossible d'initialiser une référence de type "Ray &"(non qualifié const) avec une valeur de type "Ray"

bon j'ai testé ça aussi :

mon.h de ma classe comporte

Code:

bool intersect(Ray const &r, float t0, float t1) const;

monn/cpp de ma classe comporte

Code:

bool Box::intersect(Ray const &r, float t0, float t1) const {...

appel depuis le main :

Code:

b.intersect(r,0,4)

erreur :

Citation:

Error: il n'existe aucune conversion définie par l'utilisateur appropriée de "Ray" en "const Ray"

:aie:
20/08/2015, 12h39
Iradrille

Hello,

Il va falloir donner plus de détails car on peut pas deviner d'où vient le problème.

Citation:

Envoyé par Iradrille

Hello,

Il va falloir donner plus de détails car on peut pas deviner d'où vient le problème.

Code:

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
#include "box.h"
 
Box::Box(const Vec3f &mini, const Vec3f &maxi) {
		bounds[0] = mini;
		bounds[1] = maxi;
	}
 
void Box::expand(Box box){
	bounds[0] = Vec3f(std::min(box.bounds[0].x,bounds[0].x),std::min(box.bounds[0].x,bounds[0].x),std::min(box.bounds[0].x,bounds[0].x));	
	bounds[1] = Vec3f(std::max(box.bounds[0].x,bounds[0].x),std::max(box.bounds[0].x,bounds[0].x),std::max(box.bounds[0].x,bounds[0].x));
}
 
bool Box::intersect( Ray const &r, float t0, float t1) const {
	float tmin, tmax, tymin, tymax, tzmin, tzmax;
	tmin = (bounds[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tmax = (bounds[1-r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tymin = (bounds[r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	tymax = (bounds[1-r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	if ( (tmin > tymax) || (tymin > tmax) )
		return false;
	if (tymin > tmin)
		tmin = tymin;
	if (tymax < tmax)
		tmax = tymax;
	tzmin = (bounds[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	tzmax = (bounds[1-r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	if ( (tmin > tzmax) || (tzmin > tmax) )
		return false;
	if (tzmin > tmin)
		tmin = tzmin;
	if (tzmax < tmax)
		tmax = tzmax;
	return ( (tmin < t1) && (tmax > t0) );
}

Code:

1
2
3
4
5
6
7
8
9
10
class Box {
public:
	Box();
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(Ray const &r, float t0, float t1) const;
	void expand(Box box);
 
protected :
	Vec3f bounds[2];
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main(int argc, char **argv)
{
	Vec3f mini(1,1,1);
	Vec3f maxi(2,2,2);
	Box b(mini,maxi);
	Vec3f o(1.5,1.5,0);
	Vec3f d(0,0,1);
	Ray r(o,d);
	if(b.intersect(r,0,4))
		cout << "interstion ok"<< endl;
	else
		cout << "nok" <<endl;

	system("pause");
	return 0;
}

l'erreur se trouve au niveau du "r" souligné

20/08/2015, 13h16
ternel

Pour la deuxième erreur, c'est qu'on ne peut pas fournir une valeur temporaire à une référence modifiante (Ray&).

Pour la première, c'est probablement lié à une interférence entre plusieurs noms "Ray".
Vérifie les namespace et autre.
Vérifie aussi que ce ne soit pas un include manquant (si c'est ca, ton compilateur n'est pas poli)

Hum...

En ajoutant les classes Vec3f et Ray ça compile sans problème. A quoi elles ressemblent ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct Vec3f {
	float x, y, z;
 
	Vec3f() { }
	Vec3f(float, float, float) { }
};
 
struct Ray {
	Ray(Vec3f const&, Vec3f const&) { }
 
	int sign[42];
	Vec3f origin;
	Vec3f inv_direction;
};

Code:

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <iostream>
#include <algorithm>
 
using std::cout;
using std::endl;
 
struct Vec3f {
	float x, y, z;
 
	Vec3f() { }
	Vec3f(float, float, float) { }
};
 
struct Ray {
	Ray(Vec3f const&, Vec3f const&) { }
 
	int sign[42];
	Vec3f origin;
	Vec3f inv_direction;
};
 
class Box {
public:
	Box();
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(Ray const &r, float t0, float t1) const;
	void expand(Box box);
 
protected:
	Vec3f bounds[2];
};
 
Box::Box(const Vec3f &mini, const Vec3f &maxi) {
	bounds[0] = mini;
	bounds[1] = maxi;
}
 
void Box::expand(Box box) {
	bounds[0] = Vec3f(std::min(box.bounds[0].x, bounds[0].x), std::min(box.bounds[0].x, bounds[0].x), std::min(box.bounds[0].x, bounds[0].x));
	bounds[1] = Vec3f(std::max(box.bounds[0].x, bounds[0].x), std::max(box.bounds[0].x, bounds[0].x), std::max(box.bounds[0].x, bounds[0].x));
}
 
bool Box::intersect(Ray const &r, float t0, float t1) const {
	float tmin, tmax, tymin, tymax, tzmin, tzmax;
	tmin = (bounds[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tmax = (bounds[1 - r.sign[0]].x - r.origin.x) * r.inv_direction.x;
	tymin = (bounds[r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	tymax = (bounds[1 - r.sign[1]].y - r.origin.y) * r.inv_direction.y;
	if ((tmin > tymax) || (tymin > tmax))
		return false;
	if (tymin > tmin)
		tmin = tymin;
	if (tymax < tmax)
		tmax = tymax;
	tzmin = (bounds[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	tzmax = (bounds[1 - r.sign[2]].z - r.origin.z) * r.inv_direction.z;
	if ((tmin > tzmax) || (tzmin > tmax))
		return false;
	if (tzmin > tmin)
		tmin = tzmin;
	if (tzmax < tmax)
		tmax = tzmax;
	return ((tmin < t1) && (tmax > t0));
	return false;
}
 
int main(int argc, char **argv)
{
	Vec3f mini(1, 1, 1);
	Vec3f maxi(2, 2, 2);
	Box b(mini, maxi);
	Vec3f o(1.5, 1.5, 0);
	Vec3f d(0, 0, 1);
	Ray r(o, d);
	if (b.intersect(r, 0, 4))
		cout << "interstion ok" << endl;
	else
		cout << "nok" << endl;
 
	system("pause");
	return 0;
}

20/08/2015, 14h07
romainprogdebutant

Citation:

Pour la première, c'est probablement lié à une interférence entre plusieurs noms "Ray".
Vérifie les namespace et autre.

Je pense que c'est la cause en effet, le problème c'est que j'ai plusieurs classe qui s'incluent les unes les autres parfois oui parfois non du coup j'ai mis des
#ifndef EX
#define EX
#include "exemple.h"
#endif

à chaque fois mais ça ne fonctionne, toujours pas c'est quoi la bonne méthode du coup svp ?
20/08/2015, 14h49
ternel

mettre le define dans le .h

utiliser des namespace et ne pas (trop) utiliser using namespace

C'est ce que j'ai fait je vous met mes fichiers parceque là je m'en sors pas, le compilo me met des erreurs à cotés de la plaque
geometry.h

Code:

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <cmath>
#include <stdint.h>
 
template<typename T>
class Vec3
{
public:
    Vec3() : x(T(0)), y(T(0)), z(T(0)) {}
    Vec3(T xx) : x(xx), y(xx), z(xx) {}
    Vec3(T xx, T yy, T zz) : x(xx), y(yy), z(zz) {}
    Vec3 operator + (const Vec3 &v) const
    { return Vec3(x + v.x, y + v.y, z + v.z); }
    Vec3 operator - (const Vec3 &v) const
    { return Vec3(x - v.x, y - v.y, z - v.z); }
    Vec3 operator - () const
    { return Vec3(-x, -y, -z); }
    Vec3 operator * (const T &r) const
    { return Vec3(x * r, y * r, z * r); }
    Vec3 operator * (const Vec3 &v) const
    { return Vec3(x * v.x, y * v.y, z * v.z); }
    T dotProduct(const Vec3<T> &v) const
    { return x * v.x + y * v.y + z * v.z; }
    Vec3& operator /= (const T &r)
    { x /= r, y /= r, z /= r; return *this; }
    Vec3& operator *= (const T &r)
    { x *= r, y *= r, z *= r; return *this; }
    Vec3 crossProduct(const Vec3<T> &v) const
    { return Vec3<T>(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x); }
    T norm() const
    { return x * x + y * y + z * z; }
    T length() const
    { return sqrt(norm()); }
	bool operator < (const Vec3<T> &v)
	{ return x<v.x && y<v.y && z<v.z ;}
    const T& operator [] (uint8_t i) const { return (&x)[i]; }
    T& operator [] (uint8_t i) { return (&x)[i]; }
    Vec3& normalize()
    {
        T n = norm();
        if (n > 0) {
            T factor = 1 / sqrt(n);
            x *= factor, y *= factor, z *= factor;
        }
 
        return *this;
    }  
    T x, y, z;
};
typedef Vec3<float> Vec3f;
typedef Vec3<int> Vec3i;

triangle.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <vector>
#ifndef BOX
#define Box
#include "box.h"
#endif
 
class Triangle{
public:
 
	Triangle(){
		p0 = 0;
		p1 = 0;
		p2 = 0;
	}
 
	Triangle(Vec3i indices, const std::vector<Vec3f> &vertexList);
	Box getBoundingBox();
 
	Vec3f *p0,*p1,*p2:
};

triangle.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "triangle.h"
#include "box.h"
 
Box Triangle::getBoundingBox(){	
		*p0=0;
		Vec3f boxMin(std::min(p0->x,std::min(p1->x,p2->x)),std::min(p0->y,std::min(p1->y,p2->y)),std::min(p0->z,std::min(p1->z,p2->z)));
		Vec3f boxMax(std::max(p0->x,std::max(p1->x,p2->x)),std::max(p0->y,std::max(p1->y,p2->y)),std::max(p0->z,std::max(p1->z,p2->z)));
		return Box(boxMin,boxMax);
	}
Triangle::Triangle(Vec3i indices, const std::vector<Vec3f> &vertexList){
		p0 = vertexList[indices.x];
		p1 = vertexList[indices.y];
		p2 = vertexList[indices.z];
	}

ray.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#ifndef GEO
#define GEO
#include "geometry.h"
#endif
 
class Ray {
public:
	Ray(Vec3f &o, Vec3f &d) {
		origin = o;
		direction = d;
		inv_direction = Vec3f(1/d.x, 1/d.y, 1/d.z);
		sign[0] = (inv_direction.x < 0);
		sign[1] = (inv_direction.y < 0);
		sign[2] = (inv_direction.z < 0);
	}
	Vec3f origin;
	Vec3f direction;
	Vec3f inv_direction;
	int sign[3];
};

box.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef RAY
#define RAY
#include "ray.h"
#endif
 
class Box {
public:
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(const Ray &r, float t0, float t1) const;
	void expand(Box box);
 
protected :
	Vec3f bounds[2];
};

box.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef RAY
#define RAY
#include "ray.h"
#endif
 
class Box {
public:
	Box(const Vec3f &mini, const Vec3f &maxi);
	bool intersect(const Ray &r, float t0, float t1) const;
	void expand(Box box);
 
protected :
	Vec3f bounds[2];
};

main

Code:

1
2
3
4
5
6
7
8
#include <windows.h>
 
int main(int argc, char **argv)
{
 
	system("pause");
	return 0;
}

Bonjour,

Je comprends que le compilateur soit perdu, c'est un peu le chaos avec ces #ifndef sauvages.

Pour éviter les ennuis, vaut mieux respecter l'organisation définie dans la FAQ :
http://cpp.developpez.com/faq/cpp/?p...un-fichier-cpp

En gros :

Dans Truc.h, entourer le code "d'include guard" pour éviter les pb d'inclusions multiples :
Code:

1 2 3 4 5 6 7 8 #ifndef IDENTIFIANT_TRUC #define IDENTIFIANT_TRUC // le code ... #endif
Truc.cpp
Code:

1 2 3 4 5 #include "Truc.h" // le code // ...
Puis pour régler les problèmes d'inter-inclusion entre classes, il faut utiliser les déclarations anticipées (forward declaration)
Un résumé ici :

http://stackoverflow.com/questions/5...rd-declaration

Un example, dans ta classe Triangle.h, tu peux faire une déclaration anticipée de Box, pas besoin d'inclure Box.h (Par contre il faudra faire un #include "Box.h" dans Triangle.cpp)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #include <vector> class Box; // declaration anticipée class Triangle{ public: Triangle(){ p0 = 0; p1 = 0; p2 = 0; } Triangle(Vec3i indices, const std::vector<Vec3f> &vertexList); Box getBoundingBox(); Vec3f *p0,*p1,*p2: };

la bonne manière de faire une "include guard" c'est dans le fichier inclus, pas dans l'inclueur
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #ifndef RAY_H_INCLUDED #define RAY_H_INCLUDED #include "geometry.h" struct Ray { Ray(Vec3f const& o, Vec3f const& d) : origin(o), direction(d), inv_direction(1/d.x, 1/d.y, 1/d.z) { sign[0] = (inv_direction.x < 0); sign[1] = (inv_direction.y < 0); sign[2] = (inv_direction.z < 0); } Vec3f origin; Vec3f direction; Vec3f inv_direction; int sign[3]; }; #endif
J'en profite opur améliorer ton constructeur: utilisation de la liste d'initialisation, et des références constantes.

Fais de même avec tous tes .h, et le problème devrait se résoudre de lui même.

20/08/2015, 15h54
Médinoc

Citation:

Envoyé par Arzar

Un example, dans ta classe Triangle.h, tu peux faire une déclaration anticipée de Box, pas besoin d'inclure Box.h (Par contre il faudra faire un #include "Box.h" dans Triangle.cpp)

Je ne crois pas que ça marche dans cet exemple, un objet de la classe Box étant retourné par valeur par une des fonctions membres.
20/08/2015, 16h04
romainprogdebutant

Merci ça marche :ptdr: