Je sais que ca peut paraitre aberrant de demander ca, mais je me
demandais si quelqu'un pouvait me donner une adresse ou m'eclairer un
peu pour implementer un tableau de type pile ou file, les pointeurs et
moi ca fait vraiment deux, mais j'aimerais avoir une structure
d'elements ordonnes dont la taille varie lors du programme, je ne pense
pas que ce soit tres optimise de creer un tableau de 500 cases pour
avoir au plus une trentaine de donnees dedans...
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
David MAREC
Bonjour,
D'après MALIS Pierre-Yves:
[...] j'aimerais avoir une structure d'elements ordonnes dont la taille varie lors du programme, je ne pense pas que ce soit tres optimise de creer un tableau de 500 cases pour avoir au plus une trentaine de donnees dedans...
Pour ne pas ré-inventer la roue, utilisez les conteneurs de la STL, i.e., pour votre problème, un _vector_ ou un _list_.
Il exite des exemples d'utilisation de la STL un peu partout.
->google : "tutorial STL".
Grossierement :
#include <vector>
class test{ typedef struct {int toto;} maStructure;
std::vector<myStruct> maPile;
maStructure uneStructure,uneAutreStructure;
maPile.push_back(uneStructure);
uneAutreStructure=maPile.back();
Bonjour,
D'après MALIS Pierre-Yves:
[...]
j'aimerais avoir une structure
d'elements ordonnes dont la taille varie lors du programme, je ne pense
pas que ce soit tres optimise de creer un tableau de 500 cases pour
avoir au plus une trentaine de donnees dedans...
Pour ne pas ré-inventer la roue, utilisez les conteneurs de la STL, i.e.,
pour votre problème, un _vector_ ou un _list_.
Il exite des exemples d'utilisation de la STL un peu partout.
->google : "tutorial STL".
Grossierement :
#include <vector>
class test{
typedef struct {int toto;} maStructure;
[...] j'aimerais avoir une structure d'elements ordonnes dont la taille varie lors du programme, je ne pense pas que ce soit tres optimise de creer un tableau de 500 cases pour avoir au plus une trentaine de donnees dedans...
Pour ne pas ré-inventer la roue, utilisez les conteneurs de la STL, i.e., pour votre problème, un _vector_ ou un _list_.
Il exite des exemples d'utilisation de la STL un peu partout.
->google : "tutorial STL".
Grossierement :
#include <vector>
class test{ typedef struct {int toto;} maStructure;
std::vector<myStruct> maPile;
maStructure uneStructure,uneAutreStructure;
maPile.push_back(uneStructure);
uneAutreStructure=maPile.back();
David MAREC
Bonjour,
D'après MALIS Pierre-Yves:
d'elements ordonnes dont la taille varie lors du programme, je ne pense pas que ce soit tres optimise de creer un tableau de 500 cases pour avoir au plus une trentaine de donnees dedans...
Pour ne pas ré-inventer la roue, utilisez les conteneurs de la STL, i.e., pour votre problème, un _vector_ ou un _list_.
Il exite des exemples d'utilisation de la STL un peu partout.
->google : "tutorial STL".
Grossierement :
#include <vector>
class test{ typedef struct {int toto;} maStructure;
std::vector<maStructure> maPile;
maStructure uneStructure,uneAutreStructure;
maPile.push_back(uneStructure);
uneAutreStructure=maPile.back();
Sinon, pour discuter de ceci, fr.comp.lang.c++ est plus approprié, me semble-t-il.
Bonjour,
D'après MALIS Pierre-Yves:
d'elements ordonnes dont la taille varie lors du programme, je ne pense
pas que ce soit tres optimise de creer un tableau de 500 cases pour
avoir au plus une trentaine de donnees dedans...
Pour ne pas ré-inventer la roue, utilisez les conteneurs de la STL, i.e.,
pour votre problème, un _vector_ ou un _list_.
Il exite des exemples d'utilisation de la STL un peu partout.
->google : "tutorial STL".
Grossierement :
#include <vector>
class test{
typedef struct {int toto;} maStructure;
std::vector<maStructure> maPile;
maStructure uneStructure,uneAutreStructure;
maPile.push_back(uneStructure);
uneAutreStructure=maPile.back();
Sinon, pour discuter de ceci, fr.comp.lang.c++ est plus approprié, me
semble-t-il.
d'elements ordonnes dont la taille varie lors du programme, je ne pense pas que ce soit tres optimise de creer un tableau de 500 cases pour avoir au plus une trentaine de donnees dedans...
Pour ne pas ré-inventer la roue, utilisez les conteneurs de la STL, i.e., pour votre problème, un _vector_ ou un _list_.
Il exite des exemples d'utilisation de la STL un peu partout.
->google : "tutorial STL".
Grossierement :
#include <vector>
class test{ typedef struct {int toto;} maStructure;
std::vector<maStructure> maPile;
maStructure uneStructure,uneAutreStructure;
maPile.push_back(uneStructure);
uneAutreStructure=maPile.back();
Sinon, pour discuter de ceci, fr.comp.lang.c++ est plus approprié, me semble-t-il.
adebaene
MALIS Pierre-Yves wrote in message news:...
Je sais que ca peut paraitre aberrant de demander ca, mais je me demandais si quelqu'un pouvait me donner une adresse ou m'eclairer un peu pour implementer un tableau
std::vector
de type pile
std::stack
ou file
std::queue
Ceci dit, un tableau ce n'est ni une pile ni une file, tu devrais commencer par mettre au clair quel est ton besoin exactement.
les pointeurs et moi ca fait vraiment deux
Ah bon? Et tu fais de l'embarqué?
mais j'aimerais avoir une structure d'elements ordonnes dont la taille varie lors du programme,
std::set est probablement ce que tu cherches alors.
Arnaud
MALIS Pierre-Yves <linfg176@cict.fr> wrote in message news:<3FE2E3F9.15EC0546@cict.fr>...
Je sais que ca peut paraitre aberrant de demander ca, mais je me
demandais si quelqu'un pouvait me donner une adresse ou m'eclairer un
peu pour implementer un tableau
std::vector
de type pile
std::stack
ou file
std::queue
Ceci dit, un tableau ce n'est ni une pile ni une file, tu devrais
commencer par mettre au clair quel est ton besoin exactement.
les pointeurs et
moi ca fait vraiment deux
Ah bon? Et tu fais de l'embarqué?
mais j'aimerais avoir une structure
d'elements ordonnes dont la taille varie lors du programme,
std::set est probablement ce que tu cherches alors.
Je sais que ca peut paraitre aberrant de demander ca, mais je me demandais si quelqu'un pouvait me donner une adresse ou m'eclairer un peu pour implementer un tableau
std::vector
de type pile
std::stack
ou file
std::queue
Ceci dit, un tableau ce n'est ni une pile ni une file, tu devrais commencer par mettre au clair quel est ton besoin exactement.
les pointeurs et moi ca fait vraiment deux
Ah bon? Et tu fais de l'embarqué?
mais j'aimerais avoir une structure d'elements ordonnes dont la taille varie lors du programme,
std::set est probablement ce que tu cherches alors.
Arnaud
Christophe Lephay
MALIS Pierre-Yves wrote:
Je sais que ca peut paraitre aberrant de demander ca, mais je me demandais si quelqu'un pouvait me donner une adresse ou m'eclairer un peu pour implementer un tableau de type pile ou file
Les tableaux sont une structure spécifique au même titre qu'une pile ou une file (tout ça pour dire que c'est contradictoire de parler de tableau de type pile ou file).
, les pointeurs et moi ca fait vraiment deux, mais j'aimerais avoir une structure d'elements ordonnes dont la taille varie lors du programme, je ne pense pas que ce soit tres optimise de creer un tableau de 500 cases pour avoir au plus une trentaine de donnees dedans...
En C++, tu as différents types de containers qui t'évitent d'avoir à passer par des pointeurs. Le type le plus approprié dépend plus précisément de l'usage qui en sera fait dans ton application. Notemment, il me semble qu'il y a encore une contradiction entre une pile ou une file, qui ont chacunes des comportements bien spécifiques, et le fait d'avoir des données ordonnées.
En C++ standard, tu as std::stack pour une pile, std::queue pour une file, std::set ou std::multiset pour des éléments ordonnés, std::priority_queue pour avoir une file tout en réordonnant l'odre d'accès aux éléments. Selon le cas, il est tout aussi possible au'un simple std::vector fasse l'affaire.
Je t'invite donc à préciser ton problème, notemment à quelle fréquence tu envisages l'ajout d'éléments, la suppression d'éléments (ce que semble indiquer ton évocation d'une pile ou d'une file), et de quelle manière tu souhaites y accéder...
Chris
MALIS Pierre-Yves wrote:
Je sais que ca peut paraitre aberrant de demander ca, mais je me
demandais si quelqu'un pouvait me donner une adresse ou m'eclairer un
peu pour implementer un tableau de type pile ou file
Les tableaux sont une structure spécifique au même titre qu'une pile ou une
file (tout ça pour dire que c'est contradictoire de parler de tableau de
type pile ou file).
, les pointeurs et
moi ca fait vraiment deux, mais j'aimerais avoir une structure
d'elements ordonnes dont la taille varie lors du programme, je ne
pense pas que ce soit tres optimise de creer un tableau de 500 cases
pour avoir au plus une trentaine de donnees dedans...
En C++, tu as différents types de containers qui t'évitent d'avoir à passer
par des pointeurs. Le type le plus approprié dépend plus précisément de
l'usage qui en sera fait dans ton application. Notemment, il me semble qu'il
y a encore une contradiction entre une pile ou une file, qui ont chacunes
des comportements bien spécifiques, et le fait d'avoir des données
ordonnées.
En C++ standard, tu as std::stack pour une pile, std::queue pour une file,
std::set ou std::multiset pour des éléments ordonnés, std::priority_queue
pour avoir une file tout en réordonnant l'odre d'accès aux éléments. Selon
le cas, il est tout aussi possible au'un simple std::vector fasse l'affaire.
Je t'invite donc à préciser ton problème, notemment à quelle fréquence tu
envisages l'ajout d'éléments, la suppression d'éléments (ce que semble
indiquer ton évocation d'une pile ou d'une file), et de quelle manière tu
souhaites y accéder...
Je sais que ca peut paraitre aberrant de demander ca, mais je me demandais si quelqu'un pouvait me donner une adresse ou m'eclairer un peu pour implementer un tableau de type pile ou file
Les tableaux sont une structure spécifique au même titre qu'une pile ou une file (tout ça pour dire que c'est contradictoire de parler de tableau de type pile ou file).
, les pointeurs et moi ca fait vraiment deux, mais j'aimerais avoir une structure d'elements ordonnes dont la taille varie lors du programme, je ne pense pas que ce soit tres optimise de creer un tableau de 500 cases pour avoir au plus une trentaine de donnees dedans...
En C++, tu as différents types de containers qui t'évitent d'avoir à passer par des pointeurs. Le type le plus approprié dépend plus précisément de l'usage qui en sera fait dans ton application. Notemment, il me semble qu'il y a encore une contradiction entre une pile ou une file, qui ont chacunes des comportements bien spécifiques, et le fait d'avoir des données ordonnées.
En C++ standard, tu as std::stack pour une pile, std::queue pour une file, std::set ou std::multiset pour des éléments ordonnés, std::priority_queue pour avoir une file tout en réordonnant l'odre d'accès aux éléments. Selon le cas, il est tout aussi possible au'un simple std::vector fasse l'affaire.
Je t'invite donc à préciser ton problème, notemment à quelle fréquence tu envisages l'ajout d'éléments, la suppression d'éléments (ce que semble indiquer ton évocation d'une pile ou d'une file), et de quelle manière tu souhaites y accéder...
