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