«

Caleb wrote:
>
> I thought of a way I could set it up where I can add multiple elements
> with one statement....rather simple, really. Just overload an
> "add_doors" function with one integer, two integers, five integers, and
> whatever amounts of integers that I need, and write it to push_back the
> elements that were provided one at a time. Contemplating whether that
> would really be worth it, though.

There is an 'assign' library in boost. It may be what you are looking
for.

My latest problem: All commands are entered by an integer selected
from a menu (or "0" for quit). If something invalid is entered, like
"x" or ".", the program enters a neverending loop. This seems to be a
common problem for n00bs as I have researched it on Google. I have
found workarounds to detect invalid input, but they all seem to cause
"0" and invalid input to be read the same. The value is being read to
an "int" variable. Can anyone help with that one? Thanks again for
all the help.

Caleb a écrit :
> My latest problem: All commands are entered by an integer selected
> from a menu (or "0" for quit). If something invalid is entered, like
> "x" or ".", the program enters a neverending loop. This seems to be a
> common problem for n00bs as I have researched it on Google. I have
> found workarounds to detect invalid input, but they all seem to cause
> "0" and invalid input to be read the same. The value is being read to
> an "int" variable. Can anyone help with that one? Thanks again for
> all the help.
>
http://www.parashift.com/c++-faq-lit....html#faq-15.3

Caleb a écrit :
> std::vector does exactly what I want it to do. It seems to be
> extremely advantageous over regular arrays, too. There's just one
> thing I'm wondering....is there a way to push_back three elements at
> once? For example, I'm going to have a list of door initializations
> that look like this:
>
> Foyer.destination.push_back(2);Foyer.destination.p ush_back(3);Foyer.destination.push_back(6);
>
> And that's only for a 3-door room....is there a more efficient way to
> code that?
>
Certainly:
- you can read your data from a file and insert it into a vector
- you can use arrays (http://www.boost.org/doc/html/array/):
boost::array<int,3> foyer_dest = { 2, 3, 6 } ;
Foyer.destination.insert(foyer_dest.begin(),foyer_ dest.end());

Caleb wrote:
> std::vector does exactly what I want it to do. It seems to be
> extremely advantageous over regular arrays, too. There's just one
> thing I'm wondering....is there a way to push_back three elements at
> once? For example, I'm going to have a list of door initializations
> that look like this:
>
> Foyer.destination.push_back(2);Foyer.destination.p ush_back(3);Foyer.destination.push_back(6);
>
> And that's only for a 3-door room....is there a more efficient way to
> code that?

You can use something like the code below. Something similar may even
be part of the next version of the C++ standard. Code separates into a
for_each that works on containers or arrays and some custom functors as
examples to use with it. push_back loads a container and output sends
it to output stream. functions below functors just make each functor a
bit more convenient to use.
Can also define your own functors too...

regards
Andy Little

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

//container for_each
template <typename Container, typename F>
void for_each(Container & c, F const & f)
{
std::for_each(c.begin(),c.end(),f);
}

//array version of for_each
template <typename T,int N,typename F>
void for_each(T (&ar)[N],F const & f)
{
for (int i = 0; i < N;++i){
f(ar[i]);
}
}

// use with foreach to load a std container
// from another container or an array
template <typename Container>
struct push_back_{
Container & c;
push_back_(Container & c_in):c(c_in){}

template <typename T>
void
operator()(T const & t)const
{
return c.push_back(t);
}
};
// function returns functor above
template <typename Container>
inline
push_back_<Container> push_back(Container & c)
{
return push_back_<Container>(c);
}

// do output
template <typename CharType>
struct output_{
std::basic_ostream<CharType> & os;
CharType sep;
output_(
std::basic_ostream<CharType> & os_in,
CharType sep_in)s(os_in),sep(sep_in){}

template <typename T>
std::basic_ostream<CharType> &
operator()(T const & t)const
{
return os << t << sep;
}
};
// function returns functor above
template <typename CharType>
inline
output_<CharType>
output(std::basic_ostream<CharType>& os, CharType sep)
{
return output_<CharType>(os,sep);
}

// etc


int main()
{
int array [] = {1,2,3,4,5};

std::vector<int> vect;

for_each(array,push_back(vect));

for_each(vect,output(std::cout,'\n'));
}

kwikius a écrit :
> Caleb wrote:
>> std::vector does exactly what I want it to do. It seems to be
>> extremely advantageous over regular arrays, too. There's just one
>> thing I'm wondering....is there a way to push_back three elements at
>> once? For example, I'm going to have a list of door initializations
>> that look like this:
>>
>> Foyer.destination.push_back(2);Foyer.destination.p ush_back(3);Foyer.destination.push_back(6);
>>
>> And that's only for a 3-door room....is there a more efficient way to
>> code that?
>
> You can use something like the code below. Something similar may even
> be part of the next version of the C++ standard. Code separates into a
> for_each that works on containers or arrays and some custom functors as
> examples to use with it. push_back loads a container and output sends
> itc to output stream. functions below functors just make each functor a
> bit more convenient to use.
> Can also define your own functors too...
>
> [code]
>
>
> int main()
> {
> int array [] = {1,2,3,4,5};
>
> std::vector<int> vect;
>
> for_each(array,push_back(vect));
>
> for_each(vect,output(std::cout,'\n'));
> }
>

Yes, you can use the for_each structure but it is expected to be less
efficient than the std::vector::insert method.

I don't see the advantage of defining a for_each specifically for arrays
since there is boost::array that works fine (even though it is not
really a container).

And using POD:
int array [] = {1,2,3,4,5};
std::vector<int> vect;
//should work
vect.insert(&array[0],&array[sizeof(array)/sizeof(int)]);
// if you use gcc:
vect.insert(normal_iterator(&array[0]),
normal_iterator(&array[sizeof(array)/sizeof(int)]));



Alternatively, you can use lambda programming:
http://www.boost.org/doc/html/lambda.html

Michael DOUBEZ wrote:

> And using POD:
> int array [] = {1,2,3,4,5};
> std::vector<int> vect;
> //should work
> vect.insert(&array[0],&array[sizeof(array)/sizeof(int)]);

hmm.... clearly superior to:

for_each(array,push_back(vect));



regards
Andy Little

Michael DOUBEZ wrote:

> std::vector<int> vect;
> //should work
> vect.insert(&array[0],&array[sizeof(array)/sizeof(int)]);

FWIW output with your version in VC7.1, gcc4.1 and VC8 ---> below.
Which vector::insert signature is it meant to be using?

regards
Andy Little

/*
..
..
..
*/

int main()
{
int array [] = {1,2,3,4,5};

std::vector<int> vect;

/* for_each(array,push_back(vect)); */
vect.insert(&array[0],&array[sizeof(array)/sizeof(int)]);
}

Test.cpp
VC7.1 output:

d:\Projects\Test\Test.cpp(80) : error C2664:
'std::vector<_Ty>::iterator
std::vector<_Ty>::insert(std::vector<_Ty>::iterato r,const _Ty &)' :
cannot convert parameter 2 from 'int *__w64 ' to 'const int &'
with
[
_Ty=int
]
Reason: cannot convert from 'int *__w64 ' to 'const int'
This conversion requires a reinterpret_cast, a C-style cast or
function-style cast

/////////////

gcc 4.1 output:


test.cpp: In function 'int main()':
test.cpp:80: error: no matching function for call to 'std::vector<int,
std::allo
cator<int> >::insert(int*, int*)'
/opt/conceptgcc-4.1.1-alpha-4/lib/gcc/i686-pc-cygwin/4.1.1/../../../../include/c
++/4.1.1/bits/vector.tcc:93: note: candidates are: typename
std::vector<_Tp, _Al
loc>::iterator std::vector<_Tp,
_Alloc>::insert(__gnu_cxx::__normal_iterator<typ
ename std::_Vector_base<_Tp, _Alloc>::_Tp_alloc_type:ointer,
std::vector<_Tp,
_Alloc> >, const _Tp&) [with _Tp = int, _Alloc = std::allocator<int>]
/opt/conceptgcc-4.1.1-alpha-4/lib/gcc/i686-pc-cygwin/4.1.1/../../../../include/c
++/4.1.1/bits/stl_vector.h:651: note: void std::vector<_Tp,
_Alloc>::insert(__g
nu_cxx::__normal_iterator<typename std::_Vector_base<_Tp,
_Alloc>::_Tp_alloc_typ
e:ointer, std::vector<_Tp, _Alloc> >, size_t, const _Tp&) [with _Tp =
int, _Al
loc = std::allocator<int>]
make: *** [test.o] Error 1

//////////////////

VC8,=.o output:

..\test.cpp(80) : error C2664: 'std::_Vector_iterator<_Ty,_Alloc>
std::vector<_Ty>::insert(std::_Vector_iterator<_Ty ,_Alloc>,const _Ty
&)' : cannot convert parameter 1 from 'int *' to
'std::_Vector_iterator<_Ty,_Alloc>'
with
[
_Ty=int,
_Alloc=std::allocator<int>
]
No constructor could take the source type, or constructor
overload resolution was ambiguous

Michael DOUBEZ wrote:

> Alternatively, you can use lambda programming:
> http://www.boost.org/doc/html/lambda.html

I would be interested to see what the boost lambda version looks like
too. Not knocking it. Just have no idea. Anyone care to reveal it ?

regards
Andy Little

Michael DOUBEZ wrote:

> I don't see the advantage of defining a for_each specifically for arrays
> since there is boost::array that works fine (even though it is not
> really a container).

I covered that in the example code FWIW. If you want to use
boost::array ( or another container) you can do, but you have to
specify the size, which can be inconvenient when adding stuff to the
initialiser list.


int main()
{
// int array [] = {1,2,3,4,5};

boost::array<int,5> array = {1,2,3,4,5};

std::vector<int> vect;

for_each(array,push_back(vect));

for_each(array,output(std::cout,'\n'));

}

regards
Andy Little