C++ function definition and variable declaration mismatch?

Question

Consider this very simple code:

#include <memory>

class Foo
{
public:
    Foo() {};
};

class Bar
{
public:
    Bar( const std::shared_ptr<Foo>& foo ) {}
}; 

int main()
{
    Foo* foo = new Foo;
    Bar bar( std::shared_ptr<Foo>( foo ) );
    return 0;
}

Why does Visual Studio reports

warning C4930: 'Bar bar(std::shared_ptr<Foo>)': prototyped function not called (was a variable definition intended?)

and there is no bar object created...how can this line Bar bar( std::shared_ptr<Foo>( foo ) ); be interpreted as a function definition?

I checked Do the parentheses after the type name make a difference with new? and also C++: warning: C4930: prototyped function not called (was a variable definition intended?), but I feel my problem is different here as I did not use the syntax Foo() nor Bar().

Edit: Note that it successfully compiles:

Foo* foo = new Foo;
std::shared_ptr<Foo> fooPtr( foo );
Bar bar( fooPtr );

@RichardHodges so does MSVC, it's only a warning. 眠りネロク is correct. — Quentin, Sep 14 '17 at 12:18
@RichardHodges Yes, it's a correct program. Which doesn't do what was almost certainly intended (the `Bar` constructor will never be called) because of the Most Vexing Parse. — aschepler, Sep 14 '17 at 12:18
Moreover, with the idea you had, the shared pointer is destroyed at the next line, disalocating the resource, and making your object failing (probably). — Caduchon, Sep 14 '17 at 12:23

JFMR · Accepted Answer · 2017-09-14T12:33:51.220

14

This issue is about C++'s most vexing parse. The statement:

Bar bar( std::shared_ptr<Foo>( foo ) );

declares a function called bar that returns Bar and takes an argument called foo of type std::shared_ptr<Foo>.

The innermost parenthesis have no effect. It is as if you would have written the following:

Bar bar( std::shared_ptr<Foo> foo);

Assuming C++11 (since you are already using std::shared_ptr) you could use the brace syntax instead of parenthesis:

Bar bar(std::shared_ptr<Foo>{foo});

This would actually construct an object bar of type Bar, since the statement above can't be interpreted as a declaration because of the braces.

edited Sep 14 '17 at 12:33

answered Sep 14 '17 at 12:17

JFMR

23,265
4
52
76

3

You mean it's equivalent to `Bar bar( std::shared_ptr foo );`? – jpo38 Sep 14 '17 at 12:18
2

Correct, but could be a better answer if you had an explanation or link about the Most Vexing Parse and offered a solution. – aschepler Sep 14 '17 at 12:20
A possible C++98 or TR1 solution is to use double parentheses after the intended variable name. A parameter name can be enclosed in gratuituous parentheses, as you pointed out, but not the whole parameter list, even if it contains only one parameter declaration. So, e.g.: ``Bar bar((std::tr1::shared_ptr(foo)))``. Not very readable though… – Arne Vogel Sep 14 '17 at 14:55

C++ function definition and variable declaration mismatch?

1 Answers1

Linked

Related