Discussion :

[koala01]

Si je ne m'abuse, points.end() donne un pointeur vers le dernier élément de la map, et donc ->first la valeur de la première clé.
Par conséquent, le dernier élément, c'est celui qui a été mis dans la map avec le plus grand increment, et la valeur de cette clé, c'est increment.

Eh, non... end est un itérateur qui donne sur... ce qui suit le dernier élément de la collection...

Begin() pointe bel et bien, quant à lui, sur le premier élément, mais, si tu arrives sur end(), c'est que tu as passé le dernier élément
(c'est la raison pour laquelle une boucle se fera sur for(it = collection.begn(); it!=collection.end();++it) )

Tu peux, pour certains type de collections, accéder aux éléments en "ordre inverse" (du dernier au premier) avec des "revert_iterator" grace aux fonctions rbegin() et rend()

[Gm7468]

Ah oui effectivement, ca m'a échappé.
Pourtant je le savais, comme pour l'exemple des boucles, mais heureusement que tu es là
Donc finalement, je peux conserver mon système, mais en utilisant rbegin(), le premier en partant de la fin, donc bien le dernier?

Mais comment cela se fait alors qu'il me renvoyait des valeurs correspondant au nombre d'éléments - 1, le hasard?

[koala01]

Ah oui effectivement, ca m'a échappé.
Pour tant je le savais, comme pour l'exemple des boucles, mais heureusement que tu es là
Donc finalement, je peux conserver mon système, mais en utilisant rbegin(), le premier en partant de la fin, donc bien le dernier?

Mais comment cela se fait alors qu'il me renvoyait des valeurs correspondant au nombre d'éléments - 1, le hasard?

Oui, il y a de fortes chances...

Voir, en fonction de l'implémentation de ta version de la STL, "qui sait", peut etre le nombre d'élément maintenus dans la map, vas savoir

Mais, ceci dit, si tu introduit les clés 2, 6 et 1 (quelle que soit l'ordre dans laquelle tu la met), il y a de fortes chances qu'elles soient stockées sous une forme proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
   2
  / \
 1   6

parce que le principe d'une map est le stockage sous la forme d'un arbre binaire (une petite recherche sur RBTree t'en apprendra sans doute d'avantage).

En gros, c'est une structure de donnée qui permet un acces systématique en O= log(n) (principe dit "dichotomique" )

C'est la manière dont l'arbre binaire est parcouru (on parle de parcours "infixe" : on parcourt d'abord le coté gauche de l'arbre, puis l'élément, puis son coté droit, et cela de manière récursive) qui va permettre d'obtenir les éléments classé dans leur ordre de grandeur réel

[Gm7468]

Très intéressantes ces histoires d'arbres
L'arbre binaire semble tout indiqué pour les maps, ou du moins, dans l'autre sens, vu les utilisations conseillées pour les maps, cela correspond bien aux avantages de ce type d'arbres.

Je me permets de revenir à une question que j'avais posée il y a quelques temps, mais qui n'avait pas trouvée de réponse.

Encore une fois celle-ci

Le problème n'est pas bloquant à proprement parler, car j'ai pu continuer à développer malgré cela, en commentant ce qui posait problème, mais cela ôte une fonctionnalité importante qui doit forcément être implémentée. La résolution de ce point est donc primordial.
Je pense encore une fois qu'il y a une solution au problème, mais que mon manque d'expérience en C++ m'empêche d'en avoir connaissance, c'est pourquoi vous pourrez, j'en suis sur, m'aider à débloquer ce point.

Pour rappel:

J'ai:
- une classe d'objet: Objet (.hpp et .cpp)
- une structure: Structure (.hpp)
- un namespace pour diverses actions: Namespace (.hpp et .cpp)

La structure Structure a une variable membre de type Objet et le namespace Namespace a des fonctions qui utilisent la structure Structure. Les problèmes de déclarations anticipées, etc... ont été réglés -grâce à vous-, et le tout fonctionne correctement ensemble.

Voici un résumé des fichiers .hpp de ces trois entités:

Structure.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "Objet.hpp"
 
namespace Structure {
struct Variables {
    (...)
    Objet objet;
    (...)
 
    //constructeur de la structure, avec initialisation de certaines variables
    Variables()
    {
        (...)
    }
};
} //namespace Structure

Objet.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
#include "Namespace.hpp"
 
/*déclaration anticipée*/
namespace Structure{
    struct Variables;
}
 
class Objet : public Objetparent
{
    (...) //des fonctions, des slots, des signaux, des variables membres...
};

Namespace.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#include "Structure.hpp"
 
namespace General {
 
    namespace Transversaux {
 
        //fonction que je souhaite appeler dans Objet
        void fonction(Structure::Variables & datas, ...);
 
    } //namespace Transversaux
 
} //namespace General

A partir de cela, je voudrais utiliser la fonction fonction de Namespace, qui attend en argument une référence vers un objet Structure, à l'intérieur même d'une fonction de Objet.
En somme, je voudrais, dans Objet, avoir une fonction du type:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void fonctionObjet(Structure::Variables & datas){
     General::Transversaux::fonction(datas);
}

Mon problème est que, dans Objet, je n'ai pour le moment pas moyen d'accéder à cette référence sur Structure.
Comment procéder, pour que dans Objet je puisse disposer de cette variable, à savoir une référence vers la structure de données, qui elle-même contient l'objet?

J'avais pensé doter les objets Objet d'une variable membre contenant une référence (ou un pointeur?) vers la structure qui le contient. Seulement, je n'ai pas réussi à renseigner cette variable lors de la construction de la structure (et donc de l'objet qui est membre de la structure vers laquelle il doit avoir une référence).

Est-ce que cela est possible?
Y a-t-il une autre/meilleure solution?

[Gm7468]

Aucune réponse?
Pas même une idée, une suggestion?

Est-ce que mon problème est mal exposé?
Est-ce que ce que je cherche à faire n'est pas conseillé/pertinent/possible?

Pour aller plus loin dans la présentation du problème, voici ce que j'ai essayé de faire, c'est ce qui me semble le plus "correct", mais ca ne fonctionne tout de même pas:
Structure.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "Objet.hpp"
 
namespace Structure {
struct Variables {
    (...)
    Objet objet;
    (...)
 
    //constructeur de la structure, avec initialisation de certaines variables
    Variables()
    {
        (...)
        objet = new Objet(*this);
    }
};
} //namespace Structure

Objet.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "Namespace.hpp"
 
/*déclaration anticipée*/
namespace Structure{
    struct Variables;
}
 
class Objet : public Objetparent
{
public:
    Objet(); //constructeur par défaut
    Objet(Structure::Variables & datas);
    (...)
 
private:
    (...)
    Structure::Variables & donnees;
 
};

Objet.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "Objet.hpp"
#include "Structure.hpp"
 
Objet::Objet() : Objetparent()
{
    /*actions d'initialisation de certaines variables membres
            (pas de donnees)*/
}
 
Objet::Objet(Structure::Variables & datas) : Objetparent(), donnees(datas)
{
    /*mêmes actions d'initialisation de certaines variables membres
            (pas de donnees)*/
}

et avec cela, à la compilation, j'obtiens l'erreur:
(dans Structure.hpp à la ligne du new)
erreur : no match for 'operator=' in '((Structure::Variables*)this)->Structure::Variables::objet= (operator new(136u), (<statement>, ((Objet*)<anonymous>)))'
candidates are: Objet& Objet::operator=(const Objet&)

Plus d'idées?

[Gm7468]

Aucune proposition?
Aucune suggestion?
Pas d'idée?

Tout commentaire est le bienvenu pour faire avancer les choses

[valAa]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "Objet.hpp"
 
namespace Structure {
struct Variables {
    (...)
    Objet objet;
    (...)
 
    //constructeur de la structure, avec initialisation de certaines variables
    Variables()
    {
        (...)
        objet = new Objet(*this);
    }
};
} //namespace Structure

Ici tu essaye d'allouer dynamiquement (sur le tas) alors que `objet` n'est pas un pointeur, d'où l'erreur de compilation.

L'initialisation peut se faire tout simplement sur la pile dans la liste d'intialisation du constructeur de ta structure.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "Objet.hpp"
 
namespace Structure {
struct Variables {
    (...)
    Objet objet;
    (...)
 
    //constructeur de la structure, avec initialisation de certaines variables
    Variables() : objet(*this)
    {
        (...)
    }
};
} //namespace Structure

[Gm7468]

D'accord d'accord, tout simplement, effectivement.
J'avais un doute sur le *this, qui renvoie un objet de type structure (c'est bien ca?), alors que mon objet Objet attend une référence vers ce type d'objet...

J'ai fait les modifications, et il n'y plus de problème à ce niveau, mais à un autre, qui découle en réalité des modifications.
J'ai donc:
Structure.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include "Objet.hpp"
 
namespace Structure {
struct Variables {
    (...)
    Objet objet;
    (...)
 
    //constructeur de la structure, avec initialisation de certaines variables
    Variables() : objet(*this)
    {
        (...)
    }
};
} //namespace Structure

Objet.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include "Objet.hpp"
#include "Structure.hpp"
 
Objet::Objet() : Objetparent()
{
    /*actions d'initialisation de certaines variables membres
            (pas de donnees)*/
}
 
Objet::Objet(Structure::Variables & datas) : Objetparent(), donnees(datas)
{
    /*mêmes actions d'initialisation de certaines variables membres
            (pas de donnees)*/
}

Et à la compilation j'obtiens l'erreur:
In constructor 'Objet::Objet()': erreur : uninitialized reference member 'Objet::donnees'

Effectivement, dans le constructeur par défaut (utilisé lors de la déclaration du membre objet de type Objet dans Structure), je ne donne pas de valeur par défaut à ce membre de Objet.
Mais que puis-je donner par défaut?
J'ai essayé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Objet::Objet() : Objetparent(), donnees(0)
{
}

Pour que la référence vers la structure, par défaut, "pointe" vers la case mémoire 0, mais le compilateur me renvoie une erreur, encore une fois logique, puisque je lui dis d'initialiser une référence vers structure avec un entier...

Ou bien est-ce que passer justement par un pointeur vers la structure, à la place d'une référence vers la structure, serait plus judicieux?

Et à ce moment là, dans les fonctions de Namespace qui nécessitent une référence vers Structure utilisées dans Objet (je rappelle que c'était le but du problème ), du type:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void fonction(Structure::Variables & datas, ...);

Il suffira que je passe *donnees? (donnees: pointeur vers Structure, donc *donnees la structure, passée comme référence dans la fonction, c'est bien cela?)

[Gm7468]

En attendant la réponse à

cela,

voici une nouvelle petite question de détail.

Je ne vais pas mettre tout le code de la classe et du namespace où j'utilise cela, à moins que vous ne me le demandiez, mais je pense que ce qui suit suffira. Quelque part dans mon code, je fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
for(std::vector<Objet*>::iterator iterateurPoints = variable.begin(); iterateurPoints != variable.end(); iterateurPoints++)
    {
        Objet* point;
        point = *iterateurPoints;
 
        if(point->getTypePoint() == "test")
        {
            //...
        }else{
            //...
        }
    }

Pour cela, pas de problème... variable étant bien entendu de type std::vector<Objet*>. La classe Objet dispose de la méthode getTypePoint(). Par conséquent, quand j'ai un pointeur vers un objet Objet, je fais ->getTypePoint(). Pour avoir ce pointeur vers cet Objet, comme j'ai justement un vector qui en contient, je fais Objet* point; point = *iterateurPoints;, iterateurPoints étant l'itérateur sur le vector d'Objet*. Ce fonctionnement un peu compliqué fonctionne.
Mais mon problème, c'est que j'en suis venu à cela, car la simplicité ne fonctionnait pas. J'ai commencé par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
for(std::vector<Objet*>::iterator iterateurPoints = variable.begin(); iterateurPoints != variable.end(); iterateurPoints++)
    {
        if(*iterateurPoints->getTypePoint() == "test")
        {
            //...
        }else{
            //...
        }
    }

Mais le compilateur me renvoie:
erreur : request for member 'getTypePoint' in '* iterateurPoints.__gnu_cxx::__normal_iterator<_Iterator, _Container>::operator-> [with _Iterator = Objet**, _Container = std::vector<Objet*, std::allocator<Objet*> >]()', which is of non-class type 'Objet*'

Comment se fait-il alors que la première solution fonctionne et pas celle-ci?

[cob59]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(*iterateurPoints)->getTypePoint()

En réponse au #108, en effet, il est impossible de créer une référence nulle en C++.
De plus, il est impossible de changer une référence en cours de route (via un setData() par exemple). Donc soit tu utilises un pointeur nu (Variables* ou Variables* const ou const Variables*) soit tu utilises un std::shared_ptr<Variables> ce qui, dans certains cas, peut être plus indiqué.

[Gm7468]

Héhé, que de subtilités
Merci!
On (enfin... personnellement ^^, donc je) pense effectivement plus facilement aux priorités des opérations mathématiques, par habitude, qu'à celles des autres opérateurs.
Et c'est bon à savoir:
l'opérateur -> est prioritaire par rapport au déréférencement *


Il ne reste donc plus que:

cela

[Gm7468]

En réponse au #108, en effet, il est impossible de créer une référence nulle en C++.
De plus, il est impossible de changer une référence en cours de route (via un setData() par exemple). Donc soit tu utilises un pointeur nu (Variables* ou Variables* const ou const Variables*) soit tu utilises un std::shared_ptr<Variables> ce qui, dans certains cas, peut être plus indiqué.

Je t'aurais bien mis 2 votes positifs d'un coup, pour les 2 réponses pertinentes en un seul post, mais je ne peux pas, alors simplement, merci

D'accord, je pense donc utiliser un pointeur, je commence à plus ou moins avoir l'habitude ^^
Et donc, avec un pointeur, si j'ai une fonction qui demande une référence vers un objet de type Objet, et que j'ai un pointeur ptr vers un type Objet, il suffit de donner *ptr en arguent, c'est bien cela?

[Gm7468]

Le tout a l'air de fonctionner

Merci pour ces réponses

à bientôt pour de nouvelles ^^

[Gm7468]

Bonjour,
Ça faisait longtemps que je n'avais pas posé une petite question

Cette fois c'en est une vraiment spécifique, donc s'il faut plutôt créer un sujet à part entière, dites-le moi.

J'utilise dans mon programme des matrices, avec des inversions. Comme j'avais choisis BOOST pour les matrices, qui fait tout ce que je veux, j'ai conservé ce système pour le fonctionnement, y compris les matrices, et toute la documentation trouvée aussi bien sur les forums et sur BOOST m'a envoyé ici.
Soit. J'utilise donc InvertMatrix pour mes inversions.

je ne comprends pas la ligne:

// REMEMBER to update "lu.hpp" header includes from boost-CVS

Pour utiliser cette fonction InvertMatrix, il faut que je bidouille le lu de BOOST?

Cette fonction me renvoie de bonnes choses à certains endroits, et fait complètement planter l'application à d'autres... Mais je ne comprends pas pourquoi.

Par exemple, pour la matrice:

0.127213 -0.00600185 -0.000149287 0.587534
-0.00600185 0.00553831 -0.00593579 -0.0335789
-0.000149287 -0.00593579 0.0298501 0
0.587534 -0.0335789 0 3

La fonction me renvoie:

82.8377 -11.3315 -1.83901 -16.3502
-11.3315 252.673 50.1882 5.04737
-1.83901 50.1882 43.4716 0.921916
-16.3502 5.04737 0.921916 3.59192

Par contre, Excel me donne:

82.8339694 -11.33084355 -1.83890416 -16.34941688
-11.33084355 252.6730142 50.18818708 5.047245904
-1.83890416 50.18818708 43.47161365 0.921894277
-16.34941688 5.047245904 0.921894277 3.591773088

Ce qui fait une différence de:

0.003730597 -0.000656448 -0.00010584 -0.000783119
-0.000656448 -1.41645E-05 1.29217E-05 0.000124096
-0.00010584 1.29217E-05 -1.36459E-05 2.17228E-05
-0.000783119 0.000124096 2.17228E-05 0.000146912

Bon, au moins l'inversion fonctionne.
mais d'où peut venir la différence? Mes matrices sont en double, ce qui devrait être suffisant pour conserver la précision... non? Faudrait-il que je passe en long double? Y a-t-il plus grand encore? ^^

Cependant, pour la matrice:

29.1694 145.914 2.9161 0.0291432
145.914 729.909 14.5872 0.145783
2.9161 14.5872 0.291527 0.00291348
0.0291432 0.145783 0.00291348 2.91E-05

Le programme bug et renvoie:
Check failed in file c:\qtsdk\mingw\bin\../lib/gcc/mingw32/4.4.0/../../../../include/boost/numeric/ublas/lu.hpp at line 299:
detail::expression_type_check (prod (triangular_adaptor<const_matrix_type, upper> (m), e), cm2)
terminate called after throwing an instance of 'boost::numeric::ublas::internal_logic'
what(): internal logic
...c'est-à-dire au niveau du lu_substitute de InvertMatrix...

Une idée sur le problème?

Excel me renvoie:

29583.05966 -1036.301438 -110716.8234 -13342628.25
-1036.301438 263.7012475 -687.1073365 -214312.0502
-110716.8234 -687.1073363 1034457.92 10747589.39
-13342628.25 -214312.0502 10747589.4 13352224310

La matrice est donc bien inversible, par contre, on voit que l'étendue est très importante, +/- 10^10... Mais ce qui devrait largement tenir dans du double...

Encore une idée?


Merci!

[Gm7468]

Des éléments de réponse ici, avec une solution...

Merci