operateur []

16 réponses

docCarcass

09/07/2004 à 16:52

Bonjour a tous,
je debute en c++ et je ne trouve pas de reponse a une question :
je dispose d'une classe Vector1D ou il n'y a pas de constructeur par
default :

template<class K> class Vector1D
{

private:
unsigned int dim;
K *t;

public:

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);
}

Vector1D(const Vector1D &v):dim(v.dim),t(new K[dim])
{
operator=(v);
}

Vector1D &operator=(const Vector1D &v)
{
assert(dim==v.dim);
memcpy(t,v.t,dim*sizeof(K));
return *this;
}

/*bla bla bla*/

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>. Je connais la syntaxe type *toto = new type[NBITEM]
mais exise-t-il une syntaxe ou un moyen d'utiliser un autre constructeur
que le constructeur par default pour ne pas faire un truc du genre:

Vector1D<K> *t = new Vector1D<K>[NBITEM];
for(int i; i<NBITEM;i++)
{
/*Initialiser les donnees membres de t[i] avec le parametre dim*/
}

mais plutot :
je sais que cette syntaxe et fausse mais elle est porteuse de sens ...

Vector1D<K> *t= new Vector1D<K>(dim)[NBITEM];

bien a vous,
Seb

--

int main(){int j=1234,putchar();char t[]=":@abcdefghij-lmnopqrstuv"
"wxyz.\n",*i="@jq:.pn.q:ibf.gd\noz.dn@ew\nlwh-i",*strchr();while(*i)
{j+=strchr(t,*i++)-t;j%=sizeof t-1;putchar(t[j]);}return 0;}

10 réponses

1 2

docCarcass

09/07/2004 à 17:09

On Fri, 9 Jul 2004, docCarcass wrote:

Je veux parler de l'operateur new [] et pas de l'operateur [] au fait ...

Bonjour a tous,
je debute en c++ et je ne trouve pas de reponse a une question :
je dispose d'une classe Vector1D ou il n'y a pas de constructeur par
default :

template<class K> class Vector1D
{

private:
unsigned int dim;
K *t;

public:

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);
}

Vector1D(const Vector1D &v):dim(v.dim),t(new K[dim])
{
operator=(v);
}

Vector1D &operator=(const Vector1D &v)
{
assert(dim==v.dim);
memcpy(t,v.t,dim*sizeof(K));
return *this;
}

/*bla bla bla*/

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>. Je connais la syntaxe type *toto = new type[NBITEM]
mais exise-t-il une syntaxe ou un moyen d'utiliser un autre constructeur
que le constructeur par default pour ne pas faire un truc du genre:

Vector1D<K> *t = new Vector1D<K>[NBITEM];
for(int i; i<NBITEM;i++)
{
/*Initialiser les donnees membres de t[i] avec le parametre dim*/
}

mais plutot :
je sais que cette syntaxe et fausse mais elle est porteuse de sens ...

Vector1D<K> *t= new Vector1D<K>(dim)[NBITEM];

bien a vous,
Seb

--

int main(){int j34,putchar();char t[]=":@abcdefghij-lmnopqrstuv"
"wxyz.n",*i="@jq:.pn.q:",*strchr();while(*i)
{j+=strchr(t,*i++)-t;j%=sizeof t-1;putchar(t[j]);}return 0;}

--

int main(){int j34,putchar();char t[]=":@abcdefghij-lmnopqrstuv"
"wxyz.n",*i="@jq:.pn.q:",*strchr();while(*i)
{j+=strchr(t,*i++)-t;j%=sizeof t-1;putchar(t[j]);}return 0;}

Alexandre

09/07/2004 à 20:17

bonjour,

template<class K> class Vector1D
{

private:
unsigned int dim;
K *t;
(snip)

tiens revoilà cette classe. C'est un exo classique non ?

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>. Je connais la syntaxe type *toto = new type[NBITEM]
mais exise-t-il une syntaxe ou un moyen d'utiliser un autre constructeur
que le constructeur par default pour ne pas faire un truc du genre:

pourquoi ne pas faire un Vector1D< Vector1D<K> > ?

Vector1D<K> *t = new Vector1D<K>[NBITEM];
for(int i; i<NBITEM;i++)
{
/*Initialiser les donnees membres de t[i] avec le parametre dim*/
}

en quoi ce code te gène-t-il ? Tu as NBITEM à effecter, c'est normal de
boucler, non ?
Sinon tu peux faire, ce qui est AMA moins bien car moins clair, un memset.
Mais c'est très "C-like". Et inutile puisque ton Vector2D<K> peut s'écrire
comme Vector1D< Vector1D<K> >.

Franck Branjonneau

09/07/2004 à 21:01

docCarcass écrivait:

je debute en c++ et je ne trouve pas de reponse a une question :
je dispose d'une classe Vector1D ou il n'y a pas de constructeur par
default :

Pourquoi ne pas utiliser std::vector<> ? Ce serait mieux que :

template<class K> class Vector1D
{

private:
unsigned int dim;
K *t;

public:

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);

assert inutile.

}

Vector1D(const Vector1D &v):dim(v.dim),t(new K[dim])
{

Pas d'assert inutile ?

operator=(v);

L'assignation et la copie ont la même sémantique ?

}

Vector1D &operator=(const Vector1D &v)
{
assert(dim==v.dim);
memcpy(t,v.t,dim*sizeof(K));

Quel est le résultat si t est v.t ?

return *this;
}

/*bla bla bla*/

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>. Je connais la syntaxe type *toto = new type[NBITEM]
mais exise-t-il une syntaxe ou un moyen d'utiliser un autre constructeur
que le constructeur par default pour ne pas faire un truc du genre:

Vector1D<K> *t = new Vector1D<K>[NBITEM];
for(int i; i<NBITEM;i++)
{
/*Initialiser les donnees membres de t[i] avec le parametre dim*/
}

Je n'en connais pas. Peut-être implémenter Vector2D en terme de
Vector1D ? Mai, à nouveau, j'utiliserais std::vector<>.

mais plutot :
je sais que cette syntaxe et fausse mais elle est porteuse de sens ...

Vector1D<K> *t= new Vector1D<K>(dim)[NBITEM];

J'ai beaucoup de mal à trouver un sens à cette formulation. Peut-être
veux-tu jouer avec

Vector1D<K> (*t)[NBITEM]= new Vector1D<K>[dim][NBITEM];

où NBITEM est une constante entière connue du compilateur ?

Est-ce que j'ai dit que std::vector<> est la solution ?
--
Franck Branjonneau

docCarcass

09/07/2004 à 23:00

On Fri, 9 Jul 2004, Franck Branjonneau wrote:

docCarcass écrivait:

je debute en c++ et je ne trouve pas de reponse a une question :
je dispose d'une classe Vector1D ou il n'y a pas de constructeur par
default :

Pourquoi ne pas utiliser std::vector<> ? Ce serait mieux que :

Ba justement, le but est de ne pas utiliser la STL .
Merci pour ces indications .

template<class K> class Vector1D
{

private:
unsigned int dim;
K *t;

public:

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);

assert inutile.

}

Vector1D(const Vector1D &v):dim(v.dim),t(new K[dim])
{

Pas d'assert inutile ?

operator=(v);

L'assignation et la copie ont la même sémantique ?

}

Vector1D &operator=(const Vector1D &v)
{
assert(dim==v.dim);
memcpy(t,v.t,dim*sizeof(K));

Quel est le résultat si t est v.t ?

return *this;
}

/*bla bla bla*/

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>. Je connais la syntaxe type *toto = new type[NBITEM]
mais exise-t-il une syntaxe ou un moyen d'utiliser un autre constructeu r
que le constructeur par default pour ne pas faire un truc du genre:

Vector1D<K> *t = new Vector1D<K>[NBITEM];
for(int i; i<NBITEM;i++)
{
/*Initialiser les donnees membres de t[i] avec le parametre dim*/
}

Je n'en connais pas. Peut-être implémenter Vector2D en terme de
Vector1D ? Mai, à nouveau, j'utiliserais std::vector<>.

mais plutot :
je sais que cette syntaxe et fausse mais elle est porteuse de sens ...

Vector1D<K> *t= new Vector1D<K>(dim)[NBITEM];

J'ai beaucoup de mal à trouver un sens à cette formulation. Peut-êt re
veux-tu jouer avec

Vector1D<K> (*t)[NBITEM]= new Vector1D<K>[dim][NBITEM];

où NBITEM est une constante entière connue du compilateur ?

Est-ce que j'ai dit que std::vector<> est la solution ?

--

int main(){int j34,putchar();char t[]=":@abcdefghij-lmnopqrstuv"
"wxyz.n",*i="@jq:.pn.q:",*strchr();while(*i)
{j+=strchr(t,*i++)-t;j%=sizeof t-1;putchar(t[j]);}return 0;}

On Fri, 9 Jul 2004, Franck Branjonneau wrote:

docCarcass <bigotseb@etu.utc.nospam.fr> écrivait:

je debute en c++ et je ne trouve pas de reponse a une question :
je dispose d'une classe Vector1D ou il n'y a pas de constructeur par
default :

Pourquoi ne pas utiliser std::vector<> ? Ce serait mieux que :

Ba justement, le but est de ne pas utiliser la STL .
Merci pour ces indications .

template<class K> class Vector1D
{

private:
unsigned int dim;
K *t;

public:

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);

assert inutile.

}

Vector1D(const Vector1D &v):dim(v.dim),t(new K[dim])
{

Pas d'assert inutile ?

operator=(v);

L'assignation et la copie ont la même sémantique ?

}

Vector1D &operator=(const Vector1D &v)
{
assert(dim==v.dim);
memcpy(t,v.t,dim*sizeof(K));

Quel est le résultat si t est v.t ?

return *this;
}

/*bla bla bla*/

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>. Je connais la syntaxe type *toto = new type[NBITEM]
mais exise-t-il une syntaxe ou un moyen d'utiliser un autre constructeu r
que le constructeur par default pour ne pas faire un truc du genre:

Vector1D<K> *t = new Vector1D<K>[NBITEM];
for(int i; i<NBITEM;i++)
{
/*Initialiser les donnees membres de t[i] avec le parametre dim*/
}

Je n'en connais pas. Peut-être implémenter Vector2D en terme de
Vector1D ? Mai, à nouveau, j'utiliserais std::vector<>.

mais plutot :
je sais que cette syntaxe et fausse mais elle est porteuse de sens ...

Vector1D<K> *t= new Vector1D<K>(dim)[NBITEM];

J'ai beaucoup de mal à trouver un sens à cette formulation. Peut-êt re
veux-tu jouer avec

Vector1D<K> (*t)[NBITEM]= new Vector1D<K>[dim][NBITEM];

où NBITEM est une constante entière connue du compilateur ?

Est-ce que j'ai dit que std::vector<> est la solution ?

--

int main(){int j=1234,putchar();char t[]=":@abcdefghij-lmnopqrstuv"
"wxyz.n",*i="@jq:.pn.q:ibf.gdnoz.dn@ewnlwh-i",*strchr();while(*i)
{j+=strchr(t,*i++)-t;j%=sizeof t-1;putchar(t[j]);}return 0;}

docCarcass

09/07/2004 à 23:18

On Fri, 9 Jul 2004, docCarcass wrote:

mais plutot :
je sais que cette syntaxe et fausse mais elle est porteuse de sens .. .

Vector1D<K> *t= new Vector1D<K>(dim)[NBITEM];

J'ai beaucoup de mal à trouver un sens à cette formulation. Peut- être
veux-tu jouer avec

Vector1D<K> (*t)[NBITEM]= new Vector1D<K>[dim][NBITEM];

où NBITEM est une constante entière connue du compilateur ?

En fait je voulais dire par la utiliser le constructeur
Vector1D<K>(unsigned int) avec le parametre dim pour allouer mon
tableau de NBITEM Vecteur1D<K> plutot que d'utiliser
le constructeur par default comme dans

Vector1D<K> *t = new Vector<K>[NBITEM];

Si je suis l'idee Vector1D< Vector1D<K> > le problème est le meme
puisque le constructeur de la classe Vector1D<K> fait un t(new K[dim]):

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);
}

Question: pourquoi le assert est-il inutile ?
Ne faut-il pas verifier si l'allocation de t a echouee ou est-ce une
erreur de ma part ?

--

int main(){int j34,putchar();char t[]=":@abcdefghij-lmnopqrstuv"
"wxyz.n",*i="@jq:.pn.q:",*strchr();while(*i)
{j+=strchr(t,*i++)-t;j%=sizeof t-1;putchar(t[j]);}return 0;}

drkm

10/07/2004 à 00:56

docCarcass writes:

Question: pourquoi le assert est-il inutile ?
Ne faut-il pas verifier si l'allocation de t a echouee ou est-ce une
erreur de ma part ?

Le new que tu as écrit ne renvoit jamais 0. En cas d'échec, il
lance une exception.

--drkm

Franck Branjonneau

10/07/2004 à 01:25

docCarcass écrivait:

On Fri, 9 Jul 2004, docCarcass wrote:

mais plutot :
je sais que cette syntaxe et fausse mais elle est porteuse de sens ...

Vector1D<K> *t= new Vector1D<K>(dim)[NBITEM];

J'ai beaucoup de mal à trouver un sens à cette formulation. Peut-être
veux-tu jouer avec

Vector1D<K> (*t)[NBITEM]= new Vector1D<K>[dim][NBITEM];

où NBITEM est une constante entière connue du compilateur ?

En fait je voulais dire par la utiliser le constructeur
Vector1D<K>(unsigned int) avec le parametre dim pour allouer mon
tableau de NBITEM Vecteur1D<K> plutot que d'utiliser
le constructeur par default comme dans

Vector1D<K> *t = new Vector<K>[NBITEM];

Les operator new[] utilisent toujours les constructeurs par défaut.

Si je suis l'idee Vector1D< Vector1D<K> > le problème est le meme
puisque le constructeur de la classe Vector1D<K> fait un t(new
K[dim]):

Ton Vector2D doit-il impérativement s'appuyer sur ton Vector1D ?

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);
}

Question: pourquoi le assert est-il inutile ?

operator new[] n'est pas malloc. En particulier soit l'allocation
réussit soit il jette std::bad_alloc.

Ne faut-il pas verifier si l'allocation de t a echouee ou est-ce une
erreur de ma part ?

L'intention était bonne.
--
Franck Branjonneau

Fabien LE LEZ

10/07/2004 à 02:12

On Fri, 9 Jul 2004 16:52:43 +0200, docCarcass
:

je debute en c++ et je ne trouve pas de reponse a une question :
je dispose d'une classe Vector1D ou il n'y a pas de constructeur par
default :

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>. Je connais la syntaxe type *toto = new type[NBITEM]

En plus des réponses données : cherche "placement new" dans ton
manuel.
Note de traduction : dans (une vieille) VF du Stroustrup ils parlent
de "syntaxe de placement" (section 10.4.11).
C'est assez tordu, à tel point que je n'ai jamais eu l'occasion de
l'utiliser, mais il me semble que c'est ce qu'utilise std::vector<>.

--
schtroumpf schtroumpf
Jean-Emile de France

Loïc Joly

10/07/2004 à 11:33

docCarcass wrote:

Bonjour a tous,
je debute en c++ et je ne trouve pas de reponse a une question :
je dispose d'une classe Vector1D ou il n'y a pas de constructeur par
default :
[...]

Pour creer une classe Vector2D<K> je souhaite declarer un tableaux de
Vector1D<K>.

Une autre solution pour ce genre de choses est pour avoir un Vector2D de
n sur m, de créer un seul Vector1D, de taille (n*m), et quand tu veux
l'élément (i, j) de ton Vector2D, de retourner l'élément (i*n + j) du
Vector1D sous jacent.

--
Loïc

Falk Tannhäuser

12/07/2004 à 12:54

docCarcass wrote:

template<class K> class Vector1D
{

private:
unsigned int dim;
K *t;

public:

Vector1D(unsigned int dim):dim(dim),t(new K[dim])
{
assert(t);
}

Vector1D(const Vector1D &v):dim(v.dim),t(new K[dim])
{
operator=(v);
}

Vector1D &operator=(const Vector1D &v)
{
assert(dim==v.dim);
memcpy(t,v.t,dim*sizeof(K));

'memcpy' n'est pas approprié pour copier des objets de n'importe
quel type ! (Par exemple, imagine que tu instancies ton template
avec 'Vector1D<double>' pour 'K' - où vont-ils pointer 'v.t[0].t'
et 'this->t[0].t' ? Que se passe-t-il avec '*this' lorsque 'v' sera
modifié, ou pire, détruit après cette affectation [ou vice-versa] ?)
Faire plutôt :

std::copy(v.t, v.t + dim, t);

Avec un bon compilo, 'std::copy' est spécialisé afin d'utiliser 'memcpy'
en interne pour les types pour lesquels cela est possible, de manière
à ne pas perdre en performance. En revanche, lorsque le type en question
n'est pas copiable par 'memcpy', l'opérateur d'affectation Qui Va Bien
sera appelé.

return *this;
}

Falk

1 2

operateur []

10 réponses

Veuillez sélectionner un problème