| <list> seems to be a powerful structure to store the related nodes in
| memory for fast operations, but the examples I found are all related
to
| primitive type storage.
| I'm doing a project on C++ with my defined classes to be added to
| linked list structure so as to facilitate the operation of all
| instances of defined classes. Is that possible to apply such classes
to
| <list> or <Vector> structure?
|
Not only can a list store some particular node-type, but virtually any
node type, including your own. I've left out one of the requirements,
the assignment operator for the nodes. The std::list container itself
can be encapsulated within a templated class with your own interface.
#include <iterator> // for std:
stream_iterator
#include <algorithm> // for std::copy
#include <list>
#include <ostream>
#include <iostream>
// my own list container class
template< class T >
class TList
{
std::list< T > m_list;
public:
TList() : m_list() { }
~TList() { }
void push_back(const T& t)
{
m_list.push_back(t);
}
void pop_back()
{
m_list.pop_back();
}
void display() const
{
std::cout << "list contents:\n ";
std::copy( m_list.begin(),
m_list.end(),
std:
stream_iterator< T >( std::cout, " ") );
std::cout << std::endl;
}
};
// a templated, complex Node type
template< class N, class D, class L>
class Node
{
N m_n;
D m_d;
L m_l;
public:
Node(N n, D d, L l) : m_n(n), m_d(d), m_l(l) { }
Node(const Node& copy)
{
m_n = copy.m_n;
m_d = copy.m_d;
m_l = copy.m_l;
}
~Node() { }
/* friends */
friend std:
stream&
operator<<(std:
stream& os, const Node& a)
{
os << a.m_n << ", " << a.m_d << ", " << a.m_l;
return os << std::endl;
}
};
int main()
{
TList<int> nlist; // a list of integers
typedef Node<int, double, long> t_Node;
TList< t_Node > nodelist; // a list of complex nodes
for ( int sz = 0; sz < 10; ++sz)
{
nlist.push_back(sz);
nodelist.push_back( t_Node(sz, sz + 0.1, sz * 10) );
}
nlist.display();
nodelist.display();
return 0;
}
/* output:
list contents:
0 1 2 3 4 5 6 7 8 9
list contents:
0, 0.1, 0
1, 1.1, 10
2, 2.1, 20
3, 3.1, 30
4, 4.1, 40
5, 5.1, 50
6, 6.1, 60
7, 7.1, 70
8, 8.1, 80
9, 9.1, 90
*/
The same applies to any other standard container (std::vector,
std::queue, std::deque, etc) except that associative containers (set,
map, multiset, multimap, etc) have additional requirements other than
copy ctor and operator=.
Even the node type itself can be composed of other templated user-types.
And that would not require any modification of either the Node or TList
class (You can derive from TList to provide supplimentary features).
Comparitively, the work required is minute when you consider the
flexibility and reusability of the templated classes.
