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
Bonjour !
Q1) Je voudrais savoir si on peut demander au compilateur d'inferer le
type d'un element d'un vecteur :
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.
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
On Mar 4, 12:38 pm, Michael DOUBEZ wrote:
Bonjour !
Q1) Je voudrais savoir si on peut demander au compilateur d'inferer le type d'un element d'un vecteur :
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
On Mar 4, 12:38 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:
Bonjour !
Q1) Je voudrais savoir si on peut demander au compilateur d'inferer le
type d'un element d'un vecteur :
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.
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
Michel Decima
On Mar 4, 12:38 pm, Michael DOUBEZ 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<>).
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 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<>).
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<>).
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: 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 Mar 4, 5:37 pm, David Côme <davidc...@wanadoo.fr> wrote:
On Tue, 04 Mar 2008 12:38:39 +0100, Michael DOUBEZ
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
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: 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
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>());
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>());
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>());
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 :D 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; }
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
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 :D
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;
}
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 :D 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; }
Falk Tannhäuser
mderie schrieb:
On Mar 4, 12:38 pm, Michael DOUBEZ wrote:
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 :
On Mar 4, 12:38 pm, Michael DOUBEZ <michael.dou...@free.fr> wrote:
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 :
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 :
On Tue, 04 Mar 2008 18:13:59 +0100, James Kanze wrote:
[...]
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; }
Ce qui est déroutant, pour le moindre. J'aurais tendance à le considérer même de l'obfusation et l'abus du surcharge de l'opérateur. (Mais est-ce qu'il y a jamais des cas de surcharge de l'opérateur virgule qui ne sont pas d'abus ?)
-- James Kanze (GABI Software) email: 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 4 mar, 18:43, David Côme <davidc...@wanadoo.fr> wrote:
On Tue, 04 Mar 2008 18:13:59 +0100, James Kanze <james.ka...@gmail.com>
wrote:
[...]
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;
}
Ce qui est déroutant, pour le moindre. J'aurais tendance à le
considérer même de l'obfusation et l'abus du surcharge de
l'opérateur. (Mais est-ce qu'il y a jamais des cas de surcharge
de l'opérateur virgule qui ne sont pas d'abus ?)
--
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, 04 Mar 2008 18:13:59 +0100, James Kanze wrote:
[...]
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; }
Ce qui est déroutant, pour le moindre. J'aurais tendance à le considérer même de l'obfusation et l'abus du surcharge de l'opérateur. (Mais est-ce qu'il y a jamais des cas de surcharge de l'opérateur virgule qui ne sont pas d'abus ?)
-- James Kanze (GABI Software) email: 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
Falk Tannhäuser
James Kanze wrote:
On 4 mar, 18:43, David Côme wrote:
Sinon voici une exemple complet et minimaliste de boost::assign.
#include <boost/assign/std/vector.hpp> // for 'operator+=()'
using namespace std; using namespace boost::assign;
int main() { vector<int> values ; values += 1900,1984,2000,2007,2008; }
Ce qui est déroutant, pour le moindre. J'aurais tendance à le considérer même de l'obfusation et l'abus du surcharge de l'opérateur. (Mais est-ce qu'il y a jamais des cas de surcharge de l'opérateur virgule qui ne sont pas d'abus ?)
Surtout ça donne des résultats "intéressants" dès que les expressions ayant des effets de bord entrent en jeu :
int i = 0; values += ++i, ++i, ++i, i--, i--, i--; std::copy(values.begin(), values.end(), std::ostream_iterator<int>(std::cout, " "));
m'affiche "1 2 3 3 2 1 " avec GCC et "0 0 0 -2 -1 0 " avec MSVC, et les deux ont raison...
Falk
James Kanze wrote:
On 4 mar, 18:43, David Côme <davidc...@wanadoo.fr> wrote:
Sinon voici une exemple complet et minimaliste de boost::assign.
#include <boost/assign/std/vector.hpp> // for 'operator+=()'
using namespace std;
using namespace boost::assign;
int main()
{
vector<int> values ;
values += 1900,1984,2000,2007,2008;
}
Ce qui est déroutant, pour le moindre. J'aurais tendance à le
considérer même de l'obfusation et l'abus du surcharge de
l'opérateur. (Mais est-ce qu'il y a jamais des cas de surcharge
de l'opérateur virgule qui ne sont pas d'abus ?)
Surtout ça donne des résultats "intéressants" dès que les expressions
ayant des effets de bord entrent en jeu :
int i = 0;
values += ++i, ++i, ++i, i--, i--, i--;
std::copy(values.begin(), values.end(),
std::ostream_iterator<int>(std::cout, " "));
m'affiche "1 2 3 3 2 1 " avec GCC et "0 0 0 -2 -1 0 " avec MSVC, et les
deux ont raison...
Sinon voici une exemple complet et minimaliste de boost::assign.
#include <boost/assign/std/vector.hpp> // for 'operator+=()'
using namespace std; using namespace boost::assign;
int main() { vector<int> values ; values += 1900,1984,2000,2007,2008; }
Ce qui est déroutant, pour le moindre. J'aurais tendance à le considérer même de l'obfusation et l'abus du surcharge de l'opérateur. (Mais est-ce qu'il y a jamais des cas de surcharge de l'opérateur virgule qui ne sont pas d'abus ?)
Surtout ça donne des résultats "intéressants" dès que les expressions ayant des effets de bord entrent en jeu :
int i = 0; values += ++i, ++i, ++i, i--, i--, i--; std::copy(values.begin(), values.end(), std::ostream_iterator<int>(std::cout, " "));
m'affiche "1 2 3 3 2 1 " avec GCC et "0 0 0 -2 -1 0 " avec MSVC, et les deux ont raison...