Объясните пожалуйста, для чего нужен. Мои соображения дальше такого не пошли

void fun(const std::auto_ptr<int> &);

void g()
{
    fun(std::auto_ptr<int>(new int(10)));//так нельзя из-за хитрого конуструктора
// копирования. С auto_ptr_ref было бы можно, но какой смысл?
}

Так для чего сабж?

Здравствуйте, Аноним, Вы писали:

А>Объясните пожалуйста, для чего нужен. Мои соображения дальше такого не пошли

А>

А>void fun(const std::auto_ptr<int> &);

А>void g()
А>{
А>    fun(std::auto_ptr<int>(new int(10)));//так нельзя из-за хитрого конуструктора
А>// копирования. С auto_ptr_ref было бы можно, но какой смысл?
А>}
А>

А>Так для чего сабж?

'auto_ptr_ref' нужен для того, чтобы можно было так

std::auto_ptr<int> foo();
...
std::auto_ptr<int> p = foo()

Это транслируется в вызов оператора приведения типа от 'std::auto_ptr<int>' в 'std::auto_ptr<int>::auto_ptr_ref<int>' и последний передается в конструктор нового 'std::auto_ptr<int>'. Прямой вызов конструктора копирования невозможен именно потому, что он "хитрый", т.е. принимает ссылку на неконстантный объект.

Спасибо, Андрей.

Есть такое

class B{};
class C
{
public:
   operator B()const;
};

class A
{
public:
    A(B);
};

void g()
{
   C c;
   A a = c;
}

Это неверный код, потому как тут имеет место инициализация копированием, для конструктора копий нужен объект типа A, конструктору А нужен В — т.е. получается двукратное пользовательское преобразование. Чем лучге ситуация с auto_ptr ?

Здравствуйте, Аноним, Вы писали:

А>Есть такое
А>

А>class B{};
А>class C
А>{
А>public:
А>   operator B()const;
А>};

А>class A
А>{
А>public:
А>    A(B);
А>};

А>void g()
А>{
А>   C c;
А>   A a = c;
А>}

А>

А>Это неверный код, потому как тут имеет место инициализация копированием, для конструктора копий нужен объект типа A, конструктору А нужен В — т.е. получается двукратное пользовательское преобразование. Чем лучге ситуация с auto_ptr ?

Ситуация с 'auto_ptr' лучше тем, что там производится декларация объекта 'auto_ptr', который инициализируется объектом 'auto_ptr'. Так как с обеих сторон инициализации стоит объект одного и того же типа, запрет на двукратное пользовательское преобразование "снимается". Более детально, согласно стандарту языка (см. 8.5/14) объявление

std::auto_ptr<int> p = foo(); // в терминах моего примера

немедленно трактуется компилятором как

std::auto_ptr<int> p(foo());

а этот последний вариант уже требует тоько одного неявного пользовательского преобразования. Т.е. другими словами преобразование 'auto_ptr_ref -> auto_ptr' как бы становится в этом случае явным, а неявным остается только одно преобразование 'auto_ptr -> auto_ptr_ref'. Эту тонкость стандарта иногда обзывают такими словами как "loophole" и "defect", но тем не менее она имеет место и используется в реализации 'std::auto_ptr'

В твоем же примере типы левой и правой части не совпадают ('A' и 'C') и, поэтому, оба пользовательских преобразования являются неявными, что приводит к ошибке.

> Так для чего сабж?

Вообще, эта штука была одним из самых темных страшных уголков в C++. ищи подробности здесь

Но, будем надеятся, что он скоро будет не нужен: auto_ptr: improved implementation

--
Maxim Egorushkin
MetaCommunications Engineering
http://www.meta-comm.com/engineering/