[Fonction]strcpy

Est-il possible d'utiliser cette fonction avec un tableau de destination non déterminé?
Si oui, comment?
Sinon, quelle est la meilleure solution? Utiliser une boucle?

Re: [Débutant(e)][Fonction]strcpy

Citation:

Envoyé par Lucky-94

Est-il possible d'utiliser cette fonction avec un tableau de destination non déterminé?
Si oui, comment?
Sinon, quelle est la meilleure solution? Utiliser une boucle?

J'ai rien compris. Montre ce que tu veux faire.

Voici un exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* Exemple */
 
# include <stdio.h>
 
int main (void)
{
    char str1[] = "Exemple", str2[];
    printf("Avant copie de str1 dans str2:\n");
    printf("str1 contient: %s\n", str1);
    printf("str2 contient: %s\n", str2);
    strcpy (str2, str1);
    printf("Apres copie de str1 dans str2:\n");
    printf("str1 contient: %s\n", str1);
    printf("str2 contient: %s\n", str2);
    return 0;
}

Compilation: array size missing in 'str2'

Avec:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/* Exemple2 */
 
# include <stdio.h>
 
int main (void)
{
    char str1[] = "Exemple", str2[] = "";
    printf("Avant copie de str1 dans str2:\n");
    printf("str1 contient: %s\n", str1);
    printf("str2 contient: %s\n", str2);
    strcpy (str2, str1);
    printf("Apres copie de str1 dans str2:\n");
    printf("str1 contient: %s\n", str1);
    printf("str2 contient: %s\n", str2);
    return 0;
}

Sortie:
Avant copie de str1 dans str2:
str1 contient: Exemple
str2 contient:
Apres copie de str1 dans str2:
str1 contient: xemple
str2 contient: Exemple

Je pense que c'est ceci que tu désires.
Code:

1 2 3 4 char tableau[101] = {0}; strncpy (tableau, "coucou", sizeof (tableau) - 1);
Tu peux simplifier en cela.
Code:

1 2 #define CopyString(dst,src) strncpy (dst, src, sizeof (dst) - 1)
Mais ATTENTION, cela ne sera fonctionnel qu'avec des tableaux définit comme dans l'exemple.

J'espère avoir répondu à ta question.[/img]

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 # include <stdio.h> int main (void) { char str1[] = "Exemple", str2[] = ""; printf("Avant copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2); strcpy (str2, str1); printf("Apres copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2); return 0; }
Ça doit planter car tu recopies str1 dans str2 qui
:arrow: est trop courte, c'est une chaîne initialisée avec une chaîne de longueur 0, donc le compilo a réservé un seul octet pour elle.
:arrow: est non modifiable, car les chaînes définies en dur se trouvent en principe dnas une zone non modifiable de la mémoire. Ça semble fonctionner peut-être mais le moins que l'on puisse dire est qu'il est faux et non portable.

D'ailleur si tu prends

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
# include <stdio.h>
 
int main (void)
{
    char  str1[] = "Exemple", str2[] = "",
            str3[]  = "vive le jardinage";/***/
    printf("Avant copie de str1 dans str2:\n");
    printf("str1 contient: %s\n", str1);
    printf("str2 contient: %s\n", str2);
    strcpy (str2, str1);
    printf("Apres copie de str1 dans str2:\n");
    printf("str1 contient: %s\n", str1);
    printf("str2 contient: %s\n", str2);
    printf("str3 contient: %s\n", str3);/***/
    return 0;
}

Tu risque d'etre surpris quand à la valeur de str3, dans le meilleur des cas ça va passer puis en release tu auras une erreur de segmentation.

Bonjour,

Citation:

Envoyé par Lucky-94

Compilation: array size missing in 'str2'

Comment il fait le compilateur pour connaitre la taille de str2 ? au hasard ?

Citation:

Envoyé par Lucky-94

Code:

char str1[] = "Exemple", str2[] = "";

Dans ce cas, au moins le compilateur connait la taille à allouer pour str2 mais attention à la concordance des tailles lors de l'utilisation de strcpy!

Citation:

Envoyé par ronan99999

dans le meilleur des cas ça va passer puis en release tu auras une erreur de segmentation.

cela s'appel un comportement indéfinie, tout est possible.

Citation:

Envoyé par gege2061

Citation:

Envoyé par Lucky-94

Code:

char str1[] = "Exemple", str2[] = "";

Dans ce cas, au moins le compilateur connait la taille à allouer pour str2 mais attention à la concordance des tailles lors de l'utilisation de strcpy!

Dans le cas d'une initialisation en dur, la zone est non modifiable, donc le strcpy plante.

Citation:

Envoyé par Trap D

Dans le cas d'une initialisation en dur, la zone est non modifiable, donc le strcpy plante.

Je ne crois pas (je peut me tromper, bien sûr) :

Code:

char s[] = "Bonjour";

la chaîne est recopiée dans s, qui au passage est un tableau de 8 char.
Par contre avec :

Code:

char *s = "Bonjour";

Dans ce cas, l'adresse de la chaîne peut pointer sur une zone non modifiable de la manière.

:oops: il se pourrait (et quand je dis il se pourrait ...) bien que tu aies raison, je viens de tester, ça ne plante pas, j'ai confondus avec le char *

Citation:
Envoyé par Lucky-94
Voici un exemple:
Code:

1 2 3 4 5 6 7 /* Exemple */ # include <stdio.h> int main (void) { char str1[] = "Exemple", str2[];
Comme l'indique ton compilateur, il n'est pas possible de définir un tableau sans taille(ni de taille 0). Ce code n'a donc aucun sens. Si tu veux un tableau dynamique, tu l'alloues avec malloc() et tu stockes son adresse dans un pointeur du bon type.
Citation:
Compilation: array size missing in 'str2'

Avec:
Code:

1 2 3 4 5 6 7 /* Exemple2 */ # include <stdio.h> int main (void) { char str1[] = "Exemple", str2[] = "";
Ce code est techniquement correct, mais le tableau défini a une taille de 1 char (ici, 0), soit une longueur de chaine utile de 0, ce qui n'est pas grand chose...
Citation:
Code:

1 2 3 strcpy (str2, str1); }
Vu la taille de str2, le comportement est indéfini.

Citation:
Envoyé par Trap D
Code:

1 2 3 char str1[] = "Exemple", str2[] = ""; }
Ça doit planter car tu recopies str1 dans str2 qui
:arrow: est non modifiable, car les chaînes définies en dur se trouvent en principe dnas une zone non modifiable de la mémoire.
Non un tableau de char est modifiable. Le problème, c'est la taille. (1, soit une charge utile de 0!)

Citation:

Envoyé par Trap D

:oops: il se pourrait (et quand je dis il se pourrait ...) bien que tu aies raison, je viens de tester, ça ne plante pas, j'ai confondus avec le char *

C'est même certain, aucun doute là-dessus.

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par Trap D

Code:

char str1[] = "Exemple", str2[] = "";
}
Ça doit planter car tu recopies str1 dans str2 qui
Arrow est non modifiable, car les chaînes définies en dur se trouvent en principe dnas une zone non modifiable de la mémoire.

Non un tableau de char est modifiable. Le problème, c'est la taille. (1, soit une charge utile de 0!)

Je ne comprends pas trop ce que tu entends par "un tableau de char est modifiable" ?

Tu peux modifier les données du tableau. Le problème est de ne pas aller modifier des trucs qui ne seraient pas dans le tableau.

D'accord à ce niveau là, mais le fait de dire qu'un tableau de char est modifiable m'a fait penser qu'il pouvait modifier la taille du tableau ce qui porte à confusion.

C'est pour cela que je voulais une explication afin de comprendre ce qu'il voulait dire.

Citation:

Envoyé par swirtel

Je ne comprends pas trop ce que tu entends par "un tableau de char est modifiable" ?

Code:

char s[123];

est un tableau de char. Il est modifiable. Je peux écrire dedans.

Code:

char s[] = "hello";

est un tableau de char initialisé. Il est modifiable. Je peux écrire dedans.

Code:

char const s[] = "hello";

est un tableau de char initialisé. Il est non modifiable. Je ne peux pas écrire dedans.

Code:

char *s = "hello";

est un pointeur sur une chaine. Cette chaine n'est pas modifiable. Pour le signifier au compilateur, il est préférable de le préciser :

Code:

char const *s = "hello";

Emmanuel, merci de l'explication, mais je précisais dans mon commentaire que je n'avais pas très bien compris le sens de "tableau modifiable".

Simple problème de compréhension.

Bonjour,
Je sais que ce fil commence à dater, mais j'y reviens tout de même.
J'ai bien lu vos réponses et essayé de comprendre.
Ce que je n'arrive pas à expliquer (ou comprendre) c'est pourquoi, par rapport à ce nouvel exemple (3)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 /* Exemple3 */ # include <stdio.h> int main (void) { char str1[] = "Exemple", str2[7]=""; printf("Avant copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2); strcpy (str2, str1); printf("Apres copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2); return 0; }
pourquoi, donc, dans l'exemple 2 l'utilisation de «*strcpy*» modifie mon tableau «*str1*» en lui ajoutant le caractère nul (\0)?
Ou plutôt, ce caractère nul devant être ajouté automatiquement à l'initialisation, pourquoi «*strcpy*» décale mon tableau «*str1*» d'un octet?
Sûrement une particularité de «*strcpy*» que je ne connais pas...
Merci.

Citation:
Envoyé par Lucky-94
J'ai bien lu vos réponses et essayé de comprendre.
Ce que je n'arrive pas à expliquer (ou comprendre) c'est pourquoi, par rapport à ce nouvel exemple (3)
Code:

1 2 3 4 5 6 7 /* Exemple3 */ # include <stdio.h> int main (void) { char str1[] = "Exemple", str2[7]="";
Attention. La taille de str2 est de 7 char, soit 6 + 1 (le 0 final). La chaine "Exemple" fait 7 + 1, soit 8 char.
Citation:
Code:

1 2 3 4 printf("Avant copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2);
Ok.
Citation:
Code:

1 2 strcpy (str2, str1);
Comportement indéterminé. La source est plus grande que la destination.
Citation:
Code:

1 2 3 4 5 6 printf("Apres copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2); return 0; }
A cause du comportement indéterminé, le reste n'a plus aucun sens. Il faut commencer par corriger le code.

Citation:

Envoyé par Emmanuel Delahaye

Attention. La taille de str2 est de 7 char, soit 6 + 1 (le 0 final). La chaine "Exemple" fait 7 + 1, soit 8 char.

Je vois à peut près ce que vous voulez me faire comprendre et pourtant pour moi les deux chaînes font bien 8 «*char*» ou «*octets*»:
strx[0], strx[1], strx[2], strx[3], strx[4], strx[5], strx[6], strx[7].
D'ailleurs, j'obtiens bien la même longueur pour les deux tableaux:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 /* Exemple4 */ # include <stdio.h> int main (void) { char str1[] = "Exemple", str2[7]=""; printf("Avant copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2); printf("Longueur de \"str1[]\": %d octets.\n", strlen(str1)); printf("longueur de \"str2[]\": %d octets.\n", strlen(str2)); strcpy (str2, str1); printf("Apres copie de str1 dans str2:\n"); printf("str1 contient: %s\n", str1); printf("str2 contient: %s\n", str2); printf("Longueur de \"str1[]\": %d octets.\n", strlen(str1)); printf("longueur de \"str2[]\": %d octets.\n", strlen(str2)); return 0; }
Sortie:
Avant copie de str1 dans str2:
str1 contient: Exemple
str2 contient:
Longueur de "str1[]": 7 octets.
longueur de "str2[]": 0 octets.
Apres copie de str1 dans str2:
str1 contient: Exemple
str2 contient: Exemple
Longueur de "str1[]": 7 octets.
longueur de "str2[]": 7 octets.

Que n'ais-je toujours pas compris? :-(

Citation:

Envoyé par Lucky-94

Que n'ais-je toujours pas compris? :-(

Que strlen() n'a jamais servi a mesurer la taille d'un tableau, mais la longueur d'une chaine.

La taille d'un tableau se mesure avec sizeof. Ajoute çà au début de ton code, et tu vas comprendre pourquoi ça ne fonctionne pas. :
Code:

1 2 3 printf("Taille de \"str1[]\": %d octets.\n", (int) sizeof str1); printf("Taille de \"str2[]\": %d octets.\n", (int) sizeof str2);

Citation:

Envoyé par Lucky-94

Citation:

Envoyé par Emmanuel Delahaye

Attention. La taille de str2 est de 7 char, soit 6 + 1 (le 0 final). La chaine "Exemple" fait 7 + 1, soit 8 char.

Je vois à peut près ce que vous voulez me faire comprendre et pourtant pour moi les deux chaînes font bien 8 « char » ou « octets »:
strx[0], strx[1], strx[2], strx[3], strx[4], strx[5], strx[6], strx[7].

Euh je crois que si tu définies strx[7], ça veut dire qu'il aura une taille de 7, de strx[0] à strx[6].

Citation:

Envoyé par Emmanuel Delahaye

Que strlen() n'a jamais servi a mesurer la taille d'un tableau, mais la longueur d'une chaine.

Je pensais, faussement, étant donné qu'une chaîne de caractères est un tableau de caractères que cela produirait le même résultat.
Alors que la bonne définition est: «*Une chaîne de caractères est un tableau de caractères terminé avec un caractère nul*».

De plus la remarque:

Citation:

Envoyé par Tellmarch

Euh je crois que si tu définies strx[7], ça veut dire qu'il aura une taille de 7, de strx[0] à strx[6].

Est totalement vrai, toute mes excuses.

Je vous remercie tous pour votre patience et votre aide, en particulier Emmanuel.