Bonjour, j'ai un Exercice ou je dois trouver les erreurs dans des bouts de codes, j'aimerais avoir votre avis sur mes choix. Il y à 13 code je ne l'ai ai pas encore tous fait donc je mettrais à jour au fur et a mesure.
ERREUR : L'instruction (i=0) doit être une condition et non une affectation donc (i==0). De plus si argc == 1 alors on à pas accès à argv[1] il faudrait argc == 2. Et enfin i doit être initialisé.Code:
1
2
3
4
5
6
7
8 Code 1 : main (int argc, char **argv) { int i; if (argc ==1) i = atoi(argv[1]); if (i = 0) printf(0 is not valid!\n); }
Code 2 :
ERREUR : Celui-ci m'as posé quelques soucisCode:
1
2
3
4
5
6
7
8
9
10 #define IS_VALID_NUM(x) (((x)>='0' && (x)<='9')?1:0) void ma_fonction(char* chaine) { int lg = 0; while(IS_VALID_NUM(*chaine++)) { lg++; } printf(Cette chaine commence par %d digits\n, lg); }
La fonction is_valid_num ne fait pas ce que l'on attendrait d'elle, elle n'évalue que les indice pair de la chaine. Il aurait falut faire *chaine plutot que *chaine++ car il incrémente directement et n'évalue que les nombres paires.
CODE 3 :
Ces lignes se comportent-elles de la même manière sur une machine 32 bits et sur une machine 64Code:
1
2
3
4
5
6
7
8
9
10 int res; long start_usecs, stop_usecs, delta2_usecs; struct timeval t1, t2; res = gettimeofday(&t1, NULL); my_func(); res = gettimeofday(&t2, NULL); stop_usecs= (t2.tv_sec * 1000000) + t2.tv_usec; start_usecs= (t1.tv_sec * 1000000) + t1.tv_usec; delta2_usecs = stop_usecs start_usecs;
bits?
Je pense que sur 64 bits le temps évalué sera plus court, et de plus c'est "long long start_usecs" et non pas "long".
CODE 4 :
ERREUR : Ici je ne sais pas trop, d'après l'utilisation des threads que je fais habituellement je déclare toujours en premier le prototype de la fonction et apres mon main j'y met le corps. Donc cela donnerai :Code:
1
2
3
4
5
6
7
8
9
10 void * myfunc(void *myarg) { printf("Myfunc\n"); } main() { pthread_t *th; int res; res = pthread_create(th, NULL, myfunc, NULL); ...blah...blah... }
Mais est-ce vraiment cela et pourquoi ?Code:
1
2
3
4
5
6
7
8
9
10
11 void * myfunc(void *myarg); main() { pthread_t *th; int res; res = pthread_create(th, NULL, myfunc, NULL); ...blah...blah... } void * myfunc(void *myarg) { printf("Myfunc\n"); }
CODE 5 :
ERREUR : Le malloc fait une allocation de taille fixe! Mais l'argument n'est pas de taille fixe! Il aurait fallu écrire malloc(strlen(argv[1]+1);Code:
1
2
3
4
5
6
7
8 #define MAX_LEN 32 main(int argc, char* argv[1]) { char *my_str; my_str= malloc(MAX_LEN); if ((argv[1] != NULL) & (my_str != NULL)) strcpy(my_str, argv[1]); }
CODE 6 :
ERREUR : Ici c'est le principe même d'un fork bomb j'imagine. Rappel : "Une fork bomb fonctionne en créant un grand nombre de processus très rapidement afin de saturer l'espace disponible dans la liste des processus gardée par le système d'exploitation. Si la table des processus se met à saturer, aucun nouveau programme ne peut démarrer tant qu'aucun autre ne termine". Donc il n'y à pas d'erreur mais un danger ...Code:
1
2
3
4
5 int res, i; for (i =0; i < 20; i++){ res = fork(); ....blah blah... }
CODE 7 :
ERREUR : Aucude idée.Code:
1
2
3
4
5
6
7
8 void * my_func(void* arg) { int res; .... for (int i =0; i < 20; i++){ res = pthread_create(...., NULL, my_func, NULL); }
Les autres code sont d'un niveau bien plus élevé et je ne les ai pas encore commencé donc je les publierai au moment voulu.
Voila si vous avez des suggestions, des modifications, si j'ai faux ou quoi que se soit faites moi savoir. Merci.