j'aimerai comprendre maintenant comment se passe l'initialisation des
vector, exemple j'ai un vector de 3 vector de 6 entier, soit un tableau
a 3 lignes et 6 colones. J'aimerai initialiser les 3 lignes ainsi :
| > | J'en ferais bien partie si j'avais une adresse email qui marchait. | | > | J'ai pas mal de problèmes personnels en ce moment. Alors, le C++ | > | devient un peu moins important. | | > Je comprends très bien. Nous avons tous chacun notre liste de priorité | > lié à nos problèmes et situations personnels. Par exemple, te faire | > parvenir les copies des messages du pôle d'expertise C/C++ n'est pas | > la priorité la plus importante. | | C'est certainement moins important que la réussite scolaire de mes | enfants, par exemple.
Très certainement. Et m'assurer que les messages t'arrivent est nettement moins important que m'occuper de ma famille (village serait plus approprié). M'enfin bon. Je ne sais pas pour toi, mais quand j'envoie un message et que je reçois un bounce, je regarde quand même -- en général, quand j'envoie un mail à quelqu'un, c'est que cela présente une certaine valeur. Un ou deux bounces occasionnels, c'est rien. Cela finit par agacer (au même titre que les spams), lorsque systématique et si c'est une fausse adresse publiée pour conscience professionnelle.
| Au moins dans mon cas, il y a d'autres choses dans la vie que le C++.
À qui le dis-tu :-) Tu as une famille dont il faut que tu t'occupes. D'autres ont des villages à leurs charges.
Dois-je comprendre que lorsque tu seras de nouveau intéressé, tu feras signe ?
-- Gaby
kanze@gabi-soft.fr writes:
[...]
| > | J'en ferais bien partie si j'avais une adresse email qui marchait.
|
| > | J'ai pas mal de problèmes personnels en ce moment. Alors, le C++
| > | devient un peu moins important.
|
| > Je comprends très bien. Nous avons tous chacun notre liste de priorité
| > lié à nos problèmes et situations personnels. Par exemple, te faire
| > parvenir les copies des messages du pôle d'expertise C/C++ n'est pas
| > la priorité la plus importante.
|
| C'est certainement moins important que la réussite scolaire de mes
| enfants, par exemple.
Très certainement. Et m'assurer que les messages t'arrivent est
nettement moins important que m'occuper de ma famille (village serait
plus approprié). M'enfin bon. Je ne sais pas pour toi, mais quand
j'envoie un message et que je reçois un bounce, je regarde quand même
-- en général, quand j'envoie un mail à quelqu'un, c'est que cela
présente une certaine valeur. Un ou deux bounces occasionnels, c'est
rien. Cela finit par agacer (au même titre que les spams), lorsque
systématique et si c'est une fausse adresse publiée pour conscience
professionnelle.
| Au moins dans mon cas, il y a d'autres choses dans la vie que le C++.
À qui le dis-tu :-) Tu as une famille dont il faut que tu t'occupes.
D'autres ont des villages à leurs charges.
Dois-je comprendre que lorsque tu seras de nouveau intéressé, tu feras
signe ?
| > | J'en ferais bien partie si j'avais une adresse email qui marchait. | | > | J'ai pas mal de problèmes personnels en ce moment. Alors, le C++ | > | devient un peu moins important. | | > Je comprends très bien. Nous avons tous chacun notre liste de priorité | > lié à nos problèmes et situations personnels. Par exemple, te faire | > parvenir les copies des messages du pôle d'expertise C/C++ n'est pas | > la priorité la plus importante. | | C'est certainement moins important que la réussite scolaire de mes | enfants, par exemple.
Très certainement. Et m'assurer que les messages t'arrivent est nettement moins important que m'occuper de ma famille (village serait plus approprié). M'enfin bon. Je ne sais pas pour toi, mais quand j'envoie un message et que je reçois un bounce, je regarde quand même -- en général, quand j'envoie un mail à quelqu'un, c'est que cela présente une certaine valeur. Un ou deux bounces occasionnels, c'est rien. Cela finit par agacer (au même titre que les spams), lorsque systématique et si c'est une fausse adresse publiée pour conscience professionnelle.
| Au moins dans mon cas, il y a d'autres choses dans la vie que le C++.
À qui le dis-tu :-) Tu as une famille dont il faut que tu t'occupes. D'autres ont des villages à leurs charges.
Dois-je comprendre que lorsque tu seras de nouveau intéressé, tu feras signe ?
-- Gaby
Gabriel Dos Reis
Marc Boyer writes:
| Gabriel Dos Reis wrote: | > Marc Boyer writes: | > Ces templates sont devenus classiques | > | > template<typename T, int N> | > inline const T* begin(const T (&array)[N]) | > { return array; } | > | > template<typename T, int N> | > inline const T* end(const T (&array)[N]) | > { return array + N; } | | J'avais raté que la résolution de template savait | prendre en compte la taille d'un tableau.
yep. Mais il faut faire attention à bien passer par référence.
| Je vais de surprise en surprise.
:-)
Le crédo « les tableaux C ne sont pas des pointeurs et encore plus vrai en C++ » :-)
| Sinon, merci pour la ref du "Ruminations". J'ai beaucoup | aimé le passage sur les itérateurs (et la subtilité des | iterateurs en sens inverse). Le passage sur les objets | fonctions qu'on peut composer aussi m'a un peu décoiffé | aussi.
c'est un prêté pour un rendu :-)
-- Gaby
Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
| Gabriel Dos Reis wrote:
| > Marc Boyer <Marc.Boyer@enseeiht.yahoo.fr.invalid> writes:
| > Ces templates sont devenus classiques
| >
| > template<typename T, int N>
| > inline const T* begin(const T (&array)[N])
| > { return array; }
| >
| > template<typename T, int N>
| > inline const T* end(const T (&array)[N])
| > { return array + N; }
|
| J'avais raté que la résolution de template savait
| prendre en compte la taille d'un tableau.
yep. Mais il faut faire attention à bien passer par référence.
| Je vais de surprise en surprise.
:-)
Le crédo « les tableaux C ne sont pas des pointeurs et encore plus
vrai en C++ » :-)
| Sinon, merci pour la ref du "Ruminations". J'ai beaucoup
| aimé le passage sur les itérateurs (et la subtilité des
| iterateurs en sens inverse). Le passage sur les objets
| fonctions qu'on peut composer aussi m'a un peu décoiffé
| aussi.
| Gabriel Dos Reis wrote: | > Marc Boyer writes: | > Ces templates sont devenus classiques | > | > template<typename T, int N> | > inline const T* begin(const T (&array)[N]) | > { return array; } | > | > template<typename T, int N> | > inline const T* end(const T (&array)[N]) | > { return array + N; } | | J'avais raté que la résolution de template savait | prendre en compte la taille d'un tableau.
yep. Mais il faut faire attention à bien passer par référence.
| Je vais de surprise en surprise.
:-)
Le crédo « les tableaux C ne sont pas des pointeurs et encore plus vrai en C++ » :-)
| Sinon, merci pour la ref du "Ruminations". J'ai beaucoup | aimé le passage sur les itérateurs (et la subtilité des | iterateurs en sens inverse). Le passage sur les objets | fonctions qu'on peut composer aussi m'a un peu décoiffé | aussi.
c'est un prêté pour un rendu :-)
-- Gaby
Falk Tannhäuser
|> template<typename T, int N> |> inline size_t size(const T (&)[N]) |> { return N; } Parfois on a besoin d'une constante de compilation ; dans ce cas la solution suivante est applicable : _______________________________________________________ template <std::size_t N> struct array { char value[N]; };
Je ne sais pas s'il y a un moyen d'éviter le #define sans rendre l'utilisation de cette solution trop compliquée...
Falk
|> template<typename T, int N>
|> inline size_t size(const T (&)[N])
|> { return N; }
Parfois on a besoin d'une constante de compilation ;
dans ce cas la solution suivante est applicable :
_______________________________________________________
template <std::size_t N>
struct array { char value[N]; };
|> template<typename T, int N> |> inline size_t size(const T (&)[N]) |> { return N; } Parfois on a besoin d'une constante de compilation ; dans ce cas la solution suivante est applicable : _______________________________________________________ template <std::size_t N> struct array { char value[N]; };
Je ne sais pas s'il y a un moyen d'éviter le #define sans rendre l'utilisation de cette solution trop compliquée...
Falk
Gabriel Dos Reis
Falk Tannhäuser writes:
| |> template<typename T, int N> | |> inline size_t size(const T (&)[N]) | |> { return N; } | Parfois on a besoin d'une constante de compilation ; | dans ce cas la solution suivante est applicable : | _______________________________________________________ | template <std::size_t N> | struct array { char value[N]; }; | | template<typename T, std::size_t N> | array<N> array_size_helper(T (&)[N]); | | #define array_size(array) (sizeof array_size_helper(array).value) | _______________________________________________________ | | Je ne sais pas s'il y a un moyen d'éviter le #define sans | rendre l'utilisation de cette solution trop compliquée...
C'est, entre autres, pour couper court à ces « abus » de macros et de templates que j'ai proposé les « constant-valued functions »
| |> template<typename T, int N>
| |> inline size_t size(const T (&)[N])
| |> { return N; }
| Parfois on a besoin d'une constante de compilation ;
| dans ce cas la solution suivante est applicable :
| _______________________________________________________
| template <std::size_t N>
| struct array { char value[N]; };
|
| template<typename T, std::size_t N>
| array<N> array_size_helper(T (&)[N]);
|
| #define array_size(array) (sizeof array_size_helper(array).value)
| _______________________________________________________
|
| Je ne sais pas s'il y a un moyen d'éviter le #define sans
| rendre l'utilisation de cette solution trop compliquée...
C'est, entre autres, pour couper court à ces « abus » de macros et de
templates que j'ai proposé les « constant-valued functions »
| |> template<typename T, int N> | |> inline size_t size(const T (&)[N]) | |> { return N; } | Parfois on a besoin d'une constante de compilation ; | dans ce cas la solution suivante est applicable : | _______________________________________________________ | template <std::size_t N> | struct array { char value[N]; }; | | template<typename T, std::size_t N> | array<N> array_size_helper(T (&)[N]); | | #define array_size(array) (sizeof array_size_helper(array).value) | _______________________________________________________ | | Je ne sais pas s'il y a un moyen d'éviter le #define sans | rendre l'utilisation de cette solution trop compliquée...
C'est, entre autres, pour couper court à ces « abus » de macros et de templates que j'ai proposé les « constant-valued functions »
« literals for user-defined types » http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1511.pdf
-- Gaby
Falk Tannhäuser
Gabriel Dos Reis wrote:
Falk Tannhäuser writes: | Parfois on a besoin d'une constante de compilation ; | dans ce cas la solution suivante est applicable : | _______________________________________________________ | template <std::size_t N> | struct array { char value[N]; }; | | template<typename T, std::size_t N> | array<N> array_size_helper(T (&)[N]); | | #define array_size(array) (sizeof array_size_helper(array).value) | _______________________________________________________ | | Je ne sais pas s'il y a un moyen d'éviter le #define sans | rendre l'utilisation de cette solution trop compliquée...
C'est, entre autres, pour couper court à ces « abus » de macros et de templates que j'ai proposé les « constant-valued functions » http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1521.pdf
Voir également « literals for user-defined types » http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1511.pdf
Cool ! Espérons que ça passera à la prochaine révision de la Norme...
Falk
Gabriel Dos Reis wrote:
Falk Tannhäuser <falk.tannhauser@crf.canon.fr> writes:
| Parfois on a besoin d'une constante de compilation ;
| dans ce cas la solution suivante est applicable :
| _______________________________________________________
| template <std::size_t N>
| struct array { char value[N]; };
|
| template<typename T, std::size_t N>
| array<N> array_size_helper(T (&)[N]);
|
| #define array_size(array) (sizeof array_size_helper(array).value)
| _______________________________________________________
|
| Je ne sais pas s'il y a un moyen d'éviter le #define sans
| rendre l'utilisation de cette solution trop compliquée...
C'est, entre autres, pour couper court à ces « abus » de macros et de
templates que j'ai proposé les « constant-valued functions »
http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1521.pdf
Voir également « literals for user-defined types »
http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1511.pdf
Cool ! Espérons que ça passera à la prochaine révision de la Norme...
Falk Tannhäuser writes: | Parfois on a besoin d'une constante de compilation ; | dans ce cas la solution suivante est applicable : | _______________________________________________________ | template <std::size_t N> | struct array { char value[N]; }; | | template<typename T, std::size_t N> | array<N> array_size_helper(T (&)[N]); | | #define array_size(array) (sizeof array_size_helper(array).value) | _______________________________________________________ | | Je ne sais pas s'il y a un moyen d'éviter le #define sans | rendre l'utilisation de cette solution trop compliquée...
C'est, entre autres, pour couper court à ces « abus » de macros et de templates que j'ai proposé les « constant-valued functions » http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1521.pdf
Voir également « literals for user-defined types » http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1511.pdf
Cool ! Espérons que ça passera à la prochaine révision de la Norme...
Falk
kanze
Gabriel Dos Reis wrote in message news:...
Dois-je comprendre que lorsque tu seras de nouveau intéressé, tu feras signe ?
Disons que ça m'intéresse toujours, même si actuellement toute participation serait plutôt passive. Et que je ferais signe dès que j'ai une adresse email qui fonctionne.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Gabriel Dos Reis <gdr@integrable-solutions.net> wrote in message
news:<m3he0kzqez.fsf@uniton.integrable-solutions.net>...
Dois-je comprendre que lorsque tu seras de nouveau intéressé, tu feras
signe ?
Disons que ça m'intéresse toujours, même si actuellement toute
participation serait plutôt passive. Et que je ferais signe dès que j'ai
une adresse email qui fonctionne.
--
James Kanze GABI Software mailto:kanze@gabi-soft.fr
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
Dois-je comprendre que lorsque tu seras de nouveau intéressé, tu feras signe ?
Disons que ça m'intéresse toujours, même si actuellement toute participation serait plutôt passive. Et que je ferais signe dès que j'ai une adresse email qui fonctionne.
-- James Kanze GABI Software mailto: Conseils en informatique orientée objet/ http://www.gabi-soft.fr Beratung in objektorientierter Datenverarbeitung 11 rue de Rambouillet, 78460 Chevreuse, France, +33 (0)1 30 23 45 16
