[debutant] vector

On Fri, 12 Aug 2005 11:15:50 +0200, Bruno CAUSSE <envoi@lesSpam.fr>:

En passant, si cette adresse n'est pas correcte, merci de rajouter
".invalid" à la fin.

/* pointeur pour pouvoir intervertir premier et deuxieme rapidement c.a.d.
Sans recopie d'objet; */

A* premier;
A* deuxieme;

C'est un peu une bombe nucléaire pour tuer une mouche.
Tu fais là de l'optimisation précoce : tu compliques le code dans
l'espoir que ton programme aille plus vite, mais sans savoir à
l'avance s'il y a réellement un problème de vitesse.
Si ça se trouve, tes bidouillages ralentiront le programme.

Donc, ton code me paraît incorrect pour deux raisons :

- comme il y a des pointeurs et de l'allocation dynamique, tu dois
rajouter un construteur de copie et un opérateur de copie -- en
l'état, ça plantera à la première copie.

- ton code est inutilement compliqué, et je considère ça comme une
erreur de programmation.

Peut on fixer ("const") la taille d'un vecteur. Aucun retrait ou ajout?

J'ai du mal à comprendre ta terminologie. Parles-tu ici d'un tableau
(std::vector<>),

ou d'un vecteur, i.e. objet mathématique, élément
d'un espace vectoriel, représenté généralement par un tableau de
taille fixe ?

Si tu veux un tableau de taille fixe connue à la compilation, un
tableau "à la C" convient :
static size_t const taille_tableau= 42;
int tableau [taille_tableau];

Si tu veux un tableau de taille fixée dans le constructeur, ce n'est
pas très difficile à programmer :

template <class T> class TableauTailleFixe
{
public:
typedef std::vector<T> Data;
typedef Data::iterator iterator;
typedef Data::const_iterator const_iterator;

TableauTailleFixe (size_t taille, T const& t= T())
: data (taille, t) {}

T& operator[] (size_t n) { return data.at(n); }
T const& operator[] (size_t n) const { return data.at(n); }

const_iterator begin() const { return data.begin(); }
const_iterator end() const { return data.end(); }
iterator begin() { return data.begin(); }
iterator end() { return data.end(); }

private:
Data data;
};

Note : il manque quelques trucs, comme les reverse_iterator, mais tu
peux les rajouter au fur et à mesure de tes besoins.

Evidement A n'est pas si simple. Et je peux en intervertir + de 100 000 par
seconde.

Si tu veux un tableau de taille fixe connue à la compilation, un
tableau "à la C" convient :
static size_t const taille_tableau= 42;
int tableau [taille_tableau];

Justement je passe aux vector (1ere ligne de mon 1er post)

B(const B& src) {

//cas particulier que des membres primitifs (int)
*premier = *(src.premier);
*deuxieme = *(src.deuxieme);
};

1/ quel est la difference entre
*this != src
et
this != &src

2/ Pourquoi est-ce que le test
*this != src
est necessaire? (En premiere approximation, si un tel test est
necessaire, il y a grande chance que le code soit incorrect en
presence d'exceptions)

dans l'article pxbzmrnmqfp.fsf@news.bourguet.org, Jean-Marc Bourguet à
jm@bourguet.org a écrit le 12/08/05 11:53 :

1/ quel est la difference entre
*this != src
et
this != &src

Encore un fois un peu trop vite

*this != src -> compare le contenu? (est ce valide sur A?)

Donc this != &src compare les adresses.

2/ Pourquoi est-ce que le test
*this != src
est necessaire? (En premiere approximation, si un tel test est
necessaire, il y a grande chance que le code soit incorrect en
presence d'exceptions)

Explication svp.