Positionnement des fichiers en C

Version imprimable

Voir 40 message(s) de cette discussion en une page

26/03/2011, 13h14
temps

Positionnement des fichiers en C

Bonjour,
je suis débutant en C, et j'ai écris quelques lignes de code qui me permettent de lire et de créer des fichiers en fonction de ce qui est lu. Maintenant, je voudrais que ces quelques lignes de codes puissent être utilisées sur d'autres ordinateur, mais voila mes liens travaillent à l'aide d'adresses fixes ( en exemple /home/nom_d_utilisateur/mon_repertoire_de_travaille ) et bien sur, sur un autre P.C ce type d'adresse n'est plus la même. En d'autres mots, je recherche en C un fonction comme en bash qui donne ~/mon_repertoire_de_travaille , un chemin relatif.

Après quelques tests j'ai trouvé une solution, c'est de placer ./ devant le répertoire de travail
ce qui donne ./mon_repertoire_de_travaille

Je viens de me faire une telle fonction hier ! Je serais heureux que ça existe déjà...

Mon but est de transformer le chemin pt->fichier[0] en chemin relatif par rapport à ((char **)param)[1] .

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
        for (tmp=pt->fichier[0],tmp1=((char **)param)[1];*tmp!=0 && *tmp1!=0 && *tmp1==*tmp;tmp++,tmp1++)
            if (*tmp==SEPARATEUR)
                tmp2=tmp;
        if (*tmp1==0 && *tmp==0)
        { /* même répertoire */
            fprintf(fichier," <perso>.%c%s</perso>\n",SEPARATEUR,pt->fichier[1]);
        }
        else if (tmp2!=NULL)
        {
            if (*tmp==SEPARATEUR && *tmp1==0)
            {
                fprintf(fichier," <perso>%s%c%s</perso>\n",tmp+1,SEPARATEUR,pt->fichier[1]);
            }
            else
            {
                if (*tmp==0 && *tmp1==SEPARATEUR)
                {
                    ch[0]=0;
                }
                else
                    sprintf(ch,"..%c%s",SEPARATEUR,tmp2+1);
                while(*tmp1!=0)
                { /* répertoire différent, mais pas dans l'arborescence de  ((char **)param)[1] */
                    if (*tmp1==SEPARATEUR)
                    {
                        if (*ch==0)
                            sprintf(aff,"..%s",ch);
                        else
                            sprintf(aff,"..%c%s",SEPARATEUR,ch);
                        strcpy(ch,aff);
                    }
 
                    tmp1++;
                }
                fprintf(fichier," <perso>%s%c%s</perso>\n",ch,SEPARATEUR,pt->fichier[1]);
            }
        }
        else /* reprendre à la racine, rien en commun */
            fprintf(fichier," <perso>%s%c%s</perso>\n",pt->fichier[0],SEPARATEUR,pt->fichier

Je veux bien prendre toute amélioration !

une solution plus simple ne pourrait pas être :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
l = strlen(param[1]) ;
 
if ( (p = strstr (pt->fichier[0], param[1])) != NULL )
  {
       l1 = strlen(pt->fichier[0]);
 
       memmove ( &(pt->fichier[0][0]), &(pt->fichier[0][l+1]), (l1-l-1)) ;
 
       pt->fichier[0][l1-l-1] = '\0' ;
  }

Ou, si on veut le vrai relatif :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
l = strlen(param[1]) ;
p = param[1] ;
 
n = 0 ;
while ( (p = strchr(p, '/')) != NULL )
   n = n + 1 ;
 
if ( (p = strstr (pt->fichier[0], param[1])) != NULL )
  {
       l1 = strlen(pt->fichier[0]);
 
       memmove ( &(pt->fichier[0][n*3]), &(pt->fichier[0][l+1]), (l1-l-1)) ;
 
       pt->fichier[0][l1-l-1+3*n] = '\0' ;
 
       for ( i = 0 ; i < n ; i++ )
         {
              pt->fichier[0][i*3] = '.' ;
              pt->fichier[0][i*3+1] = '.' ;
              pt->fichier[0][i*3+2] = '/' ;
         }
  }

qui crée un chemin "../../../xxx"

?

26/03/2011, 15h26
souviron34

j'ajoute que j'ai fait une petite erreur :

il faut ajouter un décalage de 1 à cause du / avant le nom du fichier...

donc la longueur à copier est l1-l-1, et le positionnement est &(pt->fichier[0][l+1]) ..

car on ne veut pas que le nom du fichier commence par /
26/03/2011, 15h34
troumad

Une autre erreur, tu as écrit memove à la place de memmove

Je regarde ton code...

Il donne quoi avec deux chemins du type : /a/b/c et /a/c/d ?? Si ça marche, je ne comprends pas tout ! Pour moi, je souhaite en sortie ../c .
26/03/2011, 15h55
souviron34

Citation:

Envoyé par troumad

Une autre erreur, tu as écrit memove à la place de memmove

vivi.. tapé trop vite sans vérifier.. sniff...

Citation:

Envoyé par troumad

Il donne quoi avec deux chemins du type : /a/b/c et /a/c/d ??

si ces 2 chemins sont d'une part le param et d'autre part le nom, il ne donne rien de plus..

Si param est /a il sortra

b/c
c/d

Citation:

Envoyé par troumad

Si ça marche, je ne comprends pas tout ! Pour moi, je souhaite en sortie ../c .

Donc c'est plutôt la 2ième solution

Si param est /a, avec tes 2 chemins ci-dessus il sortira :

../b/c
../c/d

Dis-moi ce que tu ne comprends pas et j'expliquerai.. ça me semble assez simple...
26/03/2011, 16h22
souviron34
Pour la compréhension :
- pour la première solution :
  
  Si le chemin "racine" existe :
  
  on décale la chaîne de telle manière que le premier caractère du nom du fichier devienne le premier caractère après le "/" suivant cette racine
- Pour la seconde solution :
  
  on compte le nombre de niveaux de sous-répertoires
  
  si le chemin "racine" existe
  
  on décale la chaîne de telle manière que le premier caractère du nom de fichier après le "/" suivant cette racine soit à la bonne position en fonction du nombre de niveaux de sous-répertoires (même chose que ci-dessus, mais décalé de 3*n (voir ci-dessous)).
  
  On complète le début de la chaîne par "../" répété autant de fois qu'il y a de nombre de niveaux de sous-répertoires ..
PS: j'ai corrigé le code
26/03/2011, 16h59
troumad

Les 2 données sont :
Départ : /a/b/c
Arrivée : /a/b/d

La procédure devra alors trouver ../d pour aller en chemin relatif de Départ vers Arrivée.
26/03/2011, 17h28
souviron34

Citation:

Envoyé par troumad

Les 2 données sont :
Départ : /a/b/c
Arrivée : /a/b/d

La procédure devra alors trouver ../d pour aller en chemin relatif de Départ vers Arrivée.

c'est ce que trouvera ma 2ième éthode si tu lui rentres en paramètre param1 "a/b" : elle trouvera ../c et ../d

Si tu lui rentres "/a/b" elle trouvera ../../c et ../../d

Mais voir plus bas...

Si par contre ce que tu veux trouver c'est d'abord la partie commune sur 2 chemins différents, alors le problème n'est plus le même que celui indiqué par :

Citation:

Mon but est de transformer le chemin pt->fichier[0] en chemin relatif par rapport à ((char **)param)[1]

Il faut déjà alors trouver la partie commune...

Et ensuite légèrement modifier pour ne pas compter les "/" depuis le début de la chaîne, mais simplement depuis la fin de la partie commune..
26/03/2011, 17h36
troumad

J'aurais du dire le chemin relatif le plus cours possible ;)

OK.

Dans ce cas-là c'est quasi aussi simple, tout ce que ça fait c'est décaler le calcul du nombre de sous-niveaux, et démarrer au bon niveau dans la recopie de la chaine (arpès le dernier "/")..

Si la racine ne contient pas de "/" final, on a :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 l = strlen(param[1]) ; if ( (p = strstr (pt->fichier[0], param[1])) != NULL ) { /* ici on compte le nombre de / entre la racine et le nom du fichier */ p1 = p + 1 ; /* premier caractère après la fin de la racine */ p0 = p1 ; /* sauvegarde */ n = 0 ; while ( (p1 = strchr(p1, '/')) != NULL ) { n = n + 1 ; p0 = p1 ; } /* calcul de la vraie longueur du nom du fichier (avec le /) */ l1 = strlen(p0); /* calcul de la vraie position depuis le début de la chaine */ l2 = strlen(pt->fichier[0]) - l1 + 1 ; /* on bouge la chaine */ memmove ( &(pt->fichier[0][n*3]), &(pt->fichier[0][l2+1]), l1-1) ; pt->fichier[0][l1-1+3*n] = '\0' ; /* on complète */ for ( i = 0 ; i < n ; i++ ) { pt->fichier[0][i*3] = '.' ; pt->fichier[0][i*3+1] = '.' ; pt->fichier[0][i*3+2] = '/' ; } }
Si elle contient un "/" final, il faut intialiser n à 1..

PS: pas testé, mais le principe est là.. (de mon point de vue)

[EDIT]

re-modifé car je m'étais trompé dans le calcul de l2 (position du début du vrai nom du fichier)

Et il faut aussi enlever le +1 dans le "l2+1" du memmove dans le cas où on considère un '/' final dans la racine

Avec ça, en partant de :

Départ : /a/b/c
Arrivée : /a/b/d

tu devrais arriver à :

../c
../d

avec "/a/b" comme param1

et si tu avais

/a/b/c/d
/a/b/e

tu obtiendrais :

../../d
../e

Si par contre tu veux obtenir le chemin "../c/d", il faudrait à mon avis utiliser la première solution (chemin relatif global) et compter le nombre de niveaux de "../" par élément, prendre le minimum-1, et re-décaler les chaînes résultantes..

Par exemple, dans le cas des 2 dernières chaînes :

/a/b/c/d
/a/b/e

on commencerait par avoir

../../c/d
../../e

On compte le nombre de "../" et on enlève 1, et on décale les chaines et on a bien : "../c/d" et "../e"

Et ceci, on peut le faire directement, donc on ne change quasiment rien au premier code donné, simplement on assigne directement n à 1.. :D
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 l = strlen(param[1]) ; p = param[1] ; if ( (p = strstr (pt->fichier[0], param[1])) != NULL ) { l1 = strlen(pt->fichier[0]); memmove ( &(pt->fichier[0][3]), &(pt->fichier[0][l+1]), (l1-l-1)) ; pt->fichier[0][l1-l-1+3] = '\0' ; pt->fichier[0][i*3] = '.' ; pt->fichier[0][i*3+1] = '.' ; pt->fichier[0][i*3+2] = '/' ; } }
[/EDIT]

je re-poste car je ne sais si tu auras vu mon (gros) EDIT...

Je disais en résumé :

Si ce que tu veux c'est partant de

/a/b/c/d
/a/b/e

Arriver à

../c/d
../e

C'est simple (premier code en mettant n à 1) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
l = strlen(param[1]) ;
 
if ( (p = strstr (pt->fichier[0], param[1])) != NULL )
  {
       l1 = strlen(pt->fichier[0]) - l  ;
 
       memmove ( &(pt->fichier[0][3]), &(pt->fichier[0][l+1]), l1) ;
 
       pt->fichier[0][l1+3] = '\0' ;
 
       pt->fichier[0][0] = '.' ;
       pt->fichier[0][1] = '.' ;
       pt->fichier[0][2] = '/' ;
  }

Si la racine contient un '/' final, enlever le +1 dans le memmove et ajouter +1à l1.

Si ce que tu veux c'est partant de

/a/b/c/d
/a/b/e

Arriver à

../../d
../e

C'est à peine plus compliqué (il faut juste compter les "/" dans le nom) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
l = strlen(param[1]) ;
 
if ( (p = strstr (pt->fichier[0], param[1])) != NULL )
  {
       p = p + l  ; 
       p0 = p + 1 ;  /* sauvegarde */
 
       /*compter les / dans le nom */
       n = 0 ;  
       while ( (p = strchr(p, '/')) != NULL )
         {
            n = n + 1 ;
            p0 = p + 1 ;
         } 
 
       l1 = strlen(p0) ;
 
       memmove ( &(pt->fichier[0][3*n]), p0, l1) ;
 
       pt->fichier[0][l1+3*n] = '\0' ;
 
       for ( i = 0 ; i < n ; i++ )
        {
            pt->fichier[0][i*3+0] = '.' ;
            pt->fichier[0][i*3+1] = '.' ;
            pt->fichier[0][i*3+2] = '/' ;
         }
  }

Si la racine contient un '/' final, il faut initialiser n à 1 et enlver le +1 au premier assignement de p0.

Bonjour

Je ne comprends pas tout ce que tu fais. Par contre, je comprends les sorties identiques de ces programmes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <string.h>
 
int main()
{
 
 char ch1[32]="/a/b/c/d";
 char ch2[32]="/a/b/e";
 unsigned short l,l1;
 char * p;
 
 l = strlen(ch1) ;
 
  if ( (p = strstr (ch2, ch1)) != NULL )
  {
       l1 = strlen(ch2) - l  ;
 
       memmove ( &(ch2[3]), &(ch2[l+1]), l1) ;
 
       ch2[l1+3] = '\0' ;
 
       ch2[0] = '.' ;
       ch2[1] = '.' ;
       ch2[2] = '/' ;
  }  
  printf("Final %s et %s avec p=%s,l=%hu et l1=%hu",ch1,ch2,p,l,l1);
 
  return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <stdio.h>
#include <string.h>
 
int main()
{
 
 char ch1[32]="/a/b/c/d";
 char ch2[32]="/a/b/e";
 unsigned short l,l1,i,n;
 char * p,*p0;
 
  l = strlen(ch2) ;
 
if ( (p = strstr (ch1, ch2)) != NULL )
  {
       p = p + l  ; 
       p0 = p + 1 ;  /* sauvegarde */
 
       /*compter les / dans le nom */
       n = 0 ;  
       while ( (p = strchr(p, '/')) != NULL )
         {
            n = n + 1 ;
            p0 = p + 1 ;
         } 
 
       l1 = strlen(p0) ;
 
       memmove ( &(ch1[3*n]), p0, l1) ;
 
       ch1[l1+3*n] = '\0' ;
 
       for ( i = 0 ; i < n ; i++ )
        {
            ch1[i*3+0] = '.' ;
            ch1[i*3+1] = '.' ;
            ch1[i*3+2] = '/' ;
         }
  }
  printf("Final %s et %s avec p=%s,l=%hu et l1=%hu",ch1,ch2,p,l,l1);
 
  return 0;
}

Code:

1
2
$ gcc test.c;./a.out 
Final /a/b/c/d et /a/b/e avec p=(null),l=8 et l1=0

Je crois que tu souhaiterais que strstr te renvoie un pointeur sur le dernier caractère semblable des deux chaînes de caractères.

euh...

non.. :aie:

Quand tu fais :

Code:

if ( (p = strstr (ch2, ch1)) != NULL )

tu cherches dans ch2, ch1, qui est plus long...

je ne crois pas que ça risque de marcher...

parce que, avec tes exemples, il n'y a aucune occurence de ch2 dans ch1 ni de ch1 dans ch2...

D'après ce que tu avais dis plus haut, tu AVAIS la chaine commune et tu cherchais le chemin relatif..

Dans ton exemple la chaine commune est /a/b, pas /a/b/c/d ...

Ce n'est pas ce que j'avais compris que tu cherchias à faire..

Si je prend ton premier exemple, ce que j'avais compris était :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 #include <stdio.h> #include <string.h> int main() { char ch1[32]="/a/b/c/d"; char ch2[32]="/a/b/e"; char *racine = "/a/b" ; /* J'AVAUS COMPRIS QUE TU AVAIS LA RACINE */ unsigned short l,l1; char * p; l = strlen(racine) ; /* ET DONC ICI C EST LA RACINE Qu ON UTILISE */ if ( (p = strstr (ch2, racine)) != NULL ) { l1 = strlen(ch2) - l ; memmove ( &(ch2[3]), &(ch2[l+1]), l1) ; ch2[l1+3] = '\0' ; ch2[0] = '.' ; ch2[1] = '.' ; ch2[2] = '/' ; } printf("Final %s et %s avec p=%s,l=%hu et l1=%hu",ch1,ch2,p,l,l1); return 0; }
Si maintenant tu veux déterminer automatiquement la racine commune, c'est un autre algo..

27/03/2011, 17h31
troumad

Citation:

Envoyé par souviron34

Si maintenant tu veux déterminer automatiquement la racine commune, c'est un autre algo..

OK ! Maintenant je comprends mieux ton programme !
Le but est bien sûr de trouver aussi la racine ! Et mon programme marche bien avec les essais que j'ai fait au moins.

Citation:

Envoyé par troumad

OK ! Maintenant je comprends mieux ton programme !
Le but est bien sûr de trouver aussi la racine ! Et mon programme marche bien avec les essais que j'ai fait au moins.

c'était pas clair avec

Citation:

Mon but est de transformer le chemin pt->fichier[0] en chemin relatif par rapport à ((char **)param)[1] .

d'après ça param est donc un paramètre, qui je le croyais correspondait à la racine..

:aie::aie::aie::aie:

Maintenant, c'est aussi simple comme première étape :

Si je reprend ton exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 #include <stdio.h> #include <string.h> int main() { char ch1[32]="/a/b/c/d"; char ch2[32]="/a/b/e"; char racine[32] ; unsigned short l,l1; char * p, p1; /* On détermine d'abord la racine commune */ p = ch2 ; p1 = ch1 ; l = 0 ; while ( (p != NULL) && (p1 != NULL) ) { if ( *p != *p1 ) break ; racine[l] = *p ; l++, p++ , p1++ ; } racine[l] = '\0' ; /* et maintenant on applique le même algo */ if ( (p = strstr (ch2, racine)) != NULL ) { l1 = strlen(ch2) - l + 1 ; memmove ( &(ch2[3]), &(ch2[l]), l1) ; ch2[l1+3] = '\0' ; ch2[0] = '.' ; ch2[1] = '.' ; ch2[2] = '/' ; } printf("Final %s et %s avec p=%s,l=%hu et l1=%hu",ch1,ch2,p,l,l1); return 0; }
ici automatiquement la racine contiendra le '/' final..

31/03/2011, 16h26
troumad

Et si on prends comme chemin :
/a/bb/c
/a/bc/d
Tu crois que ton programme fonctionne encore ?
La partie commune sera /a/ ou /a/b ?

Citation:

Envoyé par troumad

Et si on prends comme chemin :
/a/bb/c
/a/bc/d
Tu crois que ton programme fonctionne encore ?
La partie commune sera /a/ ou /a/b ?

:oops: :aie: bien vu :oops: voilà ce que c'est de pas tester et de faire juste les trucs de tête...

il faut arrêter sur un '/'...

ça ça devrait passer :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 p = ch2 ; p1 = ch1 ; l = 0 ; while ( (p != NULL) && (p1 != NULL) ) { if ( *p != *p1 ) break ; p2= strchr ( p, '/' ); if ( p2 == NULL ) break ; while ( p <= p2 ) { racine[l] = *p ; l++, p++ , p1++ ; } } racine[l] = '\0' ;

31/03/2011, 18h11
troumad

On va arriver presque à ma solution...

Donc, maintenant avec
/a/ba/bd/bc
/a/ba/bc/be
Ça donne quoi ?

J'avoue que je parcours très rapidement ton code sans tester !

Citation:

Envoyé par troumad

On va arriver presque à ma solution...

Donc, maintenant avec
/a/ba/bd/bc
/a/ba/bc/be
Ça donne quoi ?

J'avoue que je parcours très rapidement ton code sans tester !

ok, je crois que ce serait plus simple comme ça..
Code:

1 2 3 4 5 6 7 8 9 10 11 12 /* On détermine d'abord la racine commune */ p = ch2 ; p1 = ch1 ; l = 0 ; while ( (p != NULL) && (p1 != NULL) && (*p == *p1) ) { racine[l] = *p ; l++, p++ , p1++ ; } while ( racine[l-1] != '/' ) /* on revient au dernier séparateur */ l-- ; racine[l] = '\0' ;

Voir 40 message(s) de cette discussion en une page