Discussion :

[temps]

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

[troumad]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

[souviron34]

une solution plus simple ne pourrait pas être :

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C :

Sélectionner tout - Visualiser dans une fenêtre à part

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"


?

[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 /

[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 .

[souviron34]

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

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

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

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...

[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

[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.

[souviron34]

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 :

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..

[troumad]

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

[souviron34]

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 C :

Sélectionner tout - Visualiser dans une fenêtre à part

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..

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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]

[souviron34]

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 C :

  Sélectionner tout - Visualiser dans une fenêtre à part

  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 C :

  Sélectionner tout - Visualiser dans une fenêtre à part

  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.

[troumad]

Bonjour

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[souviron34]

euh...

non..


Quand tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

  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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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..

[troumad]

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.

[souviron34]

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

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..




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

Si je reprend ton exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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..

[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 ?

[souviron34]

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 ?

bien vu 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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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' ;

[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 !

[souviron34]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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' ;