Re: The joy (?) of C++98 argument forwarding

Consider ...

<code>
// Copyright (c) Alf P. Steinbach, 2010.
#include "_config.h"

#include <progrock/cppx/pointers/Shared.h>
#include <iostream>

namespace {
    using namespace progrock;

    cppx::Size count = 0;

    class Foo
    {
    protected:
        ~Foo()
        {
            using namespace std;
            --count;
            cout << "Foo destroyed" << endl;
        }

    public:
        Foo()
        {
            using namespace std;
            cout << "Foo constructed" << endl;
            ++count;
        }

        Foo( int x )
        {
            using namespace std;
            cout << "Foo constructed with arg " << x << endl;
            ++count;
        }

        Foo( int x, char const s[] )
        {
            using namespace std;
            cout << "Foo constructed with args " << x << " and \"" << s
<< "\"" << endl;
            ++count;
        }
    };

    void test()
    {
        using namespace cppx;

        Shared< Foo > r1 = newObject();
        assert( count == 1 );

        Shared< Foo > r2( r1 );
        assert( count == 1 );

        Shared< Foo > r3( newObject(), args( 42 ) );
        assert( count == 2 );

        Shared< Foo > r4( newObject(), args( 42, "blah blah" ) );
        assert( count == 3 );

        r4 = r2;
        assert( count == 2 );

        r3 = r2;
        assert( count == 1 );

        r3 = r3;
        assert( count == 1 );
    }
}; // namespace anon

void testShared()
{
    test();
    assert( count == 0 );
}
</code>

Is the notation in the 'test' routine OK, or would it be better (in some
sense) with some macro, e.g. like

  Shared< Foo > r( CPPX_NEW_SHARED( 42, "blah blah" ) );

?