C++

[STL] fonction de comparaison et algos

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : [STL] fonction de comparaison et algos

farib

je recontre un léger probleme à la compilation, qui ne me parait pas
logique (evidemment)

je définit quelques structures de données:

Code :

class point {
public:
point(){};
point(int nx,int ny) { x=nx; y=ny;}
int x;
int y;
};
typedef enum { far_, trial_, alive_ } point_type_t;
class properties {
public:
double potential;
double action;
point_type_t type;
};

je définis par ailleurs une classe fast_marching qui contient entre autres

Code :

class fast_marching{
public:
bool comp_function(point p1, point p2)
{ return grid[p2.x+p2.y*size_x].action < grid[p1.x+p1.y*size_x].action; }
private:
properties* grid ;
vector<point> trial_heap;
};

dans une des méthodes, je veux créer mon tas

Code :

void fast_marching::foo()
{
make_heap(trial_heap.begin(),trial_heap.end(),comp_function);
}

l'erreur du compilateur concerne l'argument "comp_function" dans le make heap et est la
suivante

cannot convert parameter 3 from 'bool (class point,class point)' to 'bool (__thiscall *)(class point,class point)'

compilo VC++ 6.0, testerai sous gcc ce soir.

il me semble pourtant avoir défini la fonction de comparaison de la
même manière que la doc le fait.

Avez-vous une idée sur la question ?

Message édité par farib le 07-06-2005 à 16:29:47

---------------
Bitcoin, Magical Thinking, and Political Ideology

Publicité

farib

hum, solution 'partielle' au probleme, declarer la fonction static, mais du coup, la comparaison n'a plus le droit d'acceder aux membres... et n'est donc plus utile... Taz, if tu passes par la...

---------------
Bitcoin, Magical Thinking, and Political Ideology

nathan_g

Je me rappele de problèmes similaires, sous linux et gcc, rencontrés également lorsque je cherchais à passer une méthode en argument d'une autre méthode. J'avais adoptée la solution donnée ici par farib, en passant la méthode en static.

Une solution (très très très sale) que j'avais du adoptée (mais c'était sans doute un cas plus simple) était de passer également grid en argument static ! Dans ce cas, ça doit compiler.

Ainsi, avant chaque appel à make_heap, il te faudrait également t'arranger pour que l'argument static grid prenne la valeur souhaitée (et peut être le changer alors très souvent dans ton code !).

nathan_g

l'argument => le membre private

voulais-je dire !

farib

bon, en fait je pense que je n'avais pas le choix, et j'ai gruike :

Code :

class properties {
public:
double potential;
double action;
point_type_t type;
};
class point {
public:
point(){};
point(int nx,int ny,properties* p ) { x=nx; y=ny;prop=p;}
int x;
int y;
properties* prop; //pointeur direct vers la case du tableau
};
bool comp_function(point p1,point p2)
{
return p2.prop->action < p1.prop->action;
}

il s'agissait d'avoir un tas qui contienne une comme donnees des coordonnes de points, et construise le tas en fonction du potentiel f(x,y) du point. la je gruike, je fais pointer sur ce potentiel.

---------------
Bitcoin, Magical Thinking, and Political Ideology

Taz

bisounours-codeur

rhoo le massacre
/me fuit

farib

vazy, explique le massacre.

---------------
Bitcoin, Magical Thinking, and Political Ideology

Taz

bisounours-codeur

Code :

#include <vector>
#include <algorithm>
namespace Farib
{
struct Point
{
enum Type
{
Far,
Trial,
Alive
};
int x;
int y;
Point(int nx, int ny)
: x(nx), y(ny)
{ }
Point()
{ }
};
struct Properties
{
double potential;
double action;
Point::Type type;
};
class FastMarching
{
std::vector<Properties> grid;
std::vector<Point> trial_heap;
size_t size_x;
public:
bool operator()(const Point& p1, const Point& p2) const
{
const double p1action = this->grid[p1.x+p1.y*this->size_x].action;
const double p2action = this->grid[p2.x+p2.y*this->size_x].action;
return p1action < p2action;
}
void foo()
{
std::make_heap(this->trial_heap.begin(), this->trial_heap.end(),
*this);
}
};
}
int main()
{
Farib::FastMarching fm;
fm.foo();
}

par exemple

farib

t'es trop fort :sweat:

je te cache pas que j'avais utilisée ma solution *gruik* comme précisé, parce que je n'avais la propre.

---------------
Bitcoin, Magical Thinking, and Political Ideology

Taz

bisounours-codeur

Plus généralement, tu peux utiliser une classe pour t'aider. Si tu ne veux pas exposer ton operator() ou bien si tu dois utiliser plusieurs stratégies

Code :

class FastMarching
{
std::vector<Properties> grid;
std::vector<Point> trial_heap;
size_t size_x;
struct Comparator
{
FastMarching *fm;
Comparator(FastMarching *ffm)
: fm(ffm)
{ }
bool operator()(const Point& p1, const Point& p2) const
{
const double p1action = this->fm->grid[p1.x+p1.y*this->fm->size_x].action;
const double p2action = this->fm->grid[p2.x+p2.y*this->fm->size_x].action;
return p1action < p2action;
}
};
public:
void foo()
{
std::make_heap(this->trial_heap.begin(), this->trial_heap.end(),
Comparator(this));
}
};

Publicité

Taz

bisounours-codeur

fm peut être const d'ailleurs. Tu peux aussi utiliser une référence

Taz

bisounours-codeur

tu ferais bien de regarder les multi_array de boost : c'st vachement bien foutu et implémenté

farib

tant que je suis à me cultiver:
le namespace, c'est pour encapsuler et que ce soit plus propre ?
le struc au lieu de class, c'est parce que class est pas nécessaire ?
l'utilisation de this souvent, c'est pour éviter les ambiguités de résolutions ?

---------------
Bitcoin, Magical Thinking, and Political Ideology

Taz

bisounours-codeur

1) pour éviter les collisions de noms. En C y a pas de namespace, donc on préfixe : genre gtk_label_new, gtk_box_pack_start
2) struct c'est comme classe sauf que la visibilité des membres est public et que le mode d'héritage par défaut est public.
3) oui, prend l'habitude.

farib

en résolvant tranquillement mes gruikeries dans l'ordre:

reprenons le premier post:
comment faire compiler ça ?

finalement; c'est pas tant différent de ce que tu proposais, seulement j'ai gruiké parce que je n'arrivais pas à faire avaler ça au compilo

Message édité par farib le 20-06-2005 à 10:41:01

---------------
Bitcoin, Magical Thinking, and Political Ideology

Taz

bisounours-codeur

ben si c'est différent. Comme tu avais pas saisi le concept d'objet fonction, tu mémoriser dans chaque point un pointeur vers FastMarching.

Le mieux, c'est la solution avec le comparateur. Comme ça tu n'a pas à exposer FastMarching::operator()

farib

en fait, la fonction de comparation, si elle n'est pas statique, doit OBLIGATOIREMENT être un operator() d'une classe ?

---------------
Bitcoin, Magical Thinking, and Political Ideology

farib

eupe : pourquoi le code proposé dans le premier post compile pas ?

---------------
Bitcoin, Magical Thinking, and Political Ideology

Taz

bisounours-codeur

farib a écrit :

en fait, la fonction de comparation, si elle n'est pas statique, doit OBLIGATOIREMENT être un operator() d'une classe ?

non. Elle doit être du type template spécifié en paramètre, tel que T t = T(); t(a, b); soit valide

farib

mais c'est pas logique la raison pour laquelle il me refuse de compiler

quand comp_function est déclarée dans la classe, ça veut pas compiler, quand ça l'est en dehors, ça passe.

---------------
Bitcoin, Magical Thinking, and Political Ideology

Taz

bisounours-codeur

ben TaClasse::comp_function(a, b) n'est pas valide.

Publicité

FORUM HardWare.fr

Programmation

C++

[STL] fonction de comparaison et algos

Sujets relatifs
fonction eregi php	[ActionScript] fonction de temporisation
Appel de fonction avec les touches directionnelles	Parametrer la fonction mail sous Debian
fonction d'instalation de plugin de recherche	Dérivation d'une fonction en python
Fonction indefinie [regler] probleme de recup d'emplacement	stocker le résultat d'une fonction javascript dans une var php
[vba]cherche fonction equivalente de Access 97 --> 2003	[PHP] probleme avec la fonction sleep()
Plus de sujets relatifs à : [STL] fonction de comparaison et algos

Page générée en 0.090 secondes