Why is my array declared as an array of references

Question

Today, while compiling some code with GCC 4.9.2 for the first time, I encountered a strange error about an array being interpreted as an array of references.

I was able to reproduce the error with a quick example. Why is the constructor of Link interpreting buses as an array of references in the constructor of Stuff.

The following code works with MSVC10 and ICC 11.1

#include <iostream>

struct Bus
{
    Bus(std::string n) : name(n) {}
    std::string name;
};

template<typename T>
class Link
{
public:
    Link(const T* i)
    {
        data = (T*)i;   
    }

    const T* get() const
    {
        return data;
    }
private:
    T* data = nullptr;  
};

class Stuff
{
public:
    Stuff(Link<Bus> l_b) : link(l_b) {}
private:
    Link<Bus> link;
};

void print(Link<Bus> l)
{
    std::cout << l.get()->name << '\n';   
}

int main(void) {
    Bus buses[4] = { Bus("0"), Bus("1"), Bus("2"), Bus("3") };

    print(Link<Bus>(&buses[0]));

    Stuff s(Link<Bus>(&buses[0]));    

    return 0;
}

But with GCC and Clang, this gives an error :

main.cpp: In function 'int main()':

main.cpp:44:32: error: declaration of 'buses' as array of references

     Stuff s(Link<Bus>(&buses[0]));

Yet, the call to the print function works as intended. I am clueless about why the constructor fails.

I found a solution to that problem, by calling buses lik that in the call to the constructor of Stuff

Stuff s(Link<Bus>((&buses)[0]));

But I'm really interested to know why it fails.

Live example here

If I rewrite your declaration as `Stuff s(Link& buses[0])`, does it make more sense? — KABoissonneault, Feb 16 '18 at 15:51
@Angew its is still not working with a recent GCC https://wandbox.org/permlink/goDtz3TABvmswhCJ — bl4ckb0ne, Feb 16 '18 at 15:55
@Bl4ckb0ne MVP is not a bug, it's a characteristic of the language. Which means the compiler is *correct.* It's one of the reasons `{}` was introduced as universal initialisation. — Angew is no longer proud of SO, Feb 16 '18 at 16:32
@Angew: It's not a compiler bug, but it's not outrageous to suggest that it's a bug in the design of the language. Albeit, yes, one that is known and acknowledged. — Lightness Races in Orbit, Feb 16 '18 at 18:10

Hatted Rooster · Accepted Answer · 2018-02-16T16:02:41.877

5

You are the victim of the Most Vexing Parse rule.

The compiler sees:

Stuff s(Link<Bus>((&buses)[0]));

As a function declaration of a function named s that returns a Stuff object and asks for an 0-element array of Link object references.

To fix this and tell the compiler you're actually trying to create a Stuff object you should use the {} syntax to avoid ambiguity:

Stuff s{ Link<Bus>((&buses)[0]) };

edited Feb 16 '18 at 16:02

answered Feb 16 '18 at 15:57

Hatted Rooster

35,759
6
62
122

Is it the same thing if I call `Stuff s(Link{&buses[0]});` ? – bl4ckb0ne Feb 16 '18 at 16:00
@Bl4ckb0ne Yes, since that no longer can be a function declaration. – Hatted Rooster Feb 16 '18 at 16:01
Now my old MSVC fails with the fix. Awesome. Thanks for your explication. – bl4ckb0ne Feb 16 '18 at 16:05
@Bl4ckb0ne this syntax has been Standard C++ since 2011 and has been accepted by Visual Studio since VS2013. – DodgyCodeException Feb 16 '18 at 16:24
@DodgyCodeException I'll put a note for when we upgrade then *sigh* – bl4ckb0ne Feb 16 '18 at 16:30
2

@Bl4ckb0ne If you need this to work with pre C++11 MSVC, surround the constructor argument with parens. That should also work. I.e `Stuff s((Link(&buses[0])));` – WhozCraig Feb 16 '18 at 17:31
3

Finally a Q&A mentioning the most-vexing parse which is _actually_ about the most-vexing parse :D – Lightness Races in Orbit Feb 16 '18 at 17:53
@LightnessRacesinOrbit I know, right? I've lost count of how many basic function decls have been misbranded with mvp nomenclature on this site. It's nice to actually see a *real* one. – WhozCraig Feb 16 '18 at 18:10

Why is my array declared as an array of references

1 Answers1