Discussion :

[Rulio777]

Salut, j'essaie d'écrire une fonction dans le cadre d'un projet d'étude qui inverse les valeurs d'un tableau et retourne ce tableau. Seulement la console me renvoie "segmentation fault". j'ai donc essayé d'allouer la mémoire de ce pointeur mais sans effet. Si quelqu'un peut m'aider

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
char* IMPLEMENT(mkReverse)(char *str)
{
	int i,j;
	int n;
	int temp;
	while(str[n] != '\0')
	{
		n = n+1;
	}
	str = malloc(n*sizeof(char));
	for(j=n-1 ,i=0; j>i ; j--,i++)
	{
		temp = str[i];
		str[i] = str[j];
		str[j] = temp;
	}
	return(str);
}

[Bousk]

- C'est quoi l'idée de prendre un screenshot et l'uploader au lieu de copier/coller le texte ?
- Que vaut n ?
- strlen est interdit ?

[Sve@r]

Bonjour

j'ai donc essayé d'allouer la mémoire de ce pointeur mais sans effet.

Ben si, un gros effet: tu perds la string d'origine !!!
Tu reçois une string dans "str" et là, tu écris 3 lignes en dessous "ce qu'il y a dans str je m'en fiche, je lui mets autre chose" alors détrompe toi, cela a un effet du tonnerre.

j'essaie d'écrire une fonction dans le cadre d'un projet d'étude qui inverse les valeurs d'un tableau et retourne ce tableau.

Ben ton algo est bon. Aurait été bon si "str" n'avait pas été perdu entre temps.

Code c :

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

1
2
3
4
while(str[n] != '\0')
	{
		n = n+1;
	}

Tu peux me dire combien vaut "n" quand la boucle commence ????

for (n=0; str[n] != '\0'; n++);.

PS: ta fonction ne pourra pas fonctionner sur les chaines statiques (car invariantes). Autrement dit, impossible de lui passer une chaine en dur style "toto". Tu ne pourras que lui passer un tableau de char.

[-Eks-]

PS: ta fonction ne pourra pas fonctionner sur les chaines statiques (car invariantes). Autrement dit, impossible de lui passer une chaine en dur style "toto". Tu ne pourras que lui passer un tableau de char.

Pour cette raison, je serais moins optimiste sur l'algorithme, qui ne semblerait bon que pour un traitement de la chaîne fournie sur place (donc avec un tableau passé en paramètre).

Si la fonction à vocation à pouvoir traiter n'importe quelle chaîne, alors il semble nécessaire qu'une fonction avec un prototype du genre char * reverse(char * str) renvoie avec le return un pointeur vers une nouvelle chaîne, allouée avec malloc() par la fonction.

Dans ce cas, l'algorithme de traitement de la chaîne sur place n'est plus utile. On fera bien plus simple en copiant les chars de la chaîne passée en paramètre dans la nouvelle en partant de la fin.

La fonction appelante aura la responsabilité de libérer la mémoire allouée par cette fonction. Cela devrait être documenté.

On peut aussi faire deux fonctions :

• une void reverse_null_terminated_char_array(char * str) qui peut fonctionner sur place et n'a pas à retourner quoi que ce soit
• une char * get_any_C_string_reversed(char * str) qui traite toute chaîne C et renvoie une nouvelle chaîne allouée

@Rulio777 : c'est quoi "IMPLEMENT(mkReverse)" ... une macro ? Par curiosité, peux-tu nous dire ce qu'elle fait ?

[Sve@r]

Pour cette raison, je serais moins optimiste sur l'algorithme, qui ne semblerait bon que pour un traitement de la chaîne fournie sur place (donc avec un tableau passé en paramètre).

Si la fonction à vocation à pouvoir traiter n'importe quelle chaîne, alors il semble nécessaire qu'une fonction avec un prototype du genre char * reverse(char * str) renvoie avec le return un pointeur vers une nouvelle chaîne, allouée avec malloc() par la fonction.

Exact (tout comme le fait strdup()). Mais je suis parti de l'hypothèse qu'il était très débutant (il n'utilise pas de pointeur pour compter la longueur, et sa déclaration de fonction semble assez fantaisiste), lequel n'est pas encore familiarisé avec ces notions de pointeur et de malloc. Sinon effectivement je suis bien d'accord. Pour une fonction universelle qui pourra manger des trucs comme "toto" qu'elle ne pourra pas modifier fatalement il faudra créer une nouvelle string à la volée
Tout dépend en fait du contexte de ce topic (devoir? exo? TP? ops?)

Dans ce cas, l'algorithme de traitement de la chaîne sur place n'est plus utile.

Ben en fait, ça sera carrément interdit, la chaine reçue étant présumée const.

La fonction appelante aura la responsabilité de libérer la mémoire allouée par cette fonction. Cela devrait être documenté.

Ce ne sera pas une nouveauté. Des tas de fonctions sont comme ça (strdup(), getline(), ...).

@Rulio777 : c'est quoi "IMPLEMENT(mkReverse)" ... une macro ? Par curiosité, peux-tu nous dire ce qu'elle fait ?

Quand j'ai tapé ça (j'avais pas pensé à une macro), le compilo l'a traduit par un pointeur de fonction mal foutu...

[Guesset]

Bonjour,

Tel qu'écrit, même avec les modifications proposées, il reste le problème de n qui est l'indice le plus élevé mais pas le nombre d'éléments (1 de plus).

Par ailleurs, la permutation oublie de remettre un caractère nul en position n. Il n'est alors pas pas étonnant qu'au premier usage de la chaine retournée ça fasse

Salutations

[Sve@r]

Par ailleurs, la permutation oublie de remettre un caractère nul en position n. Il n'est alors pas pas étonnant qu'au premier usage de la chaine retournée ça fasse

Pas besoin et non, tel qu'il est écrit l'algo fonctionne ("j" commence à "n-1"). La chaine "abcd" (ou plus précisément {'a', 'b', 'c', 'd', '\0'}) devient donc "dcba" et le '\0' n'a pas bougé.

[Médinoc]

D'un certain côté, ça dépend un peu si on privilégie la compréhension, avec l'idée de faire ça "étape par étape", ou la performance.
Point de vue compréhension, on peut apprécier l'idée de faire l'inversion "sur place":

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
size_t strlen_pour_epitarques(char const *str)
{
	size_t n = 0;
	while(str[n]!='\0')
		n++;
	return n;
}
 
char* inPlaceReverse2(char *str, size_t length)
{
	size_t i;
	for(i=0 ; i<length/2 ; i++)
	{
		char tmp = str[length-1-i];
		str[length-1-i] = str[i];
		str[i] = tmp;
	}
	return str;
}
char* inPlaceReverse(char *str)
{
	return inPlaceReverse2(str, strlen_pour_epitarques(str));
}

Ou de faire une copie puis une inversion "sur place":

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
char* strdup(char const *src)
{
	size_t length = strlen_pour_epitarques(src);
	char* ret = malloc(length+1);
	if(ret != NULL)
	{
		size_t i;
		for(i=0 ; i <= length ; i++) //Ici on va de 0 à length INCLUS pour copier le \0
			ret[i] = src[i];
	}
	return ret;
}
 
char* reverseA(char const *str)
{
	char* ret = strdup(str);
	if(ret != NULL)
		inPlaceReverse(ret);
	return ret;
}

Par contre, si on veut de la performance, on préférera mesurer la longueur une seule fois, et faire l'inversion dès la copie:

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
void reverse_memcpy(void* dstV, void const* srcV, size_t size)
{
	char * dst = dstV;
	char const* src = srcV;
	size_t i;
	for(i=0 ; i<size ; i++)
	{
		dst[i] = src[size-1-i];
	}
}
 
char* reverseB(char const *str)
{
	size_t length = strlen_pour_epitarques(str);
	char* ret = malloc(length+1);
	if(ret != NULL)
	{
		reverse_memcpy(ret, str, length);
		ret[length]='\0';
	}
	return ret;
}

[Guesset]

Bonjour Sve,

Pas besoin et non, tel qu'il est écrit l'algo fonctionne ("j" commence à "n-1"). La chaine "abcd" (ou plus précisément {'a', 'b', 'c', 'd', '\0'}) devient donc "dcba" et le '\0' n'a pas bougé.

Si le /0 est en n il y a donc, de 0 à n, n+1 caractères.
Or le malloc n'en affecte que n soit de 0 à n-1.
Je ne vois pas où il pourrait mettre le \0 terminal.

Ceci étant je ne vois pas à quoi sert le malloc (qui de plus va écraser l'accès au contenu du str d'origine) si c'est pour faire une inversion in situ.

Salutations

[Sve@r]

Ceci étant je ne vois pas à quoi sert le malloc (qui de plus va écraser l'accès au contenu du str d'origine) si c'est pour faire une inversion in situ.

Hé oui, sans ce malloc (auquel je n'avais plus fait attention), son algo fonctionne puisqu'il permute une str in situ donc ayant déjà le '\0' de positionné (et qui n'est alors pas perdue)