Bonjour !

Q1) Je voudrais savoir si on peut demander au compilateur d'inferer le
type d'un element d'un vecteur :

template<class T>
class DumpVisitor
{
public:
void operator()(T item)
{
cout << "Item = " << item << endl;
}
};

vector<int> v;
....
for_each(v.begin(), v.end(), DumpVisitor<int>); // OK
for_each(v.begin(), v.end(), DumpVisitor<v.?>); // ?

Le but : definir une macro qui ne prend qu'un parametre, le vector !

Q2) Est-ce qu'avec le TR1 on peut ecrire plus simplement ceci :

vector<int> v;
v.push_back(1900);
v.push_back(1984);
v.push_back(2000);
v.push_back(2007);
v.push_back(2008);

Genre : vector<int> v = { 1900, 1984, 2000, 2007, 2008 };

Un tout grand merci.

mderie a écrit :
> Bonjour !
>
> Q1) Je voudrais savoir si on peut demander au compilateur d'inferer le
> type d'un element d'un vecteur :
>
> template<class T>
> class DumpVisitor
> {
> public:
> void operator()(T item)
> {
> cout << "Item = " << item << endl;
> }
> };
>
> vector<int> v;
> ...
> for_each(v.begin(), v.end(), DumpVisitor<int>); // OK
> for_each(v.begin(), v.end(), DumpVisitor<v.?>); // ?
>
> Le but : definir une macro qui ne prend qu'un parametre, le vector !

Le define vector<>::value_type to donne le type des données que
contients le vecteur.

>
> Q2) Est-ce qu'avec le TR1 on peut ecrire plus simplement ceci :
>
> vector<int> v;
> v.push_back(1900);
> v.push_back(1984);
> v.push_back(2000);
> v.push_back(2007);
> v.push_back(2008);
>
> Genre : vector<int> v = { 1900, 1984, 2000, 2007, 2008 };

Non mais tu peux le faire avec boost::array (std::tr1::array<>).

boost::array<int,5> v_init = { { 1900,1984, 2000, 2007,2008 } };
vector<int> v(v_init.begin(),v_init.end());

Sinon, il n'est pas trop du de se faire une fonction make_vector<>() qui
prends un tableau en entrée et retourne le vector<> correspondant puis
tu swap.

Michael

On Mar 4, 12:38 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:
> mderie a écrit :
>
>
>
> > Bonjour !
>
> > Q1) Je voudrais savoir si on peut demander au compilateur d'inferer le
> > type d'un element d'un vecteur :
>
> > template<class T>
> > class DumpVisitor
> > {
> > public:
> > void operator()(T item)
> > {
> > cout << "Item = " << item << endl;
> > }
> > };
>
> > vector<int> v;
> > ...
> > for_each(v.begin(), v.end(), DumpVisitor<int>); // OK
> > for_each(v.begin(), v.end(), DumpVisitor<v.?>); // ?
>
> > Le but : definir une macro qui ne prend qu'un parametre, le vector !
>
> Le define vector<>::value_type to donne le type des données que
> contients le vecteur.

Oui mais bon cela m'oblige a ecrire qqch de ridicule :

for_each(v.begin(), v.end(), DumpVisitor<vector<int>::value_type>());

Or v a ete entierement defini...
==> Ma conclusion est donc que non le compilo ne peut pas m'aider:-(

> > Q2) Est-ce qu'avec le TR1 on peut ecrire plus simplement ceci :
>
> > vector<int> v;
> > v.push_back(1900);
> > v.push_back(1984);
> > v.push_back(2000);
> > v.push_back(2007);
> > v.push_back(2008);
>
> > Genre : vector<int> v = { 1900, 1984, 2000, 2007, 2008 };
>
> Non mais tu peux le faire avec boost::array (std::tr1::array<>).
>
> boost::array<int,5> v_init = { { 1900,1984, 2000, 2007,2008 } };

Non merci : Je dois encore compter moi-meme le nombre d'element du
tableau(ici 5)...

Merci bcp quand meme

> vector<int> v(v_init.begin(),v_init.end());
>
> Sinon, il n'est pas trop du de se faire une fonction make_vector<>() qui
> prends un tableau en entrée et retourne le vector<> correspondant puis
> tu swap.
>
> Michael

mderie a écrit :
> On Mar 4, 12:38 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:

>>> Q2) Est-ce qu'avec le TR1 on peut ecrire plus simplement ceci :
>>> vector<int> v;
>>> v.push_back(1900);
>>> v.push_back(1984);
>>> v.push_back(2000);
>>> v.push_back(2007);
>>> v.push_back(2008);
>>> Genre : vector<int> v = { 1900, 1984, 2000, 2007, 2008 };
>> Non mais tu peux le faire avec boost::array (std::tr1::array<>).
>>
>> boost::array<int,5> v_init = { { 1900,1984, 2000, 2007,2008 } };
>
> Non merci : Je dois encore compter moi-meme le nombre d'element du
> tableau(ici 5)...

Sans le TR1, ni Boost, juste avec 2 fonctions triviales (cf plus bas),
il n'y a pas besoin de compter les elements:

int v_init[] = { 1900, 1984, 2000, 2007, 2008 };
vector< int > v( begin(v_init), end(v_init) ) ;

Les deux fonctions begin et end :

template< typename T, size_t N >
inline T* begin( T (&array)[ N ] )
{ return array ; }

template< typename T, size_t N >
inline T* end( T (&array)[ N ] )
{ return array + N ; }

On Tue, 04 Mar 2008 12:38:39 +0100, Michael DOUBEZ
<michael.doubez@free.fr> wrote:

> Genre : vector<int> v = { 1900, 1984, 2000, 2007, 2008 };


Ce genre de chose est faite pour boost::assign.
Exemple.
vector<int> v m= 1900, 1984, 2000, 2007, 2008;

On Mar 4, 5:37 pm, David Côme <davidc...@wanadoo.fr> wrote:
> On Tue, 04 Mar 2008 12:38:39 +0100, Michael DOUBEZ

> <michael.dou...@free.fr> wrote:
> > Genre : vector<int> v = { 1900, 1984, 2000, 2007, 2008 };

> Ce genre de chose est faite pour boost::assign.
> Exemple.
> vector<int> v m= 1900, 1984, 2000, 2007, 2008;

Il n'y a quelque chose là qui ne va pas. C'est quoi comme
syntax ? Au moins qu'il y ait un macro que je ne vois pas, un
compilateur doit émettre une erreur sur cette ligne. « v m »,
je ne crois pas que sans macro, ça peut jamais être légal. (Je
crois qu'il y a quelque chose dans boost qui permet :
v += 1900, 1984, 2000, 2007, 2008 ;
mais ça marche parce que l'opérateur += est surchargé, et qu'il
renvoie quelque chose pour lequel l'opérateur , est surchargé.
L'obfuscation, quoi. Mais dans ton cas, il n'y a pas
d'opérateurs à surcharger.)

--
James Kanze (GABI Software) email:james.kanze@gmail.com
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

On Tue, 4 Mar 2008 03:17:04 -0800 (PST), mderie <mderie@gmail.com>:

template<class T>
class DumpVisitor_T
{ ... };

template <class C> DumpVisitor_T<C::value_type> DumpVisitor (C const&)
{
return DumpVisitor_T<C::value_type>();
}

>for_each(v.begin(), v.end(), DumpVisitor<int>); // OK

Je suis quasi-sûr que ça ne fonctionne pas. DumpVisitor<int> est un
type, et une fonction attend un objet en argument. Il faudrait donc
écrire for_each(v.begin(), v.end(), DumpVisitor<int>());

Mais avec le code ci-dessus, on peut écrire :

for_each(v.begin(), v.end(), DumpVisitor(v));


On pourrait même faire mieux :

template <class C> void ForEachDumpVisitor (C& v)
{
for_each (v.begin(), v.end(), DumpVisitor_T<C::value_type>());
}

On Tue, 04 Mar 2008 18:13:59 +0100, James Kanze <james.kanze@gmail.com>
wrote:

> On Mar 4, 5:37 pm, David Côme <davidc...@wanadoo.fr> wrote:
>> On Tue, 04 Mar 2008 12:38:39 +0100, Michael DOUBEZ
>
>> <michael.dou...@free.fr> wrote:
>> > Genre : vector<int> v = { 1900, 1984, 2000, 2007, 2008 };
>
>> Ce genre de chose est faite pour boost::assign.
>> Exemple.
>> vector<int> v m= 1900, 1984, 2000, 2007, 2008;

> Il n'y a quelque chose là qui ne va pas. C'est quoi comme
> syntax ? Au moins qu'il y ait un macro que je ne vois pas, un
> compilateur doit émettre une erreur sur cette ligne. « v m »,
> je ne crois pas que sans macro, ça peut jamais être légal. (Je
> crois qu'il y a quelque chose dans boost qui permet :
> v += 1900, 1984, 2000, 2007, 2008 ;
> mais ça marche parce que l'opérateur += est surchargé, et qu'il
> renvoie quelque chose pour lequel l'opérateur , est surchargé.
> L'obfuscation, quoi. Mais dans ton cas, il n'y a pas
> d'opérateurs à surcharger.)


Tu as raison James, ya des faute de frappe
Sinon voici une exemple complet et minimaliste de boost::assign.

#include <boost/assign/std/vector.hpp> // for 'operator+=()'
#include <boost/assert.hpp>

using namespace std;
using namespace boost::assign;

int main()
{
vector<int> values ;
values += 1900,1984,2000,2007,2008;
}