Question

I was working on a project and, while playing around with the code, I came across the following peculiar occurrence.

I have two classes. The first holds three floats in an array representing Cartesian coordinates and defines a method to get those points;

class foo
{
protected:
    float m_Coordinates[3];

public:
    foo(float coordinates[3]);
    void GetPoints(int resultArray[]);
};

foo::foo(int coordinates[3])
{
    std::copy(coordinates, coordinates+3, m_Coordinates);
}

void foo::GetPoints(float resultArray[])
{
    std::copy(m_Coordinates, m_Coordinates+3, resultArray);
}

The second class also stores an array of floats, but its constructor uses foo as a wrapper class to pass the values:

class bar
{
protected:
    float m_MoreCoordinates[3];

public:
    bar(foo f);
};

bar::bar(foo f)
{
    f.GetPoints(m_MoreCoordinates);
    //m_MoreCoordinates is passed by reference, so the values in
    //m_MoreCoordinates are equal to the values in f.m_Coordinates
    //after this line executes
}

Please ignore the fact that the approach I’ve taken to this code is simply horrible. It started out as an experiment in using arrays. Passing them as arguments, getting them as return types etc.

OK. Here’s where I noticed something strange. If I declare an array of floats and pass them as an argument to bar’s constructor, the compiler will generate an instance of class foo and pass that to bar for me. See example code below:

int main(int argv, char** argc)
{
    float coordinates[] = {1.0f, 2.1f, 3.0f};


    //Here the compiler creates an instance of class foo and passes 
    //coordinates as the argument to the constructor. It then passes 
    //the resulting class to bar's constructor.
    bar* b = new bar(coordinates);

    //Effectively, the compiler turns the previous line into
    //bar* b = new bar(foo(coordinates));

    return 0;
}

When I saw this, I thought it was a pretty neat feature of the code and was wondering how and why it happened. Is it safe to do this? I don’t understand how it works, and so I don’t want to depend on it. If someone could explain how this works, I’d really appreciate it.

Edit:
Thanks to Mankarse for pointing out how the conversion would be performed in the main. Initially, I had:

//Effectively, the compiler turns the previous line into
//bar* b = new bar(*(new foo(coordinates)));

Answer 1

As you guessed, compiler is implicitly creating a foo object and passing it to bar. Generally, this is considered a bit dangerous as the foo gets constructed without knowledge, to avoid this you can declare foos constructor as explicit. In that case compiler will not implicitly create foo from array of floats and you will get an compiler error.