Discussion :

[valliere]

Salut à tous, le code suivant doit en principe faire la concaténation de deux chaines de caractères, mais c'est pas le cas. Sinon, ça compile quand même mais ça renvoi autre chose. J'arrive pas à trouver l'erreur.

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
#include <stdio.h>
#include <stdlib.h>
 
size_t stringLength(const char* str)
{
   size_t cpt = 0;
	while (* str!='\0')
	{
		str++;
		cpt++;
	}
  return cpt;
}
 
char *concatenateString(const char *str1, const char *str2)
{
    char *ptr;
    size_t s1=stringLength((str1));
    size_t s2=stringLength((str2));
    size_t s3=s1+s2-1;
 
    ptr=(char*)malloc(stringLength(s3)*sizeof(char));
    return ptr;
}
 
 
 
int main(void)
{
   const char *chaine1 = "Salut";
   const char *chaine2 = "valli";
   char *concatenation;
 
    concatenation = concatenateString(chaine1, chaine2);
 
    printf("La nouvelle chaine est %s", concatenation);
 
    return 0;
}

merci d'avance

[Invité]

Bonsoir,

Code :

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

ptr=(char*)malloc(stringLength(s3)*sizeof(char));

• le cast de malloc est inutile en C.
• s3 est une valeur numérique et non une chaine de caractères. stringLength est en trop.

Enfin tu ne fais qu'allouer une zone mémoire (à laquelle il manque deux char : size_t s3=s1+s2+1;) sans y copier les chaines str1 et str2 dedans.

N'oublie pas de libérer la mémoire allouée à la fin.

[Sve@r]

Code :

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

size_t s3=s1+s2-1;

Salut
Pourquoi ce "-1" ???

Code :

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

1
2
3
4
5
6
7
8
9
10
size_t stringLength(const char* str)
{
   size_t cpt = 0;
	while (* str!='\0')
	{
		str++;
		cpt++;
	}
  return cpt;
}

Code :

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

1
2
3
4
5
6
size_t stringLength(const char* str)
{
   size_t cpt;
   for (cpt=0; *str != '\0'; str++, cpt++);
   return cpt;
}

[jabbounet]

pourquoi deux incrémentations quand l'arithmétique des pointeurs permet d'en éliminer une...

Code :

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

1
2
3
4
5
6
size_t stringLength(const char* str)
{
  const char *p = str;
  while ( *p++ != '\0');
  return p - str -1;
}

l'exemple ci dessous permet de comparer le résultat par rapport a strlen (qui fait le même job au passage)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int main()
{
  char *hello = "hello";
  char world[50]= { 'W' , 'o', 'r', 'l', 'd', 0, };
  char *empty = "";
 
  printf("%d %d %s\n",stringLength(hello),strlen(hello), hello);
  printf("%d %d %s\n",stringLength(world),strlen(world), world);
  printf("%d %d %s\n",stringLength(empty),strlen(empty), empty);
 
  return EXIT_SUCCES;
}

donne

gcc test.c -o test.exe && test.exe
5 5 hello
5 5 World
0 0

pour info strlen pour la glibc 2.7 est par exemple disponible ici:
http://www.stdlib.net/~colmmacc/strlen.c.html

[Sve@r]

pourquoi deux incrémentations quand l'arithmétique des pointeurs permet d'on éliminer 1...

Code :

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

1
2
3
4
5
6
size_t stringLength(const char* str)
{
  const char *p = str;
  while ( *p++ != '\0');
  return p - str -1;
}

Tant qu'à faire, pourquoi cette incrémentation de trop qui t'oblige a exécuter une soustraction (- 1) supplémentaire...

Code :

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

1
2
3
4
5
6
size_t stringLength(const char* str)
{
  const char *p;
  for (p=str; *p != '\0'; p++);
  return p - str;
}

...

[Médinoc]

Ce qui est traitre avec les chaînes de caractères, c'est qu'on oublie facilement si une taille donnée contient ou non le caractère nul terminal.

Je conseille d'adopter une convention pour ça. Personnellement, je différencie mes noms de variable/fonction entre "length" (sans caractère nul, comme le retourne strlen()) et "size" (avec caractère nul, comme une taille de buffer).

Ce qui donne:

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
size_t StringLength(char const *str)
{
	size_t i;
	for(i=0 ; str[i]!='\0' ; i++) {}
	return i;
}
 
void StringCopy(char *buf, size_t bufSize, char const *input)
{
	size_t i;
	for(i=0 ; i<bufSize ; i++) 
	{
		/*On copie d'abord, puis on vérifie si on a copié le \0*/
		if((buf[i] = input[i]) == '\0')
			break;
	}
	/*On termine systématiquement le buffer par \0, pour être sûr.*/
	buf[bufSize-1] = '\0';
}
 
char* StringConcatAlloc(char const *left, char const *right)
{
	size_t leftLength = StringLength(left);
	size_t rightLength = StringLength(right);
	size_t concatLength = leftLength + rightLength;
	size_t concatSize = concatLength + 1;
	char* buf = malloc(concatSize * sizeof *buf);
	if(buf != NULL)
	{
		StringCopy(buf, concatSize, left);
		StringCopy(buf+leftLength, concatSize-leftLength, right);
	}
	return buf;
}

Quand je bosse avec des wchar_t, j'ajoute en plus de la notation hongroise pour différentier les tailles en bytes des tailles en caractères, mais ici ce n'est pas la peine.

[Sve@r]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void StringCopy(char *buf, size_t bufSize, char const *input)
{
	size_t i;
	for(i=0 ; i<bufSize ; i++) 
	{
		/*On copie d'abord, puis on vérifie si on a copié le \0*/
		if((buf[i] = input[i]) == '\0')
			break;
	}
	/*On termine systématiquement le buffer par \0, pour être sûr.*/
	buf[bufSize-1] = '\0';
}

Ta fonction ressemble à strncpy(). La seule différence, c'est que strncpy() ne met pas le '\0' quand elle arrête sa copie à n caractères. En plus des pb que ça m'a causé quand je l'ai utilisée sans connaitre ce détail, je trouve ça dommage et je suis content que toi tu forces le '\0'...