Bonjour,
j'ai un tableau t d'entiers, séparés par un espace, de taille n. ex:t={ 12 15 16 86 896 854 589 569 123 156} (taille 10) et une fonction f. je voudrais appliquer à chaque entier du tableau t la fonction f de sorte que:    res = f(12). Comment prendre chaque élément de t?
Voici un code:
for(i=0; i<10; i++)
{res=f(i)};
 
Auriez vous s'il vous plaît un code si la taille du tableau n'est pas connue?
Merci.

ne pas répondre quand on fait autre chose
 
pour l'accès aux éléments d'un tableau t : t[indice]

sizeof

Les données dont tu parles (entiers séparé par un espace) elles sont dans un fichier texte, ou une chaine de caractère ? C'est pas très clair tout ça...

Les données dont tu parles (entiers séparé par un espace) elles sont dans une chaine de caractère ?
si  c'est la cas alors :
 
1) tu ne doit pas inissialiser comme ce : t={ 12 15 16 86 896 854 589 569 123 156}
tu peut faire :  t={ 12 , 15 , 16 , 86 , 896 , 854 , 589 , 569 , 123 , 156 }
 
 
2)tu peux acceder au element du tableau grace à t[i]   ( ou  *(t+i)   si tu ve utiliser les pointeurs )
 
for(i=0; i<10; i++)      { res = f(i) };
 
 
for(i=0; i<10; i++)        {  res = f( t[i] );    }
 
la variable res prandra à chaque passage :
f(12) ; f(15) ; f(16) ; f(86) ... jusqu'à   f(156) ;
 
 
 
 

Non... voici la bonne syntaxe

Il te faut alors mettre dans ton tableau une valeur dite "sentinelle" qui servira à détecter la fin du tableau. Bien évidemment, cette valeur particulière ne doit pas pouvoir s'y trouver de façon involontaire du programmeur...
Ex: On pose "-1" comme sentinelle

vinoromano a écrit :
 
j'ai un tableau t d'entiers, séparés par un espace, de taille n. ex:t={ 12 15 16 86 896 854 589 569 123 156} (taille 10) et une
 
----------------------------------------------------------------------
Les données dont tu parles (entiers séparé par un espace) elles sont dans un fichier texte, ou une chaine de caractère ? C'est pas très clair tout ça...
 
 
 
Le tableau est enregistré dans un fichier que j'ouvre mais je bloque sur comment lire chaque entier séparé par un espace et déterminer le nombre total d'elements.

Se documenter d'urgence sur:
- opération sur les fichiers: ouverture, fermeture, lecture.
- les tableaux.

 
Donne des détails sur la structure de ton fichier. Comment le tableau est-il écrit dans ton fichier ? Un nombre par ligne ?? Tous les nombres sur une même ligne ??? Est-il écrit textuellement "t={........}" ???
 

A mon avis, il serait bon de jeter aussi un oeuil sur les bases, les boucles, les manipulations de chaînes, bref tout le C...

 
pourquoi static ?
 
 

 
je comprends pas l'interet d'une telle solution, c'est tres restrictif et inutile car tu connais toujours la taille d'un tableau que tu manipules

C'est une habitude que j'ai prise lorsque j'ai vu que certain compilos refusaient de créer un tableau initialisé s'il n'était pas mis en classe d'allocation "static"...
 

En général oui. Il existe cependant un cas où la solution de la sentinelle est assez intéressante à employer
C'est le cas où tu as une liste de valeurs que tu veux traiter tout en laissant ton programme évolutif.
Si tu définis un tableau de "n" éléments, tu peux en effet boucler de 0 à "n". Mais le jour où tu rajoutes quelques valeur dans ton tableau, tu dois reprendre tout ton code et remplacer dans chaque boucle "n" par le nouveau "n".
Avec la valeur sentinelle, t'as plus ce soucis. Tu insères autant d'éléments que tu veux quand tu veux. Evidemment tu es restreint sur une valeur interdite.
 
T'as un exemple d'un tel tableau ici: http://forum.hardware.fr/hardwaref [...] 8189-1.htm
J'ai posté un code le 4/10/2004 où je balaye (ligne 49) un tableau nommé "tabQuestion" grâce à une sentinelle. Je peux y rajouter ainsi autant de questions que je veux sans me préoccuper de la boucle...

 
sur ? vieux compilateurs alors
et c'est tres problematique comme habitude car la sémantique n'est plus la meme (sauf si le tableau constant)
 

 
non ! un tableau reste un tableau, ce n'est pas parce que tu peux ne pas préciser sa taille en l'initialisant que celle-ci est inconnue
 

 
avec ca tu peux modifier la liste de valeur d'initialisation du tableau sans remplacer un "n" par un autre "n", je vois pas ou est le probleme et surtout dans quel cas une valeur "sentinelle" se justifie

Tout le monde n'est pas sur du Linux Mandrake 10.2    
 

 
Très joli exemple - En voici un autre

Je préfère personnellement cette solution qui inclut automatiquement le critère de fin dans le tableau que je manipule, plutôt que de définir une seconde variable où sa liaison avec le tableau "v" ne saute pas forcément aux yeux du néophyte.
 
Mais je ne dis pas que la sentinelle est "toujours" la meilleure solution. Surtout avec un tableau d'entiers où il peut être difficile d'aller trouver une valeur qui n'est jamais utilisée. Je dis que c'est "une solution" (je sais, dans mon post initial j'ai dit "il faut" mais c'est une erreur...)
 

Ah ? Que veux-tu dire avec la "sémantique" ???

 
pour une histoire de forme... tu peux aussi faire une macro si tu trouves ca trop lourd
 

 
et aucun probleme d'éfficacité puisque c'est évalué à la compilation
 
de toute facon tu as toujours besoin de connaitre la taille d'un tableau et ta méthode de parcours en testant une valeur sentinnelle doit severement brider le compilateur à l'étape optimisation
 
le seul interet que je vois aux valeurs sentinelles c'est pour les listes d'arguments variables (comme les fonctions exec), c'est nettement mieux au niveau de la sécurité que de devoir mettre à jour un entier indiquant le nombre d'arguement passés à la fonction
mais pour les tableaux c'est inutile et surement inefficace
 

 
si ton tableaux est déclarée "static" et de fait non constant les modifications seront conservées d'un appel à l'autre (puisque c'est le meme tableau, d'ailleur attention à la non-réentrance du code) alors que si il est lexical (automatique) il est créé et initialisé à chaque appel donc ce n'est pas du tout le meme comportement et le choix du qualificateur 'static' doit se faire avant tout en fonction de ca (la sémantique)

 
Je vois - Ce pourrait être illustré ainsi

Si "v" est static, v[0] s'incrémente au fur et à mesure qu'on appelle "f" alors que si "v" n'est pas static, v[0] vaut toujours 6 en fin de fonction
 
 

j'aimerais bien voir ça quand même... t'es sur de pas confondre avec le fait que l'initialiseur doit être constant ?