comparing elements of vector<int> and list<int>

[arnuld]

It is quite an ugly hack but it is all I am able to come up with for
now :-( and it does the requires work. I want to improve the program, I
know you people have much better ideas ;-)
/* C++ Primer - 4/e
*
* exercise 9.20
* STATEMENT:
* Write a program to to compare whether a vector<intconta ins the
* same elements as a list<int>.
*
*/
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>
int main()
{
std::cout << "Enter some integers for VECTOR: ";
std::vector<int ivec;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ivec ) );

std::cin.clear( );
std::cout << "Enter some integers for LIST: ";
std::list<intil ist;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ilist ) );

std::cout << "\nNow we will compare VECTOR & LIST for equality :: ";

bool comp_result = true;
std::vector<int >::const_iterat or viter = ivec.begin();
std::list<int>: :const_iterator liter = ilist.begin();
/* If sizes are unequal, then they can not be equal :-) */
if( ivec.size() != ilist.size() )
{
comp_result = false;
}
else
{
for( ; ( viter != ivec.end() ) || ( liter != ilist.end() );
++viter, ++liter )
{
if( *viter != *liter )
{
comp_result = false;
}
}
}

if( comp_result )
{
std::cout << "VECTOR & LIST are EQUAL" << std::endl;
}
else
{
std::cout << "VECTOR & LIST are NOT equal" << std::endl;
}
return 0;
}

========= A FEW RUNS =============== ==
~/programming/c++ $ g++ -ansi -pedantic -Wall -Wextra ex_09-20.cpp
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2 1

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT equal
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1
Enter some integers for LIST: 1 2 3 4 5 6 7 8 9 0 9 9 8 8 8 8 8 8 8 8 8 8
8 8 8 88 88 88 8 8 8 88 8 8 88 8 8 8 8 8 8 8 8

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT equal
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2 3

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are EQUAL
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT
equal

-- arnuld
http://lispmachine.wordpress.com

[AnonMail2005]

On Oct 9, 12:45 pm, arnuld <geek.arn...@gm ail.comwrote:

It is quite an ugly hack but it is all I am able to come up with for
now :-( and it does the requires work. I want to improve the program, I
know you people have much better ideas ;-)

/* C++ Primer - 4/e
*
* exercise 9.20
* STATEMENT:
* Write a program to to compare whether a vector<intconta ins the
* same elements as a list<int>.
*
*/

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>

int main()
{
std::cout << "Enter some integers for VECTOR: ";
std::vector<int ivec;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ivec ) );

std::cin.clear( );
std::cout << "Enter some integers for LIST: ";
std::list<intil ist;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ilist ) );

std::cout << "\nNow we will compare VECTOR & LIST for equality :: ";

bool comp_result = true;
std::vector<int >::const_iterat or viter = ivec.begin();
std::list<int>: :const_iterator liter = ilist.begin();

/* If sizes are unequal, then they can not be equal :-) */
if( ivec.size() != ilist.size() )
{
comp_result = false;
}
else
{
for( ; ( viter != ivec.end() ) || ( liter != ilist.end() );
++viter, ++liter )
{
if( *viter != *liter )
{
comp_result = false;
}
}
}

if( comp_result )
{
std::cout << "VECTOR & LIST are EQUAL" << std::endl;
}
else
{
std::cout << "VECTOR & LIST are NOT equal" << std::endl;
}

return 0;

}

========= A FEW RUNS =============== ==
~/programming/c++ $ g++ -ansi -pedantic -Wall -Wextra ex_09-20.cpp
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2 1

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT equal
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1
Enter some integers for LIST: 1 2 3 4 5 6 7 8 9 0 9 9 8 8 8 8 8 8 8 8 8 8
8 8 8 88 88 88 8 8 8 88 8 8 88 8 8 8 8 8 8 8 8

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT equal
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2 3

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are EQUAL
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT
equal

-- arnuldhttp://lispmachine.wor dpress.com

You could also try std::equal for containers of the same length.

Also, your code should stop looping as soon as an element doesn't
match.

hth

[red floyd]

An**********@gm ail.com wrote:

On Oct 9, 12:45 pm, arnuld <geek.arn...@gm ail.comwrote:

>It is quite an ugly hack but it is all I am able to come up with for
now :-( and it does the requires work. I want to improve the program, I
know you people have much better ideas ;-)

/* C++ Primer - 4/e
*
* exercise 9.20
* STATEMENT:
* Write a program to to compare whether a vector<intconta ins the
* same elements as a list<int>.
*
*/

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <iterator>

int main()
{
std::cout << "Enter some integers for VECTOR: ";
std::vector<int ivec;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ivec ) );

std::cin.clear( );
std::cout << "Enter some integers for LIST: ";
std::list<intil ist;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ilist ) );

std::cout << "\nNow we will compare VECTOR & LIST for equality :: ";

bool comp_result = true;
std::vector<int >::const_iterat or viter = ivec.begin();
std::list<int>: :const_iterator liter = ilist.begin();

/* If sizes are unequal, then they can not be equal :-) */
if( ivec.size() != ilist.size() )
{
comp_result = false;
}
else
{
for( ; ( viter != ivec.end() ) || ( liter != ilist.end() );
++viter, ++liter )
{
if( *viter != *liter )
{
comp_result = false;
}
}
}

if( comp_result )
{
std::cout << "VECTOR & LIST are EQUAL" << std::endl;
}
else
{
std::cout << "VECTOR & LIST are NOT equal" << std::endl;
}

return 0;

}

========= A FEW RUNS =============== ==
~/programming/c++ $ g++ -ansi -pedantic -Wall -Wextra ex_09-20.cpp
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2 1

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT equal
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1
Enter some integers for LIST: 1 2 3 4 5 6 7 8 9 0 9 9 8 8 8 8 8 8 8 8 8 8
8 8 8 88 88 88 8 8 8 88 8 8 88 8 8 8 8 8 8 8 8

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT equal
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2 3

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are EQUAL
~/programming/c++ $ ./a.out
Enter some integers for VECTOR: 1 2 3
Enter some integers for LIST: 1 2

Now we will compare VECTOR & LIST for equality :: VECTOR & LIST are NOT
equal

-- arnuldhttp://lispmachine.wor dpress.com

You could also try std::equal for containers of the same length.

Also, your code should stop looping as soon as an element doesn't
match.

hth

So, it's easy to say:

if (ivec.size() != ilist.size())
return false;
else
return std::equal(ivec .begin(), ivec.end(), ilist.begin());

[arnuld]

On Tue, 09 Oct 2007 12:17:16 -0700, red floyd wrote:

So, it's easy to say:

if (ivec.size() != ilist.size())
return false;
else
return std::equal(ivec .begin(), ivec.end(), ilist.begin());

I have wrapped everything into 2 functions and I used main(), only to call
them. how about this ?

bool comp_elem( std::vector<int const& ivec, std::list<intco nst& ilist )
{
if( ivec.size() != ilist.size() )
{
return false;
}
else
{
return std::equal( ivec.begin(), ivec.end(), ilist.begin() );
}
}
void print_result( bool result )
{
if( result )
{
std::cout << "VECTOR & LIST are EQUAL" << std::endl;
}
else
{
std::cout << "VECTOR & LIST are NOT equal" << std::endl;
}
}
int main()
{
std::cout << "Enter some integers for VECTOR: ";
std::vector<int ivec;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ivec ) );

std::cin.clear( );
std::cout << "Enter some integers for LIST: ";
std::list<intil ist;
std::copy( std::istream_it erator<int>( std::cin ),
std::istream_it erator<int>(),
std::back_inser ter( ilist ) );
std::cout << "\nNow we will compare VECTOR & LIST for equality :: ";
bool comp_result = comp_elem( ivec, ilist );
print_result( comp_result );
return 0;
}

-- arnuld
http://lispmachine.wordpress.com

[Jerry Coffin]

In article <pa************ *************** @ippimail.com>,
ar****@ippimail .com says...

[ ... just FWIW]

bool comp_elem( std::vector<int const& ivec, std::list<intco nst& ilist )
{
if( ivec.size() != ilist.size() )
{
return false;
}
else
{
return std::equal( ivec.begin(), ivec.end(), ilist.begin() );
}
}

return (ivec.size() == ilist.size()) &&
std::equal(ivec .begin(), ivec.end(), ilist.begin());

void print_result( bool result )
{
if( result )
{
std::cout << "VECTOR & LIST are EQUAL" << std::endl;
}
else
{
std::cout << "VECTOR & LIST are NOT equal" << std::endl;
}
}

static char const *strings[] = {
"VECTOR and LIST are NOT equal",
"VECTOR and LIST are EQUAL"
};

std::cout << strings[result] << std::endl;

--
Later,
Jerry.

The universe is a figment of its own imagination.

[arnuld]

On Tue, 09 Oct 2007 23:23:25 -0600, Jerry Coffin wrote:

[ ... just FWIW]

return (ivec.size() == ilist.size()) &&
std::equal(ivec .begin(), ivec.end(), ilist.begin());

...[SNIP]....

static char const *strings[] = {
"VECTOR and LIST are NOT equal",
"VECTOR and LIST are EQUAL"
};

std::cout << strings[result] << std::endl;

hey man, its cool 8-)
-- arnuld
http://lispmachine.wordpress.com

[James Kanze]

;red floyd wrote:

An**********@gm ail.com wrote:

[...]

You could also try std::equal for containers of the same length.

Also, your code should stop looping as soon as an element doesn't
match.

So, it's easy to say:

if (ivec.size() != ilist.size())
return false;
else
return std::equal(ivec .begin(), ivec.end(), ilist.begin())

And even easier (and more readable) to say:

return ivec.size() == ilist.size()
&& std::equal( ivec.begin(), ivec.end(), ilist.begin() ) ;

(There's also a function lexographical_c ompare, or something
like that, which might---or might not---be usable here. I'd
look it up quickly, but the file server here is acting up,
and I can't access my online copies of the standard at the
moment.)

--
James Kanze (GABI Software) mailto: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]

[Marjancek]

On Oct 10, 2:23 am, Jerry Coffin <jcof...@taeus. comwrote:

In article <pan.2007.10.10 .05.00.52.70... @ippimail.com>,
arn...@ippimail .com says...

[ ... just FWIW]

bool comp_elem( std::vector<int const& ivec, std::list<intco nst& ilist )
{
if( ivec.size() != ilist.size() )
{
return false;
}
else
{
return std::equal( ivec.begin(), ivec.end(), ilist.begin() );
}
}

return (ivec.size() == ilist.size()) &&
std::equal(ivec .begin(), ivec.end(), ilist.begin());

void print_result( bool result )
{
if( result )
{
std::cout << "VECTOR & LIST are EQUAL" << std::endl;
}
else
{
std::cout << "VECTOR & LIST are NOT equal" << std::endl;
}
}

static char const *strings[] = {
"VECTOR and LIST are NOT equal",
"VECTOR and LIST are EQUAL"

};

std::cout << strings[result] << std::endl;

'True' is not always 1, it would be safer to do

std::cout << strings[result ? 1 : 0] << std::endl;

Marjancek

[red floyd]

James Kanze wrote:

;red floyd wrote:

>An**********@gm ail.com wrote:

[...]

>>You could also try std::equal for containers of the same length.

>>Also, your code should stop looping as soon as an element doesn't
match.

>So, it's easy to say:

>if (ivec.size() != ilist.size())
return false;
else
return std::equal(ivec .begin(), ivec.end(), ilist.begin())

And even easier (and more readable) to say:

return ivec.size() == ilist.size()
&& std::equal( ivec.begin(), ivec.end(), ilist.begin() ) ;

Picky picky picky. :-)

[James Kanze]

On Oct 10, 4:23 pm, Marjancek <marjan...@gmai l.comwrote:

On Oct 10, 2:23 am, Jerry Coffin <jcof...@taeus. comwrote:

In article <pan.2007.10.10 .05.00.52.70... @ippimail.com>,
arn...@ippimail .com says...

[...]

static char const *strings[] = {
"VECTOR and LIST are NOT equal",
"VECTOR and LIST are EQUAL"
};

std::cout << strings[result] << std::endl;

'True' is not always 1,

In C++ it is. The standard requires it.

it would be safer to do

std::cout << strings[result ? 1 : 0] << std::endl;

If the type being tested is not a bool, then something like:

std::cout << strings[ result != 0 ] << std::endl ;

might be appropriate. But for a bool, true is guaranteed to
convert to 1, and false to 0.

--
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]