une simple fonction

Question

Salut à tous J'ai besoin de déclarer une variable dans le nœud pour maintenir la position de ce noeud, donc je déclare dans node.h

comme: std::vector<double> exPosition;(public)

je défini une fonction simple pour obtenir cette variable comme: vecteur virtuel

GetmyPosition (void) const=0; 

puis dans node.cc j'ai écrit cette fonction simple:

node::GetmyPosition (void) const 
{ 
    return exPosition; 
} 

mais quand je le lance, il a cette erreur:

cannot allocate an object of abstract type 'ns3::Node' 
note: because the following virtual functions are pure within 'ns3::Node'; 

ici est le code complet pour node.h:

#ifndef NODE_H 
#define NODE_H 

#include <vector> 

#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<Ptr<Node> > exPosition; 
    std::vector<double> exPosition; 
    /// current position of the node 
    //std::vector<double> 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<NetDevice> 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<NetDevice> 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<Application> application); 
    /** 
    * \param index 
    * \returns the application associated to this requested index 
    *   within this Node. 
    */ 
    Ptr<Application> 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->GetAddress(). 
    * \param packetType type of packet received 
    *     (broadcast/multicast/unicast/otherhost); Note: 
    *     this value is only valid for promiscuous mode 
    *     protocol handlers. 
    */ 
    typedef Callback<void,Ptr<NetDevice>, Ptr<const Packet>,uint16_t,const Address &, 
        const Address &, NetDevice::PacketType> 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<NetDevice> 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<NetDevice> device); 
    bool NonPromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet>, uint16_t protocol, const Address &from); 
    bool PromiscReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet>, uint16_t protocol, 
           const Address &from, const Address &to, NetDevice::PacketType packetType); 
    bool ReceiveFromDevice (Ptr<NetDevice> device, Ptr<const Packet>, uint16_t protocol, 
          const Address &from, const Address &to, NetDevice::PacketType packetType, bool promisc); 

    void Construct (void); 

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

}; 

} //namespace ns3 

#endif /* NODE_H */ 

et aussi le code complet pour node.cc

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */ 
/* 
* Copyright (c) 2006 Georgia Tech Research Corporation, INRIA 
* 
* This program is free software; you can redistribute it and/or modify 
* it under the terms of the GNU General Public License version 2 as 
* published by the Free Software Foundation; 
* 
* This program is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU General Public License for more details. 
* 
* You should have received a copy of the GNU General Public License 
* along with this program; if not, write to the Free Software 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
* 
* Authors: George F. Riley<riley@ece.gatech.edu> 
*   Mathieu Lacage <mathieu.lacage@sophia.inria.fr> 
*/ 
#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 (&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 (&Node::m_cposition), 
        MakeVectorChecker())*/ 


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


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

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

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

    Object::DoStart(); 
} 

void 
Node::NotifyDeviceAdded (Ptr<NetDevice> device) 
{} 

void 
Node::RegisterProtocolHandler (ProtocolHandler handler, 
           uint16_t protocolType, 
           Ptr<NetDevice> 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<Ptr<NetDevice> >::iterator i = m_devices.begin(); 
       i != m_devices.end(); i++) 
      { 
       Ptr<NetDevice> dev = *i; 
       dev->SetPromiscReceiveCallback (MakeCallback (&Node::PromiscReceiveFromDevice, this)); 
      } 
     } 
     else 
     { 
      device->SetPromiscReceiveCallback (MakeCallback (&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->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<NetDevice> device, Ptr<const Packet> packet, uint16_t protocol, 
           const Address &from, const Address &to, NetDevice::PacketType packetType) 
{ 
    NS_LOG_FUNCTION(this); 
    return ReceiveFromDevice (device, packet, protocol, from, to, packetType, true); 
} 

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

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

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

}//namespace ns3 

Je serai reconnaissant si quelqu'un m'aider à ce sujet. Bests Bahar

Answer 1

Vous ne pouvez pas instancier un objet qui a une fonction virtuelle déclarée =0.
Vous pouvez avoir des pointeurs sur eux, mais les éléments pointés auront en fait un type qui hérite de votre classe de base.

Answer 2

GetMyPosition est défini, doit-il être purement virtuel? Avez-vous essayé de supprimer =0 de la déclaration de fonction?