Bonjour,

Je suis en train de me former sur l'utilisation du pointeur unique (unique_ptr).
Ainsi, je voudrais implémenter ce type de smart pointeur dans un certain algorithme qui initialement utilise des pointeurs bruts classiques et fonctionne très bien.

Mais je rencontre des problèmes dans l'utilisation du pointeur unique.

Afin de ne pas embrouiller les lecteurs de mon message par un code compliqué, j'ai pu reproduire le problème actuel dans un petit programme que je vous présente ci-dessous avec ses commentaires.

Ce programme fonctionne très bien tant que je mets en commentaire les lignes 49 et 52.
Dans ces lignes j’essaye simplement de transférer le contenu d’une case de tableau (contenant un pointeur) dans un pointeur de la même nature.
Cela fonctionne avec les pointeurs bruts, mais j’obtiens des erreurs de compilation avec le unique_ptr :.


Merci par avance.

Cordialement

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
 
void testuniqueptr(void)
 
{
 
    #define TAILLEMAX 10000 // Taille maximale du tableau de pointeurs de float à allouer.
 
    int Taille,k;
    int Taillemax(TAILLEMAX);
    typedef float *ADDFLOAT; // ADDFLOAT représente donc un pointeur sur float.
 
    string message("Taille du vecteur de float :");
 
    while (oglirnombre(Taille, message)) {
 
        if (Taille<=0 || Taille>Taillemax) continue;
 
        // Allocation dynamique d'un tableau de N=Taille ADDFLOAT :
 
        unique_ptr<ADDFLOAT[]> panier(new ADDFLOAT[Taille]); // panier est donc un tableau de ADDFLOAT. Ainsi, pour chaque k, panier[k] sera un pointeur sur float.
 
        for (k=0; k<Taille; k++ ) {
 
            // 1. On teste l'affectation à nullptr de panier[k] :
 
            panier[k]=nullptr;
 
            // 2. On alloue dans point un float, donc point est du même type que panier[k] (c'est à dire un pointeur sur float) :
 
            unique_ptr<float> point(new float);
 
            // 3. On assigne une valeur (en l'occurrence k), à l'adresse pointée par point, histoire de présenter un résultat contrôlable :
 
            (*point)=(float)k;
 
            // 4. On assigne point qui est un pointeur(valide) sur float, à panier[k], lui même pointeur sur float . Tout se passe bien, y compris à l'exécution :
 
            panier[k]=point.get();
 
            // 5. Inversement, on essaye d'assigner la valeur de panier[k] (pointeur sur float) à point (également pointeur sur float). C'est ici que ça se gâte :
 
            // 5.1 - 1er version (sans get()) :ERREUR compilation: "no match for operator= in point = panier.std::unique_ptr<_Tp ..."
 
            point=panier[k];
 
 
            // 5.2 - 2eme version (avec get()) :ERREUR compilation: "error: request for member 'get' in panier.std::unique_ptr<_Tp [], ..."
 
            point=panier[k].get();
 
 
            // On affiche les contenus de tous ces pointeurs pour vérification. Tout est ok à l'exécution lorsque les instructions 5.1 et 5.2 sont désactivées :
 
            cout << "panier[" << k << "]= " << (*panier[k]) << " (*point)= " << *point << endl;
 
        }
 
    }
 
}