FILE *f1, f2;
et il n'y a plus aucune ambiguïté...

Heu, tu as recopié la même chose que moi

Ah si, tu as déplacé l'* sur le f1... Enfin, c'est bof comme changement.

Qu'est-ce que ça apporte de plus de déclarer une variable sans lui affecter de valeur directement ?

Je vais essayer de te donner des éléments de réponses pour le langage C.

Pour des raisons historiques, on a défini pas mal de compilateur où les blocs d'instructions étaient découpés en : déclaration | liste d'instruction. La grammaire de ce type de langage est beaucoup plus simple à écrire. C'est une habitude que certains ont pris

De même, dans les notations algorithmiques classiques qui font intervenir des déclarations, on déclare déjà tout avant sans les initialiser à l'instar des langages décrites par le type de grammaire que j'ai donné avant.

Avant la norme C89 (même C99 pour certains cas), le fait de devoir placer les déclarations en début de bloc était une contrainte du langage. C'est vraiment que maintenant, c'est plutôt devenu une contrainte méthodologique car ça peut permettre de gagner en lisibilité.

Lorsque le nombre de déclaration est assez importante, cela rend plus lisible les commentaires liés à l'utilisation d'une variable particulière.

Cela dit, certains types de variables nécessite de les initialiser dès la déclaration, notamment les variables static (elles sont déclarés et initialisé une seule fois dans toute l'exécution du programme).




Ensuite, je ne parle pas des initialisations en cascade du type :

int i,j,k;

C'est aussi à éviter car certaines erreurs arrivent fréquemment, notamment avec des déclarations du type :

Code:

FILE* f1, f2;

Et oui, c'est une feinte, f2 n'est pas de type FILE* mais du type FILE.

Une excellente habitude est de systématiquement affecter une valeur par défaut à une variable lors de sa déclaration

Pourtant, la plupart des programmeurs C sont d'accord sur le fait de séparer déclaration et affectation.


Je dis au passage que :

Code:

float chiffre1, chiffre2;
       printf("Enter the first number :  ");
       scanf("%lf", &chiffre1);
       printf("\nEnter the second number :  ");
       scanf("%lf", &chiffre2);
       
       float resultat = chiffre1 + chiffre2;
       printf("\nResult of %lf + %lf  is  =  %lf", chiffre1, chiffre2, resultat);
       break;

Tu as toujours une forme similiaire pour chaque cas de ton switch. Tu devrais penser à utiliser une fonction pour plus de clareté

Oula, attention.

Depuis quand utilisez-vous Linux ?

Depuis 4 5 ans.

Qu'est-ce qui vous a fait choisir Linux ?

L'existence de certaines applications qui fonctionnent plus simplement sous linux. Notamment valgrind pour vérifier les fuites mémoires ou purify. Il admet des intépreteurs lisp nettement plus pratique que sous windows.

Cela me permet de tester le bon fonctionnement d'application sur plusieurs plate-forme.

Quelle distribution(s) utilisez-vous ou avez utilisées ?

A partir de mandrake 8.x jusqu'au dernier mandriva. Redhat. Des SunOS Solaris (sur des sparcstations), des fedora, ubuntu et j'en passe.

Qu'aimez-vous dans Linux ?

Le fait qu'il choppe pas des virus pour un oui ou pour un non. Le bloquage automatique des droits sur les fichiers. La simplicité pour la création de script.

Que faites-vous avec Linux ?

Tester la compatibilité de mes applications.

Quelles sont vos connaissances en matière de Linux ?

Question vraiment vague...


Je m'autorise à ajouter une question :

Qu'est ce que vous n'aimez pas dans linux

Le manque cruel d'application spécialisé (j'en utilise pas mal). Le manque d'aide sur des problèmes très précis (la communauté windowsienne est plus large). La difficulté de mise en oeuvre de certaines choses par rapport à d'autres OS.

[segmentation fault sous unix]

tu essayes des logiciels libres de droits comme les systemes unix, qui sont de nos jours faciles a utiliser

Je suis loin d'être convaincu.

Ce genre de message d'erreur apparait typiquement lorsqu'il y a une écriture dans une zone mémoire non valide (segmentation fault sous unix).
Cela peut être provoqué par un pointeur non vérifié, un dépassement de pile d'appel...

Normal c'est windows

Tu es modérateur... Je trouve ce message tout sauf constructif Gob... Je peux t'en trouver des bugs à la pelle du type seg fault sous unix.

Je signale au passage que ce n'est pas toujours bien de déclarer des gros tableaux comme ça. Notamment car le tableau est directement mis sur la pile du programme (qui est de taille assez limité par rapport au tas).

Par exemple, le programme :

Code:

int main(void)
{
int t[1000][1000];

return EXIT_SUCCESS;
}

Fait un dépassement de pile chez moi.

Alors que :

Code:

int main(void)
{
int* t = malloc(1000*1000*sizeof(int));
return EXIT_SUCCESS;
}

Ne provoque aucun problème.

Salut
Moi aussi je suis un newbie mais ce qui ma édé a commencer c'est d'apprendre le language html

va jeter un oeul sur ces sites:
http://c.developpez.com/

Pour commencer l'HTML, tu donnes un lien sur des ressources de langage C. Bizarre comme approche.

Tiens, j'avais écrit un petit truc sur les phases de compilation, c'est assez sommaire, mais ça pourra peut être t'interesser :

http://www.newbiecontest.org/punbb/viewtopic.php?id=599

Ca dépend à quel point tu en as besoin.

Si ce n'est que pour une fonction, je ne pense pas que ça vaille la peine.

Mais si tu arrives à dégager des types abstraits et à écrire comme ça, tu es sur le bon chemin . Et petit à petit, tu pourras créer des modules en cachant l'implémentation des choses... (en gros, faire de la programmation objet en C)

Tu es sûr que ce terme n'est pas exclusivement utilisé dans ce film ?

Une question.

Tu comptes insérer des requetes SQL tout dans le même fichier. C'est vraiment bourrin... Pourquoi tu as besoin d'une base de donnée ?

Bon, j'ai carrément du mal à lire ton code, il faudrait que tu essayes de découper en plus de sous fonction.

Quelque remarque général (je ne dis pas que ce soit ça qui fasse planter) :

- Il est déconseillé de déclarer des pointeurs l'un à la suite de l'autre, prefère
SDL_Surface* surf1;
SDL_Surface* surfe2; pour plus de lisibilité

Dans ta boucle :

Code:

while(continuer)
 {

     if(ecranAccueil)
     {
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_KEYUP:
                exit(EXIT_SUCCESS);
        }
        SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
        SDL_BlitSurface(IMG_Chargement6, NULL, ecran, &positionChargement);
        SDL_Flip(ecran);
     }
     else if(ecranOption)
     {
     }

continuer n'est jamais modifié, je ne sais pas si c'est normal.



Dans :

Code:

if(file_login != NULL)
 {

Tu ouvres des grandes accolades. Tu sais d'avance que dans l'autre cas, tu vas arrêter, prefère écrire sous la forme:

Code:

if(file_login == NULL)
{
  fprintf(stderr, "Ouverture de fichier non réussi");
  exit("Sortie à l'arrache");
}

- Attention, tu utilises le type bool qui n'est défini que dans la norme C99. C'est à dire qu'il est possible que ton code ne soit pas compilable avec d'autres compilateurs

- Tu as oublié de liberer l'espace pour la 6ém image

La lecture de fichier je ne suis pas sûr de l'avoir vraiment comprise.

Dans ce cas, essaye de tester ce bout de code séparement de SDL.

En principe, si on a besoin de tableau bidimensionnel pour représenter un certain type de donnée de bonne qualité.

On crée un type abstrait de donnée du genre :

Code:

struct {
 int* tableau;
 size_t tailleH;
 size_t tailleY;
} Image;

Pis des opérateurs du style :

Code:

int imageCreer(struct Image*, size_t tailleH, size_t tailleY);
void imageDetruire(struct Image*);

int imageEcrire(struct Image*, size_t posH, size_t posY, int valeur);

...

Ca permet de plus de vérifier le bon appel au donnée.

Genre tu peux récuperer une erreur du type : imageEcrire(image, -1 ,-2,3); qui retournerait EXIT_FAILURE par exemple.

La définition la : int analyse(char **No Sms**[]);

M'a l'air suspecte... Genre, il manque une virgule, un type, ou je ne sais quoi.

Quand tu dis : déclarer un tableau avec une variable, tu parles des défintions #define ? Elles seront remplacés lors de la précompilation, ça ne devrait pas poser de problème normalement.

J'ai testé :

Code:

#include <stdlib.h>
#include <stdio.h>

void test(int t[][4])
{
 int i;

 for(i=0; i<4;i++)
   printf(" %d ", t[1][i]);


}

int main(void)
{
    int t[3][4] = {{0,0,0,0}, {1,1,1,1}, {2,2,2,2}};

    test(t);

  return EXIT_SUCCESS;
}

Avec les options de compilation, aucun problème. L'exécution, aucun problème.

A mon avis, ton prof a craqué.

Par contre, le problème, c'est que tu ne connais qu'une dimension du tableau donc ta fonction est susceptible de tout faire planter.