vector déclaration

Le Mon, 24 Nov 2003 19:28:26 +0100, Nicolas Aunai a écrit :

j'ai une classe :

class C_Tab
{
private:
vector <int> tableau(6);

public:
int somme(vector <int> tab);
bool comparetab(const vector <int> a,
const vector <int> b) const;

tu préfèrerais pas utiliser operator< ? surtout que là tu va devoir
travailler comme ça

a.comparetab(b, c);

};

à moins que ça soit didactique, ne réinvente pas la roue, regarde les
std::valarray et les boost::array (www.boost.org)

et sur la ligne de déclaration du vector, j'ai l'erreur suivante :

" invalid data member initialization"


donc je ne comprends pas, pourtant j'ai bien vu qu'on pouvait déclarer
des vector ainsi...

déclarer oui, initialiser non

private:
vector <int> tableau;

public:
C_Tab()
: tableau(6)
{
// ...
}

"Benoit Dejean" vient de nous annoncer :

public:
int somme(vector <int> tab);
bool comparetab(const vector <int> a,
const vector <int> b) const;

tu préfèrerais pas utiliser operator< ?

c'est ce que je viens de voir sur le site SGI, j'ignorais sont
existence... je viens de voir aussi :

bool operator==(const vector&,
const vector&)

ça s'utilise comme un opérateur '==' normal ?

exemple

(a==b) renvoi false ou true suivant que les vector sont les même ou pas
?

ce sont des opérateurs surchargés ?

surtout que là tu va devoir
travailler comme ça

a.comparetab(b, c);

et même plutot a.comparetab(a,b)

ce sont mes réflexes de langage C que de faire des fonctions comme
ça...

};

à moins que ça soit didactique, ne réinvente pas la roue, regarde les
std::valarray et les boost::array (www.boost.org)

en fait c'est pour faire un projet pour mes cours, mais autant utiliser
des trucs standards qui vont bien. en cours nous n'avons vu que les
tableaux a la C. On m'avait dit ici que vector était bcp plus utilisé
pour les tableaux...

mais d'après ce que j'ai vu il existe tout un tas de conteneurs...

déclarer oui, initialiser non

private:
vector <int> tableau;

public:
C_Tab()
: tableau(6)
{
// ...
}

désolé, certainement par manque de bases, mais je comprend pas ton :

C_Tab():tableau(6)


c'est le constructeur de la classe qui initialise les données statiques
?

imaginons que j'ai n variables statiques a initialiser, je ferai :

C_Tab()
:n1=2
:n2=3
.
.
.
:nn=9
{

}


??

et que mettre dans le corps du constructeur s'i je n'ai que des
variables statiques a initialiser ? et rien d'autres a lui faire faire
?


merci

--
Nico,
http://astrosurf.com/nicoastro
messenger : nicolas_aunai@hotmail.com

Bonjour,

c'est ce que je viens de voir sur le site SGI, j'ignorais sont
existence... je viens de voir aussi :

bool operator==(const vector&,
const vector&)

ça s'utilise comme un opérateur '==' normal ?
Pas exactement, cette fonction doit être extérieure à la classe vector car

elle possède deux paramètres (si elle était membre, il n'y en aurait qu'un,
l'autre étant implicitement this)

exemple

(a==b) renvoi false ou true suivant que les vector sont les même ou pas
Oui.

ce sont des opérateurs surchargés ?
Oui.

ce sont mes réflexes de langage C que de faire des fonctions comme
ça...
Reflexes à perdre, donc ;-)

à moins que ça soit didactique, ne réinvente pas la roue, regarde les
std::valarray et les boost::array (www.boost.org)

en fait c'est pour faire un projet pour mes cours, mais autant utiliser
des trucs standards qui vont bien. en cours nous n'avons vu que les
tableaux a la C. On m'avait dit ici que vector était bcp plus utilisé
pour les tableaux...
les std::valarray sont standards, (le namespace std te le prouve. Par

contre, tout ce qui vient de boost ne l'est pas, même si c'est très utilisé)

mais d'après ce que j'ai vu il existe tout un tas de conteneurs...
Oui des tas : regardes dans la doc list, deque, map, etc...

désolé, certainement par manque de bases, mais je comprend pas ton :

C_Tab():tableau(6)

Dans la définition d'un constructeur tu places après le signe : ce qu'on
appelle la liste d'initialisation, ie les différents appels des
constructeurs nécessaires pour construire ton objet.
Par exemple :
class X
{
///....
};
class Y
{
X x;
};

pour construire un Y, il te faut construire un X. Si tu ne le fais pas
explicitement,
Y::Y()
{...}
alors le compilateur va appeler le constructeur par défaut de X. Il a donc
besoin d'exister...
Dans le cas du vector , le constructeur par défaut de celui-ci ne fait pas
la même chose que le constructeur avec un entier en paramètre...
Lors de l'appel de ton constructeur :
C_Tab() {}
Tu ne précises pas au compilateur comment construire ton membre vector.
Alors il appelle le seul constructeur qu'il peut, à savoir le constructeur
par défaut. Alors que si tu fais :
C_Tab:tableau(6)
{}
Tu précises au compilateur qu'il construit "tableau" en utilisant le
constructeur de vector avec un entier en paramètre. Donc ton vecteur est
d'office déclaré avec une taille de 6 éléments.

c'est le constructeur de la classe qui initialise les données statiques
Ici la donnée n'est pas statique.

imaginons que j'ai n variables statiques a initialiser, je ferai :
PAS STATIQUE.

C_Tab()
:n1=2
:n2=3
.
.
.
:nn=9
{

}
Non, la syntaxe est

C_Tab() : n1(2), n2(3), .... nn(9) { // et ici tu fais du code, non des
init...}

et que mettre dans le corps du constructeur s'i je n'ai que des
variables statiques a initialiser ? et rien d'autres a lui faire faire
?
Et bien rien. Tu ouvres et tu fermes les crochets, uniquement.

Alex

"Alexandre" a émis l'idée suivante :

C_Tab():tableau(6)

Dans la définition d'un constructeur tu places après le signe : ce qu'on
appelle la liste d'initialisation, ie les différents appels des
constructeurs nécessaires pour construire ton objet.
Par exemple :
class X
{
///....
};
class Y
{
X x;
};

pour construire un Y, il te faut construire un X. Si tu ne le fais pas
explicitement,
Y::Y()
{...}
alors le compilateur va appeler le constructeur par défaut de X. Il a donc
besoin d'exister...

ok je comprends.

Dans le cas du vector , le constructeur par défaut de celui-ci ne fait pas
la même chose que le constructeur avec un entier en paramètre...
Lors de l'appel de ton constructeur :
C_Tab() {}
Tu ne précises pas au compilateur comment construire ton membre vector.
Alors il appelle le seul constructeur qu'il peut, à savoir le constructeur
par défaut. Alors que si tu fais :
C_Tab:tableau(6)
{}
Tu précises au compilateur qu'il construit "tableau" en utilisant le
constructeur de vector avec un entier en paramètre. Donc ton vecteur est
d'office déclaré avec une taille de 6 éléments.

ok je comprends bien lorsque la donnée membre est un objet.

c'est le constructeur de la classe qui initialise les données statiques
Ici la donnée n'est pas statique.

imaginons que j'ai n variables statiques a initialiser, je ferai :
PAS STATIQUE.

C_Tab()

n1=2
n2=3
.

.
.

nn=9
{

}
Non, la syntaxe est

C_Tab() : n1(2), n2(3), .... nn(9) { // et ici tu fais du code, non des
init...}

franchement j'ai du mal a comprendre ce que tu me dis, si j'ai :

class A
{
public :
int x;
A();
}


A::A()
:x(6)
{

}

x(6) fait bien l'initialisation de x à 6 lors de la création d'un objet
de type A... et pourtant il n'est pas question d'allocation dynamique
du tout, x est une variable entière, je vois pas ce que ça signifie
d'appeler le constructeur d'un entier...

--
Nico,
http://astrosurf.com/nicoastro
messenger : nicolas_aunai@hotmail.com

Nicolas Aunai wrote:

franchement j'ai du mal a comprendre ce que tu me dis, si j'ai :

class A
{
public :
int x;
A();
}


A::A()

x(6)
{

}

x(6) fait bien l'initialisation de x à 6 lors de la création d'un
objet
de type A... et pourtant il n'est pas question d'allocation dynamique
Mais qui a parlé d'allocation dynamique? Il s'agit d'initialiser les membres

d'un objet nouvellement créé, peu importe qu'il soit alloué dynamiquement ou
pas.

x est une variable entière, je vois pas ce que ça signifie
d'appeler le constructeur d'un entier...
Ca veut dire simplement l'initialiser à la valeur passée en paramètre ;-)

Si tu fais
A::A()
{
x=6;
}

L'effet final est le même mais c'est moins efficace, car le compilateur
commence par appeler le constructeur par défaut de int (qui met la variable
à 0), puis seulement ensuite dans le corps du constructeur tu mets la valeur
à 6. C'est donc équivalent à :
A::A()
: 0
{
x=6;
}

Arnaud

Dans news:3fc27273$0$27036$626a54ce@news.free.fr, Arnaud

L'effet final est le même mais c'est moins efficace, car le
compilateur commence par appeler le constructeur par défaut de int
(qui met la variable à 0), puis seulement ensuite dans le corps du

« Malheureusement » non, ce n'est pas si logique que ça : le
constructeur par défaut de int ne fait rien... (Ne pas confondre
avec int() qui vaut bien 0 :-)

--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/

"Michel Michaud" <mm@gdzid.com> writes:

| Dans news:3fc27273$0$27036$626a54ce@news.free.fr, Arnaud
| > L'effet final est le même mais c'est moins efficace, car le
| > compilateur commence par appeler le constructeur par défaut de int
| > (qui met la variable à 0), puis seulement ensuite dans le corps du
|
|
| « Malheureusement » non, ce n'est pas si logique que ça : le
| constructeur par défaut de int ne fait rien... (Ne pas confondre
| avec int() qui vaut bien 0 :-)

Je ne comprends pas ce que tu veux dire. int() est une expression
résulte en un appel de constructeur.

-- Gaby

Dans news:m3he0t2ons.fsf@uniton.integrable-solutions.net, Gabriel Dos

"Michel Michaud" <mm@gdzid.com> writes:

Dans news:3fc27273$0$27036$626a54ce@news.free.fr, Arnaud

L'effet final est le même mais c'est moins efficace, car le
compilateur commence par appeler le constructeur par défaut de int
(qui met la variable à 0), puis seulement ensuite dans le corps du

« Malheureusement » non, ce n'est pas si logique que ça : le
constructeur par défaut de int ne fait rien... (Ne pas confondre
avec int() qui vaut bien 0 :-)

Je ne comprends pas ce que tu veux dire. int() est une expression
résulte en un appel de constructeur.

Une notation explicite, qui donne bien 0. Tu as raison, maintenant
que je me relis : j'ai voulu faire une blague du fait que ce n'est
pas simple ni intuitif (en mettant le mot « Malheureusement » entre
guillemets et en mettant le :-) à la fin), mais finalement je n'ai
pas été assez clair pour que ma réponse soit satisfaisante et
enlève toute équivoque.

Je te laisse le soin de nous expliquer ce mystère de la norme :-)
Même si je sais très bien ce qui en est en terme pratique (int()
vaut 0, mais class X { int x; ...}; n'initialise jamais x à 0
automatiquement), il me faudrait fouiller dans la norme pour
donner une explication aussi parfaite que celle que tu nous
donneras tout naturellement...

(Ça fait plaisir de voir que tu suis encore ce qui se passe ici !)

--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/

"Michel Michaud" <mm@gdzid.com> writes:

| Dans news:m3he0t2ons.fsf@uniton.integrable-solutions.net, Gabriel Dos
| > "Michel Michaud" <mm@gdzid.com> writes:
| >
| >> Dans news:3fc27273$0$27036$626a54ce@news.free.fr, Arnaud
| >>> L'effet final est le même mais c'est moins efficace, car le
| >>> compilateur commence par appeler le constructeur par défaut de int
| >>> (qui met la variable à 0), puis seulement ensuite dans le corps du
| >>
| >>
| >> « Malheureusement » non, ce n'est pas si logique que ça : le
| >> constructeur par défaut de int ne fait rien... (Ne pas confondre
| >> avec int() qui vaut bien 0 :-)
| >
| > Je ne comprends pas ce que tu veux dire. int() est une expression
| > résulte en un appel de constructeur.
|
| Une notation explicite, qui donne bien 0. Tu as raison, maintenant
| que je me relis : j'ai voulu faire une blague du fait que ce n'est
| pas simple ni intuitif (en mettant le mot « Malheureusement » entre
| guillemets et en mettant le :-) à la fin), mais finalement je n'ai
| pas été assez clair pour que ma réponse soit satisfaisante et
| enlève toute équivoque.
|
| Je te laisse le soin de nous expliquer ce mystère de la norme :-)

Le mystère est essentiellement un accident historique que le comité a
essayé de corriger au fur et à mesure que l'utilisation et la
compréhension du langage s'affinent. Le dernier raffinement apporté
par Andy Koenig (i.e. « value initialization ») rend la chose un peu
plus cohérente.

Quand une variable est déclarée sans initialisation explicite, il y a
trois sortes d'action qui peuvent être prises :
(1) « zero-initialization »
(2) « default-initialization »
(3) pas d'initialisation;

les variables ayant une durée de stockage statique sont toujours
initialisés.

C'est un peu élaboré pour un objet avec une durée de vie automatique :
on peut soit l'initialiser par défaut ou ne pas
l'initialiser. L'initialisation par défaut n'a de sens que pour un
objet de type classe.

| Même si je sais très bien ce qui en est en terme pratique (int()
| vaut 0, mais class X { int x; ...}; n'initialise jamais x à 0
| automatiquement),

sauf si tu demandes une « value-initialization » en disant X().

| il me faudrait fouiller dans la norme pour
| donner une explication aussi parfaite que celle que tu nous
| donneras tout naturellement...
|
| (Ça fait plaisir de voir que tu suis encore ce qui se passe ici !)

Hé, je ne suis pas complètement parti. Je suis à College Station mais
ma deuxième moitié (dans tous les sens du terme) est encore en France
et j'espère que je ne vais pas être exclu de la communauté francophone
C++ juste parce que je travaille actuellement au Texas A&M University.
Et cela ne fait que une semaine.
J'aurais voulu que cela s'apprenne autrement que par Herb l'annonçant
dans une discussion sur comp.lang.c++.moderated.

J'espère continuer ma participation à l'AFNOR et dans ce groupe ; mais
pour le moment, il me faut juste un peu de temps pour m'installer.

-- Gaby