#1 Le 25/10/2013, à 12:59
- temps
[résolu] switch vs sprintf
Bonjour,
J'ai écrit une application en favorisant les switch
Cette application contient plusieurs exécutable de 1Mo
Si je remplace les switch par une boucle et %c, je réduits le poids des exécutable d'un facteur 10
Je me demande ce qui est le mieux, garder les switch ou utiliser sprintf ?
Est-ce que quelqu'un a une idée, je mets le choix des codes "équivalent !" en dessous.
Cordialement
/***************************************************************************************************************************/
case 2 : /*a*/
actif = 1;
/**************/
char assemblagelet;
for (debut = 0; debut < fin; debut++) {
if (quicou == quiaitu[debut]) {
assemblagelet = quiaitu[debut];}
}
printf("avec c %c\n",assemblagelet);
char passemoi[16];
sprintf(passemoi,"a%c.jo",assemblagelet);
printf("avec passemoi %s\n",passemoi);
/***/
fichierjo1 = NULL;
fichierjo1 = fopen(passemoi, "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n",passemoi);
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
/**************/
break;/***sortie*****switch actif 2*****/ou
/***************************************************************************************************************************/
case 49 : /*X*/
actif = 1;
switch (assemblage1) {/* debut switch (assemblage1)*/ /**acco 3**/
case 0 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xa.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xa.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 1 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xb.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xb.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 2 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xc.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xc.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 3 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xd.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xd.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 4 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xe.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xe.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 5 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xf.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xf.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 6 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xg.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xg.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 7 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xh.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xh.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 8 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xi.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xi.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 9 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xj.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xj.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 10 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xk.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xk.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 11 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xl.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xl.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 12 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xm.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xm.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 13 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xn.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xn.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 14 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xo.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xb.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 15 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xp.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xp.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 16 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xq.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xq.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 17 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xr.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xr.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 18 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xs.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xs.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 19 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xt.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xt.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 20 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xu.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xu.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 21 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xv.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xv.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 22 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xw.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xw.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 23 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xx.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xx.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 24 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xy.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xy.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 25 :
fichierjo1 = NULL;
fichierjo1 = fopen("Xz.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xz.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 29 :
fichierjo1 = NULL;
fichierjo1 = fopen("XA.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XA.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 30 :
fichierjo1 = NULL;
fichierjo1 = fopen("XB.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XB.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 31 :
fichierjo1 = NULL;
fichierjo1 = fopen("XC.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XC.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 32 :
fichierjo1 = NULL;
fichierjo1 = fopen("XD.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XD.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 33 :
fichierjo1 = NULL;
fichierjo1 = fopen("XE.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XE.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 34 :
fichierjo1 = NULL;
fichierjo1 = fopen("XF.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XF.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 35 :
fichierjo1 = NULL;
fichierjo1 = fopen("XG.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XG.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 36 :
fichierjo1 = NULL;
fichierjo1 = fopen("XH.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XH.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 37 :
fichierjo1 = NULL;
fichierjo1 = fopen("XI.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XI.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 38 :
fichierjo1 = NULL;
fichierjo1 = fopen("XJ.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XJ.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 39 :
fichierjo1 = NULL;
fichierjo1 = fopen("XK.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XK.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 40 :
fichierjo1 = NULL;
fichierjo1 = fopen("XL.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XL.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 41 :
fichierjo1 = NULL;
fichierjo1 = fopen("XM.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XM.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 42 :
fichierjo1 = NULL;
fichierjo1 = fopen("XN.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XN.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 43 :
fichierjo1 = NULL;
fichierjo1 = fopen("XO.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XO.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 44 :
fichierjo1 = NULL;
fichierjo1 = fopen("XP.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XP.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 45 :
fichierjo1 = NULL;
fichierjo1 = fopen("XQ.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XQ.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 46 :
fichierjo1 = NULL;
fichierjo1 = fopen("XR.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XR.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 47 :
fichierjo1 = NULL;
fichierjo1 = fopen("XS.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XS.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 48 :
fichierjo1 = NULL;
fichierjo1 = fopen("XT.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XT.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 49 :
fichierjo1 = NULL;
fichierjo1 = fopen("XU.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XU.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 50 :
fichierjo1 = NULL;
fichierjo1 = fopen("XV.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XV.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 51 :
fichierjo1 = NULL;
fichierjo1 = fopen("XW.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XW.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 52 :
fichierjo1 = NULL;
fichierjo1 = fopen("XX.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XX.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 53 :
fichierjo1 = NULL;
fichierjo1 = fopen("XY.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XY.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
case 54 :
fichierjo1 = NULL;
fichierjo1 = fopen("XZ.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","XZ.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
break;/**fin */
/***************************************************************************************************************************/
default :/*************************/
fichierjo1 = NULL;
fichierjo1 = fopen("Xz.jo", "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n","Xz.jo");
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
}/* fin switch (assemblage1)*/
break;/***sortie*****switch actif 49*****/
/******************************************************************fin X******************************************************/Dernière modification par temps (Le 27/10/2013, à 23:39)
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#2 Le 25/10/2013, à 13:33
- telliam
Re : [résolu] switch vs sprintf
le plus court, ton code avec des switch case est crado
"- Un intellectuel assis va moins loin qu'un con qui marche."
Maurice Biraud - Un Taxi pour Tobrouk
Michel Audiard
Hors ligne
#3 Le 25/10/2013, à 14:13
- ssdg
Re : [résolu] switch vs sprintf
En général, le copier/coller (j'ai l'impression que ton truc avec des case est construit comme ça) c'est le MALLLL.
Si tu as une erreur dans un de tes copier/coller, tu va devoir tous les retrouver et tous les corriger. En général, une fonction ou une boucle est une bien meilleure idée.
PS: J'avoue ne pas avoir tout lu.
s'il n'y a pas de solution, c'est qu'il n'y a pas de problème... ou pas.
Hors ligne
#4 Le 25/10/2013, à 21:52
- temps
Re : [résolu] switch vs sprintf
Bonjour,
Merci pour les réponses.
Quand j'ai commencé à coder en C, un des meilleurs tux s'il en est, m'a confié dans un café "utilise le switch" c'est très puissant.
De fait dans le code long, le résultat est obtenue en passant 2 switch, alors que dans le code plus courts (il passe l'appli de presque 1Mo à 40 ko) c'est pas du tout pareil, c'est beaucoup plus long en temps.
Une boucle ou une fonction, c'est très lourd en temps d'execution et n'a rien de la puissance d'un switch.
La question que je me posais c'est est-ce qu'il vaut mieux avoir des appli lourdes mais très rapides ou des appli légères mais moins performantes ?
Bien sur pour faire mes switch je crée une base, ensuite je fais des copiés/collés pour la reproduire en travaillant sur plusieurs fenêtres, je ne vois pas ce qui gène, est-ce que je peux avoir plus de détails ?
Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#5 Le 26/10/2013, à 02:43
- ssdg
Re : [résolu] switch vs sprintf
Mettons que tu te sois trompé et que ton sizeof(regle) ne soit pas bon (qu'il te faille faire appel à sizeof(regle)-1 par exemple) alors il va falloir que tu repasse sur tout ton code pour faire la même modif au risque d'en oublier un. Si tu n'a qu'une version du code avec une variable ou un paramètre pour ce qui change alors tu ne prends pas autant de risque d'oublier ou d'introduire un bug.
Sinon, tu peux me dire ce qui change d'un switch à l'autre? si c'est juste le nom du fichier, tu peux faire ça avec un tableau par exemple (une seule version du code, tu va juste chercher la lettre à changer avec un "lettre[chiffreDe0A54]" (à la limite un controle pour le défaut, je ne vois pas bien ce que ton code fait)
Quand aux perfs, je ne suis pas expert en C mais:
1) en général, il vaut mieux une petite perte de perfs qu'un cout de maintenance élevé. (si tu gagne 20 minutes sur toute la vie du logiciel mais que la moindre correction ou ré-utilisation de code te prends 2h, alors tu perds des morceaux de ta vie que tu ne récupèrera jamais
2) Ne serait-il pas plus rapide de consommer les caractères du fichier en bloc plutot qu'un par un? (en général, quand une lecture est bufferée, au global, ça va plus vite)
s'il n'y a pas de solution, c'est qu'il n'y a pas de problème... ou pas.
Hors ligne
#6 Le 26/10/2013, à 02:47
- ssdg
Re : [résolu] switch vs sprintf
Oh, et c'est moi où:
for (debut = 0; debut < fin; debut++) {
if (quicou == quiaitu[debut]) {
assemblagelet = quiaitu[debut];}
}
est une façon subtile d'écrire
assemblagelet = quicou
Ou de laisser le truc qui trainait en mémoire à l'endroit d'assemblagelet si quicou n'est pas dans le tableau quiaitu?
s'il n'y a pas de solution, c'est qu'il n'y a pas de problème... ou pas.
Hors ligne
#7 Le 26/10/2013, à 12:01
- temps
Re : [résolu] switch vs sprintf
Bonjour,
Bien vue ssdg et merci pour les précieux conseils pratiques.
Mon objectif premier était de construire un code que chacun pouvait customisé (modifier les sons à l'intérieur).
Pour se faire j'ai pensé à le construire de manière à ce qu'en utilisant la fonction recherche d'un éditeur de texte, la personne puisse retrouver facilement, les différentes fenêtres de chaque instrument, et la note jouée de chaque instrument.
Ensuite, il me fallait un code très réactif, qu'au simple effleurement de la touche du clavier le son soit joué, d'ou le choix des switch.
Pour revenir sur le code oui écrire la boucle revient à écrire : assemblagelet = quicou;
Et effectivement, je pense que dès que j'aurai le temps, il va falloir que je revienne sur les codes pour au moins enlever toutes les anciennes traces des anciennes applications qui m'ont conduis à celle-ci. Au test à oreille, j'ai eu l'impression que la version sprintf était moins performante que celle switch, mais comme j'ai un a priori pour les switch, je cherchais à savoir si j'étais dans le vrai malgré la grande différence de poids des deux versions.
Au sujet des perf, il faut approfondir, car l'application touche l'audio, et les sens du toucher, le temps de retard de réaction va créditer l'outil ou le discrédité. La question à laquelle je ne sais pas encore répondre est : est-ce que la nouvelle version sprintf crée une différence perceptible ?
Et c'est un point d'égale importance à la structure du code, et c'est là que le test et les conseils d'autres intervenants sont necessaires.
je vais relire les postes afin d'en utiliser toutes les informations évidentes ou subtiles.
Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#8 Le 26/10/2013, à 12:45
- temps
Re : [résolu] switch vs sprintf
Bonjour,
Le temps de la lecture approfondie des messages.
J'y lis, peut-être qu'il faut reprendre comment arriver le plus simplement à la tâche plutot que de chercher à arriver à la tâche.
Ensuite il faut que j'étudie les cas possibles par rapport aux contraintes.
L'application va lire un texte composé d'une suite de 2 caractères, et ensuite crée un fichier audio compatible avec les cartes sons étant sur le marché.
De l'analyse l'application lit les caractères un à un dans le fichier texte, cette forme est passe partout car elle permet de donner au caractère "espace" une action. Mais dans le cas ou l'application est relié à une touche du piano, il serait peut-être bon de lire deux caractères et ensuite de faire un sprintf pour lancer la conversion.
De fait peut-être le fait que la base du code sert à de nombreuses fonctions différentes il faudrait que je reprenne les bases de manière à les dédier en fonction du résultat final attendue. Ensuite et seulement ensuite, je pourrait comparer switch vs sprintf
Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#9 Le 26/10/2013, à 17:20
- telliam
Re : [résolu] switch vs sprintf
Bonjour,
Merci pour les réponses.
Quand j'ai commencé à coder en C, un des meilleurs tux s'il en est, m'a confié dans un café "utilise le switch" c'est très puissant.
Bon déjà ça c'est une bétise, le switch c'est puissant mais seulement si il est utilisé au bon moment.
De fait dans le code long, le résultat est obtenue en passant 2 switch, alors que dans le code plus courts (il passe l'appli de presque 1Mo à 40 ko) c'est pas du tout pareil, c'est beaucoup plus long en temps.
Une boucle ou une fonction, c'est très lourd en temps d'execution et n'a rien de la puissance d'un switch.
la tu compares des poires et des bananes, une boucle ou un switch ne joue pas le mm role donc tu px pas les comparer.
pour ce qui est de ton code, si les cas de ton switch sont équiprobables c'est quasi équivalent en temps d'execution à une boucle, sauf que ton code avec une boucle sera plus propre, donc plus court donc moins buggé.
Si tu es dans un code ou un cas du switch est bcp plus fréquent qu'un autre, cela peut etre plus rapide qu'une boucle si la donnée a traité n'est trouvé que sur une des dernières valeurs de la boucle. Mais là c'est simple à résoudre, il suffit de associer les élements qui ont la plus forte occurence avec une valeur faible de l'index de la boucle.
La question que je me posais c'est est-ce qu'il vaut mieux avoir des appli lourdes mais très rapides ou des appli légères mais moins performantes ?
Bien sur pour faire mes switch je crée une base, ensuite je fais des copiés/collés pour la reproduire en travaillant sur plusieurs fenêtres, je ne vois pas ce qui gène, est-ce que je peux avoir plus de détails ?
Cordialement
Tout dépend de ce que tu appelles un code lourd ou pas.
Si par exemple tu prends un code qui ne fait pas d'allocation mémoire et qui ne travaille qu'avec des variables statiques, elle va potentiellement être en grosse en mémoire mais sera plus rapide que la même appli qui fait des pleins d'allocation dynamiques.
Si tu parles du code pure, je suis partisan de la légèreté (en code et en mémoire d'ailleurs), si tu px faire un code léger, facile à relire ça sert à rien de complexifier ton code.
De toute façon les meilleurs optimisations de code sont dans le compilo, rarement dans les doigts du codeur 
"- Un intellectuel assis va moins loin qu'un con qui marche."
Maurice Biraud - Un Taxi pour Tobrouk
Michel Audiard
Hors ligne
#10 Le 26/10/2013, à 17:33
- telliam
Re : [résolu] switch vs sprintf
Bonjour,
Bien vue ssdg et merci pour les précieux conseils pratiques.Mon objectif premier était de construire un code que chacun pouvait customisé (modifier les sons à l'intérieur).
Pour se faire j'ai pensé à le construire de manière à ce qu'en utilisant la fonction recherche d'un éditeur de texte, la personne puisse retrouver facilement, les différentes fenêtres de chaque instrument, et la note jouée de chaque instrument.
L'idée est louable mais l'approche mauvaise, qd on veut ouvrir son code et permettre à d'autre de le 'customiser', il vaut mieux leur fournir un ensemble de fonctions qui permettra d'enregistrer des callback qui seront appelés au moment que tu trouves le plus pertinent.
cela évite que les codeurs de devoir relire ton code, ils ont juste a bien lire la doc, à coder et à utiliser tes fonctions.
ça évite bcp de bugs.
Ensuite, il me fallait un code très réactif, qu'au simple effleurement de la touche du clavier le son soit joué, d'ou le choix des switch.
Pour revenir sur le code oui écrire la boucle revient à écrire : assemblagelet = quicou;
Et effectivement, je pense que dès que j'aurai le temps, il va falloir que je revienne sur les codes pour au moins enlever toutes les anciennes traces des anciennes applications qui m'ont conduis à celle-ci. Au test à oreille, j'ai eu l'impression que la version sprintf était moins performante que celle switch, mais comme j'ai un a priori pour les switch, je cherchais à savoir si j'étais dans le vrai malgré la grande différence de poids des deux versions.
attention un sprintf peut etre tres couteux en temps d'execution, si tu fais des contructions de chaines simples, cela peut etre plus pertinent de coder 2-3 fonctions.
Au sujet des perf, il faut approfondir, car l'application touche l'audio, et les sens du toucher, le temps de retard de réaction va créditer l'outil ou le discrédité. La question à laquelle je ne sais pas encore répondre est : est-ce que la nouvelle version sprintf crée une différence perceptible ?
Et c'est un point d'égale importance à la structure du code, et c'est là que le test et les conseils d'autres intervenants sont necessaires.je vais relire les postes afin d'en utiliser toutes les informations évidentes ou subtiles.
Cordialement
tu px aussi te raccrocher aux IT du claviers mais ça reste plus complexe à faire. et à faire qu'en dernier recours.
Dans un 1er temps, je te conseille d'utiliser un profileur de code pour voir ou tu perds le plus de temps.
"- Un intellectuel assis va moins loin qu'un con qui marche."
Maurice Biraud - Un Taxi pour Tobrouk
Michel Audiard
Hors ligne
#11 Le 26/10/2013, à 18:23
- pires57
Re : [résolu] switch vs sprintf
Essayes de penser au développeur qui peut éventuellement reprendre ton projet parce que moi, on me donne un code comme cela sans fonction je n'y touche même pas, c'est ce que je qualifierais de "bordel infâme".
Et indentes ton code aussi
Utilisateur d'Archlinux, Ubuntu et Kali Linux
Administrateur système et réseau spécialisé Linux.
LinkedIn
Hors ligne
#12 Le 26/10/2013, à 22:14
- temps
Re : [résolu] switch vs sprintf
Merci pour ces nombreuses réponses. Je vais travailler les différentes ouvertures et je reviendrai dire laquelle je retiens et posterai en résolu.
Actuellement je vais mettre en ligne la version sprintf à 37 ko à la place du 1Mo, mais je sais que j'y retournerai plus tard pour l'améliorer( pas dans le sens de pires57 qui a le droit de s'imposer des règles, mais si un tux peut demander des conseils, il ne peut demander de faire pour lui ou encore imposer ses idées, donc se sera dans le sens ou elle sera plus adapté à sa tache). Donc ce sera certainement vers une création de fonctions pour remplacer sprintf sans retourner vers les 1 Mo
Il faut que je test, une fois fait je reviendrai dire
N.B. : En parlant des concepts qui permettent à cette appli de fonctionner et des structures qui les lient, j'indique comment changer les effets, mais il ne faut pas attendre que je structure à l'aide de concepts incompatibles. Depuis plusieurs décennie je régule des systèmes quand je dis comment je fais, on me répond que c'est pas vrai. En 93 j'ai réalisé mon chef d'oeuvre, quand j'énonce les principes, j'entends des insultes. Cette application audio est construite sans fréquence, sans algèbre, la manipulation des liens et ses structures sont construites pour fonctionner, je ne cherche pas un conflit de plus, je dis juste que la technique ne rentre pas dans la petite boite des croyances actuelles, et que ma démarche n'est pas d'aller contre les croyances, juste d'apporter un outil aux tux qui sont éventuellement intéressés de créer des nouveaux sons et d'avoir un format audio ultra léger.
Plusieurs amis après avoir vérifié le bon fonctionnement de mon format audio, se sont déja frotté à essayer d'intégrer mes concepts dans le jupon des croyances, des heures, des jours perdues, pour arriver à un désespoir de leurs croyances. C'est pour ça que j'ai écris dans l'entête de l'appli que les sciences ne fonctionnent pas comme les religions, c'est une manière courtoise de dire de garder les yeux fermés quand on a peur de voir la réalité.
Savoir que l'on ne sait pas, ce n'est que de l'ignorance, croire que l'on sait quelque chose que l'on ne sait pas et vouloir imposer avec une structure est un signe d'incohérence (j'ai bien aimé le mot bordel).
Cordialement
Dernière modification par temps (Le 26/10/2013, à 22:44)
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#13 Le 26/10/2013, à 22:45
- pires57
Re : [résolu] switch vs sprintf
ce n'est pas une règle que je m'impose, c'est ce qu'on appelle la modularité.
sprintf(), puts() getchar() ... ce sont toutes des fonctions bien qu'elle aient été regroupé dans des fichiers header. Elle sont la pour aider le développeur parce que si elle n'existait pas tu serais obliger de trouver un moyen pour la remplacer.
La modilarité c'est une chose importante dans la programmation, par exemple, imagine qu'on a une application qui permet d'entrer des nouveau clients, de supprimer un clients et de quitter (quand la journée de travail est fini) . on aura donc un menu de départ avec les différents choix ;
------------------------------------
1- Ajouter un nouveau client
2- Supprimer un client
3- Quitter
------------------------------------
Veuillez saisir le numéro correspondant a votre choix:Après avoir fait le choix et fini, l'employé a besoin de voir son menu donc tu fait quoi? tu recopies le code sources du menu pour chacun des cas?
tu crois pas que ce serais plus simple de faire dans ton appli un appel a une fonction?
Comme ici par exemple : au lieu d'inclure tout dans le main j'ai fait des fonctions et je les appelles quand j'en ai besoin, cela allège le code.
main(){
AfficherMenu();
while(n!=4){
printf("choisir l'opération a effectuer\n");
scanf("%d",&n);
switch(n){
case 0: printf("Sens\n");
AfficherSensLigne();
getchar();
AfficherMenu();
break;
case 1: printf("etat port:\n");
AfficherEtatLigne();
getchar();
AfficherMenu();
break;
case 2: printf("Angle\n");
AfficherAngle();
getchar();
AfficherMenu();
break;
case 3: printf("Afficher position\n");
VerifFichier();
getchar();
AfficherMenu();
break;
case 4: printf("vous avez quitter l'application\n");
break;
default : printf("mauvais choix\n");
AfficherMenu();
break;
}
}
}Loin de moi l'envie de t'imposer une structure pour ton code, tu fait ce que tu veut au final, cela ne me dérange aucunement, je pense simplement au développeur éventuel qui pourrais reprendre ton projet et risque de s'arracher les cheveux, c'est beaucoup plus simple quand on segmente et qu'on ne réécrit pas plusieurs fois le même bout de code.
Dernière modification par pires57 (Le 26/10/2013, à 22:57)
Utilisateur d'Archlinux, Ubuntu et Kali Linux
Administrateur système et réseau spécialisé Linux.
LinkedIn
Hors ligne
#14 Le 26/10/2013, à 22:58
- telliam
Re : [résolu] switch vs sprintf
Euh Pires.... tu confonds pas Modularité et Factorisation ?
La modularité c'est concevoir un ensemble de fonction qui peut etre réutilisable ailleurs.
Alors que la tu parles juste de Factorisation de code.
Néanmoins je confirme le code de temps est bordélique ( voir hideux), le pb de Temps c'est qu'il considère que toute remarques, plus ou moins liées au bon sens et/ou au génie logiciel, comme un carquant que les codeurs appliquent bêtement alors qu'il s'agit juste de conseils/règles qui aident à rendre un code propre, stable et robuste.(et qui ne limite en rien l'ingeniosité des codeurs.)
"- Un intellectuel assis va moins loin qu'un con qui marche."
Maurice Biraud - Un Taxi pour Tobrouk
Michel Audiard
Hors ligne
#15 Le 26/10/2013, à 23:11
- pires57
Re : [résolu] switch vs sprintf
Heu oui effectivement Telliam, tu as raison.
Mais rien n’empêche de faire de la modularité, cela fonctionnera aussi.
Utilisateur d'Archlinux, Ubuntu et Kali Linux
Administrateur système et réseau spécialisé Linux.
LinkedIn
Hors ligne
#16 Le 26/10/2013, à 23:17
- temps
Re : [résolu] switch vs sprintf
Bonsoir,
J'aime bien la réaction de pires57 qui argumente, et c'est vrai ce que dit telliam que je considère que toute application pré-maché structure la pensée vers des incohérences. Mais même si je refuse les règles, il serait faux de croire que je les cherche pas. Je les cherche afin de les décortiqué à la recherche de ce qui pourrait m'être utile. Je considère que ce qui est bon à tout est bon à rien. Je considère que tout tableur est destructeur car il oriente les liens dans un système limité en dimension. Je considère que le bon sens, n'est pas celui qui plait, mais est celui qui permet d'atteindre l'objectif en utilisant le moins de ressources en proportion du poids de la mesure (le poids de la mesure en exemple est qu'on n'indique pas le poids d'un camion en micro-gramme, comme on n'indique pas l'amplitude d'un front d'onde avec un chiffre ayant une précision de 10 valeurs après la virgule.
Mon plaisir est de passer de bons moments avec d'autres tux au café et éventuellement parfois créer quelques applications, en m'appuyant sur l'expérience d'autres tux sur les forum de tux (kubuntu, ...) en respectant toujours de citer mes retours d'expériences.
Je ne dis pas il faut utiliser mon format audio, je dis que j'écris les sons d'une manière très légère, en exemple le marteau avec 60 octets, un son qu'audacity écrit en dizaine de ko. Et ceci peut encore être abaissé en poids, en utilisant une fonction avec mon système mathématique pour donner les formes directement, et encore ceci pourra être abaissé en poids en compressant, ...
Regarder ma démarche, je donne les codes, je dis dans mes codes comment rendre l'audio compatible avec l'étrange technologie des cartes audio actuelle, en comparant à la démarche d'audacity par exemple, au début ne sachant pas comment fonctionnait les cartes audio, j'ai envoyé des dizaine de mail aux mainteneur d'audacity pour savoir, je n'ai jamais obtenue ma réponse. J'ai du utiliser ghex pour découvrir le fonctionnement des entêtes audio.
Au sujet des DEV éventuel, j'ai contacté les DEV audio linux en 2010 quand j'ai créé mon format audio, pour leur dire les lois sur les sons. Ils m'ont répondu :
l'oscilloscope est claire, les sons sont fréquences,
j'ai répondu, immédiatement dans la minute que leurs arguments étaient douteux, car l'oscilloscope montre ce qu'on lui a demandé de montrer (pour cause dans les années 1980 je m'en étais fais un pour tester mes montages électroniques, et je sais pertinemment que c'est des moyennes, l'oeil ne peut suivre, l'oscillo ne peut voir le gros ou le petit et les effets du gros ou du petit, il ne montre que ce qu'on lui demande, à savoir une moyenne).
De plus que j'avais mon application qui faisais force de loi, qui montrait le vrai du faux. C'était en 2010, on est en 2013 et on trouve encore des références aux fréquences sur les lois des sons ? Pour revenir aux éventuels DEV, s'ils ne remettent pas en question leurs croyances, s'ils ne remettent pas en question les lois d'associations d'idées qui permettent de construire les structures, je comprends qu'ils ne puissent jamais commencé à percevoir la simplicité de mes codes. Et même je dirais que quoi que je fasse (et j'en ai déja pas mal fais qui ne m'a rapporté qu'insultes et bien plus grave, je ne dis pas tout), il me semble certain qu'à part quelques tux amis qui travaillent sur des versions dans le monde non libre, il n'y ai que moi comme DEV sur le projet (Voila pourquoi aussi ce dernier projet n'avance pas vite, c'est le plus long pour moi aujourd'hui, il a déja plus de trois ans en travaillant une ou deux heures par nuit.)
Pour faire plus simple, comment coder quelque chose qu'on ne comprend pas, comment critiquer un code quand on en aperçoit pas le sens ?
Pourtant c'est simple, prenez un rivage, faite la moyenne des hauteurs des vagues, et ensuite analyser les effets à l'aide de cette moyenne, ainsi avec tous les autres formats audio vous arrivez à créer des codes qui disent que Nice, Fukushima, les 400 villages rayés de la carte en inde n'existe pas puisque c'est le même effet en moyenne. Que l'eau soit sans mouvement, morte pendant six mois et qu’après elle arrache les terres un bref instant, ou qu'elle ne varie peu d'une manière constante c'est le même effet, jolis codes tout propre, tout va bien, il suffit de l'imaginer et de le modéliser avec des codes parfais. Et quand l'un montre quelque chose, on essai de voir ce qu'il montre, pas si son doigt est vieux et usé par un système ou la religion a remplacé la science.
Pour tester les temps de réaction, j'avais utilisé gtk il y a quelques temps, le temps de retrouver et voici comment j'avais fais, mais il va falloir que j'adapte mes codes pour pouvoir tester.
En premier, j'étais allé chercher des lib :
sudo apt-get install libgtk2.0-0 libgtk2.0-devEnsuite, j'avais créé un main nommé quellevitesse.c
#include <gtk/gtk.h>
typedef struct _GTimer GTimer;
double timer;
/* Timer
GTimer* g_timer_new (void);
void g_timer_destroy (GTimer *timer);
void g_timer_start (GTimer *timer);
void g_timer_start (GTimer *timer);
void g_timer_reset (GTimer *timer);
gdouble g_timer_elapsed (GTimer *timer, gulong *microseconds);
*/
int main( int argc, char **argv)
{
int qui = 15;
void g_timer_start(GTimer *timer);
/* c'est ceci que je test mais il va falloir adapter*/
printf("lettre debut est %d\n",qui);
/* fin de es-tu une bonne idée*/
void g_timer_stop(GTimer *timer);
printf ("Temps ecoule : %f\n", timer);
void g_timer_destroy (GTimer *timer);
return 0;
}et encore derrière j'avais compilé pour rendre le code executable
gcc -o quellevitesse quellevitesse.c `pkg-config --libs --cflags gtk+-2.0`Et enfin j'avais lancé le code pour savoir
./quellevitesseMaintenant que j'ai retrouvé, il ne me reste qu'à adapter mes deux codes pour tester switch vs sprintf
Au passage, je vais utiliser qt5 (qt4 étant la version d'origine dans ubuntu), de manière à pouvoir piloter directement les sons avec le synthétiseur de son lm3jo. Car actuellement en faisant appel à system on ne peut bouger les curseurs dans qt quand un son ce joue.
j'ai mis en ligne la dernière version qui contient qt5 à la place de qt4, j'ai conservé dans l'appli les deux version SDL
Cordialement
Dernière modification par temps (Le 31/10/2013, à 23:16)
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#17 Le 27/10/2013, à 23:38
- temps
Re : [résolu] switch vs sprintf
Bonjour,
Je poste en résolu, voici la réponse à sprintf du code donné ci-dessus
Temps ecoule : 0.000000je garde ce passage en mémoire des fois qu'un jour, il apparaisse quelque chose.
Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#18 Le 05/02/2014, à 06:11
- temps
Re : [résolu] switch vs sprintf
Bonjour,
Je reviens un peu sur le sujet.
Ce matin j'ai repris un peu les codes en remplaçant les switch par des sprintf,
l'application semble bien fonctionner, elle passe de 37 Ko à 17 ko.
Pour détail, l'application lit un texte composé d'une série de 2 lettres sensibles à la casse avec aussi le cas de 1 caractère "l'espace", chaque série de deux lettres correspond à un fichier audio différents qui sont mixés jusqu'à 16 pistes.
Voici le code d'identification des lettres :
while (((qui= fgetc(jojo)) != EOF) && (saitfait == 1))/* qui vient chercher tout ce qui bouge*/
{
if (qui != '\n'){
printf("lettre debut est %d\n",qui);
if (((qui > 'a')&& (qui< 'z')) ||((qui > 'A')&& (qui< 'Z')) || (qui == 'a' ) || (qui == ' ' )|| (qui == 'z'))
{
commesa++;
if(commesa==1)
{
apremier = qui;
}
if (commesa>1)
{
adeuxieme = qui;
commesa = 0;
sprintf(passemoi,"%c%c.jo",apremier, adeuxieme);
printf("passemoi est %s\n",passemoi);
/***/
FILE* fichierjo1 = NULL;
FILE* fichiertampon1 = NULL;
fichierjo1 = NULL;
fichierjo1 = fopen(passemoi, "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n",passemoi);
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
/**************/
}
}
}
/****traitement un caractere espace****/
if (qui == ' ' )
{
apremier = qui;
commesa = 0;
sprintf(passemoi,"%c.jo",apremier);
printf("passemoi est %s\n",passemoi);
/***/
FILE* fichierjo1 = NULL;
FILE* fichiertampon1 = NULL;
fichierjo1 = NULL;
fichierjo1 = fopen(passemoi, "rb");
if(fichierjo1 == NULL){
printf("Ce fichier ne va pas %s\n",passemoi);
exit(1);
}
fichiertampon1 = fopen(construit, "ab");
if(fichiertampon1 == NULL){
printf("Ce fichier ne va pas %s\n",construit);
exit(1);
}
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;
fclose(fichierjo1), fichierjo1 = NULL;
/**************/
}
}
/***fin traitement caractere espace
} /*while (qui != EOF);*jusqua la fin du texte*/
fclose(jojo);Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#19 Le 05/02/2014, à 17:55
- claudius01
Re : [résolu] switch vs sprintf
Bonjour,
En marge du sujet présenté, ne pourrais-tu pas indenter le code suivant certaines règles établies (cf. Style d'Indentation) avec des outils comme bcpp ou autres et qui donnent sur un extrait dudit code :
Avant ;-(
if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL){
abadie = fgetc(fichierjo1);
while (abadie != EOF){
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;Et après, avec la commande suivante qui fournit une présentation Style K&R (car je suis de la vieille école ;-) :
$ bcpp -s -i 3 ... if (fichierjo1 != NULL) {
if (fichiertampon1 != NULL) {
abadie = fgetc(fichierjo1);
while (abadie != EOF) {
fwrite(&abadie,1,sizeof(regle),fichiertampon1);
abadie = fgetc(fichierjo1);
}
}
}
fclose(fichiertampon1), fichiertampon1 = NULL;;NB: Si un code source est écrit au moins une fois, il sera lu ... des centaines de fois.
Cordialement, A+
--
Claudius
Hors ligne
#20 Le 06/02/2014, à 05:33
- temps
Re : [résolu] switch vs sprintf
Bonjour,
Merci pour le commentaire.
C'est vrai qu'il existe des outils pour améliorer la présentation visuel.
Le problème c'est le temps qui me manque. Je code tout sans outils de manière à ne pas être orienté.
Ma démarche actuelle est de mettre un peu chaque jour mon savoir en ligne en passant par :
1- un tableur qui montre comment est construit tel son et de mettre le son sur wikimedia
2- développer un peu sous windows de manière à essayer de trouver une source financière pour mes projets libres
3- améliorer un peu les codes de lm3jo, écrire les explications et mettre sur les forum ubuntu, kubuntu, xubuntu comment je fais (retour d'info)
C'est vrai qu'il existe des outils pour mieux présenter, mais dès que j'ai un moment je reprends la partie hard (carte audio linux en pause manque de temps), ensuite je passe à la partie communication en cherchant à apprendre à utiliser les outils pour mieux communiquer. Mais à regret actuellement ce n'est pas d'actualité. Si quelqu'un veut entrer dans le projet pour le faire, il est le bienvenue les codes sont en lignes.
Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#21 Le 06/02/2014, à 06:11
- temps
Re : [résolu] switch vs sprintf
Bonjour,
En relisant mon dernier poste, je m’aperçois que je me suis mal exprimer. Pour moi c'est évident que non, mais d'autres pourrait penser qu'il est facile de taper une ligne de code pour changer l'aspect avant de poster.
Je vais essayer de mieux exprimer pourquoi il me faut du temps avant de mettre en forme les codes.
En exemple sur l'audio, quelles sont les lois qui font qu'on entend tel son ou tel son ? sont-elles physiques ? sont-elles physiologiques ? sont-elles de l'entendement dues au cerveau humain, donc de l'interprétation ? ou encore un mélange en tel ou tel proportion de physique, de physiologique et d'entendements ?
Et oui, sur mes codes c'est pareil, il y a plusieurs langages, et plusieurs applications en équilibres, envoyer une forme d'intentation, reviendrai à prendre une image en 2 dimensions d'un systèmes en contenant bien plus et donc masquerait la réalité. Nous interprétons une photo 2d en 4D car le cerveau sait corriger la troisième dimension spaciale et la variation du au temps, mais dans mes codes le cerveau n'a pas l'habitude. Ainsi orienter mes codes à l'aide d'une image qui n'ouvre pas les réalités ouvertes, les feraient aborder d'une manière incompréhensibles. C'est pourquoi, quand j'aurait le temps, je trouverait une technique afin de présenter les codes pour faire ressortir les équilibres.
C'est pas évident ce que je viens de chercher à exprimer, mais en analysant comment j'ai construit le moteur de recherche système expert et en l'utilisant, les termes que j'ai employé ci-dessus deviennent beaucoup plus claires.
Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#22 Le 06/02/2014, à 15:39
- telliam
Re : [résolu] switch vs sprintf
tu te prends la tête la où il ne faut pas :
indenter du code c'est pour pouvoir facilement le relire et le partager.
Si tu l'indentes pas et que tu reviens qq temps apres sur ton code, tu auras forcément des difficultés à trouver les débuts et fins de blocs.
Tu ne rencontres peut etre pas le pb actuellement car tu as peu de lignes de code et que tu reviens souvent dessus.
tu n'es pas obligé d'indenter tous les langages de la meme maniere mais au sein d'un meme fichier, il faut etre cohérent.
d'autant plus que tu as le souhait de le partager.
Ce n'est pas rentrer dans un moule, c'est juste pratique...
En gros ce que tu nous as dit c'est que c'est le bordel dans ton cerveau et que ton code reflète cet état.
Dernière modification par telliam (Le 06/02/2014, à 18:09)
"- Un intellectuel assis va moins loin qu'un con qui marche."
Maurice Biraud - Un Taxi pour Tobrouk
Michel Audiard
Hors ligne
#23 Le 06/02/2014, à 17:07
- claudius01
Re : [résolu] switch vs sprintf
Bonjour,
C'est vrai ça, pourquoi indenter le code ?
Tiré du célèbre The International Obfuscated C Code Contest ...
char*_ = "'""/*";
#include <stdio.h>
#define m 21
#define o(l, k) for(l=0; l<k; l++)
#define n(k) o(T, k)
int E,L,O,R,G[42][m],h[2][42][m],g[3][8],c
[42][42][2],f[42]; char d[42]; void v( int
b,int a,int j){ printf("\33[%d;%df\33[4%d"
"m ",a,b,j); } void u(){ int T,e; n(42)o(
e,m)if(h[0][T][e]-h[1][T][e]){ v(e+4+e,T+2
,h[0][T][e]+1?h[0][T][e]:0); h[1][T][e]=h[
0][T][e]; } fflush(stdout); } void q(int l
,int k,int p){
int T,e,a; L=0
; O=1; while(O
){ n(4&&L){ e=
k+c[l] [T][0];
h[0][L-1+c[l][
T][1]][p?20-e:
e]=-1; } n(4){ e=k+c[l][T][0]; a=L+c[l][T][
1]+1; if(a==42 || h[0][a][p?20-e:e]+1){ O=0
; } } n(4){ e= k+c[l][T][0]; h[0][L + c[l][
T][1]][p?20-e: e]=g[1][f[p?19+l:l]]; } L++;
u(); } n(42) { o(e,m)if(h[0][T][e]<0)break;
o(a, m&&e==m){ for(L=T; L; L--) { h[0][L][a
]=h[0][L-1] [a ]; } h[0][0][a]=-1; } } u();
}int main(){ int T,e,t,r,i,s ,D,V,K; printf("\33[2J\33[?25l"); n(8)g[i=
1][T]=7-T; R--; n(42) o(e,m) G[T][e]--; while(fgets(d,42,stdin)) { r=++
R; n(17){ e=d[T]-48; d[T]=0; if ((e&7)==e) { g[0][e] ++; G[R][T+2]=e; }
} } n(8)if(g[0][7-T]){ t=g[i ][O]; g[i][O++]=g[i][T]; g[i][T]=t; } n(8)
g[2][g[i][T]]=T; n(R+i)o(e,m )if(G[T][e]+i) G[T][e]=g[2][G[T][e]]; n(19
)o(t,2){ f[T+t+T]=(T["+%#,4" "5>GP9$5-,#C?NX"]-35)>>t*3&7; o(e,4){ c[T]
[e][t]=("5'<$=$8)Ih$=h9i8'9" "t=)83)l4(99(g9>##>4(" [T+t+T]-35)>>e*2&3;
} } n(15) { s=T>9?m:(T&3)-3?15:36;o(e,s)o(t,2)c[T+19][e][t]="6*6,8*6.608.6264826668\
865::(+;0(6+6-6/8,61638065678469.;88))()3(6,8*6.608.6264826668865:+;4)-*6-6/616365,\
-6715690.5;,89,81+,(023096/:40(8-7751)2)65;695(855(+*8)+;4**+4(((6.608.626482666886\
5:+;4+4)0(8)6/61638065678469.;88)-4,4*8+4(((60(/6264826668865:+;4-616365676993-9:54\
+-14).;./347.+18*):1;-*0-975/)936.+:4*,80987(887(0(*)4.*""/4,4*8+4(((6264826668865:\
+;4/4-4+8-4)0(8)6365678469.;88)1/(6*6,6.60626466686:8)8-8*818.8582/9863(+;/""*6,6.6\
0626466686:4(8)8-8*818.8582/9863(+;/,6.60626466686:8-818.8582/9864*4+4(0())+;/.6062\
6466686:8/8380/7844,4-4*4+4(0())69+;/0626466686:818582/9864.4/4,4-4*4+4(0())+;" [e+E
+e+t]-40; E+=s+s; } n(45){ if(T>i) { v(2,T,7); v(46,T,7); } v(2+T,44,7); } T=0; o(e,
42)o(t,m)h[T][e][t]--; while(R+i) { s = D=0; if (r-R) { n(19) if (G[R+i][T]+i) V=T/2
; else if(G[R][T]+i) s++; if(s) { if(V>4){ V=9-V; D++; } V+=29; n(20) q(c[V][T][0],c
[V][T][i],D); } } n(19) if((L=G[R][T])+i) { O=T-L; e=O>9; t=e?18-O :O; o(K,((t&3)-3?
16:37)){ if(K){ L=c[t+19][K-i][0]; O=c[t+19][K-i][i] ; } q(L,O,K && e); } } if(s) q(
c[V][20][0], c[V][20][i], D); R--; } printf("\33[47;1f\33[?25h\33[40m"); return 0; }... mais là c'est du grand art au vu de ce que le programme, après compilation sans warning, réalise ;-)
NB: Tous les projets de l'année 2013 disponibles ici : All of the data for 2013
Cordialement, A+
--
Claudius
Hors ligne
#24 Le 06/02/2014, à 20:02
- temps
Re : [résolu] switch vs sprintf
Bonjour,
Très jolie graphisme.
L'idée serait plutot de placer les lignes de codes en fonction du niveau d'action sur les effets en plaçant les effets semblables ou presque au même niveau, et non pas en fonction d'un nombre d'accolades ou autre.
mais pour faire ça il faut en premier commenter pour indiquer comment sont placer les lignes, essayer de trouver un graphisme qui montre les interactions des sorties ... l'idée serait plutot d'écrire le code sous la forme d'un schéma logique et qu'une simple vue d'ensemble puisse mettre les actions en évidence. Je suis sure que si je gratte, c'est quelque chose qui doit déja exister, la particularité de la technique est qu'il est d'évidence que ce type de rangement soit difficilement automatisable car cela nécessite de l'entendement sur la raison d'être du code.
Cordialement
Parce que l'USB bootable est le support des systèmes experts,
Parce que l'USB bootable contient sa propre image au démarrage.
L'USB bootable permet de créer un monde à la dimension de son imagination
https://www.letime.net
Hors ligne
#25 Le 06/02/2014, à 20:34
- ssdg
Re : [résolu] switch vs sprintf
Ou alors: Ranger en fonction du nombre d'accollade en s'assurant que:
le second niveau est toujours une fonction ou une variable partagée (par les fonctions qui sont groupées avec) qui porte un nom concis et expressif du contenu de la fonction
Le premier niveau est une classe (si tu fais de l'objet) qui contient des fonctions et variables partagées (on pourrait appeler ça "attributs") qui porte elle même un nom concis et expressif de ce qu'elle regroupe.
À noter que ce que je décris là est la différence entre un projet développé par quelqu'un dans son coin et dont la durée de vie est bornée par la durée de vie et l'intérêt de son auteur. et un projet capable de survivre à l'intérêt de son auteur ou d'être codé par plusieurs personnes. (et parfois même des centaines de gens dont seulement une poignée se sont rencontrés en vrai.
s'il n'y a pas de solution, c'est qu'il n'y a pas de problème... ou pas.
Hors ligne