Discussion :

[JolyLoic]

Un pointeur void* ne sert guère qu'à une chose : être un point commun depuis/vers lequel on peut caster d'autres pointeurs. On peut l'utiliser de deux manières :
- Soit en la castant,
- Soit en utilisant des fonctions C non typées pour en manipuler le contenu (par exemple, memcpy).

Donc dans le cas en question, et vu que c'est un exercice sur le cast, il faut caster.

Le prototype de la fonction :

Code :

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

void unefonction( void* pletableau, int nboctets, int valeur);

N'est pas très bon. Le premier argument, ok, c'est imposé comme ça. Le second, pourquoi pas un int, un unsigned int ou mieux un size_t aurait pu faire l'affaire. Le troisième, comme la fonction va travailler avec des octets (byte en anglais), la valeur à transmettre est elle aussi en octets. Le type de prédilection en C++ pour ce genre de donnée est unsigned char.

Ensuite, pour l'écriture, on a diverses options, comme par exemple :

Code :

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

1
2
3
4
5
unsigned char*tableauDuBonType = static_cast<unsigned char*>(pletableau);
for (size_t i = 0 ; i<nboctets ; ++i)
{
  tableauDuBonType[i] = valeur;
}

Attention : On a un tableau d'entiers, à l'aide d'un cast on a forcé l'écriture d'octets dedans, si on essaye par la suite re relire le contenu du tableau sous forme d'entier, ça peut donner tout et n'importe quoi : On a menti au système de type du C++, et il nous le fera payer un jour.

[sekiryou]

Bon, voilà à quoi j'arrive, le code n'est pas tout à fait pareil, j'ai recommencé à zéro, j'étais pas chez moi... mais bon, comme je vous dis, je trouve ça tellement stupide !... bref :

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 <iostream>
 
using namespace std;
 
void unefonction( void* thearray, int nboctets, int valeur);
 
int main()
{
    int myarray[10] =
    {
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    };
    int* p = myarray;
    void* pv = static_cast<void*>(p);
 
    unefonction( pv, (sizeof(myarray) / sizeof(*myarray)), 4);
 
    for (unsigned int i = 0; i <= (sizeof(myarray) / sizeof(*myarray))-1; i++)
    {
        cout << "myarray[" << i << "] = " << myarray[i] << endl;
    }
}
 
void unefonction( void* thearray, int nboctets, int valeur)
{
    int *pointeur = static_cast<int*>(thearray);
 
    for (int i = 0; i <= nboctets-1; i++)
    {
        *(pointeur) = valeur;
        pointeur++;
    }
}

[sekiryou]

On a menti au système de type du C++, et il nous le fera payer un jour.

MDR !!!

Mais ce n'est pas très concret dans le cadre de cet exercice... Dans le fond, chaque octet va prendre exactement la même valeur. Et étant donné que un int vaut 4 octets, alors je vais avoir ma valeur copiée 4 fois dans un int une à côté de l'autre....

[sekiryou]

Salut JolyLoic,

J'ai essayé ton code, mais malheureusement il ne fonctionne pas comme voulu. Seulement les 4 premières position du tableau sont modifiées pour une raison qui m'est inconnue. J'ai essayé différentes approches, mais sans succès.

Mais cela m'amène à une autre question. Que ce passe-t-il vraiment quand tu fais :

Code :

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

tableauDuBonType[i] = valeur;

tableauDuBonType est un char*, donc, il s'attend à travailler avec des chars (1 octet)?... valeur étant un int (4 octets), que ce passe-t-il si on met un int dans un char, n'y a-t-il pas débordement?

Dans le fond, je me disais, la variable nboctets ne servirait-elle pas à donner le nombre total d'octets à modifier?... Par exemple, dans ce cas, le tableau a 10 positions de int. Donc, 10 * 4 pour pouvoir modifier chaque octets contenu dans mon tableau?

Après avoir eu cette réflexion, j'en suis arrivé à ceci :

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
#include <iostream>
using namespace std;
 
void unefonction( void* pletableau, int nboctets, unsigned char valeur);
 
int main()
{
    int myarray[10] =
    {
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    };
    int* p = myarray;
    void* pv = static_cast<void*>(p);
 
    for (unsigned int i = 0; i <= (sizeof(myarray) / sizeof(*myarray))-1; i++)
    {
        cout << "myarray[" << i << "] = " << myarray[i] << endl;
    }
    cout << endl;
 
    unefonction( pv, ((sizeof(myarray) / sizeof(*myarray))*sizeof(int)), 4);
    cout << endl;
 
    for (unsigned int i = 0; i <= (sizeof(myarray) / sizeof(*myarray))-1; i++)
    {
        cout << "myarray[" << i << "] = " << myarray[i] << endl;
    }
}
 
void unefonction( void* pletableau, int nboctets, unsigned char valeur)
{
    unsigned char*tableauDuBonType = static_cast<unsigned char*>(pletableau);
 
    for (int i = 0 ; i < nboctets ; ++i)
    {
        tableauDuBonType[i] = valeur;
    }
}

Et ça fonctionne... Bon, ça donne un résultat bidon, mais chaque position du tableau a la même valeur. Ce qui est le résultat escompté.

Est-ce que ce mon raisonnement est correct?

Voici la sortie :

myarray[0] = 1
myarray[1] = 2
myarray[2] = 3
myarray[3] = 4
myarray[4] = 5
myarray[5] = 6
myarray[6] = 7
myarray[7] = 8
myarray[8] = 9
myarray[9] = 10


myarray[0] = 67372036
myarray[1] = 67372036
myarray[2] = 67372036
myarray[3] = 67372036
myarray[4] = 67372036
myarray[5] = 67372036
myarray[6] = 67372036
myarray[7] = 67372036
myarray[8] = 67372036
myarray[9] = 67372036

[JolyLoic]

Mais cela m'amène à une autre question. Que ce passe-t-il vraiment quand tu fais :

Code :

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

tableauDuBonType[i] = valeur;

tableauDuBonType est un char*, donc, il s'attend à travailler avec des chars (1 octet)?... valeur étant un int (4 octets), que ce passe-t-il si on met un int dans un char, n'y a-t-il pas débordement?

Dans le fond, je me disais, la variable nboctets ne servirait-elle pas à donner le nombre total d'octets à modifier?... Par exemple, dans ce cas, le tableau a 10 positions de int. Donc, 10 * 4 pour pouvoir modifier chaque octets contenu dans mon tableau?

C'est bien ça. La fonction va directement modifier les octets en mémoire, un par un, et il y a 4 fois plus d'octets que de cases dans le tableau (le facteur 4 dépend de la machine).

[sekiryou]

C'est bien ça. La fonction va directement modifier les octets en mémoire, un par un, et il y a 4 fois plus d'octets que de cases dans le tableau (le facteur 4 dépend de la machine).

Ouais, c'est pour cela que je multiplie par "sizeof(int)".

Et bien, merci beaucoup à tous, je crois que ça clos le sujet. Vous avez été d'une grande aide.