cout << vector<string>

[barcaroller]

In the boost::program_ options tutorial, the author included the following
code:
cout << "Input files are: "
<< vm["input-file"].as< vector<string()
<< "\n";
Basically, he is trying to print a vector of string, in one line. I could
not get this compile (let alone run). To get it to compile and run, I had
to re-write it as:
vector<stringv = vm["input-file"].as< vector<string() ;

vector<string>: :const_iterator i;

for ( i = v.begin();
i != v.end();
++i )
{
cout << *citer << " ";
}
Does anyone know if the original line of code is correct? If so, what was I
missing?

[Jeff Schwab]

James Kanze wrote:

On Nov 7, 1:32 pm, Jeff Schwab <j...@schwabcen ter.comwrote:

>Pete Becker wrote:

>>On 2008-11-07 06:03:15 -0500, Maxim Yegorushkin
<maxim.yegoru [e-mail] said:
The example probably assumes there is an overloaded operator<<() for
std::ostre am and std::vector<>, something like this:
namespace std {
template<class A1, class A2>
ostream& operator<<(ostr eam& s, vector<A1, A2const& vec)
Which has undefined behavior. You can only add template specializations
to namespace std when they depend on user-defined types.

>The correct alternative, AIUI:

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

>template<typen ame T>
std::ostream & operator<<(std: :ostream& out, std::vector<Tco nst& v) {
if (!v.empty()) {
typedef std::ostream_it erator<Tout_ite r;
copy(v.begin(), v.end() - 1, out_iter( out, " " ));
out << v.back();
}
return out;
}

>int main() {
int const ints[] = { 1, 2, 3, 4 };
std::cout << std::vector<int >( ints, ints + 4 ) << '\n';
}

Correct in what sense? It's OK for simple test, like this, but
it's certainly not something you'd allow in production code.

Correct in the sense that it implements the OP's intent, and is allowed
by the standard. As far as using it in production code... Ad hoc
output of this sort only really comes up for debugging purposes. If you
don't even think it's OK for debug, I'd love to know your suggested
alternative.

[rio]

"Kai-Uwe Bux" <jk********@gmx .netha scritto nel messaggio
news:49******** *************** @read.cnntp.org ...

Juha Nieminen wrote:

>Jeff Schwab wrote:

>>template<type name T>
std::ostrea m& operator<<(std: :ostream& out, std::vector<Tco nst& v) {
if (!v.empty()) {
typedef std::ostream_it erator<Tout_ite r;
copy(v.begin(), v.end() - 1, out_iter( out, " " ));
out << v.back();
}
return out;
}

Is there some advantage of that code over a shorter and simpler:

template<typen ame T>
std::ostream & operator<<(std: :ostream& out, std::vector<Tco nst& v) {
for(std::size_t i = 0; i < v.size()-1; ++i)

Nit: std::size_t is not guaranteed to be vector::size_ty pe.

so could be
std::size_t != vector::size_ty pe
and what could happen if in the definition
size_t sii=big;
int a[sii];
vector<int b(a, a+sii);

> out << v[i] << " ";
out << v.back();

I think, v.back() has undefined behavior if the v is empty.

> return out;
}

Best

Kai-Uwe Bux

[rio]

"Jeff Schwab" <je**@schwabcen ter.comha scritto nel messaggio
news:Q7******** *************** *******@giganew s.com...

Pete Becker wrote:

>On 2008-11-07 06:03:15 -0500, Maxim Yegorushkin
<ma*********** ****@gmail.coms aid:

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

template<typena me T>
std::ostream& operator<<(std: :ostream& out, std::vector<Tco nst& v) {
if (!v.empty()) {
typedef std::ostream_it erator<Tout_ite r;
copy(v.begin(), v.end() - 1, out_iter( out, " " ));
out << v.back();

what is the meaning of "out << v.back();"
why not write above only?
copy(v.begin(), v.end(), out_iter( out, " " ));

why it is not easy?

is it not better the "operator<< " defined below?

#include <stdio.h>
#include <iostream.h>
#include <iterator.h>
#include <vector.h>

template<typena me T>
std::ostream& operator<<(std: :ostream& out, std::vector<T>c onst& v)
{size_t i;
for(i=0; i<v.size(); ++i)
out<<v[i]<<" ";
return out;
}

int main()
{int ints[]={1,2,3,4}, inty2[100]={0}, i;
std::vector<int vettore(inty2, inty2+100);
std::vector<int vettor1(100);

for(i=0; i<90; ++i)
vettor1[i]=i;

std::cout << std::vector<int >(ints,ints+4 ) << '\n';
std::cout << vettore << '\n';
std::cout << "Vettor1" << vettor1 << '\n';

getchar();
}

the above seems ok what not seems ok to me that this
"
std::vector<int vettor1;

for(i=0; i<90; ++i)
vettor1[i]=i;
"
here goes in segmentation fault
is not vector1 self sizabile?

than how you are sure that *all* the allocations have its deallocation?
for example it seems "std::vector<in t>(ints,ints+4) "
copy in new memory the array ints[0..3]
and than it has to deallocate it but when and where

}
return out;
}

int main() {
int const ints[] = { 1, 2, 3, 4 };
std::cout << std::vector<int >( ints, ints + 4 ) << '\n';
}

[rio]

"rio" <[e-mail] scritto nel messaggio
news:49******** *************** @reader5.news.t in.it...

>
"Kai-Uwe Bux" <jk********@gmx .netha scritto nel messaggio
news:49******** *************** @read.cnntp.org ...

>Juha Nieminen wrote:

>>Jeff Schwab wrote:
template<typ ename T>
std::ostream & operator<<(std: :ostream& out, std::vector<Tco nst& v) {
if (!v.empty()) {
typedef std::ostream_it erator<Tout_ite r;
copy(v.begin(), v.end() - 1, out_iter( out, " " ));
out << v.back();
}
return out;
}

Is there some advantage of that code over a shorter and simpler:

template<type name T>
std::ostrea m& operator<<(std: :ostream& out, std::vector<Tco nst& v) {
for(std::size_t i = 0; i < v.size()-1; ++i)

Nit: std::size_t is not guaranteed to be vector::size_ty pe.

i know max(std::size_t ) >= max(vector::siz e_type)
i know v.size()-1<=max(vector:: size_type) <= max(std::size_t )

so size_t is ok

[Kai-Uwe Bux]

rio wrote:

>
"rio" <[e-mail] scritto nel messaggio
news:49******** *************** @reader5.news.t in.it...

>>
"Kai-Uwe Bux" <jk********@gmx .netha scritto nel messaggio
news:49******* *************** *@read.cnntp.or g...

>>Juha Nieminen wrote:

Jeff Schwab wrote:
template<ty pename T>
std::ostrea m& operator<<(std: :ostream& out, std::vector<Tco nst& v) {
if (!v.empty()) {
typedef std::ostream_it erator<Tout_ite r;
copy(v.begin(), v.end() - 1, out_iter( out, " " ));
out << v.back();
}
return out;
}

Is there some advantage of that code over a shorter and simpler:

template<typ ename T>
std::ostream & operator<<(std: :ostream& out, std::vector<Tco nst& v) {
for(std::size_t i = 0; i < v.size()-1; ++i)

Nit: std::size_t is not guaranteed to be vector::size_ty pe.

i know max(std::size_t ) >= max(vector::siz e_type)

Could you provide a pointer into the standard to backup that claim? or are
you making a statement about a particular platform?

i know v.size()-1<=max(vector:: size_type) <= max(std::size_t )

so size_t is ok

Best

Kai-Uwe Bux

[Maxim Yegorushkin]

On Nov 7, 12:17*pm, Pete Becker <p...@versatile coding.comwrote :

On 2008-11-07 06:03:15 -0500, Maxim Yegorushkin
<maxim.yegorush [e-mail] id:

The example probably assumes there is an overloaded operator<<() for
std::ostream and std::vector<>, something like this:

* * #include <ostream>
* * #include <iterator>
* * #include <algorithm>

* * namespace std {

* * * * template<class A1, class A2>
* * * * ostream& operator<<(ostr eam& s, vector<A1, A2const& vec)
* * * * {
* * * * * * copy(vec.begin( ), vec.end(), ostream_iterato r<A1>(s, "
"));
* * * * * * return s;
* * * * }

* * }

Which has undefined behavior. You can only add template specializations
to namespace std when they depend on user-defined types.

Formally true.

On practice it works just fine as long as One Definition Rule is not
violated.

--
Max

[James Kanze]

On Nov 7, 7:21 pm, Jeff Schwab <j...@schwabcen ter.comwrote:

James Kanze wrote:

On Nov 7, 1:32 pm, Jeff Schwab <j...@schwabcen ter.comwrote:

Pete Becker wrote:
On 2008-11-07 06:03:15 -0500, Maxim Yegorushkin
<maxim.yegorus [e-mail] aid:
The example probably assumes there is an overloaded operator<<() for
std::ostrea m and std::vector<>, something like this:
namespace std {
template<class A1, class A2>
ostream& operator<<(ostr eam& s, vector<A1, A2const& vec)
Which has undefined behavior. You can only add template
specialization s to namespace std when they depend on
user-defined types.

The correct alternative, AIUI:

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

template<typena me T>
std::ostream& operator<<(std: :ostream& out, std::vector<Tco nst& v) {
if (!v.empty()) {
typedef std::ostream_it erator<Tout_ite r;
copy(v.begin(), v.end() - 1, out_iter( out, " " ));
out << v.back();
}
return out;
}

int main() {
int const ints[] = { 1, 2, 3, 4 };
std::cout << std::vector<int >( ints, ints + 4 ) << '\n';
}

Correct in what sense? It's OK for simple test, like this,
but it's certainly not something you'd allow in production
code.

Correct in the sense that it implements the OP's intent, and
is allowed by the standard. As far as using it in production
code... Ad hoc output of this sort only really comes up for
debugging purposes. If you don't even think it's OK for
debug, I'd love to know your suggested alternative.

Do you leave such debugging code in your production code? If
not, no problem, but there's no point in making the << a
template. If so:

-- It doesn't work. Try it with std::vector<
std::vector< int , for example.

-- It very rapidly introduces undefined behavior, as you write
the above, and some other programmer provides the same
function, but with a comma as a separator.

For a quick debugging session, the simplest solution is to knock
out a non-template version in an unnamed namespace. For
anything else, you really need to define what is wanted; you
don't output raw vectors, but vectors with a semantic
signification, which determines how you format them. If you're
using vectors to represent both sets and sequences in a
mathematical context, for example, you'll doubtlessly have a
class for each, with the vector buried deep down in it. And
those classes will provide the formatted output.

If you find that you often need such debugging output (I don't,
but I'm sure that there are applications that to), then you
might want to come up with a general FormattedSequen ce class
template, with a template function to generate it (so you get
automatic type deduction); this could, of course, be in any
namespace you want.

--
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 Nov 10, 10:19 am, Maxim Yegorushkin <maxim.yegorush [e-mail]>
wrote:

On Nov 7, 12:17 pm, Pete Becker <p...@versatile coding.comwrote :

On 2008-11-07 06:03:15 -0500, Maxim Yegorushkin
<maxim.yegorush [e-mail] id:

The example probably assumes there is an overloaded
operator<<() for std::ostream and std::vector<>, something
like this:

#include <ostream>
#include <iterator>
#include <algorithm>

namespace std {

template<class A1, class A2>
ostream& operator<<(ostr eam& s, vector<A1, A2const& vec)
{
copy(vec.begin( ), vec.end(), ostream_iterato r<A1>(s, "
"));
return s;
}
}

Which has undefined behavior. You can only add template
specializations to namespace std when they depend on
user-defined types.

Formally true.

On practice it works just fine as long as One Definition Rule
is not violated.

Taking into account all of the code, including that which you
can't see or know about, such as in the implementation of the
library.

In other words, it works just fine as long as you're lucky.

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

[rio]

"Kai-Uwe Bux" <jk********@gmx .netha scritto nel messaggio
news:49******** *************** @read.cnntp.org ...

rio wrote:

>i know max(std::size_t ) >= max(vector::siz e_type)

Could you provide a pointer into the standard to backup that claim? or are
you making a statement about a particular platform?

seems to me
should be
in the C standard in the definition of type size_t

>i know v.size()-1<=max(vector:: size_type) <= max(std::size_t )

so size_t is ok

Best

Kai-Uwe Bux

[Maxim Yegorushkin]

On Nov 10, 10:22*am, James Kanze <james.ka...@gm ail.comwrote:

On Nov 10, 10:19 am, Maxim Yegorushkin <maxim.yegorush [e-mail]>
wrote:

On Nov 7, 12:17 pm, Pete Becker <p...@versatile coding.comwrote :

On 2008-11-07 06:03:15 -0500, Maxim Yegorushkin
<maxim.yegorush [e-mail] id:
The example probably assumes there is an overloaded
operator<<() for std::ostream and std::vector<>, something
like this:
* * #include <ostream>
* * #include <iterator>
* * #include <algorithm>
* * namespace std {
* * * * template<class A1, class A2>
* * * * ostream& operator<<(ostr eam& s, vector<A1, A2const& vec)
* * * * {
* * * * * * copy(vec.begin( ), vec.end(), ostream_iterato r<A1>(s, "
"));
* * * * * * return s;
* * * * }
* * }
Which has undefined behavior. You can only add template
specializations to namespace std when they depend on
user-defined types.

Formally true.
On practice it works just fine as long as One Definition Rule
is not violated.

Taking into account all of the code, including that which you
can't see or know about, such as in the implementation of the
library.

Precisely.

In other words, it works just fine as long as you're lucky.

Not quite. Rather as long as one understands what he is doing.

--
Max