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

"Tileing" a Container

P: n/a
I've been flipping through the Josuttis book trying to find it there's
a better way to accomplish this. Haven't come across anything so I
thought I'd turn to the group.

Suppose I have 2 containers, a large one and a small one. I would like
to replace the elements of the larger container with the elements of
the smaller container, but in such a way the the elements are repeated
(or tiled, hence the subject) until the larger container is full.

Here's a simple example: I have a deque<bool> and I'd like to fill it
up with alternating 1's and 0's. Naievely, this is how I would go
about it:
deque<bool>::iterator it;
deque<bool> coll(100);

for(it = coll.begin(); it != coll.end(); ++it)
{
*it = false;
*++it = true;
}

Of course this assumes that the size of coll is even. In general, this
translates to the size of the larger container being an integer
multiple of the size of the smaller container. I can live with that
assumption.

But even with the safety assumption, this seems clumsy and error prone.
Is there a better way to accomplish this?

Thanks in advance,
Bill

Jun 30 '06 #1
Share this Question
Share on Google+
2 Replies


P: n/a
wo******@gmail.com <wo******@gmail.com> wrote:
Here's a simple example: I have a deque<bool> and I'd like to fill it
up with alternating 1's and 0's. Naievely, this is how I would go
about it:
deque<bool>::iterator it;
deque<bool> coll(100);

for(it = coll.begin(); it != coll.end(); ++it)
{
*it = false;
*++it = true;
}


I would find any way of avoiding chaning the for loop's
variable both within the for statement, and within the body.

Personally I would first try:

deque<bool> coll(100);
deque<bool> falseTrue(2); // this is your source container
// could be any size

falseTrue[0] = false;
falseTrue[1] = true;

for (int ii=0; ii<(int)coll.size(); ii++)
coll[ii] = falseTrue[ii % falseTrue.size()];

Steve
Jun 30 '06 #2

P: n/a

<wo******@gmail.com> wrote:
I've been flipping through the Josuttis book trying to find it there's
a better way to accomplish this. Haven't come across anything so I
thought I'd turn to the group.

Suppose I have 2 containers, a large one and a small one. I would like
to replace the elements of the larger container with the elements of
the smaller container, but in such a way the the elements are repeated
(or tiled, hence the subject) until the larger container is full.

Here's a simple example: I have a deque<bool> and I'd like to fill it
up with alternating 1's and 0's. Naievely, this is how I would go
about it:
deque<bool>::iterator it;
deque<bool> coll(100);

for(it = coll.begin(); it != coll.end(); ++it)
{
*it = false;
*++it = true;
}

Of course this assumes that the size of coll is even. In general, this
translates to the size of the larger container being an integer
multiple of the size of the smaller container. I can live with that
assumption.

But even with the safety assumption, this seems clumsy and error prone.
Is there a better way to accomplish this?


Yes. Probably lots, but this is what comes to my mind:

std::deque<widget> BigBox (1132);
std::deque<widget> LilBox (23);

// ... put stuff in LilBox here ...

std::deque<widget>::iterator i, j;

for (i=BigBox.begin(), j=LilBox.begin(); i != BigBox.end(); ++i,++j)
{
if (j == LilBox.end()) j=LilBox.begin();
(*i)=(*j);
}
Each time j reaches the end of LilBox, it just loops back to the
beginning; so the contents of LilBox tiles BigBox.
--
Cheers,
Robbie Hatley
Tustin, CA, USA
lonewolfintj at pacbell dot net (put "[ciao]" in subject to bypass spam
filter)
home dot pac bell dot net slant earnur slant
Jun 30 '06 #3

This discussion thread is closed

Replies have been disabled for this discussion.