argument of type * is incompatible with parameter of type "const float *"

I'm fairly new to C++. I've searched extensively but I couldn't make it work.

I've defined a custom type called vec_t:

class FloatType {
	private:
		float value;
	public:
		FloatType() : value(0.0f) {}
		FloatType(float v) : value(v) {}

		//operator float() { return value; }
		//operator float() { return value; }
		//explicit operator const float* () { return &value; }
		//operator float* () const { return &value; }
		//operator const float* () { return &value; }
		//operator const float() { return (const float)value; }
		//operator const float*() { return &value; }
};

typedef FloatType vec_t;

I've also created a function which takes a const float * as its only argument:

void Create(const float* vColor = NULL);

void Create(const float* vColor) {
    //...
}

Now, when calling the function like so:

vec_t a = { 2.5f };
vec_t* b = &a;
Create(b);

Visual Studio Community 2019 (v142) is complaining:

> argument of type "vec_t *" is incompatible with parameter of type "const float *"

Now, casting it to const float * on the spot gets it done:

Create((const float *)b);

But, my goal is to have an implicit casting operator to implicitly convert from my type to const float *, but no matter my efforts, I can not seem to have it right.

All operator comments were my attempts and they all have valid syntax, but they don't make the problem go away.

What am I not understanding?

I want to be able to handle this from within the FloatType class itself, and to my knowledge, an implicit casting operator is the way to do so.

Don't guide me to another approach, this is purely for practice and exercise.

Your vec_t type is not a pointer, so you should not be using a pointer as the argument when calling Create():

class FloatType 
{
private:
    float value;
public:
    ...
    operator const float* () const { return &value; }
               // const here ^^^^^
};

typedef FloatType vec_t;

vec_t a = { 2.5f };
Create(a);

For some reason, you introduced the pointer b, that's the main reason your code doesn't work.

Also, you should have an extra const on your conversion operator, as I've indicated above.

The problem is that while vec_t is a class type that can have conversion operators defined, vec_t * is a primitive type (a pointer), and no user-defined conversions apply to it.

Some possible solutions:

• Don't pass around pointers to vec_t, pass them by value instead. If necessary, use std::move to avoid potentially expensive copies. This boils down to just Create(a). john's answer explains this in more detail.
• Dereference the pointer, as in Create(*b), to allow the compiler to find your user-defined conversions.
• Add a float * data() member function to vec_t, just like std::vector, and call that to get at the underlying data: Create(b->data())
• Don't use your own vector type and just use std::array<float, N> for statically-sized vectors and std::vector<float> for dynamically sized ones. This is likely the best solution. To get a pointer to the raw data, use vec.data(). (Again, take advantage of these types' value semantics to get memory safety. Move / copy them, don't use raw pointers.)
• If you want something really ugly that you shouldn't do: Create(b->operator float *()).