C++ type coercion deduction - c++

Question

I'm playing around with the Colvin-Gibbons trick for implementing move semantics in C++03 and I've got the following:
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
template <typename T>
class buffer {
struct buffer_ref {
buffer_ref(T* data) : data_(data) {}
T* data_;
};
public:
buffer() : data_(NULL) {}
//explicit buffer(T* data) : data_(data) {}
buffer(size_t size) : data_(new T[size]) {}
buffer(buffer_ref other) : data_(other.data_) { other.data_ = NULL; }
buffer(buffer &other) : data_(other.data_) { other.data_ = NULL; }
~buffer() { delete [] data_; }
operator buffer_ref() { buffer_ref ref(data_); data_ = NULL; return ref; }
operator T*() { return data_; }
private:
T* data_;
};
int main() {
buffer<float> data(buffer<float>(128));
printf("ptr: %p\n", (float*)data);
}
Edit: formatting
I'd like to be able to use my buffer as a pointer to the base type when convenient, so I've added a casting operator to the pointer type, which works just as expected. However, if I uncomment my constructor that takes a pointer, then the the conversion deduction gets confused and complains about ambiguous conversion (because it can go buffer->T*->buffer or buffer->buffer_ref->buffer). I would expect an explicit modifier on the pointer constructor to fix this, but it doesn't. Can someone who understands the C++ conversion deduction better than me explain what the compilers thinking?

Answer 1

This is a direct result of 13.3.1.3 [over.match.ctor]:
When objects of class type are direct-initialized (8.5), or copy-initialized from an expression of the same or a derived class type (8.5), overload resolution selects the constructor. For direct-initialization, the candidate functions are all the constructors of the class of the object being initialized. For copy-initialization, the candidate functions are all the converting constructors (12.3.1) of that class. [...]
Because buffer<float> data(buffer<float>(128)); is a direct-initialization, you have explicitly requested that explicit constructors be considered.
If you write:
buffer<float> data = buffer<float>(128);
then there is no ambiguity.