Re: One more question
"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&
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.
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.
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).
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" ????
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