Discussion :

[SPACHFR]

Bonjour,

J'ai fais un petit pgm, pour voir s'il était possible de concatener des arguments passés à un pgm.
Pour vérifier la concatenantion, je fais un printf() des arguments.
Mais lors de l'affichage, j'ai perdu un caractère sur l'argument 2
Quelle en est la raison ?

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
 
#include <stdio.h>     
#include <stdlib.h>    
#include <errno.h>     
#include <string.h>    
#define ALPR    "ALPR" 
int main(int argc,char *argv[]) {
  int a = 0;                     
  strcat(argv[1],argv[2]);       
  printf("argv1: %s\n",argv[1]); 
  printf("argv2: %s\n",argv[2]); 
  a = strcmp(argv[1],ALPR);      
  if (a ==0){                    
     printf("OK");               
     }                           
     else {                      
     printf("nok");              
     }                           
  return 0;                      
}

sortie du pgm

Code :

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

1
2
3
4
 
argv1: ALPRMA0 
argv2: A0      
nok

[Thierry Chappuis]

Salut,

A aucun endroit je vois que tu réserves un espace mémoire pour contenir la concaténation des chaines argv[1] et argv[2]...

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 <stdlib.h>
#include <string.h>
 
#define ALPR    "ALPR"
 
int main(int argc,char *argv[])
{
    if (argc == 3)
    {
        int a = 0;
        char buffer[10] = "";
 
        strncat(buffer, argv[1], sizeof buffer - 1);
        strncat(buffer, argv[2], sizeof buffer - strlen(buffer) - 1);
        printf("argv1: %s\n",argv[1]);
        printf("argv2: %s\n",argv[2]);
        a = strcmp(buffer, ALPR);
 
        if (a == 0)
        {
            printf("OK");
        }
        else
        {
            printf("nok");
        }
    }
 
    return 0;
}

Tu peux également utiliser l'allocation dynamique, si tu ne peux pas estimer à l'avance la taille que doit prendre le tableau de caractères buffer.

Thierry

[BainE]

bonjour,

strcat n'assure pas le resize de la chaine de caractere qui accueille a concatenation. Il faut au prealable faire une allocation d'une chaine suffisement grande.

Code :

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

1
2
3
4
5
6
 
char* tmp = 0;
if( ( tmp = malloc( strlen( argv[ 1 ] ) + strlen( argv[ 2 ] ) + 1 ) != 0 )
{
    // reste du traitement, les concatenations
}

sachant qu il est de bon ton de verifier que tu a bien passé assez de parametre en verifiant argc.

De plus il est formellement interdit de modifier les parametres du main, ce qui entraine un comportement indefini du systeme.

[edit] sous la remarque de M. Chapuis, sizeof remplacé par srtrlen
et ajout de 1 (pour le '\0' final) dans le calcul de la taille

[SPACHFR]

Cela veut dire que je doit obigatoirement passer par un tableau de char[] pour faire la concatenation.
J'ai refais le code

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
 
#include <stdio.h>     
#include <stdlib.h>    
#include <errno.h>     
#include <string.h>    
#define ALPR    "ALPR" 
int main(int argc,char *argv[]) {      
  int a = 0;                           
  char tab[15]="";                     
  strncat(tab,argv[1],sizeof(argv[1]));
  strncat(tab,argv[2],sizeof(argv[2]));
  printf("argv1: %s\n",argv[1]);       
  printf("argv2: %s\n",argv[2]);       
  printf("tab: %s\n",tab);             
  a = strcmp(argv[1],ALPR);            
  if (a ==0){                          
     printf("OK");                     
     }                                 
     else {                            
     printf("nok");                    
     }                                 
  return 0;                            
}

celui fonction. Cela veut dire que j aupparavant j'écrasais une partie de l'argument 2 ?

Edit : j'avais pas vu la réponse précedante

[BainE]

Y a plus qu'a esperer que tes 2 chaines ne fasse pas plus de 14 caracteres.
Il te fais peur mon malloc ?

[edit] poster avec l'edit precedent

[SPACHFR]

Non, mais jusqu'a ton poste je ne voyais pas vraiment comment utiliser le malloc().
Maintenant c'est clair...., c'est une très bonne solution si l'on ne connais pas la taille d'un argument ou d'une variable.

Merci pour vos réponses, one more step......

[Jean-Marc.Bourguet]

Bonne solution... a condition d'utiliser quelque chose qui donne bien la taille de la chaine plutot que la taille d'un pointeur et d'ajouter 1 a la somme pour tenir compte du \0 final.

[BainE]

malloc c'est de l allocation dynamque : pendant l'execution, a la difference des tableau.
Par contre a chaque malloc *DOIT* correspondre un free.
Car toutes memoires réservées doivent être libérées, rendues pour de nouvelles aventures (nouvelles utilisations) une fois lors role rempli.

[Thierry Chappuis]

Cela veut dire que je doit obigatoirement passer par un tableau de char[] pour faire la concatenation.
J'ai refais le code

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
 
#include <stdio.h>     
#include <stdlib.h>    
#include <errno.h>     
#include <string.h>    
#define ALPR    "ALPR" 
int main(int argc,char *argv[]) {      
  int a = 0;                           
  char tab[15]="";                     
  strncat(tab,argv[1],sizeof(argv[1]));
  strncat(tab,argv[2],sizeof(argv[2]));
  printf("argv1: %s\n",argv[1]);       
  printf("argv2: %s\n",argv[2]);       
  printf("tab: %s\n",tab);             
  a = strcmp(argv[1],ALPR);            
  if (a ==0){                          
     printf("OK");                     
     }                                 
     else {                            
     printf("nok");                    
     }                                 
  return 0;                            
}

celui fonction. Cela veut dire que j aupparavant j'écrasais une partie de l'argument 2 ?

Edit : j'avais pas vu la réponse précedante

Attention, sizeof argv[1] ne fait pas ce que tu penses. Utilises strlen(argv[1]) pour obtenir la taille de la chaine pointée par argv[1].

Thierry

[Thierry Chappuis]

Code :

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

1
2
 
char* tmp = 0;

Pourquoi casser l'abstraction de NULL ici?

Thierry

[BainE]

A cause d une mauvaise habitude. Je sais c'est pas l'ideal mais j ai du mal a me defaire de ca.

Et oui houla, sizeof, strlen, en changeant 5 lettres c'est pareil
j'avais pas vu ma boulette

[Thierry Chappuis]

Un petit exemple avec allocation dynamique:

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(int argc,char *argv[])
{
    int err = EXIT_SUCCESS;
 
    if (argc == 3)
    {
        char *buffer = NULL;
        size_t buff_size = strlen(argv[1]) + strlen(argv[2]) + 1;
 
        buffer = malloc(buff_size * sizeof *buffer);
        if (buffer != NULL)
        {
            *buffer = 0;
            strcat(buffer, argv[1]);
            strcat(buffer, argv[2]);
 
            /* Suite du code */
 
            free(buffer), buffer = NULL;
        }
        else
        {
            fprintf(stderr, "Memory allocation is impossible!\n");
            err = EXIT_FAILURE;
        }
    }
    else
    {
        /* usage() */
    }
 
    return err;
}

Thierry