Copie d'une partie d'un tableau sur un intervalle régulier

Version imprimable

16/04/2010, 15h08
olivier21c

Copie d'une partie d'un tableau sur un intervalle régulier

Bonjour,
J'ai un tableau dont je souhaiterai copier une partie sur des pas régulier :

Citation:

unsigned char* tab = new char[N];

je voudrais donc copier seulement certaines cases de ce tableau, toutes les 5 cases par exemple, soit les indices 0, 5, 10, 15, etc. .

Existe-t-il une méthode rapide (stl ?) pour effectuer ceci

NB : l'utilisation d'un unsigned char* est le plus approprié dans mon cas (donc pas de réponse du style : utilise un std::vector, c'est mieux :aie:)

Merci d'avance
16/04/2010, 15h54
Arzar

Bonjour,

Citation:

Envoyé par olivier21c

je voudrais donc copier seulement certaines cases de ce tableau, toutes les 5 cases par exemple, soit les indices 0, 5, 10, 15, etc. .

Existe-t-il une méthode rapide (stl ?) pour effectuer ceci

Une boucle for ?
A vrai dire ça doit être aussi possible avec un std::copy_if + un prédicat mais c'est beaucoup d'effort pour pas grand chose (copy_if n'est pas présent dans le stl du C++03, il faut se le coder)

Citation:

Envoyé par olivier21c

NB : l'utilisation d'un unsigned char* est le plus approprié dans mon cas

Douteux.
16/04/2010, 16h11
olivier21c

Citation:

Envoyé par Arzar

Bonjour,

Une boucle for ?
A vrai dire ça doit être aussi possible avec un std::copy_if + un prédicat mais c'est beaucoup d'effort pour pas grand chose (copy_if n'est pas présent dans le stl du C++03, il faut se le coder)

ba la boucle c'est ce que j'utilise, mais je me demandais juste si une solution plus rapide n'existait pas...

Citation:

Envoyé par Arzar

Douteux.

Et bien si dans mon cas c'est la meilleur solution (je précise que je ne l'utilise pas opur des chaîne de caractères ^^)
16/04/2010, 18h27
bruno_pages

Citation:

Envoyé par olivier21c

Citation:

Envoyé par Arzar

Douteux.

je précise que je ne l'utilise pas opur des chaîne de caractères ^^

alors c'est encore plus douteux :mouarf:
17/04/2010, 08h13
3DArchi

Salut,
Plutôt que de travailler sur un prédicat et std::copy_if, à priori, je serais plutôt intervenu sur l'itérateur. Quelque chose comme un itérateur construit à partir d'un autre itérateur et d'un pas et qui ferait un std::advance lors de l'appel de l'opérateur ++. Ensuite, juste un std::copy avec cet itérateur.

Citation:

Envoyé par bruno_pages

Citation:

Envoyé par olivier21c

Citation:

Envoyé par Arzar

Douteux.

je précise que je ne l'utilise pas opur des chaîne de caractères ^^

alors c'est encore plus douteux

Pourquoi a-t-on des doutes ? std::vector<unsigned char> c'est un new unsigned char[] .... avec le RAII en bonus. C'est pour ça qu'on a du mal à comprendre que l'allocation dynamique explicite soit le plus approprié. Si c'est le cas, alors, le std::vector aussi...
17/04/2010, 10h06
bruno_pages

Citation:

Envoyé par 3DArchi

Pourquoi a-t-on des doutes ?

à cause de la phrase je ne l'utilise pas opur des chaîne de caractères qui semble laissé penser qu'un vecteur de X (autre que des caractères) est casté en unsigned char * afin de réaliser la copie, mais je suis peu être parano ?
17/04/2010, 10h47
poukill
Citation:

Envoyé par bruno_pages

à cause de la phrase je ne l'utilise pas opur des chaîne de caractères qui semble laissé penser qu'un vecteur de X (autre que des caractères) est casté en unsigned char * afin de réaliser la copie, mais je suis peu être parano ?

Attention, 3DArchi allait pleinement dans ton sens. Il a rappelé que std::vector est mieux, parce que c'est un new T[] qui est réalisé à l'intérieur, avec le RAII en plus ! ;)
Je me rajoute donc à la liste des sceptiques:
- std::vector : si la taille est susceptible de changer (push_back)
- boost::array : si la taille est connu à la compilation.
Au posteur :
Tu cherches quelque chose de compliqué à base de STL pour faire le travail de copie d'un intervalle? Utilise une boucle for, c'est pas grave, et tu vas moins te prendre la tête.
Par contre, tu nous sors un beau unsigned char*, alors que la STL fourni son équivalent en mieux ! Là par contre tu risques la prise de tête.
Rigolo, hein? 8-)
19/04/2010, 09h29
olivier21c

Bonjour à tous,

Je suis pleinement conscient que le std::vector fournit des avantages à l'utilisation d'un unsigned char*. Mais ici les intérêts que présente l'utilisation d'un vector ne m'intéresse pas (j'avais pourtant bien précisé dans mon premier post de l'inutilité d'un discussion autour de l'utilisation alternative de vector, mais bon faut croire que les gens aiment dévier les discussions dans un sens ou dans l'autre...). Les vector ne sont pas forcément la seule solution à tout codage.

La seule question à débattre ici est la rapidité améliorable en itérant d'une autre manière pour avoir accès à mes données. Si effectivemetn l'utilisation d'un vector me le permettait, pourquoi pas discutier de son utilisation, sinon c'est hors sujet à propos de mon post.
Quand je parlais de l'utilisation de STL pour itérer, ce n'était qu'une suggestion, j'étais ouvert à toute autre proposition.
19/04/2010, 10h45
jblecanard

Salut Olivier

Au vu des discussions, on peut supposer que tu sais utiliser correctement des pointeurs, ou du moins que tu sais ce que tu risques à le croire :mouarf:

Il n'y a rien de plus rapide qu'une boucle for. De toute façon, une fonction qui le fait à ta place aurait sans aucun doute utilisé une boucle for. Le seul truc à éventuellement optimiser, et à mon avis tu n'y gagnerai pas énormément, c'est jouer avec l'arithmétique des pointeurs. Mais c'est vraiment du chipotage, ne perd pas trop de temps sur la question ;).
19/04/2010, 11h10
olivier21c

Merci de la réponse.
En effet je cherchai juste à savoir si il existait une méthode existante (ou à implémenter) qui serait plus rapide. Apparemment non dans mon cas.

Je n'ai bien sur rien contre l'utilisation des vectors, et plus généralement de tous les conteneurs de la STL, seulement ici d'une part je pars d'un code existant conséquent où l'utilisation des pointeurs était tout à fait approprié. Le point le plus important est sur cette partie est le temps d'éxécutions, il y a beaucoup d'allers-retour et l'utilisation d'un vector n'aurait que peu d'avantage, si ce n'est une facilité d'utilisation dont je n'ai pas le besoin.
J'avais moi même fait il y a quelque temps des modification sur une partie des pointeurs en unsigned char* par des vector, et j'y perdais en vitesse (de peu, mais chaque ms est importante ici).

Si personne n'a d'autres idées, on peut considérer le sujet clos pour le moment
19/04/2010, 13h07
poukill

Citation:

Envoyé par jblecanard

Au vu des discussions, on peut supposer que tu sais utiliser correctement des pointeurs, ou du moins que tu sais ce que tu risques à le croire :mouarf:

Une fois que tu as lu des bouquins du genre "Exceptionnal C++", on se rend vite compte que les exceptions sont partout, et qu'il est extrêmement difficile d'écrire du code code exception-safe, c'est à dire un code qui se comporte correctement en cas d'exceptions, et tout celà sans fuite mémoire.
Tous les conteneurs standards sont exception-safe, au prix de sacré gouttes de sueurs par beaucoup de programmeurs. Les epsilons perdus en performance sont compensés par la sécurité qu'ils apportent.

@olivier21c : la boucle for fonctionnera très bien. Sujet clos alors. ;)
19/04/2010, 13h27
jblecanard

Citation:

Envoyé par poukill

Une fois que tu as lu des bouquins du genre "Exceptionnal C++", on se rend vite compte que les exceptions sont partout, et qu'il est extrêmement difficile d'écrire du code code exception-safe, c'est à dire un code qui se comporte correctement en cas d'exceptions, et tout celà sans fuite mémoire.
Tous les conteneurs standards sont exception-safe, au prix de sacré gouttes de sueurs par beaucoup de programmeurs. Les epsilons perdus en performance sont compensés par la sécurité qu'ils apportent.

Hé oui, d'où ma petite remarque. A moins que tu ne veuilles mettre les mains dans l'assembleur, le sujet est sûrement clos :).

Citation:

Envoyé par 3DArchi

Salut,
Plutôt que de travailler sur un prédicat et std::copy_if, à priori, je serais plutôt intervenu sur l'itérateur. Quelque chose comme un itérateur construit à partir d'un autre itérateur et d'un pas et qui ferait un std::advance lors de l'appel de l'opérateur ++. Ensuite, juste un std::copy avec cet itérateur.

C'est exactement l'approche retenu par boost.RangeEx, qui est actuellement dans le trunk (sous le nom boost.Range) et sera dispo dans la version 1.43 !
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #include <boost/range/algorithm/copy.hpp> #include <boost/range/adaptor/strided.hpp> using boost::copy; using boost::begin; using boost::adaptors::stride; int main() { int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int arr2[5]; int arr3[5]; int step = 2; // 1. boucle for for(int i = 0, j =0 ; i < 10 ; i += step, j++) { arr2[j] = arr[i]; } // 2. boost.RangeEx copy(stride(arr, step), arr3); }
L'assembleur généré m'a l'air un poil moins bon, mais ce one-liner "copy(stride(arr, step, arr3)" est quand même superbe, non ?

20/04/2010, 10h32
Joel F

Citation:

Envoyé par Arzar

L'assembleur généré m'a l'air un poil moins bon

Dans ce genre de cas, on s'en tape. le point limitant, c''est la BP mémoire. Alors avoir 3-4 instructions en plus ... bouarf.
20/04/2010, 10h56
jblecanard

Citation:

Envoyé par Arzar

mais ce one-liner "copy(stride(arr, step, arr3)" est quand même superbe, non ?

Oui oui boost envoie du pâté comme d'hab 8-)