>> All right.
So today we want to talk about sets and
maps and, time permitting, homework 3.
So looking at the intro to sets,
[inaudible] notes, I just remind you
of what we mean by generic containers.
Some template class, that's
a proper type that is capable
of storing arbitrary
numbers of T objects.
And an associate container is one
that supports an associated
iterator class a type iterator.
And supports -- I'm sorry -- and
an organizing accessible by value.
So, you may insert objects or
move objects in the container.
But what you as a client may not do
is determine the storage position
in the container.
So your positional details are left to
the implementation and become irrelevant
to the client's needs
and the [inaudible].
Typically that will be iterators
associated with associative containers,
but they'll typically
be constant iterators.
In other words, they can allow you to
go through the container or traverse it,
pick things out of it, look
at -- inspect items in it,
but typically don't allow you to change
the value of an item in the container.
There's an exception to that.
Works will tell you that,
which we'll talk about later.
But typically because the set
uses the -- because the container,
the associative container uses the
values that are stored in it as part
of the [inaudible] self-organizing
system, if you went
and changed the value in place you
might destroy the organization system
of the container.
And so, generally that's -- you're
prevented from being able to do that.
So, if you want to, you could have
a certain, say, key plus data stored
in an associative container.
Being able to change the key,
you typically have to remove that
and then reinsert it with the new
key rather than just change the key
as it sits in the container.
So, this can get quite confusing
because we still have iterators
and we still can iterate
through a container.
So I just want to talk for
a minute about the client.
For those in a position where have you
have a client perspective and a sort
of internal perspective
or structural perspective.
So from the client perspective
you can do the following.
You can do the standard
traversal for loop,
which is where the object container
type, that loop looks like this:
For C double colon iterator.
That names the internal
type called iterator.
Now you can see that
begin [inaudible] C dot
in plus plus i. We've seen
that loop a million times.
And you do whatever you need to inside.
Now what that loop is doing
is going through the elements
of that container one at a
time from beginning to end.
And it gives an external
feel for some sort
of sequential structure
to the container.
But that sequential structure is really
only in the line of the client program.
It does not have anything to do
with the actual structure
in the container itself.
And in fact, if we were implementing
something like a set, what you're going
to learn over the next several weeks is
that there are quite a few widely
differing ways to implement a set all
with the same external API, but
internals all being quite different.
And so how an iterator
manages to get from one item
to the next internally depends
on how that set is implemented.
And it [inaudible] very widely
from one implementation to another.
But remember, in an associative
container,
a client may not dictate
the position of an element,
really from either perspective.
So you can't decide in an ordered
set, let's say, of numbers,
you can't as a client decide
you want 3 to come before 2.
The set will say no, 3 comes after 2.
And you won't be able to
change the iteration order
because the set will insist on
storing them in a certain way.
So let's look at some examples of
-- sorry -- one more little detail.
This now a notion of multimodal
versus unimodal associative container.
So, a multimodal associative container,
duplicate elements are allowed.
In set terminology, these
things are called multisets.
So you're allowed to have
a set with two copies of A,
three copies of B and C in it.
And that multiset would have
six elements, A, A, B, B, B,
and C. But normally in a set or
uniset, you would not allow that.
And that would be the case of a
unimodal associative container.
Well, in computer [inaudible],
a multimodal set is typically
called a multiset.
That's what it happens to be
called in in the standard template
of [inaudible] C plus plus.
It's also called a bag.
That term is widely used.
It's used, I believe, in your textbook
and quite a number of other places.
It's also sometimes set - you see this
for both uni- and multimodal cases,
relying on context to
distinguish [inaudible].
Now, a unimodal associative container,
duplicate elements are not allowed.
So this is a little more
complicated because that means thanks
to our operations kind of
have a dual personality.
Let's say you want to put A into
a set, S. And let's say that A --
it does not already belong to that set.
Then inserting A into a set,
S, will make the set, S,
one element bigger in size.
And A will now be an element of the set.
But what happens if you would insert A
into a set when A is already in the set?
Well, you might think well nothing.
But not really because it might
be that A that you want to insert
and the A that's in the set
look the same structurally
but they might have different
data associated with them.
For example, if the object A might be
some sort of record, student record,
and determining whether the two
students are the same would be whether
or not they have the
same student number.
But, the student record A that you want
to insert might have the same
student number as the record A that's
in the set, but it might have updated
information in other respects.
So you might have updated
your own [inaudible].
You might have another set of
semester grades in the record.
And so when you insert A into
a set that already contains A,
rather than do nothing, what you do is
you copy the new A on top of the old A.
So it amounts to an update
of information.
This is very important to keep in mind.
You can't store.
Now, we're going to have an
ordered associative container.
We're actually going to
talk about them first.
Then we're going to have
unordered associative containers.
They will come towards
the end of the semester.
An ordered associative container
typically is structured using the order.
And that order can be either
a standard less than operator
or it can be a predicate
class which is passed
in when you create the set object.
And that predicate would then be used
for a structural setup for the set.
So, let's take a look at the
associative container API.
Typically you're going to
have an insert operation.
And that's taking a type T element.
And I have it in there as a const
reference to T. Some people might put it
in as passing it in by value.
Functionally equivalent.
One's just a little more
efficient than the other one.
Remove an element T. And notice
when you insert T into a set
or an associative container
you're putting it in there.
And that may be multi-
or unimodal insert.
When you remove, if it's a multi
container, then there might be more
than one copy of T. And so how
do you know which copy to remove?
Well, we just remove them all and
return the number that you removed.
That's typically clear, which
is making this thing empty.
So you have insert and remove.
And then you have some ways of finding
stuff in the associative container.
And then an includes method that
is typically part of the API.
And what that does is return an iterator
pointing to the location in the set.
Now, it's pointing to
the element in the set.
I shouldn't really phrase it that way
because location only
makes sense to the set.
It doesn't make sense to
the user or the client.
But nevertheless, if you're a
client and you call includes,
you will either get the end iterator,
which will tell you that T is not
in the set or you will
get a non-end iterator.
And what that will do is when you
[inaudible] reference it will give you
that element that's in the set.
Then we take that empty and size
operations and the usual support system
of equality and non-equality
operators, iterator support
for bidirectional iterators and
what your textbook calls the big 4:
constructor, destructor, copy
constructor and assignment operator.
So we're going to concentrate
now on the four operations here:
insert and remove, clear and include.
So that's pretty much all you need
to do with an associative container.
Put things in, take things out, take
everything out and find an element
in there and retrieve
the data associated.
Notice that your includes
is a const method,
which means it doesn't change the set.
Of course, insert and remove pretty
much guarantees to change the object,
make them [inaudible] so
they're not [inaudible].
Clear, obviously, changes it.
Empty and size don't.
So your const methods would
be includes, empty and size.
And your working methods,
non-const methods,
would be insert and move and clear.
Now, if it's an ordered
associative container you're going
to have a few more operations
in the API.
And I've highlighted
them in garnet here.
Lower bound and upper bound.
And lower bound means the same thing
as before reinterpreted as follows:
So it's the first position, p, in the
container with T less than or equal
such that that position value
is bigger than or equal to 2.
And upper bound is the current position
such that the position value
is strictly bigger than 2.
Of course, bear in mind, those would
not make sense unless you had an ordered
associative container.
So the ordered associative container
does give you these other operations.
Now, so let's start talking about an
ordered list and a multimodal list.
How would we create a list
that maintains the order
and therefore implements
the order set API?
Okay, let's call it MO list.
M is for multi, O is for order, list.
Notice that I'm going to have an
element type as a template parameter.
I'm also going to have this P, which is
a predicate, which tells us what order,
how to keep order in the list.
Notice that it had a default
value, which is ordinary less than.
So if you don't specify a predicate,
you'll get the less than operator.
If you do specify, then it
would be whatever you specify.
Now, underneath this we're going to have
a list that's an ordinary list, right?
Position oriented list like
the one you did for homework 1.