Discussion :

[rayder700]

Bonjour,

Comme vous pouvez le voir dans le titre du sujet j'aimerais copier un char * dans un char ** et l'afficher. Exemple, j'ai "12+3*6" je veux que array[0] = 12, array[1] = 3, et array[2] = 6. donc à chaque ligne du double tableau je stock un nombre.

J'ai d'abbord malloc mon double tableau puis j'essais copier mes data à l'intérieur.

Voici mon 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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include "my.h"
#include "evalexpr.h"
#include <stdlib.h>
#include <stdio.h>
 
char **malloc_number(char *str)
{
    char **array;
    int j = 0;
    int size_c = 0;
    int size_lastnb = cal_lasttnb(str) - 1;
 
    for (int i = 0; str[i] != '\0'; i++) {
        if (my_alpha_operator(str[i]) == 1)
            j++;
    }
    j += 1;
    array = malloc(sizeof(char *) * (j + 1));
    j = 0;
 
    for (int i = 0; str[i] != '\0'; i++) {
        if (my_alpha_operator(str[i]) == 1) {
            array[j] = malloc(sizeof(char) * (size_c + 1));
            j++;
            size_c = 0;
        } else
            size_c += 1;
    }
    array[j + 1] = malloc(sizeof(char) * size_lastnb);
    return (array);
}
 
char **parsing_number(char *str)
{
    char **array_nb = malloc_number(str);
    int size_l = 0;
    int c = 0;
 
    for (int i = 0; str[i] != '\0'; i++) {
        if (my_alpha_operator(str[i]) == 0) {
            array_nb[size_l][c] = str[i];
            c++;
        } else {
            size_l++;
            c = 0;
        }
    }
    return (array_nb);
}
 
int eval_expr(char const *str)
{
    char **array_number = parsing_number(str);
    display_char(array_number);
    free(array_number);
}

voici mon code, et je vous affiche ne dessous les functions comme display_char:

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
#include "my.h"
#include <stdlib.h>
 
int my_alpha_operator(char c)
{
    if (c == '*' || c == '/' || c == '%' || c == '+' || c == '-')
        return (1);
    return (0);
}
 
int cal_lasttnb(char *str)
{
    int size_str = my_strlen(str);
    int i = 0;
 
    while (size_str != 0) {
        if (my_alpha_operator(str[size_str]) == 1)
            return (i);
        i++;
        size_str--;
    }
    return (0);
}
 
void display_char(char **str)
{
    for (int l = 0; str[l] != NULL; l++) {
        for (int i = 0; str[l][i] != '\0'; i++) {
            my_putchar(str[l][i]);
        }
        my_putchar(10);
    }
}

Merci de votre aide

[rayder700]

Correction quand j'ai "12+3*6" je veux array[0] = "12", array[1] =" 3", et array[2] =" 6" et non pas array[0] = 12, array[1] = 3, et array[2] = 6.

[Médinoc]

En gros, tu veux séparer ta chaîne en jetons (tokens) sachant que les opérateurs mathématiques comptent comme séparateurs.
C'est exactement ce à quoi sert la fonction strtok_s(), qui permettrait de faire cela "sur place", à un problème près:
Cette histoire d'espace. Un tableau contenant {"12", "3", "6", NULL } au lieu de {"12", " 3", " 6", NULL } serait-il acceptable?

[rayder700]

En gros, tu veux séparer ta chaîne en jetons (tokens) sachant que les opérateurs mathématiques comptent comme séparateurs.
C'est exactement ce à quoi sert la fonction strtok_s(), qui permettrait de faire cela "sur place", à un problème près:
Cette histoire d'espace. Un tableau contenant {"12", "3", "6", NULL } au lieu de {"12", " 3", " 6", NULL } serait-il acceptable?

Oui mais je n'ai pas le droit d'utiliser des fonctions systeme or si je la re code et je n'ai aucune idee de comment le faire

[Médinoc]

Ah, un épitarque.

Franchement, le mieux pour cette école, c'est de refaire la bibliothèque standard:

• Commence par lire la doc de strtok_r(), strcspn() et strchr()
• Puis implémente my_strchr(), qui devrait être relativement simple à implémenter.
  Si on veut bien faire, il faudrait en faire une version const et une version non-const.
• Puis implémente my_strcspn() en utilisant my_strchr().
• Puis tu devrais pouvoir implémenter my_strtok_r() en utilisant my_strcspn().

Sinon, tu auras besoin d'autres fonctions élémentaires, notamment si tu ne fais pas ta tokenization "sur place": Il te faudra une fonction pour faire un malloc() sur une sous-chaîne et la copier dans le buffer en sortie:

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
char* my_strdup2(char const *str, size_t len)
{
	size_t bufferSizeInChars = len+1;
	size_t bufferSizeInBytes = bufferSizeInChars * sizeof(*str);
	char* ret = malloc(bufferSizeInBytes);
	if(ret != NULL)
	{
		size_t i=0;
		for(i=0 ; str[i]!='\0' && i<len ; i++)
			ret[i] = str[i];
		ret[i] = '\0';
	}
	return ret;
}

[rayder700]

Bonjour,

J'ai mis à jour mon code en rajoutant une fonction pour les operateurs meme principe: j'ai "12+7*6" je doit avoir array_ope[0] = '+' array_ope[1] = '+' array_ope[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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include "my.h"
#include "evalexpr.h"
#include <stdlib.h>
#include <stdio.h>
 
char **parsing_number(char *str)
{
    char **array_nb = malloc_number(str);
    int size_l = 0;
    int c = 0;
 
    for (int i = 0; str[i] != '\0'; i++) {
        if (my_alpha_operator(str[i]) == 0) {
            array_nb[size_l][c] = str[i];
            c++;
        } else {
            array_nb[size_l][c] = '\0';
            size_l++;
            c = 0;
        }
    }
    array_nb[size_l] = NULL;
    return (array_nb);
}
 
char **parsing_operator(char *str)
{
    char **tab = malloc_ope(str); 
    int j = 0;
 
    if (my_alpha_operator(str[0]) == 3) {
        tab[j][0] = '-';
        tab[j][1] = '\0';
        j++;
    }
    if (my_alpha_operator(str[0]) == 4) {
        tab[j][0] = '+';
        tab[j][1] = '\0';
        j++;
    }
    for (int i = 0; str[i] != '\0'; i++) {
        if (my_alpha_operator(str[i]) == 1) {
            tab[j][0] = str[i];
            tab[j][1] = '\0';
            j++;
        }
    }
    tab[j] = NULL;
    j = j + 1;
    return (tab);
}
 
int eval_expr(char const *str)
{
    //char **array_operator = parsing_operator(str);
    //parsing_operator(array_operator);
    char **array_number = parsing_number(str);
    display_char(array_number);
 
    /*for (int i = 0; array_operator[i] != NULL; i++) {
        for (int k = 0; array_operator[i][k] != '\0'; k++) {
            if (my_alpha_operator(array_operator[i][k]) == 2) {
                calcul_prio(i, array_operator[i][k], array_number);
                array_operator[i][k] = '\0';
            } else {
                calcul(i, array_operator[i][k], array_number);
            }
        }
    }*/
    return (0);
}

Puis les fonctions malloc :

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
48
49
50
51
52
53
#include "evalexpr.h"
#include "my.h"
#include <stdlib.h>
 
char **malloc_number(char *str)
{
    char **array;
    int j = 0;
    int size_c = 0;
    int size_lastnb = cal_lasttnb(str) - 1;
 
    for (int i = 0; str[i] != '\0'; i++) {
        if (my_alpha_operator(str[i]) == 1)
            j++;
    }
    j += 1;
    array = malloc(sizeof(char *) * (j + 1));
    j = 0;
 
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/' \
            || str[i] == '%') {
            array[j] = malloc(sizeof(char) * (size_c + 1));
            j++;
            size_c = 0;
        } else
            size_c += 1;
    }
    array[j] = malloc(sizeof(char) * size_lastnb + 1);
    return (array);
}
 
char **malloc_ope(char const *str)
{
    int compteur = 0;
    char **tab;
    int j = 0;
 
    for (int i = 0; str[i] != '\0'; i++) {
        if (my_alpha_operator(str[i]) == 1) {
            compteur = compteur + 1;
        }
    }
    compteur = compteur + 1;
    tab = malloc(sizeof(char *) * (compteur + 1));
 
    for (int k = 0; str[k] != '\0'; k++) {
        if (my_alpha_operator(str[k]) == 1) {
            tab[j++] = malloc(sizeof(char) * 2);
        }
    }
    return (tab);
}