Re: C++ Primer ex 9.14
On Sep 17, 11:11 am, Barry <dhb2...@gmail.com> wrote:
James Kanze wrote:
it only happens to those with none parameter like the latter
one you wrote.
std::istream_iterator< std::string >()
would be a declaration---in the context of a function parameter,
declaration of what?
a function or a pointer to function?
Yes:-).
The declaration:
std::istream_iterator< std::string > toto() ;
declares a function, with the name toto. As a function
parameter, the name is optional (so we end up with
"std::istream_iterator< std::string >()", AND "After determining
the type of each parameter, any parameter of type 'array of T'
or 'function returning T' is adjusted to be 'pointer to T' or
'pointer to function returning T,' respectively" (=A78.3.5/3).
A horrible misfeature, inherited from C, but one we have to live
with.
I think this needs more discussion:
see:
template <class F = void()>
struct Func;
template <class RET, class ARG>
struct Func <RET(ARG)>
{
};
Func<int(int)> int_int_f;
here "int(int)" is a type I think, not a variable.
Certainly. It matches a template type argument. It can only be
a type. A non-type wouldn't be legal in this context.
If you say "it differs if context differs", would you tell me more?
See above. A function is a perfectly valid type. But not as a
function parameter. In a function declaration, function types
behave much like array types; they are adjusted to pointer to
function. (Note that in general, too, an expression of type
function will be implicitly converted to a pointer to function,
unless it is the operand of a () operator.)
it's the equivalent of:
std::istream_iterator< std::string >(*ptrToFnc)()
actually, they are not equivent
As a function parameter, they are exactly the same.
int (f)(int); : f is typeof function
int (*pf) (int); : pf is typeof pointer to function.
And while I think you're right for
std::istream_iterator< std::string >( std::cin ),
something like:
std::istream_iterator< std::string >( someFile ),
is definitely a declaration.
Technically, too, it should be sufficient to disambiguate any
one of the parameters; adding the parentheses to just one of the
parameters should suffice. But I've had problems with this in
the past, and have gotten into the habit of adding them more or
less systematically, whenever there might be an ambiguity.
yeh, it depends on the compiler, I think, though I don't use
many compilers.
Note that I'm not aware of a modern compiler which has this
problem. G++ had it for a long time, however, and I've gotten
into the habit of programming against it. (Also, I prefer
orthogonality.)
maybe adding "()" around the variable is still not the
ultimate solution, it *may* (I don't have any test case) still
fail to compile on some compilers.
the most portable way, but not so elegant would be
std::istream_iterator< std::string > end;
vector<...> vec(
...
end
);
Introducing an additional named variable? That makes sense when
the name adds some significant semantic information, but the two
iterator idiom is so ubiquious that this isn't the case here.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34