By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
432,101 Members | 1,426 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 432,101 IT Pros & Developers. It's quick & easy.

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

P: n/a
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<intcontains 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<intivec;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( ivec ) );

std::cin.clear();
std::cout << "Enter some integers for LIST: ";
std::list<intilist;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( ilist ) );

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

bool comp_result = true;
std::vector<int>::const_iterator 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

Oct 9 '07 #1
Share this Question
Share on Google+
10 Replies


P: n/a
On Oct 9, 12:45 pm, arnuld <geek.arn...@gmail.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<intcontains 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<intivec;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( ivec ) );

std::cin.clear();
std::cout << "Enter some integers for LIST: ";
std::list<intilist;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( ilist ) );

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

bool comp_result = true;
std::vector<int>::const_iterator 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.wordpress.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

Oct 9 '07 #2

P: n/a
An**********@gmail.com wrote:
On Oct 9, 12:45 pm, arnuld <geek.arn...@gmail.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<intcontains 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<intivec;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( ivec ) );

std::cin.clear();
std::cout << "Enter some integers for LIST: ";
std::list<intilist;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( ilist ) );

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

bool comp_result = true;
std::vector<int>::const_iterator 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.wordpress.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());

Oct 9 '07 #3

P: n/a
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<intconst& ivec, std::list<intconst& 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<intivec;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( ivec ) );

std::cin.clear();
std::cout << "Enter some integers for LIST: ";
std::list<intilist;
std::copy( std::istream_iterator<int>( std::cin ),
std::istream_iterator<int>(),
std::back_inserter( 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

Oct 10 '07 #4

P: n/a
In article <pa***************************@ippimail.com>,
ar****@ippimail.com says...

[ ... just FWIW]
bool comp_elem( std::vector<intconst& ivec, std::list<intconst& 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.
Oct 10 '07 #5

P: n/a
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

Oct 10 '07 #6

P: n/a
;red floyd wrote:
An**********@gmail.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_compare, 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 objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Oct 10 '07 #7

P: n/a
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<intconst& ivec, std::list<intconst& 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

Oct 10 '07 #8

P: n/a
James Kanze wrote:
;red floyd wrote:
>An**********@gmail.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. :-)
Oct 10 '07 #9

P: n/a
On Oct 10, 4:23 pm, Marjancek <marjan...@gmail.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 objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Oct 10 '07 #10

P: n/a
In article <11**********************@19g2000hsx.googlegroups. com>,
ma*******@gmail.com says...

[ ... ]
'True' is not always 1, it would be safer to do
C and C++ are case sensitive. 'true' (not 'True') _is_ a value -- but
when/if you convert it to an integer, it is guaranteed to convert to 1
(and likewise, false to 0).
std::cout << strings[result ? 1 : 0] << std::endl;
This gains absolutely nothing. If you start with an integer, where any
non-zero value converts to 'true', you typically want to convert to a
bool with something like:

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

--
Later,
Jerry.

The universe is a figment of its own imagination.
Oct 11 '07 #11

This discussion thread is closed

Replies have been disabled for this discussion.