Avec BC++ vers 3.0 , j'ai construit une classe "setint" qui travaille sur
des ensembles d'entiers.
tout se passe bien , sauf que si je remplace un ensemble A par un ensemble
C[i] issu d'un tableau tout dérape ;comme si l'allocation n'avait pas été
faite par *(new setint ) .
Merci ,par avance, pour votre aide à un débutant.
PS : Mon programme ci dessous fonctionne ,
mais ne fonctionne plus si on decommente les 5 lignes.
#ifndef __SETINTBO_H
#include <setintbo.h>
#endif
#ifndef __CONIO_H
#include <conio.h>
#endif
main()
{int i, j;
setint A,B[10],C[10], E[10][10];
clrscr();
for (i=1;i<10;i++)
{B[i]=*(new setint);
C[i]=*(new setint);
for (j=1;j<10;j++) E[i][j]= *(new setint);
}
for (i=1;i<10;i++)
for (j=1;j<10;j++)
{B[i].ajoute(i*j);
E[i][j].ajoute(i+j);
}
for (i=1;i<8;i++)
{for (j=1;j<8;j++)
A=reunion(E[i][j],B[i]);
affiche(A);
}
Il a parlé ailleurs de Sukodo. [...] Sinon, pour implémenter un ensemble, std::set pourrait servir. Ou un std::vector qu'on garde trié grace à lower_bound et al.
Mon implémentation utilise std::bitset ...
Falk
James Kanze wrote:
Il a parlé ailleurs de Sukodo. [...]
Sinon, pour implémenter un ensemble, std::set pourrait servir.
Ou un std::vector qu'on garde trié grace à lower_bound et al.
Il a parlé ailleurs de Sukodo. [...] Sinon, pour implémenter un ensemble, std::set pourrait servir. Ou un std::vector qu'on garde trié grace à lower_bound et al.
Mon implémentation utilise std::bitset ...
Falk
Fabien LE LEZ
On Sat, 22 Oct 2005 17:58:10 +0200, James Kanze :
class setint { noeud * debut; //pointeur sur le début de la liste int nelem; //nombre courant d'éléments
Il a parlé ailleurs de Sukodo. Si l'intervale est des entiers est limité à 1...9, bool isMember[10] me semble une implémentation tout à fait adéquate, et on ne peut plus simple.
Pour un tableau de taille fixe, OK. Mais là, il implémente une liste chaînée, ce qui ne me paraît pas la manière la plus simple de faire.
On Sat, 22 Oct 2005 17:58:10 +0200, James Kanze <kanze@none>:
class setint
{ noeud * debut; //pointeur sur le début de la liste
int nelem; //nombre courant d'éléments
Il a parlé ailleurs de Sukodo. Si l'intervale est des entiers
est limité à 1...9, bool isMember[10] me semble une
implémentation tout à fait adéquate, et on ne peut plus simple.
Pour un tableau de taille fixe, OK. Mais là, il implémente une liste
chaînée, ce qui ne me paraît pas la manière la plus simple de faire.
class setint { noeud * debut; //pointeur sur le début de la liste int nelem; //nombre courant d'éléments
Il a parlé ailleurs de Sukodo. Si l'intervale est des entiers est limité à 1...9, bool isMember[10] me semble une implémentation tout à fait adéquate, et on ne peut plus simple.
Pour un tableau de taille fixe, OK. Mais là, il implémente une liste chaînée, ce qui ne me paraît pas la manière la plus simple de faire.
Fabien LE LEZ
On Fri, 21 Oct 2005 12:31:43 +0200, "Acetonik" :
BC++3 est ce dont je dispose
BC++ 3 est trop vieux pour être utilisable, pour deux raisons : - d'une part, il implémente un C++ d'il y a 10-15 ans, auquel il manque beaucoup de fonctionnalités indispensables ; - d'autre part, il fonctionne très certainement en 16 bits uniquement (BC++ 4.5 avait un support assez limité du 32 bits), ce qui risque de vite te poser des problèmes.
On Fri, 21 Oct 2005 12:31:43 +0200, "Acetonik"
<Acetonik@invalid.wanadoo.fr>:
BC++3 est ce dont je dispose
BC++ 3 est trop vieux pour être utilisable, pour deux raisons :
- d'une part, il implémente un C++ d'il y a 10-15 ans, auquel il
manque beaucoup de fonctionnalités indispensables ;
- d'autre part, il fonctionne très certainement en 16 bits
uniquement (BC++ 4.5 avait un support assez limité du 32 bits), ce qui
risque de vite te poser des problèmes.
BC++ 3 est trop vieux pour être utilisable, pour deux raisons : - d'une part, il implémente un C++ d'il y a 10-15 ans, auquel il manque beaucoup de fonctionnalités indispensables ; - d'autre part, il fonctionne très certainement en 16 bits uniquement (BC++ 4.5 avait un support assez limité du 32 bits), ce qui risque de vite te poser des problèmes.
kanze
Fabien LE LEZ wrote:
On Sat, 22 Oct 2005 17:58:10 +0200, James Kanze :
class setint { noeud * debut; //pointeur sur le début de la liste int nelem; //nombre courant d'élém ents
Il a parlé ailleurs de Sukodo. Si l'intervale est des entiers est limité à 1...9, bool isMember[10] me semble une implémentation tout à fait adéquate, et on ne peut plus simple.
Pour un tableau de taille fixe, OK. Mais là, il implémente une liste chaînée, ce qui ne me paraît pas la manière la plus simple de faire.
Il a parlé de Sukodo. C'est donc les ensembles de [1...9].
Falk a suggéré std::bitset, ce qui est une bonne solution. Sinon, bool[9] ou std::deque<bool> fournissent une bonne base ; ce dernier aussi si on veut que la taille soit paramètrée.
Si on considère plutôt des ensembles de [1...n], pour un n très grand, std::vector<int>, avec std::lower_bound et al. pour le garder trié, me semble un alternatif, si on ne veut pas utiliser std::set<int> tout court.
Mais c'est vrai qu'une liste chaînée ne me paraît pas trop indiquée pour ce genre de problème.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Fabien LE LEZ wrote:
On Sat, 22 Oct 2005 17:58:10 +0200, James Kanze <kanze@none>:
class setint
{ noeud * debut; //pointeur sur le début de la liste
int nelem; //nombre courant d'élém ents
Il a parlé ailleurs de Sukodo. Si l'intervale est des entiers
est limité à 1...9, bool isMember[10] me semble une
implémentation tout à fait adéquate, et on ne peut plus
simple.
Pour un tableau de taille fixe, OK. Mais là, il implémente une
liste chaînée, ce qui ne me paraît pas la manière la plus
simple de faire.
Il a parlé de Sukodo. C'est donc les ensembles de [1...9].
Falk a suggéré std::bitset, ce qui est une bonne solution.
Sinon, bool[9] ou std::deque<bool> fournissent une bonne base ;
ce dernier aussi si on veut que la taille soit paramètrée.
Si on considère plutôt des ensembles de [1...n], pour un n très
grand, std::vector<int>, avec std::lower_bound et al. pour le
garder trié, me semble un alternatif, si on ne veut pas utiliser
std::set<int> tout court.
Mais c'est vrai qu'une liste chaînée ne me paraît pas trop
indiquée pour ce genre de problème.
--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
class setint { noeud * debut; //pointeur sur le début de la liste int nelem; //nombre courant d'élém ents
Il a parlé ailleurs de Sukodo. Si l'intervale est des entiers est limité à 1...9, bool isMember[10] me semble une implémentation tout à fait adéquate, et on ne peut plus simple.
Pour un tableau de taille fixe, OK. Mais là, il implémente une liste chaînée, ce qui ne me paraît pas la manière la plus simple de faire.
Il a parlé de Sukodo. C'est donc les ensembles de [1...9].
Falk a suggéré std::bitset, ce qui est une bonne solution. Sinon, bool[9] ou std::deque<bool> fournissent une bonne base ; ce dernier aussi si on veut que la taille soit paramètrée.
Si on considère plutôt des ensembles de [1...n], pour un n très grand, std::vector<int>, avec std::lower_bound et al. pour le garder trié, me semble un alternatif, si on ne veut pas utiliser std::set<int> tout court.
Mais c'est vrai qu'une liste chaînée ne me paraît pas trop indiquée pour ce genre de problème.
-- James Kanze GABI Software Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
