a simple function
<p>Hi
I defined a variable name exPosition to keep the position of a node in my network and I did it in node.h file in pulic part but i can't access it normally in my code I mean in other classes(while its public) so I tried to write a function to return this variable in node .cc and followed the same structure in other classes but it gives me errores about "can not allocate an object of abstract type ns3::Node" and "because the following virtual functions are pured within ns3::node" and I tried to delete =0 in .h but it gave another errore about ns3::node::GetmyPosition(void) const doesnt match any prototype.
here is the code for Node.h:</p>

<pre><code>#ifndef NODE_H
#define NODE_H

#include &lt;vector&gt;

#include "ns3/object.h"
#include "ns3/callback.h"
#include "ns3/ptr.h"
#include "ns3/net-device.h"

namespace ns3 {

class Application;
class Packet;
class Address;


/**
 * \ingroup node
 *
 * \brief A network Node.
 *
 * This class holds together:
 *   - a list of NetDevice objects which represent the network interfaces
 *     of this node which are connected to other Node instances through
 *     Channel instances.
 *   - a list of Application objects which represent the userspace
 *     traffic generation applications which interact with the Node
 *     through the Socket API.
 *   - a node Id: a unique per-node identifier.
 *   - a system Id: a unique Id used for parallel simulations.
 *
 * Every Node created is added to the NodeList automatically.
 */
class Node : public Object
{
public:
   /// exposition of the node
  //std::vector&lt;Ptr&lt;Node&gt; &gt; exPosition;
  std::vector&lt;double&gt; exPosition;
  /// current position of the node
  //std::vector&lt;double&gt; cPosition;  
  static TypeId GetTypeId (void);

  /**
   * Must be invoked by subclasses only.
   */
  Node();
  /**
   * \param systemId a unique integer used for parallel simulations.
   *
   * Must be invoked by subclasses only.
   */
  Node(uint32_t systemId);

  virtual ~Node();

  /**
   * \returns the unique id of this node.
   * 
   * This unique id happens to be also the index of the Node into
   * the NodeList. 
   */
  uint32_t GetId (void) const;

  /**
   * \returns the system id for parallel simulations associated
   *          to this node.
   */
  uint32_t GetSystemId (void) const;

  /**
   * \param device NetDevice to associate to this node.
   * \returns the index of the NetDevice into the Node's list of
   *          NetDevice.
   *
   * Associate this device to this node.
   */
  uint32_t AddDevice (Ptr&lt;NetDevice&gt; device);
  /**
   * \param index the index of the requested NetDevice
   * \returns the requested NetDevice associated to this Node.
   *
   * The indexes used by the GetDevice method start at one and
   * end at GetNDevices ()
   */
  Ptr&lt;NetDevice&gt; GetDevice (uint32_t index) const;
  /**
   * \returns the number of NetDevice instances associated
   *          to this Node.
   */
  uint32_t GetNDevices (void) const;

  /**
   * \param application Application to associate to this node.
   * \returns the index of the Application within the Node's list
   *          of Application.
   *
   * Associated this Application to this Node. This method is called
   * automatically from Application::Application so the user
   * has little reasons to call this method directly.
   */
  uint32_t AddApplication (Ptr&lt;Application&gt; application);
  /**
   * \param index
   * \returns the application associated to this requested index
   *          within this Node.
   */
  Ptr&lt;Application&gt; GetApplication (uint32_t index) const;

  /**
   * \returns the number of applications associated to this Node.
   */
  uint32_t GetNApplications (void) const;

  /**
   * A protocol handler
   *
   * \param device a pointer to the net device which received the packet
   * \param packet the packet received
   * \param protocol the 16 bit protocol number associated with this packet.
   *        This protocol number is expected to be the same protocol number
   *        given to the Send method by the user on the sender side.
   * \param sender the address of the sender
   * \param receiver the address of the receiver; Note: this value is
   *                 only valid for promiscuous mode protocol
   *                 handlers.  Note:  If the L2 protocol does not use L2
   *                 addresses, the address reported here is the value of 
   *                 device-&gt;GetAddress().
   * \param packetType type of packet received
   *                   (broadcast/multicast/unicast/otherhost); Note:
   *                   this value is only valid for promiscuous mode
   *                   protocol handlers.  
   */
  typedef Callback&lt;void,Ptr&lt;NetDevice&gt;, Ptr&lt;const Packet&gt;,uint16_t,const Address &amp;,
                   const Address &amp;, NetDevice::PacketType&gt; ProtocolHandler;
  /**
   * \param handler the handler to register
   * \param protocolType the type of protocol this handler is 
   *        interested in. This protocol type is a so-called
   *        EtherType, as registered here:
   *        http://standards.ieee.org/regauth/ethertype/eth.txt
   *        the value zero is interpreted as matching all
   *        protocols.
   * \param device the device attached to this handler. If the
   *        value is zero, the handler is attached to all
   *        devices on this node.
   * \param promiscuous whether to register a promiscuous mode handler
   */
  void RegisterProtocolHandler (ProtocolHandler handler, 
                                uint16_t protocolType,
                                Ptr&lt;NetDevice&gt; device,
                                bool promiscuous=false);
  /**
   * \param handler the handler to unregister
   *
   * After this call returns, the input handler will never
   * be invoked anymore.
   */
  void UnregisterProtocolHandler (ProtocolHandler handler);


  /**
   * \returns true if checksums are enabled, false otherwise.
   */
  static bool ChecksumEnabled (void);


protected:
  /**
   * The dispose method. Subclasses must override this method
   * and must chain up to it by calling Node::DoDispose at the
   * end of their own DoDispose method.
   */
  virtual void DoDispose (void);
  virtual void DoStart (void);
private:

  /**
   * \param device the device added to this Node.
   *
   * This method is invoked whenever a user calls Node::AddDevice.
   */
  virtual void NotifyDeviceAdded (Ptr&lt;NetDevice&gt; device);
  bool NonPromiscReceiveFromDevice (Ptr&lt;NetDevice&gt; device, Ptr&lt;const Packet&gt;, uint16_t protocol, const Address &amp;from);
  bool PromiscReceiveFromDevice (Ptr&lt;NetDevice&gt; device, Ptr&lt;const Packet&gt;, uint16_t protocol,
                                 const Address &amp;from, const Address &amp;to, NetDevice::PacketType packetType);
  bool ReceiveFromDevice (Ptr&lt;NetDevice&gt; device, Ptr&lt;const Packet&gt;, uint16_t protocol,
                          const Address &amp;from, const Address &amp;to, NetDevice::PacketType packetType, bool promisc);

  void Construct (void);

  struct ProtocolHandlerEntry {
    ProtocolHandler handler;
    Ptr&lt;NetDevice&gt; device;
    uint16_t protocol;
    bool promiscuous;
  };
  typedef std::vector&lt;struct Node::ProtocolHandlerEntry&gt; ProtocolHandlerList;
  uint32_t    m_id;         // Node id for this node
  uint32_t    m_sid;        // System id for this node
  std::vector&lt;Ptr&lt;NetDevice&gt; &gt; m_devices;
  std::vector&lt;Ptr&lt;Application&gt; &gt; m_applications;
  ProtocolHandlerList m_handlers;

};

} //namespace ns3

#endif /* NODE_H */
</code></pre>

<p>and the Node.cc is here:</p>

<pre><code>#include "node.h"
#include "node-list.h"
#include "net-device.h"
#include "application.h"
#include "ns3/packet.h"
#include "ns3/simulator.h"
#include "ns3/object-vector.h"
#include "ns3/uinteger.h"
#include "ns3/log.h"
#include "ns3/assert.h"
#include "ns3/global-value.h"
#include "ns3/boolean.h"
#include "ns3/simulator.h"
#include "ns3/vector.h"

NS_LOG_COMPONENT_DEFINE ("Node");

namespace ns3{

NS_OBJECT_ENSURE_REGISTERED (Node);

GlobalValue g_checksumEnabled  = GlobalValue ("ChecksumEnabled",
                                              "A global switch to enable all checksums for all protocols",
                                              BooleanValue (false),
                                              MakeBooleanChecker ());
//Vector exposition = (0.0, 0.0, 0.0);
/*.AddAttribute ("exPosition", "The previous position of this node.",
                   TypeId::ATTR_GET,
                   VectorValue (Vector (0.0, 0.0, 0.0)), // ignored initial value.
                   MakeVectorAccessor (&amp;Node::m_exposition),
                   MakeVectorChecker ())
    .AddAttribute ("cPosition", "The current position of this node.",
                   TypeId::ATTR_GET,
                   VectorValue (Vector (0.0, 0.0, 0.0)), // ignored initial value.
                   MakeVectorAccessor (&amp;Node::m_cposition),
                   MakeVectorChecker ())*/


TypeId 
Node::GetTypeId (void)
{
  static TypeId tid = TypeId ("ns3::Node")
    .SetParent&lt;Object&gt; ()
    .AddConstructor&lt;Node&gt; ()
    .AddAttribute ("DeviceList", "The list of devices associated to this Node.",
                   ObjectVectorValue (),
                   MakeObjectVectorAccessor (&amp;Node::m_devices),
                   MakeObjectVectorChecker&lt;NetDevice&gt; ())
    .AddAttribute ("ApplicationList", "The list of applications associated to this Node.",
                   ObjectVectorValue (),
                   MakeObjectVectorAccessor (&amp;Node::m_applications),
                   MakeObjectVectorChecker&lt;Application&gt; ())
    .AddAttribute ("Id", "The id (unique integer) of this Node.",
                   TypeId::ATTR_GET, // allow only getting it.
                   UintegerValue (0),
                   MakeUintegerAccessor (&amp;Node::m_id),
                   MakeUintegerChecker&lt;uint32_t&gt; ())


    ;
  return tid;
}

Node::Node()
  : m_id(0), 
    m_sid(0)
{
  exPosition.at(1)= 0;
  exPosition.at(2)= 0;
  exPosition.at(3)= 0;

  Construct ();
}

Node::Node(uint32_t sid)
  : m_id(0), 
    m_sid(sid)
{ 
  exPosition.at(1)= 0;
  exPosition.at(2)= 0;
  exPosition.at(3)= 0;
  Construct ();
}

void
Node::Construct (void)
{
  m_id = NodeList::Add (this);
  //exPosition =(0.0,0.0,0.0);
}

Node::~Node ()
{}

uint32_t 
Node::GetId (void) const
{
  return m_id;
}

uint32_t 
Node::GetSystemId (void) const
{
  return m_sid;
}

uint32_t 
Node::AddDevice (Ptr&lt;NetDevice&gt; device)
{
  uint32_t index = m_devices.size ();
  m_devices.push_back (device);
  device-&gt;SetNode (this);
  device-&gt;SetIfIndex(index);
  device-&gt;SetReceiveCallback (MakeCallback (&amp;Node::NonPromiscReceiveFromDevice, this));
  Simulator::ScheduleWithContext (GetId (), Seconds (0.0), 
                                  &amp;NetDevice::Start, device);
  NotifyDeviceAdded (device);
  return index;
}
Ptr&lt;NetDevice&gt;
Node::GetDevice (uint32_t index) const
{
  NS_ASSERT_MSG (index &lt; m_devices.size (), "Device index " &lt;&lt; index &lt;&lt;
                 " is out of range (only have " &lt;&lt; m_devices.size () &lt;&lt; " devices).");
  return m_devices[index];
}
uint32_t 
Node::GetNDevices (void) const
{
  return m_devices.size ();
}

uint32_t 
Node::AddApplication (Ptr&lt;Application&gt; application)
{
  uint32_t index = m_applications.size ();
  m_applications.push_back (application);
  application-&gt;SetNode (this);
  Simulator::ScheduleWithContext (GetId (), Seconds (0.0), 
                                  &amp;Application::Start, application);
  return index;
}
Ptr&lt;Application&gt; 
Node::GetApplication (uint32_t index) const
{
  NS_ASSERT_MSG (index &lt; m_applications.size (), "Application index " &lt;&lt; index &lt;&lt;
                 " is out of range (only have " &lt;&lt; m_applications.size () &lt;&lt; " applications).");
  return m_applications[index];
}
uint32_t 
Node::GetNApplications (void) const
{
  return m_applications.size ();
}

void 
Node::DoDispose()
{
  m_handlers.clear ();
  for (std::vector&lt;Ptr&lt;NetDevice&gt; &gt;::iterator i = m_devices.begin ();
       i != m_devices.end (); i++)
    {
      Ptr&lt;NetDevice&gt; device = *i;
      device-&gt;Dispose ();
      *i = 0;
    }
  m_devices.clear ();
  for (std::vector&lt;Ptr&lt;Application&gt; &gt;::iterator i = m_applications.begin ();
       i != m_applications.end (); i++)
    {
      Ptr&lt;Application&gt; application = *i;
      application-&gt;Dispose ();
      *i = 0;
    }
  m_applications.clear ();
  Object::DoDispose ();
}
void 
Node::DoStart (void)
{
  for (std::vector&lt;Ptr&lt;NetDevice&gt; &gt;::iterator i = m_devices.begin ();
       i != m_devices.end (); i++)
    {
      Ptr&lt;NetDevice&gt; device = *i;
      device-&gt;Start ();
    }
  for (std::vector&lt;Ptr&lt;Application&gt; &gt;::iterator i = m_applications.begin ();
       i != m_applications.end (); i++)
    {
      Ptr&lt;Application&gt; application = *i;
      application-&gt;Start ();
    }

  Object::DoStart ();
}

void 
Node::NotifyDeviceAdded (Ptr&lt;NetDevice&gt; device)
{}

void
Node::RegisterProtocolHandler (ProtocolHandler handler, 
                               uint16_t protocolType,
                               Ptr&lt;NetDevice&gt; device,
                               bool promiscuous)
{
  struct Node::ProtocolHandlerEntry entry;
  entry.handler = handler;
  entry.protocol = protocolType;
  entry.device = device;
  entry.promiscuous = promiscuous;

  // On demand enable promiscuous mode in netdevices
  if (promiscuous)
    {
      if (device == 0)
        {
          for (std::vector&lt;Ptr&lt;NetDevice&gt; &gt;::iterator i = m_devices.begin ();
               i != m_devices.end (); i++)
            {
              Ptr&lt;NetDevice&gt; dev = *i;
              dev-&gt;SetPromiscReceiveCallback (MakeCallback (&amp;Node::PromiscReceiveFromDevice, this));
            }
        }
      else
        {
          device-&gt;SetPromiscReceiveCallback (MakeCallback (&amp;Node::PromiscReceiveFromDevice, this));
        }
    }

  m_handlers.push_back (entry);
}

void
Node::UnregisterProtocolHandler (ProtocolHandler handler)
{
  for (ProtocolHandlerList::iterator i = m_handlers.begin ();
       i != m_handlers.end (); i++)
    {
      if (i-&gt;handler.IsEqual (handler))
        {
          m_handlers.erase (i);
          break;
        }
    }
}

bool
Node::ChecksumEnabled (void)
{
  BooleanValue val;
  g_checksumEnabled.GetValue (val);
  return val.Get ();
}

bool
Node::PromiscReceiveFromDevice (Ptr&lt;NetDevice&gt; device, Ptr&lt;const Packet&gt; packet, uint16_t protocol,
                                const Address &amp;from, const Address &amp;to, NetDevice::PacketType packetType)
{
  NS_LOG_FUNCTION(this);
  return ReceiveFromDevice (device, packet, protocol, from, to, packetType, true);
}

bool
Node::NonPromiscReceiveFromDevice (Ptr&lt;NetDevice&gt; device, Ptr&lt;const Packet&gt; packet, uint16_t protocol,
                                   const Address &amp;from)
{
  NS_LOG_FUNCTION(this);
  return ReceiveFromDevice (device, packet, protocol, from, from, NetDevice::PacketType (0), false);
}

bool
Node::ReceiveFromDevice (Ptr&lt;NetDevice&gt; device, Ptr&lt;const Packet&gt; packet, uint16_t protocol,
                         const Address &amp;from, const Address &amp;to, NetDevice::PacketType packetType, bool promiscuous)
{
  NS_ASSERT_MSG (Simulator::GetContext () == GetId (), "Received packet with erroneous context ; " &lt;&lt;
                 "make sure the channels in use are correctly updating events context " &lt;&lt;
                 "when transfering events from one node to another.");
  NS_LOG_DEBUG("Node " &lt;&lt; GetId () &lt;&lt; " ReceiveFromDevice:  dev "
               &lt;&lt; device-&gt;GetIfIndex () &lt;&lt; " (type=" &lt;&lt; device-&gt;GetInstanceTypeId ().GetName ()
               &lt;&lt; ") Packet UID " &lt;&lt; packet-&gt;GetUid ());
  bool found = false;

  for (ProtocolHandlerList::iterator i = m_handlers.begin ();
       i != m_handlers.end (); i++)
    {
      if (i-&gt;device == 0 ||
          (i-&gt;device != 0 &amp;&amp; i-&gt;device == device))
        {
          if (i-&gt;protocol == 0 || 
              i-&gt;protocol == protocol)
            {
              if (promiscuous == i-&gt;promiscuous)
                {
                  i-&gt;handler (device, packet, protocol, from, to, packetType);
                  found = true;
                }
            }
        }
    }
  return found;
}

}//namespace ns3
</code></pre>

<p>actually I didn't wrote it and followed the same structer in other files for writing that const=0 in my code so I don't have any idea about it. and as I mentioned when I deleted teh =0 had errores again</p>
