2 questions sous ce titre énigmatique, parce que j'ai un peu de mal à me remettre au C  
 
1° Existe-t-il, à l'instar du shift en assembleur, une fonction qui permet de déplacer tous les éléments d'un vecteur en C d'une position vers la gauche ou la droite? Quitte à perdre une partie de l'info comme dans le shift.
 
2° J'ai un vague souvenir de fonction ayant pour paramètre des pointeurs vers d'autres fonctions, mais je n'arrive plus à mettre la main sur une doc qui en parle. si quelqu'un avait un lien, ca m'aiderait beaucoup.
 
Merci d'avance.

1) Tout déplacer en C, c'est une perte de temps. Il est beaucoup plus simple d'incrémenter un pointeur.
 
Exemple, si tu veux faire l'équivalent du shift du shell, c'est :
argv++; argc--;
 
2) Oui, ça existe. Tu veux faire quoi exactement ?

Ah bin oui, tu y perds. Mais il demande l'équivalent du shift du shell.
 
Au passage, il faut éviter ce genre de trucs avec les tableaux alloués avec malloc, ou du moins garder un pointeur vers le début quelque part...

autant pour moi alors ... j'avais pas tout lu en fait    
 
pour la remarque sur malloc, chuis entierement d'accord !

gizmo a écrit a écrit : 2 questions sous ce titre énigmatique, parce que j'ai un peu de mal à me remettre au C

 
une seule reponse a toutes tes questions:  
le langage C par Kernighan et Ritchie
Un tout petit investissement et tu pourras
faire la star en C
 
LEGREG

ok, merci pour vos réponses, je vais quand même préciser mes besoins, ca vous paraitra plus clair.
 
- le premier est dans un but de rapidité, je dois construire des matrices qui, d'une étape à l'autre ne changent que d'une colonne extrème. Or ces matrices prennent beaucoup de place mémoire et de temps à faire. donc, la solution d'un pointeur ne me va pas car je sature la mémoire de la machine car elles sont crées dynamiquement avec un malloc justement.
 
- le deuxième provient du fait que je dois appliquer une fonction à ces matrices de manière itérative. Or la fonction à appliquer dépend d'un paramètre, et de nouveau, dans un but de rapidité, pour ne pas faire un switch à chaque boucle, je cherche à stocker un acces à une fonction que je pourrais atteindre ensuite directement.
 
legreg>> merci pour la référence, mais malheureusement, je n'ai vraiment plus le temps de potasser un bouquin, ou bien je risque d'avoir tout le temps de le lire  
 
Ce problème me fait vraiment chier, j'avais tout fait en c++, et après ils viennent me dire que le but n'est pas la modularité mais la rapidité

gizmo a écrit a écrit : ok, merci pour vos réponses, je vais quand même préciser mes besoins, ca vous paraitra plus clair.   - le premier est dans un but de rapidité, je dois construire des matrices qui, d'une étape à l'autre ne changent que d'une colonne extrème. Or ces matrices prennent beaucoup de place mémoire et de temps à faire. donc, la solution d'un pointeur ne me va pas car je sature la mémoire de la machine car elles sont crées dynamiquement avec un malloc justement.   - le deuxième provient du fait que je dois appliquer une fonction à ces matrices de manière itérative. Or la fonction à appliquer dépend d'un paramètre, et de nouveau, dans un but de rapidité, pour ne pas faire un switch à chaque boucle, je cherche à stocker un acces à une fonction que je pourrais atteindre ensuite directement.   legreg>> merci pour la référence, mais malheureusement, je n'ai vraiment plus le temps de potasser un bouquin, ou bien je risque d'avoir tout le temps de le lire     Ce problème me fait vraiment chier, j'avais tout fait en c++, et après ils viennent me dire que le but n'est pas la modularité mais la rapidité

C'est pas des matrices creuses?
A+,

- le premier est dans un but de rapidité, je dois construire des matrices qui, d'une étape à l'autre ne changent que d'une colonne extrème. Or ces matrices prennent beaucoup de place mémoire et de temps à faire. donc, la solution d'un pointeur ne me va pas car je sature la mémoire de la machine car elles sont crées dynamiquement avec un malloc justement.
 
Hmouais. Pas facile comme truc. Tu peux imaginer des matrices avec pour chaque colonne un pointeur, et quasiment toutes les colonnes en commun.
 
 
- le deuxième provient du fait que je dois appliquer une fonction à ces matrices de manière itérative. Or la fonction à appliquer dépend d'un paramètre, et de nouveau, dans un but de rapidité, pour ne pas faire un switch à chaque boucle, je cherche à stocker un acces à une fonction que je pourrais atteindre ensuite directement.
 
Ça se fait sans problème, tu peux passer un pointeur vers une fonction, mais c'est le prototype qui est imbittable, il faut en trouver un pareil (au hasard, je connais pthread_create qui prend une  fonction en argument).
 
 
Ce problème me fait vraiment chier, j'avais tout fait en c++, et après ils viennent me dire que le but n'est pas la modularité mais la rapidité :fou:
 
Tu as essayé Blitz++ ? C'est fait pour ce genre de choses, c'est très rapide, et c'est du C++.

gilou>> non, malheureusement.
 
jar jar>> la solution de pointeur, j'y ai déja pensé, mais ca augmente considérablement la taille mémoire et le temps de parcours de la matrice.
 
Pour les fonctions, merci, je vais voir ce que tu m'a mis.
 
Pour blitz++ aussi, je vais me renseigner,  

ok, pour les matrices, j'ai une solution. un peu crade, mais ca va: je garde la atrice d'origine, je change une ligne désignée par un indice et je décale cet indice, ca me permet de n'écrire à chaque fois qu'une ligne et de disposer d'une sorte de liste cyclique sans l'inconvénient des pointeurs.