lesgwenos11
Messages postés dimanche 12 octobre 2003Date d'inscription
23 février 2011
Dernière intervention
-
15 févr. 2011 à 00:34 - Dernière réponse : cptpingu3784
Messages postés dimanche 12 décembre 2004Date d'inscription
18 avril 2018
Dernière intervention
- 23 févr. 2011 à 01:06
J'ai un petit problème, je ne sais pas initialiser un pointer de vector(de vector de pointer...).
Je travaille sur un code pour construire une sorte de recursivité semi-dynamique variable , je n'ai pour l'instant pas trouvé de définition plus simple...
Dans la première étape de ma quête mysterieuse, voici ce que j'essaye de faire:
(c'est beaucoup plus simple)
je crée un vector de pointeurs vers des entiers.
Je le remplis avec 4 pointeurs vers quatres entiers.
Puis je souhaiterais simplement créer un autre vector qui contient un pointeur vers le vector crée auparavant...
J'ai entendu dire que c'est pas terrible de faire cela car lorsque l'on change le vector, la reference n'est plus valable, mais pour l'instant je souhaite garder une taille de vector fixe, avant d'explorer d'autre possibilités plus adaptées à mes besoins.
Tout se passe bien jusqu'à l'initialisation du 2ème vector. Et là se pose une multitude de questions... est-ce possible, faut-il allouer de la mémoire 'manuellement', en bref comment initialiser un pointeur de vecteur de pointeur (d'entiers)
#include <cstdlib>
#include
#include <vector>
using namespace std;
int main(int argc, char *argv[])
{
//Step 1
vector myVector2;
int* p1 = new int;
int* p2 = new int;
int* p3 = new int;
int* p4 = new int;
*p1 = 1;
*p2 = 5;
*p3 = 5;
*p4 = 26;
myVector2.push_back(p1);
myVector2.push_back(p2);
myVector2.push_back(p3);
myVector2.push_back(p4);
for (int i = 0; i < 4; i++)
{
cout << *myVector2[i] << "|";
}
cout << endl;
//Step 2
vector <vector*> myVector;
vector* p = new vector;
//*p=myVector2; // ?? Not possible
//p=&myVector2; // !! Only store the address
// ???????? how to initalise the pointer?????
myVector.push_back(p);
// Controls
cout << myVector2.size() << endl;
cout << myVector[0] << endl;
cout << &myVector2 << endl;
cout << p << endl;
system("PAUSE");
return EXIT_SUCCESS;
}
C'est là ou y'a plein de points d'interrogation que je m'interroge...
J'espère que ma question est claire et qu'elle a un sens pour vous
Merci d'avance
(J'utilise Dev C++, environement Windows)
Évite les using namespace std, voir: http://0217021.free.fr/portfolio/axel.berardino/articles/bon-usage-using-namespace
Si tu cherches à faire des vector de vector, deux solutions:
- std::vector<std::vector > évidemment, ou std::vector<std::vector* > (mieux)
- Boost_multi_array
- std::vector<StaticArray >, qui est le plus simple à mettre en place, surtout si tu as une dimension fixe.
Avec StaticArray, une classe que tu crées qui encapsule un vecteur normal:
#include
#include <vector>
template <typename Type, int Size>
class StaticArray
{
public:
StaticArray()
{
}
~StaticArray()
{
}
Type operator[](int i) const
{
// To check: i >= 0 && i < Size
return _tab[i];
}
Type& operator[](int i)
{
// To check: i >= 0 && i < Size
return _tab[i];
}
private:
Type _tab[Size];
};
int main()
{
StaticArray tab1;
for (int i = 0; i < 5; ++i)
{
tab1[i] = i * 5;
std::cout << tab1[i] << std::endl;
}
std::vector<StaticArray*> vect;
vect.push_back(&tab1);
for (int i = 0; i < 5; ++i)
std::cout << (*vect[0])[i] << std::endl;
return 0;
}
________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
Cette réponse vous a-t-elle aidé ?Merci pour votre retour.
N'oubliez pas de prendre quelques secondes pour remercier l'auteur : Merci pour votre retour.
Nous sommes désolés. Notre objectif est de vous donner la meilleure réponse possible.
J'ai un prototype à te proposer. Je n'ai pas la prétention de dire qu'il est parfait, mais il semble répondre à ton besoin.
#include
#include <vector>
#include <cassert>
template <typename T>
class Array
{
typedef typename std::vector*>::const_iterator iter;
public:
Array()
: _hasList(true)
{
}
Array(const Array<T>* array)
: _hasList(true)
{
_list.push_back(array);
}
Array(T value)
: _hasList(false), _value(value)
{
}
~Array()
{
for (iter it = _list.begin(); it != _list.end(); ++it)
delete *it;
}
bool hasList() const
{
return _hasList;
}
T getvalue(int i) const
{
assert(!_hasList);
return _value;
}
void setvalue(T value)
{
assert(!_hasList);
_value = value;
}
void add(Array<T>* list)
{
assert(_hasList);
_list.push_back(list);
}
void add(T value)
{
assert(_hasList);
_list.push_back(new Array<T>(value));
}
Array<T>* getList(int i) const
{
assert(!_hasList);
return _list[i];
}
void show(std::ostream& out) const
{
if (_hasList)
{
out << "<";
bool first = true;
for (iter it = _list.begin(); it != _list.end(); ++it)
{
if (!first)
out << ",";
else
first = false;
(*it)->show(out);
}
out << ">";
}
else
out << _value;
}
private:
const bool _hasList;
std::vector*> _list;
T _value;
};
int main()
{
// <1,<9,3>,5,<0,<2,7,<4,5>,8>>>
Array list;
Array* tab45 = new Array;
tab45->add(4);
tab45->add(5);
Array* tabRight = new Array;
tabRight->add(2);
tabRight->add(7);
tabRight->add(tab45);
tabRight->add(8);
Array* tab2Right = new Array;
tab2Right->add(0);
tab2Right->add(tabRight);
Array* tab93 = new Array;
tab93->add(9);
tab93->add(3);
list.add(1);
list.add(tab93);
list.add(5);
list.add(tab2Right);
list.show(std::cout);
std::cout << std::endl;
return 0;
}
PS: Séparer proprement le code de sa définition.
________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
Cette réponse vous a-t-elle aidé ?Merci pour votre retour.
N'oubliez pas de prendre quelques secondes pour remercier l'auteur : Merci pour votre retour.
Nous sommes désolés. Notre objectif est de vous donner la meilleure réponse possible.
________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
Cette réponse vous a-t-elle aidé ?Merci pour votre retour.
N'oubliez pas de prendre quelques secondes pour remercier l'auteur : Merci pour votre retour.
Nous sommes désolés. Notre objectif est de vous donner la meilleure réponse possible.
lesgwenos11
Messages postés dimanche 12 octobre 2003Date d'inscription
23 février 2011
Dernière intervention -17 févr. 2011 à 00:52
0
Utile
Salut,
Yop!
Et pourquoi pas un vecteur de vecteur?
Code C/C++ :
vector<vector>
Merci Buno pour la suggestion, comme j'explique plus bas, je travaille sur une recursivite, et l'exemple de code en est le niveau 2, niveau 3 serait pointeur de pointeurs de pointeurs...
Évite les using namespace std, voir: sur http://0217021.free.fr/portfolio/axel.berardino/articles/bon-usage-using-namespace
Si tu cherches à faire des vector de vector, deux solutions:
- std::vector<std::vector > évidemment, ou std::vector<std::vector* > (mieux)
- Boost_multi_array
- std::vector<StaticArray >, qui est le plus simple à mettre en place, surtout si tu as une dimension fixe.
Merci CptPingu,
Pour les namespace, Dev C++ le met par defaut et je suis un peu faineant, c'est pour ca que je programme
J'ai accepte ta reponse car elle va me permettre d'avancer.
En fait, il vaut peut-etre mieux que j'explique ce que je souhaite pouvoir coder:
J'ai choisi les vector car il me semble les plus adaptes, mais peut etre que les multi array en effet, ou les list seraient plus apropries.
pour illustrer:
Je souhaite avoir des structures imbriquees du genre:
(exemple)
<1,<2,3>,5,<0,<2,7,<4,5>,8>>>
ou
<,a>>,e,<g,c>,i>
le fait que ce soient des int ou des char, des string ou meme des objets n'est pas la question.
La question est plus de l'ordre de la recursivite.
Pour la simplicite, je choisi les int
En terme de recursivite, alors:
ma structure recursive est la suivante:
element(n) est un element de la structure de niveau n.
element(0) est un entier
element(1) est une structure d'entiers
element(2) est une structure d'entiers OU/ET d'elements(1) OU/ET d'element 2
...
element(i) une structure d'entiers OU/ET d'elements(1) OU/ET d'element 2... OU/ET d'elements (i-1)
Vous m'arretez si je me gourre...
Les 2 seules facons sont:
-soit le metaprogramming pour creer une recursivite reelle (mais je n'y ai jamais mis les pieds... et je prefere eviter)
-soit avoir une etape de creation des differents niveaux d'elements avec sauvegarde des data; et une etape de lecture ou le niveau de recursivite sera connu par un chargement des data juste apres la compilation en utilisant des boucles a parametres.
L'idee en gros est que si l'on affiche une de ces structure, on puisse passer a un niveau de structure superieure si l'on a l'information necessaire pour 'zoomer' sur un des elements de la structure. Exemple:
struture d'integer:
<2,3,4,5> est affichee; je sait decomposer 5 en <2,3>... ma nouvelle structure sera alors:
<2,3,4,<2,3>>; ensuite si je sais que 2 est <1,1> j'aurai <2,3,4,<<1,1>,3>>; ... OK????
Je pense que pour arriver a mes fins, il faut desimbriquer les structures et utiliser des pointeurs, ainsi <2,3,4,<<1,1>,3>> deviendrait avec des pointeurs:
au depart:
*a=2
*b=3
*c=4
*d=5
structure1 est
a la fin:
*a=2
*b=3
*c=4
(*d=5)
*e=1
*f=1
*g=3
*h pointe vers <e,f>
*i pointe vers <h,g>
structure1(new) est
ceci n'est q'un exemple, les combinaisons sont inombrables
Donc ici je demande conseil aux experts, quelle serait le type de structure le plus adapte aux conditions citees plus haut.
Attention, Dev-C++ n'est plus tenu à jour depuis des années ! Le compilateur livré avec est extrêmement vieux.
Pour du C++ sous Windows, je conseille généralement un IDE récent: Visual Studio, Code::Blocks ou QtCreator (qui en plus d'être multi plateforme, permet de faire des interfaces graphiques).
Avant de trouver une solution à ton problème, j'ai quelques questions:
1) Pourquoi cherches-tu à faire cela ?
En effet: <,a>>,e,<g,c>,i> peut tout à fait s'écrire: , non ?
De plus, je ne vois pas l'intérêt d'avoir ce genre de structure. Est-ce que tu n'essaierais pas de trouver une solution à un faux problème ?
2) Pourquoi parles-tu de récursivité ? Structure imbriquée != récursivité.
Pour répondre à ta question:
Les templates ne te conviendront que si tu as des donnés, au final, statiques. Si la structure de ta liste est connue par avance, oui les templates seront un choix élégant à ton problème. Effectivement, maîtriser les templates demande un niveau avancé.
En revanche, si tu la structure de ta liste est variable, ça ne te sera d'aucune utilité.
J'ai une solution technique à te proposer:
Tu fais une classe Array<T>, qui contient un std::vector*> et un std::vector<T>. Tu ajoutes une méthode hasSubList() qui dit si tu dois utiliser l'une ou l'autre liste. La première liste sera évidemment sous la forme: std::vector*>.
________________________________________________________________________
Historique de mes créations, et quelques articles:
[ http://0217021.free.fr/portfolio http://0217021.free.fr/portfolio]
Merci d'utiliser Réponse acceptée si un post répond à votre question
lesgwenos11
Messages postés dimanche 12 octobre 2003Date d'inscription
23 février 2011
Dernière intervention -23 févr. 2011 à 00:27
0
Utile
Merci CptPingu,
Tout d'abord pour repondre a tes questions:
1) Pourquoi cherches-tu à faire cela ?
En effet: <,a>>,e,<g,c>,i> peut tout à fait s'écrire: , non ?
De plus, je ne vois pas l'intérêt d'avoir ce genre de structure. Est-ce que tu n'essaierais pas de trouver une solution à un faux problème ?
Je souhaite faire comme ca pour pouvoir separer plus facilement des donnees.
Je ne veux pas d'une structure plate car sinon il me faudrait travailler beaucoup sur les indices et creer des drapeaux de separations pour avoir mes sous ensembles. En ce qui concerne ce que je cherche a faire...
Une base de donnees a arborescence. Il s'agit de classer des informations simples. Par exemple: chaque element peut etre disseque en sous-elements si l'on possede l'information suffisante:
Exemple simple:
(Terre);
(Europe, Amerique du Nord, Autres Continents);
(Allemagne,Angleterre,France, Autres Pays d'Europe)(Etats-Unis,Mexique,Autres Pays d'Amerique du Nord);
(Bretagre, region Parisiennes, Autres Regions de France);
...
2) Pourquoi parles-tu de récursivité ? Structure imbriquée != récursivité.
Peut-etre que la notion de type recursif est plus adaptee. En effet chaque element peut etre un pointeur vers un element de type simple (string, pour l'exemple ci-dessus) ou un pointeur vers un ensemble de pointeurs d'elements.
Il y a certainement d'autres solutions pour ce genre de probleme, mais celle-ci me convient le mieux.
J'ai bien decortique ton prototype et je pense qu'il me convient parfaitement et me servira certainement de base de travail.
Je posterais mes travaux sur ce merveilleux site bien evidement.
