Pourquoi ne pas auto_ptr Travaux de construction en utilisant = syntaxe

Question

je suis tombé sur une erreur du compilateur qui n'a pas fait sens pour moi:

#include <memory> 
using namespace std; 

auto_ptr<Table> table = db->query("select * from t"); 

erreur: la conversion de « Table * » type non scalaire ' std :: auto_ptr < Table> » a demandé

Cependant, la ligne suivante fonctionne:

auto_ptr<Table> table(db->query("select * from t")); 

Qu'est-ce sur ce definiton du constructeur qui l'empêche de travailler comme je l'attends? Je pensais que les déclarations initialisées utilisaient les constructeurs.

Voici mon constructeur d » auto_ptr (de la STL SGI):

explicit 
auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } 

Answer 1

Il est le mot-clé « explicite ».

template <typename T> 
struct foo 
{ 
    explicit foo(T const *) 
    { 
    } 
}; 


template <typename T> 
struct bar 
{ 
    bar(T const *) 
    { 
    } 
}; 


int main(int argc, char **argv) 
{ 
    int a; 
    foo<int> f = &a; // doesn't work 
    bar<int> b = &a; // works 
} 

Le mot clé "explicit" empêche le constructeur d'être utilisé pour les conversions de type implicite. Considérons les deux prototypes fonctionnels suivants:

void baz(foo<int> const &); 
void quux(bar<int> const &); 

Avec ces définitions, essayez d'appeler les deux fonctions avec un pointeur int:

baz(&a); // fails 
quux(&a); // succeeds 

Dans le cas de quux, votre pointeur int a été implicitement converti en un bar.

EDIT: Pour développer ce que les autres personnes ont commenté, considérer les points suivants (plutôt ridicule) Code:

void bar(std::auto_ptr<int>); 


int main(int argc, char **argv) 
{ 
    bar(new int()); // probably what you want. 

    int a; 
    bar(&a); // ouch. auto_ptr would try to delete a at the end of the 
      // parameter's scope 

    int * b = new int(); 
    bar(b); 
    *b = 42; // more subtle version of the above. 
}