Je sais que c´est peut etre evident pour vous mais comment fait on pour additioner toutes valeurs d´un tableau entre elles.
Merci

en c++(dsl)

je ne connais pas le c++ masi ça doit etre dans ce style :
tu intialises une variale a 0 :
somme = 0;

tu parcours ton tableau en aisant une boucle
for(u = 0; u < longueut tableau; u++)
{
somme = tableau[u] + somme;
}

a oui c´est tout bete merci

honte a moi !

"deepblue Posté le 10 juin 2006 à 19:52:06

je ne connais pas le c++"

Mais comme tu connais le PHP, tu as de bonne base puisque la syntaxe du PHP est tiré du C

lol mais c´etais une excuse car ce que j´allais lui donner pas une syntaxe correct en C

en plus on peut simplifier par :
for (u = 0; u < longueut tableau; u++)
{
somme += tableau[u];
}

Petits ajouts à ne pas oublier:
long somme; //ou int, ou long long, ça dépend de l
a taille supposée de la somme
for(int u = 0; u < longueur; u++) {
somme += tableau[u];
}

sachant qu´on peut même contracter en :

for (int somme=0,int u=0;u<longueur;somme+=tableau[u++]);

a condition d´avoir un compilo pas trop stricte sur la norme (sinon il faut déclarer somme avant le for).

Le deuxième "int" n´est pas nécessaire
for(int somme=0,u=0;u<longueur;somme+=tableau[u++]);
Ca fonctionne mais on perd en lisibilité

Ce n´est peut etre moins strict non ?

C´est quoi le plus a executer entre
int somme=0,int u=0 et int somme=0,u=0 ?

le plus *long

Après un test, int somme=0,int u=0; ne compile pas, et dans les deux cas on ne peut pas accéder à la variable somme après, il faut donc la déclarer avant.

int somme = 0;
for(int u = 0; u < longueur; somme += tableau[u++]);

ça me parait logique en effet car la boucle ne se base que sur une seul variable

dans des vieilles spécification du C++, des variables déclarées lors de l´initialisation de la boucle for pouvaient être utilisées au delà de la boucle. C´est logique, car physiquement, elles sont hors de la boucle elle même (délimité par les accolades).

Mais les dernières normes (C99 ? peut-être, j´en sais trop rien) on changé la donne.

Mais avec la plupart des compilo, un paramètre lors de la compilaion permet de choisir la fonctionnement qu´il doit adopter.Il va sans dire que le respect de la norme est bien plus propre.

Mais lorsque que l´on crée une boucle, on sappuis sur 2 choses :
a par rapport à b, c fait partie de l´execution de la boucle :

a >> int u=0
b >> longueur
a par rapport à b >> u < longueur

et c : somme +

"la boucle ne se base que sur une seul variable"

Pas forcément, la boucle for se base sur trois expressions. Tu peux faire for(;;) { /*ton code*/ } si ça te chante, ça fera une belle boucle infinie (à moins qu´il y ait un break qui traîne)

Après ton explication est une mauvaise interprétation
Si on a for(A; B; C):
1) L´expression A est exécutée avant de commencer la boucle (et, d´après la norme qu´utilise GCC, comme faisant partie du bloc de la boucle).
2) A la fin de l´exécution du bloc de code, on teste la valeur de B, si B == false on quitte.
3) Après le test, si B == true, on exécute C et on réexécute le bloc de code.

non, on exécute A avant de rentrer dans la boucle (mais effectivement comme si on y était déjà).

Puis au début de chaque boucle on test B (avant même la première itération de la boucle, donc pas à la fin de celle-ci), particulièrement, si après A, B est faux, la boucle ne sera jamais exécuté.

Puis à la fin de la boucle on exécute C, AVANT de tester B. Si B==true on exécute de nouveau la boucle, sinon on quite.

"non, on exécute A avant de rentrer dans la boucle (mais effectivement comme si on y était déjà). "
Je me suis mal exprimé, on l´exécute effectivement avant mais on considère que s´il y a une ou plusieurs déclarations, elles sont locales dans le bloc de la boucle.

"Puis à la fin de la boucle on exécute C, AVANT de tester B. Si B==true on exécute de nouveau la boucle, sinon on quite."
En effet, j´ai réfléchi trop vite, mea culpa.