Re: Passing Two-Dimensional Array as a Function Parameter
On 03/10/2010 17:56, Pete Becker wrote:
On 2010-10-03 11:49:15 -0400, Pete Becker said:
On 2010-10-03 10:09:41 -0400, Luc Danton said:
On 03/10/2010 15:42, Pete Becker wrote:
On 2010-10-03 03:31:50 -0400, Juha Nieminen said:
Pete Becker <pete@versatilecoding.com> wrote:
int valsAcross [5] = {0,0,0,0,0};
Or, if you don't like counting all those zeros,
int valsAcross[5] = { 0 };
I think this will work too:
int valsAcross[5] = { };
Maybe. But mine is much clearer. <g>
Do you find:
template<typename T>
T make()
{
return T();
}
unclear ?
No.
What is the result of make<int>() ?
What about:
template<typename T>
T*
make()
{
return new T[10]();
}
?
What is make<int>()[0] ?
I'm not at all clear what your point is. Yes, contructors are
meaningful, and some people like to wrap them in template functions.
To me
int valsAcross[5] = {};
is just as clear as
int valsAcross[5] = { 0 };
Good for you.
Then again I've seen presentations/read things about C++0x and
value-initialization.
Once C++0x becomes widely adopted (the standard is still a year or
more away from finalization) things may change. Until then, code that
uses C++0x language features is certainly not portable, and probably
incomprehensible to many people.
However, please note that aggregate initialization of arrays is not a
new C++0x feature. It's been around since the early days of C. And while
empty braces are allowed as an aggregate initializer, I've always found
putting at least one value in the initializer to be clearer.
--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)
Arguably there are no constructor involved in int(), but you probably
know that (and it's irrelevant). My point was that there is an effort to
make initialization uniform no matter the type.
template<typename T>
T make() { return T(); }
is currently (C++03) designed to Do The Right Thing for a large number
of cases.
With C++0x,
template<typename T>
T make() { return T {}; }
is designed to take care of even more cases, notably, as you pointed
out, by pulling aggregate initialization in. Yes, C++0x is not yet here.
But the snippet already works for C++03. I don't understand your claim
that putting one value in the initializer makes it clearer, but I of
course respect that opinion. Have you however considered:
int array[5] = { 42 };
?
I'd write it in a heartbeat if I had the need rather than the more explicit:
int array[5] = {}; // or { 0 };
array[0] = 42;
but I wouldn't claim that's it's clear!
Did you really expect that an unconditional
> Maybe. But mine is much clearer.
would not generate reactions? Was it in jest?