Re: One more question
"Arnaud Debaene" <adebaene@club-internet.fr> ???g???l???s?D:%23RGBCwyUHHA.192@TK2MSFTNGP04.phx.gbl...
"Jacky" <jl@knight.com> a ?crit dans le message de news:
eFO6ahyUHHA.4632@TK2MSFTNGP04.phx.gbl...
If I have the following code:
template<class I, class T>
I find (I first, I last, const T& value)
{
while (first != last && *first != value)
++first;
return first;
}
struct int_node {
int val;
int_node *next;
};
// Wrapper
template <class Node>
struct node_wrap {
Node *ptr;
node_wrap(Node* p = 0) : ptr(p) { }
Node& operator *() const { return *ptr } <<<<< what is this? and
more coming up
This is the star operator, which allow youto dereference a node_wrap as if
it were a pointer. This operation returns a Node&
In the scenrio, what is the difference between Node, Node *, Node&?
Node* operator->() const { return ptr } <<<<< what does cont
mean here?
It means that the operation is a const-functin, which doesn't modify the
current object, and therefore the function can be called on a const
object.
So there would be a compilation error when I apply this function on a
non-const object?
As a side note : you miss the ending ";" for both of those functions
// pre-increment operator
node_wrap& operator++ () { ptr = ptr->next; return
*this; }
// post-increment operator
node_wrap operator++(int) { node_wrap tmp = *this;
++*this; return tmp; }
bool operator == (const node_wrap& i) const { return ptr ==
i.ptr; }
bool operator != (const node_wrap& i) const { return ptr !=
i.ptr; }
};
bool operator == (const int_node& node, int n) { return node.val == n; }
<<< what are these extra lines for?
bool operator != (const int_node& node, int n) { return node.val != n; }
They allow to compare for equality an int_node and an int.
Ok.
void main()
{
int_node *list_head, *list_tail;
int_node *in = new(int_node);
in->val = 100;
in->next = 0;
list_head = list_tail = in;
for (int i = 0; i < 10; i++)
{
int_node* in = new(int_node);
in->val = i;
in->next = 0;
list_tail->next = in;
list_tail = in;
}
// 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
node_wrap<int_node> r;
r = find(node_wrap<int_node>(list_head), node_wrap<int_node>(),
10); <<<<< don't understand this as well
First, it builds a node_wrap<int_node> object around list_head. It then
creates an empty node_wrap<int_node>. The both objects form a range (that
is, by aplying operator++ several times on the 1st, you should reach the
last).
Since they form a range, they can be used as an input for the find
function. Since node_wrap defines equality operators against int, an int
(10) can be passed directly as predicate to the find fnction (as the
object to search).
Are there any good reference books that I can grab on (as mine is in another
language) over this topic?
if ( r != node_wrap<int_node>())
std::cout << (*r).val << std::endl;
r = find(node_wrap<int_node>(list_head), node_wrap<int_node>(), 3);
if (r != node_wrap<int_node>())
std::cout << (*r).val << std::endl;
}
it says that find(list_head, null, 5); won't work, why?
"It" says? Who say what? The compiler, the program, your teacher? Also,
what is "null" ????
Whoops. The reference material does.
Anyway, the first call to find fails because 10 is not in the list. But
the second call succeeds because 3 is in the list.
Arnaud
MVP - VC