Stroustrup 5.9 exercise 11

[arnuld]

it works fine without any trouble. i want to have advice on improving
the code from any angle like readability, maintenance etc:

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

STATEMENT:
Read a sequence of words from the input. use "quit" as the word
to terminate the input. Print the words in the order they were
entered. don't print a word twice.modify the programme to sort the
words before printing them.

*/

#include<iostre am>
#include<string >
#include<vector >

int main()
{
std::vector<std ::stringcollect _input;

std::string input_word;
std::cin >input_word;

for(int i=0; input_word != "quit"; ++i)
{
collect_input.p ush_back(input_ word);
std::cin >input_word;
}

std::cout << "\n *** Printing WOrds ***\n";

for(unsigned int i=0; i < collect_input.s ize(); ++i)
std::cout << collect_input[i]
<< '\n';

return 0;
}

----------- OUTPUT ----------------
[arch@voodo tc++pl]$ g++ -ansi -pedantic -Wall -Wextra -O
ex_5.9-11.cpp
[arch@voodo tc++pl]$ ./a.out
like this
quitting
quite
and morq quotwe FINISHED quiT quit

*** Printing WOrds ***
like
this
quitting
quite
and
morq
quotwe
FINISHED
quiT
[arch@voodo tc++pl]$

[Victor Bazarov]

Anand Hariharan wrote:

On Apr 9, 5:34 am, Zeppe <[e-mail] rote:

>>
Another note: if the performances are not a priority, it is better to
declare the variables as close as possible to the point in which they
are used.

What does "declaring variables close to first use" have to do with
performance?

It is a common belief that for some cases (and some compilers) it is
better to declare/define an object before it's going to be used, and
especially if the use is in the loop. IOW, it's better to write

SomeType object;
while (blah) {
object = someexpression; // assignment
somehow_use_tha t(object); // use
}

than

while (blah) {
SomeType object = someexpression; // intialisation
somehow_use_tha t(object);
}

(the former case declares the variable in the scope unnecessarily
wide and sooner than the object is actually used).

It is also true that without measuring it's impossible to say for
sure.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Ian Collins]

Victor Bazarov wrote:

Anand Hariharan wrote:

>>On Apr 9, 5:34 am, Zeppe <[e-mail] rote:

>>>Another note: if the performances are not a priority, it is better to
declare the variables as close as possible to the point in which they
are used.

What does "declaring variables close to first use" have to do with
performance ?

It is a common belief that for some cases (and some compilers) it is
better to declare/define an object before it's going to be used, and
especially if the use is in the loop. IOW, it's better to write

SomeType object;
while (blah) {
object = someexpression; // assignment
somehow_use_tha t(object); // use
}

than

while (blah) {
SomeType object = someexpression; // intialisation
somehow_use_tha t(object);
}

(the former case declares the variable in the scope unnecessarily
wide and sooner than the object is actually used).

This appears to contradict your first paragraph.

--
Ian Collins.

[Victor Bazarov]

Ian Collins wrote:

Victor Bazarov wrote:

>Anand Hariharan wrote:

>>On Apr 9, 5:34 am, Zeppe <[e-mail] rote:

Another note: if the performances are not a priority, it is better
to declare the variables as close as possible to the point in
which they are used.

What does "declaring variables close to first use" have to do with
performance ?

It is a common belief that for some cases (and some compilers) it is
better to declare/define an object before it's going to be used, and
especially if the use is in the loop. IOW, it's better to write

SomeType object;
while (blah) {
object = someexpression; // assignment
somehow_use_tha t(object); // use
}

than

while (blah) {
SomeType object = someexpression; // intialisation
somehow_use_tha t(object);
}

(the former case declares the variable in the scope unnecessarily
wide and sooner than the object is actually used).

This appears to contradict your first paragraph.

Contradict? How? The belief is that the former (declaring outside
the 'while' loop) is better. I am not claiming any side in that
belief. I am not saying "contrary to the belief it's better to do
it that way" (in case you are reading it that way).

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Ian Collins]

Victor Bazarov wrote:

Ian Collins wrote:

>>Victor Bazarov wrote:

>>>Anand Hariharan wrote:

On Apr 9, 5:34 am, Zeppe <[e-mail] rote:

>Another note: if the performances are not a priority, it is better
>to declare the variables as close as possible to the point in
>which they are used.

What does "declaring variables close to first use" have to do with
performance ?

It is a common belief that for some cases (and some compilers) it is
better to declare/define an object before it's going to be used, and
especially if the use is in the loop. IOW, it's better to write

SomeType object;
while (blah) {
object = someexpression; // assignment
somehow_use_tha t(object); // use
}

than

while (blah) {
SomeType object = someexpression; // intialisation
somehow_use_tha t(object);
}

(the former case declares the variable in the scope unnecessarily
wide and sooner than the object is actually used).

This appears to contradict your first paragraph.

Contradict? How? The belief is that the former (declaring outside
the 'while' loop) is better. I am not claiming any side in that
belief. I am not saying "contrary to the belief it's better to do
it that way" (in case you are reading it that way).

OK, I thought you were expressing a preference for the first form and
then criticising it at the end. I realy should stop interpreting IOW as
Isle Of Wight!

--
Ian Collins.

[Duane Hebert]

"Victor Bazarov" <v.********@com Acast.netwrote in message
news:ev******** **@news.datemas .de...

>>(the former case declares the variable in the scope unnecessarily
wide and sooner than the object is actually used).

This appears to contradict your first paragraph.

Contradict? How? The belief is that the former (declaring outside
the 'while' loop) is better. I am not claiming any side in that
belief. I am not saying "contrary to the belief it's better to do
it that way" (in case you are reading it that way).

I think the words "unnecessar ily" and "sooner than" tend
to show a bias.

[TB]

arnuld skrev:

>On Apr 9, 2:07 pm, "arnuld" <geek.arn...@gm ail.comwrote:

i just did not get 2 things:

> // sorting the input
sort(collect_in put.begin(), collect_input.e nd());

why "std::sort" does not work ?? (as "algorithm" is a standard
library)

>-------- OUTPUT ----------
[arch@voodo tc++pl]$ g++ -ansi -pedantic -Wall -Wextra -O
ex_5.9-11.cpp
[arch@voodo tc++pl]$ ./a.out
like this and wahout
Quit quiT and quit

*** Printing Sorted Words ***
Quit
and
and
like
quiT
this
wahout
[arch@voodo tc++pl]$

why "Quit" came before "and" ?

Because 'Q' = 81 and 'a' = 97 according
to unicode and ascii.

--
TB

[Victor Bazarov]

Duane Hebert wrote:

"Victor Bazarov" <v.********@com Acast.netwrote in message
news:ev******** **@news.datemas .de...

>>>(the former case declares the variable in the scope unnecessarily
wide and sooner than the object is actually used).

This appears to contradict your first paragraph.

Contradict? How? The belief is that the former (declaring outside
the 'while' loop) is better. I am not claiming any side in that
belief. I am not saying "contrary to the belief it's better to do
it that way" (in case you are reading it that way).

I think the words "unnecessar ily" and "sooner than" tend
to show a bias.

So, you're saying that by using those words I exposed my bias
towards one of the sides [of the debate]. Had I omitted them,
would the issue actually have been clearer?

In this particular case the wideness of the scope and earlier
construction of the object (both unnecessary by themselves) are
supposedly outweighed by performance of the code, taken apriori.

If performance weren't involved, the scope *is* unnecessariry
wide and the object's construction *is* too soon. That's not
just my opinion. My opinion, however, is that it is impossible
to decide without actually measuring the performance.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[arnuld]

On Apr 10, 1:56 am, "Daniel T." <danie...@earth link.netwrote:

"arnuld" <geek.arn...@gm ail.comwrote:

1.) why do i need to "copy" the whole vector ?

You have to copy the whole vector to cout. That is what you are doing
when you print all the strings.

OK, it means , "std::cout" always copies its input.

2.) is "std::cout" is less maintainable/readable than
"ostream_iterat or" ?

No, but the loop itself is.

for ( std::vector<std ::string>::iter ator i = collected_input .begin();
i != collected_input .end(); ++i )
{
cout << *i << '\n';

}

The above works, but if you decide to change the container to anything
other than a vector, you have to change the loop also.

for ( unsigned i = 0; i < collected_input .size(); ++i )
{
cout << collected_input[i] << '\n';

}

The above also works but only for vectors and deques, not for lists or
sets.

i tried std::set, it does not make any sense to me, as of now. it is
on page 491, section 17.4.3 of Stroustrup (special edition).

With std::set, you insert the item instead of using push_back and it
keeps the items sorted.

What you came up with is great for satisfying the last sentence of the
requirement, but not the first 3.

i got it, you mean it is not a good programme at all. i need to
rewrite.

The hardest part of this exorcise is to remove duplicates *without*
sorting the input.

that is what "std::set" does. here is my try with a compile-time error
i am unable to figure out why. i tried eve "std::ostream_i terator" but
same error:

-------- PROGRAMME --------

#include<iostre am>
#include<string >
#include<algori thm>
#include<set>
#include<iterat or>

int main()
{
std::string input_word;
std::set<std::s trings; // collects inputs

while(std::cin >input_word && input_word != "quit")
{
s.insert(input_ word);
}
std::cout << "\n *** Printing Sorted Words ***\n";

std::copy(s.beg in(), s.end(),
ostream_iterato r<std::string>( std::cout, '\n');

return 0;
}

----- OUTPUT ---------
[arch@voodo tc++pl]$ g++ -ansi -pedantic -Wall -Wextra -O
ex_5.9-11_modified.cpp
ex_5.9-11_modified.cpp : In function 'int main()':
ex_5.9-11_modified.cpp :30: error: 'ostream_iterat or' was not declared
in this scope
ex_5.9-11_modified.cpp :30: error: expected primary-expression before
'>' token
ex_5.9-11_modified.cpp :30: warning: left-hand operand of comma has no
effect
[arch@voodo tc++pl]$

[red floyd]

arnuld wrote:

>
that is what "std::set" does. here is my try with a compile-time error
i am unable to figure out why. i tried eve "std::ostream_i terator" but
same error:

-------- PROGRAMME --------

#include<iostre am>

#include <ostream>

#include<string >
#include<algori thm>
#include<set>
#include<iterat or>

int main()
{
std::string input_word;
std::set<std::s trings; // collects inputs

while(std::cin >input_word && input_word != "quit")
{
s.insert(input_ word);
}
std::cout << "\n *** Printing Sorted Words ***\n";

std::copy(s.beg in(), s.end(),
ostream_iterato r<std::string>( std::cout, '\n');

return 0;
}

----- OUTPUT ---------
[arch@voodo tc++pl]$ g++ -ansi -pedantic -Wall -Wextra -O
ex_5.9-11_modified.cpp
ex_5.9-11_modified.cpp : In function 'int main()':
ex_5.9-11_modified.cpp :30: error: 'ostream_iterat or' was not declared
in this scope
ex_5.9-11_modified.cpp :30: error: expected primary-expression before
'>' token
ex_5.9-11_modified.cpp :30: warning: left-hand operand of comma has no
effect
[arch@voodo tc++pl]$

[red floyd]

Ignore my previous post. You forgot std:: on ostream_iterato r. Also,
missing a close paren on std::copy. See embedded.

arnuld wrote:

>
-------- PROGRAMME --------

#include<iostre am>
#include<string >
#include<algori thm>
#include<set>
#include<iterat or>

int main()
{
std::string input_word;
std::set<std::s trings; // collects inputs

while(std::cin >input_word && input_word != "quit")
{
s.insert(input_ word);
}
std::cout << "\n *** Printing Sorted Words ***\n";

std::copy(s.beg in(), s.end(),
ostream_iterato r<std::string>( std::cout, '\n');

std::ostream_it erator<std::str ing(std::cout, '\n'));

>
return 0;
}