Stroustrup 5.9, exercise 10 (using a function)

[arnuld]

this does not work, i know there is some problem in the "for loop" of
"print_arr" function. i am not able to correct the weired results i am
getting. i have no compile time error, it is only semantic-bug that is
causing the trouble:

EXPECTED: january, february, march....decemb er
GOT: january, january, january........ .january

------------- PROGRAMME --------------
/* Stroustrup, 5.9, exercise 10

STATEMENT:
define an array of strings,where strings contains the names months .
Print those strings. Pass the array to a function that prints those
strings.

SOLUTION:

1.) 1st, i will print array int he "main" using "for" loop and array
indexing.

2.) then i wil print he array using a function and passing the array
to the function as argument(pass by reference).

NOTICE: posted code is implementation of (2)
*/

#include<iostre am>

void print_arr(const char**, size_t);

int main()
{
const char* arr[] = {"january", "february", "march", "april", "may",
"june",
"july", "august", "september" , "october",
"november",
"december"} ;

const size_t arr_size = sizeof(arr) / sizeof(*arr);

print_arr(arr, arr_size);

return 0;

}

void print_arr(const char** arr, size_t arr_size)
{
const char** p = arr;

std::cout << "\n\tUSING FUNCTION\n";
for(unsigned int i=0; i < arr_size; ++i)
std::cout << *p << std::endl;

}

-------------- OUTPUT ----------------------
[arch@voodo tc++pl]$ g++ -ansi -pedantic -Wall -Wextra 5.9_ex-10-
function.cpp
[arch@voodo tc++pl]$ ./a.out

USING FUNCTION
january
january
january
january
january
january
january
january
january
january
january
january
[arch@voodo tc++pl]$

[Default User]

arnuld wrote:

On Apr 2, 9:55 pm, "Default User" <defaultuse...@ yahoo.comwrote:

I don't like the use of '\0' there. While it's technically not
wrong, as that's a legitimate null pointer constant, I think it
betrays a lack of understanding on your part.

:-(

That last element of the array is NOT a character, particularly it
is not a character like the null terminator in a character array
(C-style string).

well, its a new thing you told :-)

That's fine. You're in a learning situation, so details can be
important.

>

What you want in this case for an array terminator is a null
pointer. I'd prefer the use of a plain 0, or even NULL (although
many in the C++ community don't care for that macro).

OK, 0 (zero) then

That would be better. Whether it's better than maintaining and passing
the size is a design question.


Brian

[James Kanze]

On Apr 2, 11:00 am, "arnuld" <geek.arn...@gm ail.comwrote:

On Apr 2, 1:47 pm, "Erik Wikström" <eri...@student .chalmers.sewro te:
Personally I'd prefer a version where the size is passed as an
argument just to be safe, something like your first try, but also
incrementing arr:

void print_arr(const char** arr, size_t arr_size)
{
std::cout << "\n\tUSING FUNCTION\n";
for(unsigned int i=0; i < arr_size; ++i, arr++)
std::cout << *arr << std::endl;
}

this is the 1st time i have seen someone incrementing an "array",
never saw so even in any book.

There's no array in this function, just a pointer.

does it work like this:

*arr == &arr[0]
++arr == &arr[0 + 1]

?

IOW, like a pointer

If you look at the declaration of the function, it's a pointer.

Had he wanted to confuse you, he could have declared the
function:

void print_arr( char const* arr[], size_t size ) ...

Despite appearances, there's no array here either. There's a
special rule that says when the type of a function parameter is
declared to be array of T, the actual type is pointer to T.

And pointers can be incremented.

Never the less, I'd keep it simple:

void print_arr( char const* arr[], size_t size )
{
for ( size_t i = 0 ; i < size ; ++ i ) {
std::cout << arr[ i ] << std::endl ;
}
}

or (more idiomatic, because closer to what you do with the STL,
but perhaps less readable anyway):

void print_arr( char const** arr, size_t size )
{
char const** end = arr + size ;
while ( arr != end ) {
std::cout << *arr << std::endl ;
++ arr ;
}
}

Note, however, the ambiguity in the use between pointers and
arrays. The definition of the [] operator is a[b] == *(a+b).
Always. You can index arrays because an array converts
implicitly to a pointer to the first element in most contexts.
And the [] is defined as a pointer operator, not an array
operator. Note that this means that things like "abcd"[ i ],
or even i[ "abcd" ] are legal (where i is an int)---if a[b] is
legal, so is b[a]. (Obviously, putting the index in front of
the braces is only good for obfuscation. But realizing that it
is legal, and why, does help understanding the oddities of
arrays in C and in C++. And why so many people prefer
std::vector to a C style array:-).)

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Apr 2, 11:29 am, "Erik Wikström" <eri...@student .chalmers.se>
wrote:

On 2 Apr, 11:00, "arnuld" <geek.arn...@gm ail.comwrote:

Yes, arr[N] is the same as *(arr[0] + N) == *(arr + N).

You mean *(&arr[0] + N), I'm sure.

I'd point out, at least, that there are in fact two curiousities
involved there. One, of course, is the fact that the indexing
operator is defined in terms of pointer arithmetic. The second
is the fact that an expression with array type converts
implicitly, and in (far too) many contexts to a pointer to the
first element.

The whole thing has been carefully designed to confuse beginners
in the language, and thus keep the rates for freelance
specialists higher. Personally, as a freelance specialist, I'm
all for it.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[James Kanze]

On Apr 2, 8:30 pm, "arnuld" <geek.arn...@gm ail.comwrote:

On Apr 2, 9:55 pm, "Default User" <defaultuse...@ yahoo.comwrote:
I don't like the use of '\0' there. While it's technically not wrong,
as that's a legitimate null pointer constant, I think it betrays a lack
of understanding on your part.

That last element of the array is NOT a character, particularly it is
not a character like the null terminator in a character array (C-style
string).

well, its a new thing you told :-)

Then maybe we should back up a bit. An array is (by definition,
I think, and independantly of the language) a sequence of
elements, all having the same type. In your case, that type was
char const*, a *pointer* (to char). If the array contains
pointers, it cannot, ever, contain a character. The only reason
the compiler didn't complain when you put '\0' into the array is
because there are a lot (far too many, in fact) of implicit
conversions, which C++ inherits from C.

What you want in this case for an array terminator is a null pointer.
I'd prefer the use of a plain 0, or even NULL (although many in the C++
community don't care for that macro).

OK, 0 (zero) then

Which also invokes an implicit conversion. As does NULL: the
argument for NULL is that is says what you want (i.e. a special
value for a pointer). The argument against NULL that it doesn't
actually give you what it says. (G++ warns if you misuse it,
i.e. if you use it in a context where it doesn't get immediately
converted into a pointer. Which pretty much negates the main
argument against it.)

The problem is serious enough that there is a proposal to add a
"nullptr" to C++, which has been adopted by the committee for
C++09.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]