bon quand je compile mon prog sous unix il me marque un problème de fonction ansi. bon d'après ce que j'ai compris l'ansi ça marche pas sous unix. je fais comment pour que mon prg qui marche sous dos marche sous unix ????

Tu pourrais préciser ton problème ? Le C ANSI, à l'origine, ne marche que sous Unix.

bah il me marque mauvaise déclaration de fonction ansi.

Dans tous les cas, c'est un problème dans ton programme.  
C'est quoi ton problème exactement ? Si tu nous donnais les lignes entourant celle qui foire, et que tu nous mettais l'erreur exacte, ce serait un peu plus pratique (pas qu'un peu, en fait).

meme beaucoup
 
et pour dire, si t'as ecrit ton truc sous DOS a mon avis c loin de suivre la norme ANSI (avis perso)

void somme_for_procedure(int *n, int *somme)
{
 int compteur ;
 for (compteur = 0 ; compteur < *n ; compteur++)
  somme = compteur + somme ;
}

Ca, c'est pas un programme.

 
mais keske c que ce truc ???

ça c juste une fonction (j'ai pas mis tout le prog) mais d'après ce que je me rappelle de ce que disais le compilateur, il disait que j'avais une erreur dans la déclaration de la fonction. un truc par rapport à l'ansi.

 
 
C censé compilé, ca ?
 
 
 

 
ca devrait deja etre mieux (encore que j'ai du mal a voir le but de la fonction)
 
 
( et j'aime bpc le melange anglais /francais)

[jfdsdjhfuetppo]--Message édité par chrisbk--[/jfdsdjhfuetppo]

Mais t'as rien compris ! C'est hyper funky. C'est carrément staïleu, genre viens voir comme je maîtrise les pointeurs, c'est groovy, j'en mets partout là où il n'y en a pas besoin, comme ça mon programme ressemble à du Fortran, il va moins vite et personne ne comprend ce qu'il fait.

chrisbk a écrit a écrit :   C censé compilé, ca ?

Oui.
Mais à l'exécution ca risque de partir en couille.

Bof, ça risque surtout de ne rien faire.
Avec "somme = compteur + somme ;", il change le pointeur localement, et comme de toute façon il n'affecte rien dedans, ça ne segfaultera pas, et ça retournera sans avoir rien fait.

En effet, il ne déréférence pas le pointeur et somme n'est pas un int**.

Bref, une sublime fonction !

Bref, une sublime fonction !

bah euh la fonction est censé additionné les n premiers chiffre. pour N = 10 on aurait donc n=10+9+8+7+...+0
c con je suis d'accord mais bon faut voir ça avec les profs...

le sujet :  
 
1) Ecrire une fonction effectuant de maniere iterative la somme des n premiers entiers strictement positifs
(1 parametre d'entree : n - valeur produite : la somme)
Ecrire 2 autres fonctions "equivalentes" mais d'implantation differente
(utiliser les 2 autres structures iteratives presentees)
 
2) Ecrire 3 procedures "equivalentes"  
(1 parametre d'entree : n - 1 parametre de sortie : la somme)
 
3) Ecrire un programme de test qui :
- s'utilisera avec un parametre f (ou F) ou p (ou P) suivant que l'utilisateur souhaite l'executer avec
des fonctions ou des procedures
- demandera a l'utilisateur de saisir n
- proposera a l'utilisateur de choisir le sous-programme qui sera execute parmi les 3 possibles
- bouclera tant que l'utilisateur le desire
- controlera la syntaxe de la ligne de commande permettant de lancer le programme
ainsi que les valeurs saisies par l'utilisateur
 
------------ CODE --------------------------------------------
 
#include <stdio.h>
#include <stdlib.h>
 
void somme_for_procedure(int *n, int *somme)
{
 int compteur ;
 for (compteur = 0 ; compteur < *n ; compteur++)
  somme = compteur + somme ;
}
 
void somme_while_procedure(int *n, int *somme)
{
 int compteur = 0;
 while (compteur <= *somme)
  somme += (compteur++) ;
}
 
void somme_do_procedure(int *n, int *somme)
{
 int compteur = 0 ;
 do
  somme += (compteur++) ;
 while(compteur <= *n);
}
 
int somme_for_fonction(int n, int somme)
{
 int compteur ;
 for (compteur = 0 ; compteur < n ; compteur++)
  somme = compteur + somme ;
 return somme ;
}
 
int somme_while_fonction(int n, int somme)
{
 int compteur = 0;
 while (compteur <= somme)
  somme += (compteur++) ;
 return somme ;
}
 
int somme_do_fonction(int n, int somme)
{
 int compteur = 0 ;
 do
  somme += (compteur++) ;
 while(compteur <= n);
 return somme ;
}
 
 
 
int main(int argc, char *argv[])
{
  int *n ;
  char *choix ;
  if (argc = 0)
   {
     printf("parametre manquant. Fin du programme." ) ;
     exit(1) ;
   }
   else
    {
      printf("\nValeur de n : " ) ;
      scanf(n) ;
      while (*choix != 'Q'
       {
        switch (*choix)
         {
           case 'f' : {
                        goto fonction ;
                        break ;
                      }
           case 'F' : {
                        goto fonction ;
                        break ;
                      }
           case 'p' : {
                        goto procedure ;
                        break ;
                      }
           case 'P' : {
                        goto procedure ;
                        break ;
                      }
           case 'Q' : break ;
           default : { printf("Parametre non valide. Fin du programme" ) ; exit(1) ; }
         }
       }
    }
 
    procedure : {
                  printf("\nVotre choix :\nA : FOR.\nA : WHILE.\nA : DO" ) ;
                  strset(choix, '\0' ;
                  gets(choix) ;
                  switch (*choix)
                   {
                     case 'A' : {
                                  somme_for_procedure(n, somme) ;
                                  printf(somme) ;
                                  break ;
                                }
                     case 'B' : {
                                  somme_while_procedure(n, somme) ;
                                  printf(somme) ;
                                  break ;
                                }
                     case 'C' : {
                                  somme_do_procedure(n, somme) ;
                                  printf(somme) ;
                                  break ;
                                }
                     default : {
                                 printf("Parametre non valide. Fin du programme" ) ;
                                 exit(1) ;
                               }
                   }
                  strset(choix, '\0' ;
                 }
 
    fonction : {
                 printf("\nVotre choix :\nA : FOR.\nA : WHILE.\nA : DO" ) ;
                 strset(choix, '\0' ;
                 gets(choix) ;
                 switch (*choix)
                  {
                    case 'A' : {
                                 somme_for_fonction(n, somme) ;
                                 printf(somme) ;
                                 break ;
                               }
                    case 'B' : {
                                 somme_while_fonction(n, somme) ;
                                 printf(somme) ;
                                 break ;
                               }
                    case 'C' : {
                                 somme_do_fonction(n, somme) ;
                                 printf(somme) ;
                                 break ;
                               }
                    default : {
                                printf("Parametre non valide. Fin du programme" ) ;
                                exit(1) ;
                              }
                  }
                 strset(choix, '\0' ;
                }
 
  return 0;
}

Déjà, reviens quand tu sauras programmer sans Goto.
En C, ça ne devrait JAMAIS servir.
 
Ensuite, ton programme est BOURRÉ d'erreurs triviales, il suffit de lire les warnings du compilo :
> gcc -Wall toto.c
toto.c: In function `main':
toto.c:58: warning: suggest parentheses around assignment used as truth value
      if (argc = 0) Pas besoin d'expliquer ce qui manque, j'espère.
toto.c:66: warning: passing arg 1 of `scanf' from incompatible pointer type
     scanf(n) ; Tu sais vraiment te servir de scanf ? Tape man scanf, tu verras ça aide.
toto.c:95: warning: implicit declaration of function `strset'
     strset(choix, '\0' ; Cette fonction n'existe pas en C standard. C'est inutile, et en plus tu utilises gets, QUI EST LA SOURCE DES PLUS GROSSES FAILLES DE SÉCURITÉ DE L'HISTOIRE D'UNIX.
toto.c:100: `somme' undeclared (first use in this function)
toto.c:100: (Each undeclared identifier is reported only once
toto.c:100: for each function it appears in.)
     (Sans commentaire...)
toto.c:129: warning: passing arg 1 of `somme_for_fonction' makes integer from pointer without a cast
     somme_for_fonction(n, somme) ; n est un int *, et ta fonction requiert un argument de type int.
toto.c:134: warning: passing arg 1 of `somme_while_fonction' makes integer from pointer without a cast
toto.c:139: warning: passing arg 1 of `somme_do_fonction' makes integer from pointer without a cast
 
Je n'essaye pas d'aller plus loin. D'autre part, tu n'as visiblement pas compris la différence entre procédure et fonction.

[jfdsdjhfuetppo]--Message édité par Jar Jar--[/jfdsdjhfuetppo]

 
et ca ne sert jamais, a moins de programmer avec les pieds

 
moi j'aime bien goto
Et puis c'est 'achement plus dur de coder
avec les pieds, je t'y verrais toi.
 
LEGREG

 
Le goto, ca peut servir en C lorsque tu codes a la main des tables d'action d'automates d'etat finis, ou eventuellement dans des boucles imbriquees a plusieurs niveau, pour sortir de plusieurs niveau d'un coup (en c++, on peut faire plus propre avec des try/catch), mais sinon...
 
A+,

 
meme si je cherche toujours un moyen de faire autrement, la j'admets que ca peut etre chiant sans  

J'ai l'impression qu'on me prend légérement pour un con... je suis là pour apprendre alors ça sert à rien de me dire que je suis nul car je viens juste de commencer. alors franchement je trouve totalement inutile de vous foutre de ma gueule comme ça. vous n'êtes pas des dieux et vous avez tous commencer avec un niveau nul et je pense pas que vous apprécierez d'être jeté comme ça...
 
bon pour revenir au sujet principal. bah non je connais pas la différence entre les fonctions et les procédures. je m'aide d'un bouquin et dans le bouquin y'a que les fonctions.  
et non je savais pas que gets était la source des plus grosses failles de sécurité sous UNIX. comment veux tu que je sache ça moi ? bon bah vais utiliser scanf à la place.
et pour strset je savais pas non plus que c'était pas une fonction standard...

voilà c mieux comme ça ?
 
 
#include <stdio.h>
#include <stdlib.h>
 
void somme_for_procedure(int *n, int *somme)
{
 int compteur ;
 for (compteur = 0 ; compteur < *n ; compteur++)
  somme += compteur ;
}
 
void somme_while_procedure(int *n, int *somme)
{
 int compteur = 0;
 while (compteur <= *somme)
  somme += (compteur++) ;
}
 
void somme_do_procedure(int *n, int *somme)
{
 int compteur = 0 ;
 do
  somme += (compteur++) ;
 while(compteur <= *n);
}
 
int somme_for_fonction(int n)
{
 int somme ;
 int compteur ;
 for (compteur = 0 ; compteur < n ; compteur++)
  somme += compteur ;
 return somme ;
}
 
int somme_while_fonction(int n)
{
 int somme ;
 int compteur = 0;
 while (compteur <= somme)
  somme += (compteur++) ;
 return somme ;
}
 
int somme_do_fonction(int n)
{
 int somme ;
 int compteur = 0 ;
 do
  somme += (compteur++) ;
 while(compteur <= n);
 return somme ;
}
 
 
 
int main(int argc, char *argv[])
{
  int *n ;
  char *choix ;
  int *somme ;
  if (argc == 0)
   {
     printf("parametre manquant. Fin du programme." ) ;
     exit(1) ;
   }
   else
    {
      printf("\nValeur de n : " ) ;
      scanf("%d", &n) ;
      while (*choix != 'Q'
       {
        switch (*choix)
         {
           case 'P' : {
                        {
                          printf("\nVotre choix :\nA : FOR.\nA : WHILE.\nA : DO" ) ;
                          scanf("%c", choix) ;
                          switch (*choix)
                           {
                             case 'A' : {
                                          somme_for_procedure(n, somme) ;
                                          printf(somme) ;
                                          break ;
                                        }
                             case 'B' : {
                                          somme_while_procedure(n, somme) ;
                                          printf(somme) ;
                                          break ;
                                        }
                             case 'C' : {
                                          somme_do_procedure(n, somme) ;
                                          printf(somme) ;
                                          break ;
                                        }
                             default : {
                                         printf("Parametre non valide. Fin du programme" ) ;
                                         exit(1) ;
                                        }
                        }
           case 'F' : {
                        printf("\nVotre choix :\nA : FOR.\nA : WHILE.\nA : DO" ) ;
                        scanf("%c", choix) ;
                        switch (*choix)
                        {
                          case 'A' : {
                                printf(somme_for_fonction(*n)) ;
                                break ;
                                     }
                          case 'B' : {
                                printf(somme_while_fonction(*n)) ;
                                break ;
                              }
                          case 'C' : {
                                printf(somme_do_fonction(*n)) ;
                                break ;
                               }
                          default : {
                                printf("Parametre non valide. Fin du programme" ) ;
                                exit(1) ;
                                    }
                        }
                      }
           case 'Q' : break ;
           default : {
                       printf("Parametre non valide. Fin du programme" ) ;
                       exit(1) ;
                     }
         }
       }
  return 0;
}
 
 
y'a encore des erreurs mais bon là pas le temps de regarder vais en cours...

Heu... comme ca en passant, pour calculer la somme des n premier nombres entiers, c'est pas plus simple de faire somme=n*(n+1)/2 ?

si si mais les profs veulent pas qu'on utilise cette formule... ce tp c fait pour apprendre les boucles do, for, et while

Ha ouai, evidemment c'est un exercice ...

 
ouais, effectivement, moi qui suis aussi débutant, je trouve ke sur ce site y'a bocoup de gars ki pensent ke tout le monde devrait etre a leur nivo, ke la programmation C, c inné, et ke si on n'est pas capable de reprogrammer le noyau de linux en moins de 2heures, ben on est ke des sous merde.
Bref les gars, vous êtes pas seul, et on est pas forcement des star de programmation, sinon, on ne serait po sur ce forum. Meme si on fait des erreurs, meme de très grosse errreurs, vous foutez pas trop de nos gueule, c déjà pas évident...
Merci, a+

C'est normal de débuter un jour, mais avant de poser des questions aussi triviales, on se renseigne. Il y a des tonnes de livres sur le C, donc certains disponibles en ligne.
En plus, la documentation intégrée, ce n'est pas fait pour les chiens. Si on tape "man gets", on tombe sur une page qui explique pourquoi il ne faut pas s'en servir. Pas besoin d'être un dieu de la programmation pour ça.

 
Si tes profs n'en sont qu'a vous faire découvrir les boucles (:ouch oublie les pointeurs pour l'instant !!!

bah oui mais bon j'ai pas un serveur unix chez moi ! je suis qu'un pauvre étudiant fauché !!!!
et bon le goto c vrai que je déteste l'utiliser mais là j'avais pas beaucoup dormi donc bon c corrigé !

Mais tu as les moyens de te payer une licence pour un compilateur DOS. Pourtant, c'est plus cher que pas mal d'unices...

dev-c++ tu connais ? bah c gratuit...
et en plus j'y connais rien moi en C ! on a fait que 4 tp ! c bon je suis pas une star ! moi je demande de l'aide c tout ! mais bon si tu n'es capable que de me critiquer ça sert vraiment à rien de répondre. je suis là avant tout pour apprendre et que je sache tu es là aussi un peu pour ça à moins que tu maitrises totalement le C...
et bon faudrait aussi revenir au sujet principal !

pour en reveniru sujet, toutes tes fonctions qui prennent int *somme en paramètre sont fausses:
 
 
faut à l'intérieur remplacer somme par *somme
 
et il est inutile de passer int *n en paramètre puisque tu ne modifies pas la valeur de n

merci ! franchement des fois je fais des grosses conneries. pour le printf par exemple... bon voilà c corriger. bah enfin presque il me reste encore une erreur : c:\iut\c\addition\somme.c:132: parse error at end of input
il doit me rester une parenthèse en suspend ! va falloir tout relire !

Astuce : utilise Emacs.
 

Et le Windows sur lequel il tourne aussi ?
Qu'il est bon de rire, parfois...

find /usr/src/linux/ -name "*.c" -exec grep -H goto {} \; | wc -l
  14486

moi j'dis, d'accord avec jar jar, la doc c pas fait pour les chiens, et je pense pas m'avancer trop en disant qu'on a tous appris en lisant pas mal de doc

Tu fais ça pour confirmer la réputation de craditude du code de Linux ?