Copier char* in char ** et l'afficher

Version imprimable

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:

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:

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

25/10/2019, 10h53
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.
25/10/2019, 14h40
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?
25/10/2019, 15h40
rayder700

Citation:

Envoyé par 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?

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

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:

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; }

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:

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:

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);
}