Discussion :

[domiq44]

Bonjour,

J'ai un problème d'allocation mémoire sur le programme C suivant (voir en bas).
Je travaille sur AIX.

Lorsque j'exécute le programme, j'obtiens le résultat suivant :

Code :

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

1
2
3
4
5
 
$ test_malloc
a = 1234567890
Oups! Illegal storage access.
$

Et je ne parviens pas à comprendre pourquoi !
Je pense que l'erreur dois provenir de la fonction « number_duplicate() », mais je n'en suis pas certain.

Et je ne vois pas comment débogguer ce programme.

Quelqu'un peut-il m'aider ?

Merci.

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
 
typedef unsigned short int digit_t;
 
typedef struct number {
    short sign;
    int length;
    digit_t *num;
} number_t;
 
number_t *
initialize ()
{
    number_t *obj;
 
    obj = (number_t *) malloc (sizeof (number_t));
    if (obj == NULL) {
        perror ("malloc");
        exit (EXIT_FAILURE);
    }
 
    obj-> sign = 1;
    obj-> length = -1;
    obj-> num = NULL;
 
    return obj;
}
 
number_t *
number_read (char *str)
{
    number_t *obj = initialize ();
    char *ptr;
    int i;
 
    if (str[0] == '-') {
        obj-> sign = -1;
        ptr = &str[1];
    } else if (str[0] == '+') {
        obj-> sign = 1;
        ptr = &str[1];
    } else {
        obj-> sign = 1;
        ptr = &str[0];
    }
 
    obj-> length = strlen (ptr);
    obj-> num = (digit_t *) malloc (obj-> length * sizeof (digit_t));
    if (obj-> num == NULL) {
        perror ("malloc");
        exit (EXIT_FAILURE);
    }
 
    for (i = 0; i < obj-> length; i++) {
        obj-> num[i] = ptr[obj-> length - i - 1] - '0';
    }
 
    return obj;
}
 
void
number_write (char *name, number_t *this)
{
    int i;
 
    printf ("%s = ", name);
    if (this-> sign < 0)
        printf ("-");
    for (i = this-> length; i > 0; i--)
        printf ("%d", this-> num[i - 1]);
    printf ("\n");
}
 
number_t *
number_duplicate (number_t *this)
{
    number_t *obj;
 
    memcpy (obj, this, sizeof (this));
 
    return obj;
}
 
void
catch (int signal_id)
{
    printf ("Oups! Illegal storage access.\n");
    exit (EXIT_FAILURE);
}
 
int
main (void)
{
    char *str_a = "1234567890";
    number_t *a;
    number_t *b;
 
    signal (SIGSEGV, catch);
 
    a = number_read (str_a);
    number_write ("a", a);
 
    b = number_duplicate (a);
    number_write ("b", b);
 
    exit (0);
}

[Lavock]

Effectivement, il te faut allouer la mémoire de obj :

Code :

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

1
2
3
4
5
6
7
8
9
number_t *
number_duplicate (number_t *this)
{
    number_t *obj;
    obj = malloc(sizeof(number_t);
    //memcpy (obj, this, sizeof (this));
    memcpy(obj,this,sizeof *this);
    return obj;
}

Au passage, this est de type number_t*, donc tu devrait plutôt faire un sizeof *this ou même (number_t) pour eviter toute confusion. De plus, la syntaxe de sizeof est sizeof expression ou sizeof(typename).

[domiq44]

Merci Lavock pour ta réponse rapide

Est-ce que ces deux expressions sont identiques ?

Code :

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

1
2
3
 
memcpy (obj, this, sizeof *this);
memcpy (obj, this, sizeof (*this));

tu dis que c'est mieux de faire :

Code :

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

1
2
 
memcpy (obj, this, sizeof (number_t));

C'est bien ça ?

[Lavock]

Merci Lavock pour ta réponse rapide

Est-ce que ces deux expressions sont identiques ?

Code :

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

1
2
3
 
memcpy (obj, this, sizeof *this);
memcpy (obj, this, sizeof (*this));

Ben la première et la syntaxe définis par le standard, l'autre pas. Après, j'ai jamais tester sizeof(expression), mais je pense que cela devrait marcher quand même et te donner le même résultat. Peut-être aura-tu un warning en -pedantic.

tu dis que c'est mieux de faire :

Code :

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

1
2
 
memcpy (obj, this, sizeof (number_t));

Sur l'exemple présent, c'est pas très important. Mais c'est plus claire si jamais il y a 200 ligne à remonté pour savoir déjà exactement ce qu'est this.
Après, c'est plus pratique de faire avec la solution que tu propose, car si jamais tu change le type de this, ça sera déjà fait pour cette ligne.

[domiq44]

En fait, je ne savais pas qu'il y a avait une différence entre les deux expressions suivantes :

Code :

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

sizeof qqchose

défini par le standard comme tu le dit, et

Code :

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

sizeof (qqchose)

qui ne l'est pas !!!

Peux-tu m'éclairer stp ?

[Lavock]

6.5.3 Unary operators
Syntax

unary-expression:

postfix-expression
++ unary-expression
-- unary-expression
unary-operator cast-expre
sizeof unary-expression
sizeof ( type-name )

unary-operator: one of

&*+-~!

[domiq44]

Merci Lavock pour toutes ces précisions

Je pense donc que l'expression suivante

Code :

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

memcpy (obj, this, sizeof *this);

est la mieux adaptée car si on change le type du pointeur « this », le memcpy() reste correcte.

Merci.

[diogene]

Sur le sizeof :

sizeof est un opérateur qui, comme les autres opérateurs, ne demande pas la mise entre parenthèses de son opérande.
Celui-ci peut être :
- une expression. Il est bien évident qu'une expression mise entre parenthèses constitue également une expression.
- un type. Dans ce cas le type est spécifié en utilisant la syntaxe d'un cast, donc à la forme (type)

Alors, on peut écrire (et obtenir la même valeur) :

Code :

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

1
2
3
4
5
6
7
int i;
size_t dim;
dim = sizeof i;
dim = sizeof (i);
dim = sizeof ((i));
dim = sizeof (int);
// mais pas dim = sizeof ((int));  << ILLEGAL

[memspell]

Attention au piège classique :

double* val;
cette experssion est vrai : sizeof(val) != sizeof(double) et sizeof(val) != sizeof(*val)

Cédric