Re: Stroustrup 5.9, exercise 7 (using struct)
On Apr 1, 10:43 pm, Anand Hariharan <znvygb.nanaq.unevun...@tznvy.pbz>
wrote:
arnuld wrote:
const int arr_size = 12;
duo arr[] = {JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP};
Oops! arr does not have 12 elements. For this reason, it is best you
let the compiler evaluate this for you.
You have already used arr[] in the above definition. The compiler
determines its size. Likewise you say
const size_t arr_size = sizeof arr / sizeof *arr;
That's more or less what you say in C (except as a macro, not as
a const variable). But it's error prone (suppose arr is the
parameter of a function). In C++, I've generally seen:
arr_size = size( arr ) ;
where size is defined:
template< typename T, size_t N >
size_t
size( T (&array)[ N ] )
{
return N ;
}
And I know, this is way beyond the level of the original
poster. But in his case, he really does want 12 entries: you
don't want the compiler determining the number of months in a
year, in some arbitrary fashion. So I'd make two changes:
-- arr_size is a ridiculous name; it doesn't tell us anything.
Something like:
int const monthsInYear = 12 ;
is far better.
-- You want to explicitly specify the size of the array:
MonthInfo monthInfo[ monthsInYear ] = { /*...*/ } ;
If you accidentaly give too many names (e.g. because you
duplicated one), the compiler will tell you. If you
accidentally give too few, I think some compilers will warn
as well; at least, you'll get a recognizable value (a null
pointer) rather than random garbage.
duo* pduo = arr;
std::cout << "\tMONTH\tDays\n";
for(int i = 0; i < arr_size; ++i)
If you define arr_size like I have done above, you should define i also
as size_t.
You should really tell him why, as well:-). The type of your
expression is size_t (although you could have declared it int);
size_t is an unsigned type, and mixing unsigned and signed types
in C++ can sometimes lead to surprising results.
Until you really know what you are doing, I'd recommend sticking
with int. All of the time, for everything. For that matter, I
only use unsigned types in a few, very special cases:
-- raw memory is unsigned char,
-- when the values a bit masks, etc., and I'm &'ing and |'ing,
rather than +'ing and -'ing, and
-- when a third party interface is using unsigned---as I say,
mixing the two can give surprising results, and should be
avoided.
Also, you were unlucky that your program did not noisily
fail for iterating beyond i=8 (but you did note that your output showed
DEC, NOV and OCT after SEP, didn't you?)
Right. The advantage of explicitly declaring the length of the
array is that it would have noisily failed (at least on most
general purpose systems).
{
std::cout << '\t'
<< pduo->month
<< '\t'
<< pduo->days
<< std::endl;
++pduo;
}
Like Alf suggested elsewhere when responding to one of your posts, using
the subscript notation is more typical when iterating arrays.
Was more typical. I have the impression today that everyone
uses iterators, for everything. (And a pointer is an iterator.)
So you'd get something like:
for (char const** p = begin( monthNames ) ;
p != end( monthNames ) ;
++ p ) {
std::cout << '\t' << p->name << '\t' << p->days << std::endl ;
}
(with begin and end defined along the lines of size(), above).
Of course, I'm not saying that this is necessarily a positive
evolution:-).
--
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